@ls-stack/utils 2.6.0 → 2.7.0

package/dist/cache.cjs

@@ -0,0 +1,125 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cache.ts
+var cache_exports = {};
+__export(cache_exports, {
+  cachedGetter: () => cachedGetter,
+  createCache: () => createCache
+});
+module.exports = __toCommonJS(cache_exports);
+
+// src/assertions.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPromise(value) {
+  return isObject(value) && "then" in value;
+}
+
+// src/cache.ts
+function cachedGetter(getter) {
+  return {
+    get value() {
+      const value = getter();
+      Object.defineProperty(this, "value", { value });
+      return value;
+    }
+  };
+}
+function createCache({
+  maxCacheSize = 1e3,
+  maxItemAge,
+  expirationThrottle = 1e4
+} = {}) {
+  const cache = /* @__PURE__ */ new Map();
+  let lastExpirationCheck = 0;
+  function checkExpiredItems() {
+    const now = Date.now();
+    if (!maxItemAge || now - lastExpirationCheck < expirationThrottle) return;
+    lastExpirationCheck = now;
+    const maxAgeMs = maxItemAge * 1e3;
+    for (const [key, item] of cache.entries()) {
+      if (now - item.timestamp > maxAgeMs) {
+        cache.delete(key);
+      }
+    }
+  }
+  function trimToSize() {
+    const currentSize = cache.size;
+    if (currentSize > maxCacheSize) {
+      const keysToRemove = currentSize - maxCacheSize;
+      const iterator = cache.keys();
+      for (let i = 0; i < keysToRemove; i++) {
+        const { value: key } = iterator.next();
+        if (key) {
+          cache.delete(key);
+        }
+      }
+    }
+  }
+  function isExpired(timestamp, now) {
+    return maxItemAge !== void 0 && now - timestamp > maxItemAge * 1e3;
+  }
+  function getOrInsert(cacheKey, val) {
+    const now = Date.now();
+    const entry = cache.get(cacheKey);
+    if (!entry || isExpired(entry.timestamp, now)) {
+      const value = val();
+      cache.set(cacheKey, { value, timestamp: now });
+      trimToSize();
+      checkExpiredItems();
+      return value;
+    }
+    return entry.value;
+  }
+  async function getOrInsertAsync(cacheKey, val) {
+    const entry = cache.get(cacheKey);
+    if (entry && isPromise(entry.value)) {
+      return entry.value;
+    }
+    const now = Date.now();
+    if (entry && !isExpired(entry.timestamp, now)) {
+      return entry.value;
+    }
+    const promise = val().then((result) => {
+      cache.set(cacheKey, { value: result, timestamp: Date.now() });
+      return result;
+    }).catch((error) => {
+      cache.delete(cacheKey);
+      throw error;
+    });
+    cache.set(cacheKey, { value: promise, timestamp: now });
+    trimToSize();
+    checkExpiredItems();
+    return promise;
+  }
+  return {
+    getOrInsert,
+    getOrInsertAsync,
+    clear: () => cache.clear(),
+    /** @internal */
+    "~cache": cache
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cachedGetter,
+  createCache
+});

package/dist/cache.d.cts

@@ -0,0 +1,31 @@
+declare function cachedGetter<T>(getter: () => T): {
+    value: T;
+};
+type Options = {
+    /**
+     * The maximum number of items in the cache.
+     * @default 1000
+     */
+    maxCacheSize?: number;
+    /**
+     * The maximum age of items in the cache in seconds.
+     */
+    maxItemAge?: number;
+    /**
+     * The maximum number of items to check for expiration in a single call.
+     * @default 10_000
+     */
+    expirationThrottle?: number;
+};
+declare function createCache({ maxCacheSize, maxItemAge, expirationThrottle, }?: Options): {
+    getOrInsert: <T>(cacheKey: string, val: () => T) => T;
+    getOrInsertAsync: <T>(cacheKey: string, val: () => Promise<T>) => Promise<T>;
+    clear: () => void;
+    /** @internal */
+    '~cache': Map<string, {
+        value: unknown;
+        timestamp: number;
+    }>;
+};
+
+export { cachedGetter, createCache };

package/dist/cache.d.ts

@@ -0,0 +1,31 @@
+declare function cachedGetter<T>(getter: () => T): {
+    value: T;
+};
+type Options = {
+    /**
+     * The maximum number of items in the cache.
+     * @default 1000
+     */
+    maxCacheSize?: number;
+    /**
+     * The maximum age of items in the cache in seconds.
+     */
+    maxItemAge?: number;
+    /**
+     * The maximum number of items to check for expiration in a single call.
+     * @default 10_000
+     */
+    expirationThrottle?: number;
+};
+declare function createCache({ maxCacheSize, maxItemAge, expirationThrottle, }?: Options): {
+    getOrInsert: <T>(cacheKey: string, val: () => T) => T;
+    getOrInsertAsync: <T>(cacheKey: string, val: () => Promise<T>) => Promise<T>;
+    clear: () => void;
+    /** @internal */
+    '~cache': Map<string, {
+        value: unknown;
+        timestamp: number;
+    }>;
+};
+
+export { cachedGetter, createCache };

