cachimbo 0.0.4 → 0.0.5

package/dist/index.js

@@ -214,61 +214,61 @@ 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");
 		}
 	}
@@ -387,6 +387,56 @@ var WeakCache = class extends BaseLocalCache {
 	}
 };
 
+//#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
 /**
@@ -987,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 || "";
@@ -1340,5 +1390,5 @@ var MetricsCollectingCache = class {
 };
 
 //#endregion
-export { AsyncLazyCache, BaseCache, BaseLocalCache, CoalescingCache, IORedisCache, JitteringCache, KeyTransformingCache, KeyvCache, LocalLRUCache, LocalMapCache, LocalTTLCache, MemJSCache, MemcacheCache, MetricsCollectingCache, NoOpCache, RedisCache, SWRCache, TieredCache, ValkeyGlideCache, WeakCache, 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