rspack_core 0.102.0-beta.0

rspack core
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

use std::sync::Arc;

use rspack_error::Result;

use super::{Cache, CacheKey, CacheValue, Etag, cache_value::CacheValueData};

/// A namespaced view of the shared cache.
///
/// This is the minimal equivalent of webpack's `CacheFacade`: it prefixes
/// identifiers with a fixed namespace and creates child or item facades.
#[derive(Debug, Clone)]
pub struct CacheFacade {
  cache: Cache,
  name: Arc<str>,
}

impl CacheFacade {
  pub(crate) fn new(cache: Cache, name: impl Into<Arc<str>>) -> Self {
    Self {
      cache,
      name: name.into(),
    }
  }

  pub fn get_child_cache(&self, name: &str) -> Self {
    Self {
      cache: self.cache.clone(),
      name: join_name(&self.name, name, true),
    }
  }

  pub fn get_item_cache(&self, identifier: &str, etag: Option<Etag>) -> ItemCacheFacade {
    ItemCacheFacade {
      cache: self.cache.clone(),
      key: self.key(identifier),
      etag,
    }
  }

  pub fn get<T: CacheValueData>(
    &self,
    identifier: &str,
    etag: Option<Etag>,
  ) -> Result<Option<CacheValue<T>>> {
    self.cache.get(self.key(identifier), etag)
  }

  pub fn store<T: CacheValueData>(
    &self,
    identifier: &str,
    etag: Option<Etag>,
    value: CacheValue<T>,
  ) -> Result<()> {
    self.cache.store(self.key(identifier), etag, value)
  }

  fn key(&self, identifier: &str) -> CacheKey {
    CacheKey::from(join_name(&self.name, identifier, true))
  }
}

/// A cache facade with a fixed identifier and etag.
#[derive(Debug, Clone)]
pub struct ItemCacheFacade {
  cache: Cache,
  key: CacheKey,
  etag: Option<Etag>,
}

impl ItemCacheFacade {
  pub fn get<T: CacheValueData>(&self) -> Result<Option<CacheValue<T>>> {
    self.cache.get(self.key.clone(), self.etag.clone())
  }

  pub fn store<T: CacheValueData>(&self, value: CacheValue<T>) -> Result<()> {
    self.cache.store(self.key.clone(), self.etag.clone(), value)
  }
}

fn join_name(prefix: &str, name: &str, with_separator: bool) -> Arc<str> {
  let mut result = String::with_capacity(prefix.len() + name.len() + usize::from(with_separator));
  result.push_str(prefix);
  if with_separator {
    result.push('|');
  }
  result.push_str(name);
  result.into()
}