@rspack/core 1.0.0-beta.0 → 1.0.0-beta.2

package/dist/lib/CacheFacade.d.ts

@@ -1,191 +1,167 @@
-export = CacheFacade;
-declare class CacheFacade {
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/CacheFacade.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type { Cache, CallbackCache, Etag } from "./Cache";
+import type WebpackError from "./WebpackError";
+import type { HashConstructor, HashableObject } from "./cache/getLazyHashedEtag";
+type CallbackNormalErrorCache<T> = (err?: WebpackError | null, result?: T) => void;
+declare abstract class BaseCache {
+    abstract get<T>(callback: CallbackCache<T>): void;
+    abstract getPromise<T>(): Promise<T | undefined>;
+    abstract store<T>(data: T, callback: CallbackCache<void>): void;
+    abstract storePromise<T>(data: T): Promise<void>;
+}
+export declare class MultiItemCache implements BaseCache {
+    _items: ItemCacheFacade[];
     /**
-     * @param {Cache} cache the root cache
-     * @param {string} name the child cache name
-     * @param {string | HashConstructor} hashFunction the hash function to use
+     * @param items item caches
+     * @returns
      */
-    constructor(cache: Cache, name: string, hashFunction: string | HashConstructor);
-    _cache: import("./Cache");
-    _name: string;
-    _hashFunction: any;
+    constructor(items: ItemCacheFacade[]);
     /**
-     * @param {string} name the child cache name#
-     * @returns {CacheFacade} child cache
+     * @param callback signals when the value is retrieved
+     * @returns
      */
-    getChildCache(name: string): CacheFacade;
+    get<T>(callback: CallbackCache<T>): void;
     /**
-     * @param {string} identifier the cache identifier
-     * @param {Etag | null} etag the etag
-     * @returns {ItemCacheFacade} item cache
+     * @returns promise with the data
      */
-    getItemCache(identifier: string, etag: Etag | null): ItemCacheFacade;
+    getPromise<T>(): Promise<T | undefined>;
     /**
-     * @param {HashableObject} obj an hashable object
-     * @returns {Etag} an etag that is lazy hashed
+     * @param data the value to store
+     * @param callback signals when the value is stored
+     * @returns
      */
-    getLazyHashedEtag(obj: HashableObject): Etag;
+    store<T>(data: T, callback: CallbackCache<void>): void;
     /**
-     * @param {Etag} a an etag
-     * @param {Etag} b another etag
-     * @returns {Etag} an etag that represents both
+     * @param data the value to store
+     * @returns promise signals when the value is stored
      */
-    mergeEtags(a: Etag, b: Etag): Etag;
+    storePromise<T>(data: T): Promise<void>;
+}
+export declare class ItemCacheFacade implements BaseCache {
+    _cache: Cache;
+    _name: string;
+    _etag: Etag | null;
     /**
-     * @template T
-     * @param {string} identifier the cache identifier
-     * @param {Etag | null} etag the etag
-     * @param {CallbackCache<T>} callback signals when the value is retrieved
-     * @returns {void}
+     * @param cache the root cache
+     * @param name the child cache item name
+     * @param etag the etag
+     * @returns
      */
-    get<T>(identifier: string, etag: Etag | null, callback: CallbackCache<T>): void;
+    constructor(cache: Cache, name: string, etag: Etag | null);
     /**
-     * @template T
-     * @param {string} identifier the cache identifier
-     * @param {Etag | null} etag the etag
-     * @returns {Promise<T>} promise with the data
+     * @param callback signals when the value is retrieved
+     * @returns
      */
-    getPromise<T_1>(identifier: string, etag: Etag | null): Promise<T_1>;
+    get<T>(callback: CallbackCache<T>): void;
     /**
-     * @template T
-     * @param {string} identifier the cache identifier
-     * @param {Etag | null} etag the etag
-     * @param {T} data the value to store
-     * @param {CallbackCache<void>} callback signals when the value is stored
-     * @returns {void}
+     * @returns promise with the data
      */
-    store<T_2>(identifier: string, etag: Etag | null, data: T_2, callback: CallbackCache<void>): void;
+    getPromise<T>(): Promise<T | undefined>;
     /**
-     * @template T
-     * @param {string} identifier the cache identifier
-     * @param {Etag | null} etag the etag
-     * @param {T} data the value to store
-     * @returns {Promise<void>} promise signals when the value is stored
+     * @param data the value to store
+     * @param callback signals when the value is stored
+     * @returns
      */
-    storePromise<T_3>(identifier: string, etag: Etag | null, data: T_3): Promise<void>;
+    store<T>(data: T, callback: CallbackCache<void>): void;
     /**
-     * @template T
-     * @param {string} identifier the cache identifier
-     * @param {Etag | null} etag the etag
-     * @param {function(CallbackNormalErrorCache<T>): void} computer function to compute the value if not cached
-     * @param {CallbackNormalErrorCache<T>} callback signals when the value is retrieved
-     * @returns {void}
+     * @param data the value to store
+     * @returns promise signals when the value is stored
      */
-    provide<T_4>(identifier: string, etag: Etag | null, computer: (arg0: CallbackNormalErrorCache<T_4>) => void, callback: CallbackNormalErrorCache<T_4>): void;
+    storePromise<T>(data: T): Promise<void>;
     /**
-     * @template T
-     * @param {string} identifier the cache identifier
-     * @param {Etag | null} etag the etag
-     * @param {function(): Promise<T> | T} computer function to compute the value if not cached
-     * @returns {Promise<T>} promise with the data
+     * @param computer function to compute the value if not cached
+     * @param callback signals when the value is retrieved
+     * @returns
      */
-    providePromise<T_5>(identifier: string, etag: Etag | null, computer: () => T_5 | Promise<T_5>): Promise<T_5>;
-}
-declare namespace CacheFacade {
-    export { ItemCacheFacade, MultiItemCache, Cache, Etag, WebpackError, HashableObject, HashConstructor, CallbackCache, CallbackNormalErrorCache };
-}
-type Etag = import("./Cache").Etag;
-declare class ItemCacheFacade {
+    provide<T>(computer: (callback: CallbackNormalErrorCache<T>) => void, callback: CallbackNormalErrorCache<T>): void;
     /**
-     * @param {Cache} cache the root cache
-     * @param {string} name the child cache item name
-     * @param {Etag | null} etag the etag
+     * @param computer function to compute the value if not cached
+     * @returns promise with the data
      */
-    constructor(cache: Cache, name: string, etag: Etag | null);
-    _cache: import("./Cache");
+    providePromise<T>(computer: () => Promise<T> | T): Promise<T>;
+}
+export declare class CacheFacade {
     _name: string;
-    _etag: import("./Cache").Etag | null;
+    _cache: Cache;
+    _hashFunction: string | HashConstructor;
     /**
-     * @template T
-     * @param {CallbackCache<T>} callback signals when the value is retrieved
-     * @returns {void}
+     * @param cache the root cache
+     * @param name the child cache name
+     * @param hashFunction the hash function to use
      */
-    get<T>(callback: CallbackCache<T>): void;
+    constructor(cache: Cache, name: string, hashFunction: string | HashConstructor);
     /**
-     * @template T
-     * @returns {Promise<T>} promise with the data
+     * @param name the child cache name#
+     * @returns child cache
      */
-    getPromise<T_1>(): Promise<T_1>;
+    getChildCache(name: string): CacheFacade;
     /**
-     * @template T
-     * @param {T} data the value to store
-     * @param {CallbackCache<void>} callback signals when the value is stored
-     * @returns {void}
+     * @param identifier the cache identifier
+     * @param  etag the etag
+     * @returns item cache
      */
-    store<T_2>(data: T_2, callback: CallbackCache<void>): void;
+    getItemCache(identifier: string, etag: Etag | null): ItemCacheFacade;
     /**
-     * @template T
-     * @param {T} data the value to store
-     * @returns {Promise<void>} promise signals when the value is stored
+     * @param obj an hashable object
+     * @returns an etag that is lazy hashed
      */
-    storePromise<T_3>(data: T_3): Promise<void>;
+    getLazyHashedEtag(obj: HashableObject): Etag;
     /**
-     * @template T
-     * @param {function(CallbackNormalErrorCache<T>): void} computer function to compute the value if not cached
-     * @param {CallbackNormalErrorCache<T>} callback signals when the value is retrieved
-     * @returns {void}
+     * @param a an etag
+     * @param b another etag
+     * @returns an etag that represents both
      */
-    provide<T_4>(computer: (arg0: CallbackNormalErrorCache<T_4>) => void, callback: CallbackNormalErrorCache<T_4>): void;
+    mergeEtags(a: Etag, b: Etag): Etag;
     /**
-     * @template T
-     * @param {function(): Promise<T> | T} computer function to compute the value if not cached
-     * @returns {Promise<T>} promise with the data
+     * @param identifier the cache identifier
+     * @param etag the etag
+     * @param callback signals when the value is retrieved
+     * @returns
      */
-    providePromise<T_5>(computer: () => T_5 | Promise<T_5>): Promise<T_5>;
-}
-type HashableObject = import("./cache/getLazyHashedEtag").HashableObject;
-type CallbackCache<T> = (err?: (WebpackError | null) | undefined, result?: T | undefined) => void;
-type CallbackNormalErrorCache<T> = (err?: (Error | null) | undefined, result?: T | undefined) => void;
-type Cache = import("./Cache");
-type HashConstructor = any;
-/** @typedef {import("./Cache")} Cache */
-/** @typedef {import("./Cache").Etag} Etag */
-/** @typedef {import("./WebpackError")} WebpackError */
-/** @typedef {import("./cache/getLazyHashedEtag").HashableObject} HashableObject */
-/** @typedef {any} HashConstructor */
-/**
- * @template T
- * @callback CallbackCache
- * @param {(WebpackError | null)=} err
- * @param {T=} result
- * @returns {void}
- */
-/**
- * @template T
- * @callback CallbackNormalErrorCache
- * @param {(Error | null)=} err
- * @param {T=} result
- * @returns {void}
- */
-declare class MultiItemCache {
+    get<T>(identifier: string, etag: Etag | null, callback: CallbackCache<T>): void;
     /**
-     * @param {ItemCacheFacade[]} items item caches
+     * @param identifier the cache identifier
+     * @param etag the etag
+     * @returns promise with the data
      */
-    constructor(items: ItemCacheFacade[]);
-    _items: ItemCacheFacade[];
+    getPromise<T>(identifier: string, etag: Etag | null): Promise<T | undefined>;
     /**
-     * @template T
-     * @param {CallbackCache<T>} callback signals when the value is retrieved
-     * @returns {void}
+     * @param identifier the cache identifier
+     * @param etag the etag
+     * @param data the value to store
+     * @param callback signals when the value is stored
+     * @returns
      */
-    get<T>(callback: CallbackCache<T>): void;
+    store<T>(identifier: string, etag: Etag | null, data: T, callback: CallbackCache<void>): void;
     /**
-     * @template T
-     * @returns {Promise<T>} promise with the data
+     * @param identifier the cache identifier
+     * @param etag the etag
+     * @param data the value to store
+     * @returns promise signals when the value is stored
      */
-    getPromise<T_1>(): Promise<T_1>;
+    storePromise<T>(identifier: string, etag: Etag | null, data: T): Promise<void>;
     /**
-     * @template T
-     * @param {T} data the value to store
-     * @param {CallbackCache<void>} callback signals when the value is stored
-     * @returns {void}
+     * @param identifier the cache identifier
+     * @param etag the etag
+     * @param computer function to compute the value if not cached
+     * @param callback signals when the value is retrieved
+     * @returns
      */
-    store<T_2>(data: T_2, callback: CallbackCache<void>): void;
+    provide<T>(identifier: string, etag: Etag | null, computer: (callback: CallbackNormalErrorCache<T>) => void, callback: CallbackNormalErrorCache<T>): void;
     /**
-     * @template T
-     * @param {T} data the value to store
-     * @returns {Promise<void>} promise signals when the value is stored
+     * @param identifier the cache identifier
+     * @param etag the etag
+     * @param computer function to compute the value if not cached
+     * @returns promise with the data
      */
-    storePromise<T_3>(data: T_3): Promise<void>;
+    providePromise<T>(identifier: string, etag: Etag | null, computer: () => Promise<T> | T): Promise<{} | T | null>;
 }
-type WebpackError = import("./WebpackError");
+export default CacheFacade;