package/dist/cache.js

@@ -0,0 +1,93 @@
+import {
+  isPromise
+} from "./chunk-4UGSP3L3.js";
+
+// src/cache.ts
+function cachedGetter(getter) {
+  return {
+    get value() {
+      const value = getter();
+      Object.defineProperty(this, "value", { value });
+      return value;
+    }
+  };
+}
+function createCache({
+  maxCacheSize = 1e3,
+  maxItemAge,
+  expirationThrottle = 1e4
+} = {}) {
+  const cache = /* @__PURE__ */ new Map();
+  let lastExpirationCheck = 0;
+  function checkExpiredItems() {
+    const now = Date.now();
+    if (!maxItemAge || now - lastExpirationCheck < expirationThrottle) return;
+    lastExpirationCheck = now;
+    const maxAgeMs = maxItemAge * 1e3;
+    for (const [key, item] of cache.entries()) {
+      if (now - item.timestamp > maxAgeMs) {
+        cache.delete(key);
+      }
+    }
+  }
+  function trimToSize() {
+    const currentSize = cache.size;
+    if (currentSize > maxCacheSize) {
+      const keysToRemove = currentSize - maxCacheSize;
+      const iterator = cache.keys();
+      for (let i = 0; i < keysToRemove; i++) {
+        const { value: key } = iterator.next();
+        if (key) {
+          cache.delete(key);
+        }
+      }
+    }
+  }
+  function isExpired(timestamp, now) {
+    return maxItemAge !== void 0 && now - timestamp > maxItemAge * 1e3;
+  }
+  function getOrInsert(cacheKey, val) {
+    const now = Date.now();
+    const entry = cache.get(cacheKey);
+    if (!entry || isExpired(entry.timestamp, now)) {
+      const value = val();
+      cache.set(cacheKey, { value, timestamp: now });
+      trimToSize();
+      checkExpiredItems();
+      return value;
+    }
+    return entry.value;
+  }
+  async function getOrInsertAsync(cacheKey, val) {
+    const entry = cache.get(cacheKey);
+    if (entry && isPromise(entry.value)) {
+      return entry.value;
+    }
+    const now = Date.now();
+    if (entry && !isExpired(entry.timestamp, now)) {
+      return entry.value;
+    }
+    const promise = val().then((result) => {
+      cache.set(cacheKey, { value: result, timestamp: Date.now() });
+      return result;
+    }).catch((error) => {
+      cache.delete(cacheKey);
+      throw error;
+    });
+    cache.set(cacheKey, { value: promise, timestamp: now });
+    trimToSize();
+    checkExpiredItems();
+    return promise;
+  }
+  return {
+    getOrInsert,
+    getOrInsertAsync,
+    clear: () => cache.clear(),
+    /** @internal */
+    "~cache": cache
+  };
+}
+export {
+  cachedGetter,
+  createCache
+};

package/dist/main.d.ts

@@ -1,5 +1,6 @@
 ///<reference path="arrayUtils.d.ts" />
 ///<reference path="assertions.d.ts" />
+///<reference path="cache.d.ts" />
 ///<reference path="castValues.d.ts" />
 ///<reference path="consoleFmt.d.ts" />
 ///<reference path="conversions.d.ts" />

package/dist/parallelAsyncCalls.js

@@ -1,11 +1,11 @@
+import {
+  sleep
+} from "./chunk-5DZT3Z5Z.js";
 import {
   Result,
   unknownToError
 } from "./chunk-KBFP7INB.js";
 import "./chunk-VAAMRG4K.js";
-import {
-  sleep
-} from "./chunk-5DZT3Z5Z.js";
 import {
   invariant,
   isObject

package/dist/testUtils.js

@@ -1,13 +1,13 @@
+import {
+  omit,
+  pick
+} from "./chunk-ZE3DLPMN.js";
 import {
   deepEqual
 } from "./chunk-JQFUKJU5.js";
 import {
   clampMin
 } from "./chunk-HTCYUMDR.js";
-import {
-  omit,
-  pick
-} from "./chunk-ZE3DLPMN.js";
 import {
   arrayWithPrevAndIndex,
   filterAndMap

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ls-stack/utils",
   "description": "Typescript utils",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "license": "MIT",
   "files": [
     "dist"
@@ -29,6 +29,11 @@
       "types": "./dist/assertions.d.ts",
       "require": "./dist/assertions.cjs"
     },
+    "./cache": {
+      "import": "./dist/cache.js",
+      "types": "./dist/cache.d.ts",
+      "require": "./dist/cache.cjs"
+    },
     "./castValues": {
       "import": "./dist/castValues.js",
       "types": "./dist/castValues.d.ts",
@@ -208,6 +213,9 @@
       "assertions": [
         "./dist/assertions.d.ts"
       ],
+      "cache": [
+        "./dist/cache.d.ts"
+      ],
       "castValues": [
         "./dist/castValues.d.ts"
       ],