cachimbo 0.0.3 → 0.0.5

package/dist/index.js

@@ -46,21 +46,18 @@ var BaseLocalCache = class extends BaseCache {
 	disposeListeners = [];
 	/**
 	* Reads cached resources by their keys. (synchronous version)
-	* @protected
 	*/
 	_getMany(keys) {
 		return Object.fromEntries(keys.map((key) => [key, this._get(key)]));
 	}
 	/**
 	* Writes resources into cache. (synchronous version)
-	* @protected
 	*/
 	_setMany(data, options) {
 		for (const [key, value] of Object.entries(data)) this._set(key, value, options);
 	}
 	/**
 	* Deletes many cached resources by their keys. (synchronous version)
-	* @protected
 	*/
 	_deleteMany(keys) {
 		for (const key of keys) this._delete(key);
@@ -69,29 +66,41 @@ var BaseLocalCache = class extends BaseCache {
 	* Adds a listener that will be called when a cached item is disposed.
 	*
 	* @param listener The listener function to add.
-	* @protected
 	*/
 	_addDisposeListener(listener) {
 		this.disposeListeners.push(listener);
 	}
+	/**
+	* Gets access to the internal synchronous methods.
+	* @experimental
+	*/
+	get internal() {
+		return this;
+	}
+	/** @sealed **/
 	get(key) {
 		return Promise.resolve(this._get(key));
 	}
+	/** @sealed **/
 	set(key, value, options) {
 		this._set(key, value, options);
 		return Promise.resolve();
 	}
+	/** @sealed **/
 	delete(key) {
 		this._delete(key);
 		return Promise.resolve();
 	}
+	/** @sealed **/
 	getMany(keys) {
 		return Promise.resolve(this._getMany(keys));
 	}
+	/** @sealed **/
 	setMany(data, options) {
 		this._setMany(data, options);
 		return Promise.resolve();
 	}
+	/** @sealed **/
 	deleteMany(keys) {
 		this._deleteMany(keys);
 		return Promise.resolve();
@@ -205,66 +214,229 @@ var LocalTTLCache = class extends BaseLocalCache {
 * Once the limit of items is reached, the first inserted keys will be purged.
 */
 var LocalMapCache = class extends BaseLocalCache {
-	cache;
+	map;
 	max;
 	constructor(options = {}) {
 		super(options);
-		this.cache = options.cache ?? /* @__PURE__ */ new Map();
+		this.map = options.map ?? /* @__PURE__ */ new Map();
 		this.max = options.max ?? Infinity;
 	}
 	/** @internal */
 	_get(key) {
 		this.logger?.debug(this.name, "[get]", "key =", key);
-		const data = this.cache.get(key);
+		const data = this.map.get(key);
 		return data === void 0 ? null : data;
 	}
 	/** @internal */
 	_set(key, value, options) {
 		this.logger?.debug(this.name, "[set]", "key =", key);
-		const previousValue = this.cache.get(key);
-		if (this.cache.size >= this.max && previousValue === void 0) this.evict(1);
-		this.cache.set(key, value);
+		const previousValue = this.map.get(key);
+		if (this.map.size >= this.max && previousValue === void 0) this.evict(1);
+		this.map.set(key, value);
 		this.onDispose(key, previousValue, "set");
 	}
 	/** @internal */
 	_delete(key) {
 		this.logger?.debug(this.name, "[delete]", "key =", key);
-		const previousValue = this.cache.get(key);
-		this.cache.delete(key);
+		const previousValue = this.map.get(key);
+		this.map.delete(key);
 		this.onDispose(key, previousValue, "delete");
 	}
 	async setMany(data, options) {
 		this.logger?.debug(this.name, "[setMany]", "data =", data);
 		const entries = Object.entries(data);
-		const newEntries = entries.filter(([key]) => !this.cache.has(key)).length;
-		if (this.cache.size + newEntries > this.max) this.evict(this.cache.size + newEntries - this.max);
+		const newEntries = entries.filter(([key]) => !this.map.has(key)).length;
+		if (this.map.size + newEntries > this.max) this.evict(this.map.size + newEntries - this.max);
 		for (const [key, value] of entries) {
-			const previousValue = this.cache.get(key);
-			this.cache.set(key, value);
+			const previousValue = this.map.get(key);
+			this.map.set(key, value);
 			this.onDispose(key, previousValue, "set");
 		}
 	}
 	clear() {
 		this.logger?.debug(this.name, "[clear]");
-		for (const key of this.cache.keys()) this.onDispose(key, this.cache.get(key), "delete");
-		this.cache.clear();
+		for (const key of this.map.keys()) this.onDispose(key, this.map.get(key), "delete");
+		this.map.clear();
 	}
 	onDispose(key, value, reason) {
 		if (value !== void 0) super.onDispose(key, value, reason);
 	}
 	evict(length) {
-		const keys = this.cache.keys();
+		const keys = this.map.keys();
 		for (let i = 0; i < length; i++) {
 			const key = keys.next();
 			if (key.done) break;
 			this.logger?.debug(this.name, "[evict]", "key = ", key);
-			const previousValue = this.cache.get(key.value);
-			this.cache.delete(key.value);
+			const previousValue = this.map.get(key.value);
+			this.map.delete(key.value);
 			this.onDispose(key.value, previousValue, "evict");
 		}
 	}
 };
 
+//#endregion
+//#region src/local/weak/index.ts
+/**
+* A cache layer that stores objects as weak references.
+*
+* When an object is garbage collected, its entry is automatically removed from the underlying cache.
+*
+* This implementation requires support for both `WeakRef` and `FinalizationRegistry`.
+*
+* @see https://caniuse.com/mdn-javascript_builtins_finalizationregistry
+* @see https://caniuse.com/mdn-javascript_builtins_weakref
+*/
+var WeakCache = class extends BaseLocalCache {
+	cache;
+	cacheInternal;
+	registry;
+	constructor(options) {
+		super(options);
+		this.cache = options.cache;
+		this.cacheInternal = options.cache.internal;
+		this.cacheInternal._addDisposeListener(this.onCacheDispose);
+		this.registry = new FinalizationRegistry(this.onGarbageCollect);
+	}
+	onGarbageCollect = (key) => this.cacheInternal._delete(key);
+	onCacheDispose = (key, value, reason) => {
+		this.unregister(value);
+		this.onDispose(key, this.unwrap(value), reason);
+	};
+	/** @internal */
+	_get(key) {
+		return this.unwrap(this.cacheInternal._get(key));
+	}
+	/** @internal */
+	_set(key, value, options) {
+		this.cacheInternal._set(key, this.wrapAndRegister(key, value), options);
+	}
+	/** @internal */
+	_delete(key) {
+		this.unregisterByKey(key);
+		this.cacheInternal._delete(key);
+	}
+	/** @internal */
+	_getMany(keys) {
+		const data = this.cacheInternal._getMany(keys);
+		for (const key of keys) data[key] = this.unwrap(data[key]);
+		return data;
+	}
+	/** @internal */
+	_setMany(data, options) {
+		Object.keys(data).forEach((key) => this.unregisterByKey(key));
+		const wrappedData = {};
+		for (const [key, value] of Object.entries(data)) wrappedData[key] = this.wrapAndRegister(key, value);
+		this.cacheInternal._setMany(wrappedData, options);
+	}
+	/** @internal */
+	_deleteMany(keys) {
+		keys.forEach((key) => this.unregisterByKey(key));
+		this.cacheInternal._deleteMany(keys);
+	}
+	async getOrLoad(key, load, options) {
+		const wrappedLoad = async () => this.wrapAndRegister(key, await load());
+		return this.unwrap(await this.cache.getOrLoad(key, wrappedLoad, options));
+	}
+	/**
+	* Wraps the value in a WeakRef and registers it in the FinalizationRegistry if it's an object.
+	*
+	* @param key The key to reference the value in the FinalizationRegistry
+	* @param value The value to wrap
+	* @returns The wrapped value
+	*/
+	wrapAndRegister(key, value) {
+		this.unregisterByKey(key);
+		if (value !== null && typeof value === "object") {
+			this.registry.register(value, key);
+			return {
+				v: new WeakRef(value),
+				w: true
+			};
+		}
+		return {
+			v: value,
+			w: false
+		};
+	}
+	/**
+	* Unwraps the value from a WeakRef if it's an object.
+	*
+	* @param data The data to unwrap
+	* @returns The unwrapped value
+	*/
+	unwrap(data) {
+		if (data === null) return null;
+		if (data.w) return data.v.deref() ?? null;
+		return data.v;
+	}
+	/**
+	* Unregisters the value from the FinalizationRegistry if it's an object.
+	*
+	* @param value The value to unregister
+	*/
+	unregister(value) {
+		if (value && value.w) this.registry.unregister(value.v);
+	}
+	/**
+	* Unregisters the value associated with the given key from the FinalizationRegistry.
+	*
+	* @param key The key
+	*/
+	unregisterByKey(key) {
+		this.unregister(this.cacheInternal._get(key));
+	}
+};
+
+//#endregion
+//#region src/local/cloning/index.ts
+/**
+* A cache layer that deep clones data when reading and writing.
+*
+* This is useful when you mutate the objects retrieved from cache,
+* and you don't want them to also change in cache.
+*
+* Do not use this layer if you do not intend to mutate cached objects,
+* as the cloning process adds unnecessary overhead.
+*/
+var DeepCloningCache = class extends BaseLocalCache {
+	cache;
+	cacheInternal;
+	deepClone;
+	constructor(options) {
+		super(options);
+		this.cache = options.cache;
+		this.cacheInternal = options.cache.internal;
+		if (options.deepClone) this.deepClone = options.deepClone;
+		else if (typeof structuredClone === "function") this.deepClone = structuredClone;
+		else this.deepClone = (data) => JSON.parse(JSON.stringify(data));
+	}
+	_get(key) {
+		return this.deepClone(this.cacheInternal._get(key));
+	}
+	_set(key, value, options) {
+		this.cacheInternal._set(key, this.deepClone(value), options);
+	}
+	_delete(key) {
+		this.cacheInternal._delete(key);
+	}
+	_getMany(keys) {
+		return this.deepClone(this.cacheInternal._getMany(keys));
+	}
+	_setMany(data, options) {
+		this.cacheInternal._setMany(this.deepClone(data), options);
+	}
+	_deleteMany(keys) {
+		this.cacheInternal._deleteMany(keys);
+	}
+	_addDisposeListener(listener) {
+		this.cacheInternal._addDisposeListener(listener);
+	}
+	async getOrLoad(key, load, options) {
+		const loadWrapped = async () => this.deepClone(await load());
+		return this.deepClone(await this.cache.getOrLoad(key, loadWrapped, options));
+	}
+};
+
 //#endregion
 //#region src/local/noop/index.ts
 /**
@@ -568,7 +740,10 @@ var WorkersKVCache = class extends BaseCache {
 		return this.kv.delete(key);
 	}
 	async getMany(keys) {
-		const data = await this.kv.get(keys, { type: "json" });
+		const data = await this.kv.get(keys, {
+			type: "json",
+			cacheTtl: this.edgeCacheTTL
+		});
 		return Object.fromEntries(data);
 	}
 };
@@ -862,7 +1037,7 @@ var KeyTransformingCache = class {
 	transform;
 	constructor(options) {
 		this.cache = options.cache;
-		if ("transform" in options) this.transform = options.transform;
+		if ("transform" in options && typeof options.transform === "function") this.transform = options.transform;
 		else {
 			const prefix = options.prefix || "";
 			const suffix = options.suffix || "";
@@ -1215,5 +1390,5 @@ var MetricsCollectingCache = class {
 };
 
 //#endregion
-export { AsyncLazyCache, BaseCache, CoalescingCache, IORedisCache, JitteringCache, KeyTransformingCache, KeyvCache, LocalLRUCache, LocalMapCache, LocalTTLCache, MemJSCache, MemcacheCache, MetricsCollectingCache, NoOpCache, RedisCache, SWRCache, TieredCache, ValkeyGlideCache, WorkersKVCache };
+export { AsyncLazyCache, BaseCache, BaseLocalCache, CoalescingCache, DeepCloningCache, IORedisCache, JitteringCache, KeyTransformingCache, KeyvCache, LocalLRUCache, LocalMapCache, LocalTTLCache, MemJSCache, MemcacheCache, MetricsCollectingCache, NoOpCache, RedisCache, SWRCache, TieredCache, ValkeyGlideCache, WeakCache, WorkersKVCache };
 //# sourceMappingURL=index.js.map