@lukaskj/ts-utils 1.0.2 → 1.0.3

package/README.md

@@ -20,6 +20,7 @@ bun add @lukaskj/ts-utils
 ```
 
 ## Features
+Documentation folder: [docs/](docs/)
 
 ### Error Handling
 

package/dist/cache/cacheService.d.ts

@@ -0,0 +1,19 @@
+import type { CacheMetadataOptions, CacheOptions, ValueLoader } from "./internal/types.ts";
+import type { ICacheAdapter } from "./types.ts";
+export declare class Cache<TAdapter extends ICacheAdapter | undefined = undefined> {
+    private inMemoryCache;
+    private readonly options;
+    private readonly adapter?;
+    constructor(defaultOptions?: Partial<CacheOptions>);
+    constructor(adapter?: TAdapter, defaultOptions?: Partial<CacheOptions>);
+    private getFromAdapter;
+    private saveToAdapter;
+    get<T>(cacheKey: string, valueLoader?: ValueLoader<T>, options?: Partial<CacheMetadataOptions>): Promise<T | undefined>;
+    private mergeOptions;
+    private tryGetFromMemory;
+    private tryGetFromAdapter;
+    private tryGetFromValueLoader;
+    private cacheValue;
+    private createCacheEntry;
+    private isExpired;
+}

package/dist/cache/constants.d.ts

@@ -0,0 +1 @@
+export declare const CACHE_TTL_NEVER_EXPIRE = -1;

package/dist/cache/index.cjs

@@ -0,0 +1,182 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/cache/index.ts
+var exports_cache = {};
+__export(exports_cache, {
+  Cache: () => Cache,
+  CACHE_TTL_NEVER_EXPIRE: () => CACHE_TTL_NEVER_EXPIRE
+});
+module.exports = __toCommonJS(exports_cache);
+
+// src/cache/cacheService.ts
+var import_types = require("node:util/types");
+
+// src/utils/isCallable.ts
+function isCallable(value) {
+  return typeof value === "function";
+}
+
+// src/cache/cacheService.ts
+var defaultCacheOptions = {
+  expirationThresholdMs: 0,
+  ttlMs: 60 * 60 * 1000
+};
+
+class Cache {
+  inMemoryCache = new Map;
+  options;
+  adapter;
+  constructor(adapter, defaultOptions) {
+    const options = adapter && !("getValue" in adapter) ? adapter : defaultOptions;
+    if (adapter && "getValue" in adapter && "setValue" in adapter) {
+      this.adapter = adapter;
+    }
+    this.options = {
+      ...defaultCacheOptions,
+      ...options
+    };
+  }
+  async getFromAdapter(cacheKey) {
+    if (!this.adapter) {
+      return;
+    }
+    return this.adapter.getValue(cacheKey);
+  }
+  async saveToAdapter(cacheKey, value) {
+    if (!this.adapter) {
+      return;
+    }
+    return this.adapter.setValue(cacheKey, value);
+  }
+  async get(cacheKey, valueLoader, options = {}) {
+    const mergedOptions = this.mergeOptions(options);
+    const cachedValue = this.tryGetFromMemory(cacheKey);
+    if (cachedValue !== undefined) {
+      return cachedValue;
+    }
+    const freshValue = await this.tryGetFromValueLoader(valueLoader);
+    if (freshValue !== undefined) {
+      await this.cacheValue(cacheKey, freshValue, mergedOptions);
+      return freshValue;
+    }
+    const adapterValue = await this.tryGetFromAdapter(cacheKey);
+    if (adapterValue !== undefined) {
+      await this.cacheValue(cacheKey, adapterValue, mergedOptions);
+      return adapterValue;
+    }
+  }
+  mergeOptions(options) {
+    return {
+      ttlMs: this.options.ttlMs,
+      expirationThresholdMs: this.options.expirationThresholdMs,
+      ...options
+    };
+  }
+  tryGetFromMemory(cacheKey) {
+    const cached = this.inMemoryCache.get(cacheKey);
+    if (cached && !this.isExpired(cached.metadata)) {
+      return cached.data;
+    }
+    return;
+  }
+  async tryGetFromAdapter(cacheKey) {
+    const cached = await this.getFromAdapter(cacheKey);
+    if (cached && !this.isExpired(cached.metadata)) {
+      this.inMemoryCache.set(cacheKey, cached);
+      return cached.data;
+    }
+    return;
+  }
+  async tryGetFromValueLoader(valueLoader) {
+    if (valueLoader === undefined) {
+      return;
+    }
+    if (isCallable(valueLoader)) {
+      return await valueLoader();
+    }
+    if (import_types.isPromise(valueLoader)) {
+      return await valueLoader;
+    }
+    return valueLoader;
+  }
+  async cacheValue(cacheKey, value, options) {
+    const cacheData = this.createCacheEntry(value, options);
+    await this.saveToAdapter(cacheKey, cacheData);
+    this.inMemoryCache.set(cacheKey, cacheData);
+  }
+  createCacheEntry(value, options) {
+    const now = Date.now();
+    let expiresAt;
+    if (options.ttlMs < 0) {
+      expiresAt = -1;
+    } else {
+      expiresAt = now + options.ttlMs - options.expirationThresholdMs;
+    }
+    return {
+      data: value,
+      metadata: {
+        createdAt: now,
+        ttlMs: options.ttlMs,
+        expirationThresholdMs: options.expirationThresholdMs,
+        expiresAt
+      }
+    };
+  }
+  isExpired(metadata) {
+    if (!metadata) {
+      return true;
+    }
+    if (metadata.expiresAt < 0) {
+      return false;
+    }
+    const expirationTime = metadata.expiresAt ?? (metadata.createdAt && metadata.ttlMs ? metadata.createdAt + metadata.ttlMs : undefined);
+    if (expirationTime === undefined) {
+      return true;
+    }
+    return Date.now() > expirationTime;
+  }
+}
+// src/cache/constants.ts
+var CACHE_TTL_NEVER_EXPIRE = -1;
+
+//# debugId=F6FFA1F34A10A7B264756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/cache/cacheService.ts", "../src/utils/isCallable.ts", "../src/cache/constants.ts"],
  "sourcesContent": [
    "import { isPromise } from \"node:util/types\";\nimport { isCallable } from \"../utils/isCallable.ts\";\nimport type { CacheMetadataOptions, CacheOptions, CacheWithMetadata, ValueLoader } from \"./internal/types.ts\";\nimport type { CacheMetadata, ICacheAdapter } from \"./types.ts\";\n\nconst defaultCacheOptions: CacheOptions = {\n  expirationThresholdMs: 0,\n  ttlMs: 60 * 60 * 1000,\n};\n\nexport class Cache<TAdapter extends ICacheAdapter | undefined = undefined> {\n  private inMemoryCache: Map<string, CacheWithMetadata> = new Map();\n  private readonly options: CacheOptions;\n  private readonly adapter?: TAdapter;\n\n  constructor(defaultOptions?: Partial<CacheOptions>);\n  constructor(adapter?: TAdapter, defaultOptions?: Partial<CacheOptions>);\n  constructor(adapter?: TAdapter | Partial<CacheOptions>, defaultOptions?: Partial<CacheOptions>) {\n    const options = adapter && !(\"getValue\" in adapter) ? (adapter as Partial<CacheOptions>) : defaultOptions;\n    if (adapter && \"getValue\" in adapter && \"setValue\" in adapter) {\n      this.adapter = adapter as TAdapter;\n    }\n\n    this.options = {\n      ...defaultCacheOptions,\n      ...options,\n    };\n  }\n\n  private async getFromAdapter<T>(cacheKey: string): Promise<T | undefined> {\n    if (!this.adapter) {\n      return undefined;\n    }\n\n    return this.adapter.getValue(cacheKey);\n  }\n\n  private async saveToAdapter<T>(cacheKey: string, value: T): Promise<void> {\n    if (!this.adapter) {\n      return;\n    }\n\n    return this.adapter.setValue<T>(cacheKey, value);\n  }\n\n  public async get<T>(\n    cacheKey: string,\n    valueLoader?: ValueLoader<T>,\n    options: Partial<CacheMetadataOptions> = {},\n  ): Promise<T | undefined> {\n    const mergedOptions = this.mergeOptions(options);\n\n    // Try in-memory cache first\n    const cachedValue = this.tryGetFromMemory<T>(cacheKey);\n    if (cachedValue !== undefined) {\n      return cachedValue;\n    }\n\n    // Load fresh value from loader function first\n    const freshValue = await this.tryGetFromValueLoader(valueLoader);\n    if (freshValue !== undefined) {\n      await this.cacheValue(cacheKey, freshValue, mergedOptions);\n\n      return freshValue;\n    }\n\n    // Try adapter cache second\n    const adapterValue = await this.tryGetFromAdapter<T>(cacheKey);\n    if (adapterValue !== undefined) {\n      await this.cacheValue(cacheKey, adapterValue, mergedOptions);\n\n      return adapterValue;\n    }\n  }\n\n  private mergeOptions(options: Partial<CacheMetadataOptions>): CacheMetadataOptions {\n    return {\n      ttlMs: this.options.ttlMs,\n      expirationThresholdMs: this.options.expirationThresholdMs,\n      ...options,\n    };\n  }\n\n  private tryGetFromMemory<T>(cacheKey: string): T | undefined {\n    const cached = this.inMemoryCache.get(cacheKey);\n\n    if (cached && !this.isExpired(cached.metadata)) {\n      return cached.data as T;\n    }\n\n    return undefined;\n  }\n\n  private async tryGetFromAdapter<T>(cacheKey: string): Promise<T | undefined> {\n    const cached = await this.getFromAdapter<CacheWithMetadata<T>>(cacheKey);\n\n    if (cached && !this.isExpired(cached.metadata)) {\n      this.inMemoryCache.set(cacheKey, cached);\n      return cached.data;\n    }\n\n    return undefined;\n  }\n\n  private async tryGetFromValueLoader<T>(valueLoader?: ValueLoader<T>): Promise<T | undefined> {\n    if (valueLoader === undefined) {\n      return undefined;\n    }\n\n    if (isCallable(valueLoader)) {\n      return await valueLoader();\n    }\n\n    if (isPromise(valueLoader)) {\n      return await valueLoader;\n    }\n\n    return valueLoader;\n  }\n\n  private async cacheValue<T>(cacheKey: string, value: T, options: CacheMetadataOptions): Promise<void> {\n    const cacheData = this.createCacheEntry(value, options);\n\n    await this.saveToAdapter(cacheKey, cacheData);\n    this.inMemoryCache.set(cacheKey, cacheData);\n  }\n\n  private createCacheEntry<T>(value: T, options: CacheMetadataOptions): CacheWithMetadata<T> {\n    const now = Date.now();\n    let expiresAt: number;\n    if (options.ttlMs < 0) {\n      expiresAt = -1;\n    } else {\n      expiresAt = now + options.ttlMs - options.expirationThresholdMs;\n    }\n\n    return {\n      data: value,\n      metadata: {\n        createdAt: now,\n        ttlMs: options.ttlMs,\n        expirationThresholdMs: options.expirationThresholdMs,\n        expiresAt,\n      },\n    };\n  }\n\n  private isExpired(metadata?: CacheMetadata): boolean {\n    if (!metadata) {\n      return true;\n    }\n\n    if (metadata.expiresAt < 0) {\n      return false;\n    }\n\n    const expirationTime =\n      metadata.expiresAt ?? (metadata.createdAt && metadata.ttlMs ? metadata.createdAt + metadata.ttlMs : undefined);\n\n    if (expirationTime === undefined) {\n      return true;\n    }\n\n    return Date.now() > expirationTime;\n  }\n}\n",
    "export function isCallable(value: any): value is CallableFunction {\n  return typeof value === \"function\";\n}\n",
    "export const CACHE_TTL_NEVER_EXPIRE = -1;\n"
  ],
  "mappings": "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",
  "debugId": "F6FFA1F34A10A7B264756E2164756E21",
  "names": []
}

package/dist/cache/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./cacheService.ts";
+export * from "./constants.ts";
+export type * from "./types.ts";

package/dist/cache/index.mjs

@@ -0,0 +1,137 @@
+// src/cache/cacheService.ts
+import { isPromise } from "node:util/types";
+
+// src/utils/isCallable.ts
+function isCallable(value) {
+  return typeof value === "function";
+}
+
+// src/cache/cacheService.ts
+var defaultCacheOptions = {
+  expirationThresholdMs: 0,
+  ttlMs: 60 * 60 * 1000
+};
+
+class Cache {
+  inMemoryCache = new Map;
+  options;
+  adapter;
+  constructor(adapter, defaultOptions) {
+    const options = adapter && !("getValue" in adapter) ? adapter : defaultOptions;
+    if (adapter && "getValue" in adapter && "setValue" in adapter) {
+      this.adapter = adapter;
+    }
+    this.options = {
+      ...defaultCacheOptions,
+      ...options
+    };
+  }
+  async getFromAdapter(cacheKey) {
+    if (!this.adapter) {
+      return;
+    }
+    return this.adapter.getValue(cacheKey);
+  }
+  async saveToAdapter(cacheKey, value) {
+    if (!this.adapter) {
+      return;
+    }
+    return this.adapter.setValue(cacheKey, value);
+  }
+  async get(cacheKey, valueLoader, options = {}) {
+    const mergedOptions = this.mergeOptions(options);
+    const cachedValue = this.tryGetFromMemory(cacheKey);
+    if (cachedValue !== undefined) {
+      return cachedValue;
+    }
+    const freshValue = await this.tryGetFromValueLoader(valueLoader);
+    if (freshValue !== undefined) {
+      await this.cacheValue(cacheKey, freshValue, mergedOptions);
+      return freshValue;
+    }
+    const adapterValue = await this.tryGetFromAdapter(cacheKey);
+    if (adapterValue !== undefined) {
+      await this.cacheValue(cacheKey, adapterValue, mergedOptions);
+      return adapterValue;
+    }
+  }
+  mergeOptions(options) {
+    return {
+      ttlMs: this.options.ttlMs,
+      expirationThresholdMs: this.options.expirationThresholdMs,
+      ...options
+    };
+  }
+  tryGetFromMemory(cacheKey) {
+    const cached = this.inMemoryCache.get(cacheKey);
+    if (cached && !this.isExpired(cached.metadata)) {
+      return cached.data;
+    }
+    return;
+  }
+  async tryGetFromAdapter(cacheKey) {
+    const cached = await this.getFromAdapter(cacheKey);
+    if (cached && !this.isExpired(cached.metadata)) {
+      this.inMemoryCache.set(cacheKey, cached);
+      return cached.data;
+    }
+    return;
+  }
+  async tryGetFromValueLoader(valueLoader) {
+    if (valueLoader === undefined) {
+      return;
+    }
+    if (isCallable(valueLoader)) {
+      return await valueLoader();
+    }
+    if (isPromise(valueLoader)) {
+      return await valueLoader;
+    }
+    return valueLoader;
+  }
+  async cacheValue(cacheKey, value, options) {
+    const cacheData = this.createCacheEntry(value, options);
+    await this.saveToAdapter(cacheKey, cacheData);
+    this.inMemoryCache.set(cacheKey, cacheData);
+  }
+  createCacheEntry(value, options) {
+    const now = Date.now();
+    let expiresAt;
+    if (options.ttlMs < 0) {
+      expiresAt = -1;
+    } else {
+      expiresAt = now + options.ttlMs - options.expirationThresholdMs;
+    }
+    return {
+      data: value,
+      metadata: {
+        createdAt: now,
+        ttlMs: options.ttlMs,
+        expirationThresholdMs: options.expirationThresholdMs,
+        expiresAt
+      }
+    };
+  }
+  isExpired(metadata) {
+    if (!metadata) {
+      return true;
+    }
+    if (metadata.expiresAt < 0) {
+      return false;
+    }
+    const expirationTime = metadata.expiresAt ?? (metadata.createdAt && metadata.ttlMs ? metadata.createdAt + metadata.ttlMs : undefined);
+    if (expirationTime === undefined) {
+      return true;
+    }
+    return Date.now() > expirationTime;
+  }
+}
+// src/cache/constants.ts
+var CACHE_TTL_NEVER_EXPIRE = -1;
+export {
+  Cache,
+  CACHE_TTL_NEVER_EXPIRE
+};
+
+//# debugId=46944600E0400D9A64756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/cache/cacheService.ts", "../src/utils/isCallable.ts", "../src/cache/constants.ts"],
  "sourcesContent": [
    "import { isPromise } from \"node:util/types\";\nimport { isCallable } from \"../utils/isCallable.ts\";\nimport type { CacheMetadataOptions, CacheOptions, CacheWithMetadata, ValueLoader } from \"./internal/types.ts\";\nimport type { CacheMetadata, ICacheAdapter } from \"./types.ts\";\n\nconst defaultCacheOptions: CacheOptions = {\n  expirationThresholdMs: 0,\n  ttlMs: 60 * 60 * 1000,\n};\n\nexport class Cache<TAdapter extends ICacheAdapter | undefined = undefined> {\n  private inMemoryCache: Map<string, CacheWithMetadata> = new Map();\n  private readonly options: CacheOptions;\n  private readonly adapter?: TAdapter;\n\n  constructor(defaultOptions?: Partial<CacheOptions>);\n  constructor(adapter?: TAdapter, defaultOptions?: Partial<CacheOptions>);\n  constructor(adapter?: TAdapter | Partial<CacheOptions>, defaultOptions?: Partial<CacheOptions>) {\n    const options = adapter && !(\"getValue\" in adapter) ? (adapter as Partial<CacheOptions>) : defaultOptions;\n    if (adapter && \"getValue\" in adapter && \"setValue\" in adapter) {\n      this.adapter = adapter as TAdapter;\n    }\n\n    this.options = {\n      ...defaultCacheOptions,\n      ...options,\n    };\n  }\n\n  private async getFromAdapter<T>(cacheKey: string): Promise<T | undefined> {\n    if (!this.adapter) {\n      return undefined;\n    }\n\n    return this.adapter.getValue(cacheKey);\n  }\n\n  private async saveToAdapter<T>(cacheKey: string, value: T): Promise<void> {\n    if (!this.adapter) {\n      return;\n    }\n\n    return this.adapter.setValue<T>(cacheKey, value);\n  }\n\n  public async get<T>(\n    cacheKey: string,\n    valueLoader?: ValueLoader<T>,\n    options: Partial<CacheMetadataOptions> = {},\n  ): Promise<T | undefined> {\n    const mergedOptions = this.mergeOptions(options);\n\n    // Try in-memory cache first\n    const cachedValue = this.tryGetFromMemory<T>(cacheKey);\n    if (cachedValue !== undefined) {\n      return cachedValue;\n    }\n\n    // Load fresh value from loader function first\n    const freshValue = await this.tryGetFromValueLoader(valueLoader);\n    if (freshValue !== undefined) {\n      await this.cacheValue(cacheKey, freshValue, mergedOptions);\n\n      return freshValue;\n    }\n\n    // Try adapter cache second\n    const adapterValue = await this.tryGetFromAdapter<T>(cacheKey);\n    if (adapterValue !== undefined) {\n      await this.cacheValue(cacheKey, adapterValue, mergedOptions);\n\n      return adapterValue;\n    }\n  }\n\n  private mergeOptions(options: Partial<CacheMetadataOptions>): CacheMetadataOptions {\n    return {\n      ttlMs: this.options.ttlMs,\n      expirationThresholdMs: this.options.expirationThresholdMs,\n      ...options,\n    };\n  }\n\n  private tryGetFromMemory<T>(cacheKey: string): T | undefined {\n    const cached = this.inMemoryCache.get(cacheKey);\n\n    if (cached && !this.isExpired(cached.metadata)) {\n      return cached.data as T;\n    }\n\n    return undefined;\n  }\n\n  private async tryGetFromAdapter<T>(cacheKey: string): Promise<T | undefined> {\n    const cached = await this.getFromAdapter<CacheWithMetadata<T>>(cacheKey);\n\n    if (cached && !this.isExpired(cached.metadata)) {\n      this.inMemoryCache.set(cacheKey, cached);\n      return cached.data;\n    }\n\n    return undefined;\n  }\n\n  private async tryGetFromValueLoader<T>(valueLoader?: ValueLoader<T>): Promise<T | undefined> {\n    if (valueLoader === undefined) {\n      return undefined;\n    }\n\n    if (isCallable(valueLoader)) {\n      return await valueLoader();\n    }\n\n    if (isPromise(valueLoader)) {\n      return await valueLoader;\n    }\n\n    return valueLoader;\n  }\n\n  private async cacheValue<T>(cacheKey: string, value: T, options: CacheMetadataOptions): Promise<void> {\n    const cacheData = this.createCacheEntry(value, options);\n\n    await this.saveToAdapter(cacheKey, cacheData);\n    this.inMemoryCache.set(cacheKey, cacheData);\n  }\n\n  private createCacheEntry<T>(value: T, options: CacheMetadataOptions): CacheWithMetadata<T> {\n    const now = Date.now();\n    let expiresAt: number;\n    if (options.ttlMs < 0) {\n      expiresAt = -1;\n    } else {\n      expiresAt = now + options.ttlMs - options.expirationThresholdMs;\n    }\n\n    return {\n      data: value,\n      metadata: {\n        createdAt: now,\n        ttlMs: options.ttlMs,\n        expirationThresholdMs: options.expirationThresholdMs,\n        expiresAt,\n      },\n    };\n  }\n\n  private isExpired(metadata?: CacheMetadata): boolean {\n    if (!metadata) {\n      return true;\n    }\n\n    if (metadata.expiresAt < 0) {\n      return false;\n    }\n\n    const expirationTime =\n      metadata.expiresAt ?? (metadata.createdAt && metadata.ttlMs ? metadata.createdAt + metadata.ttlMs : undefined);\n\n    if (expirationTime === undefined) {\n      return true;\n    }\n\n    return Date.now() > expirationTime;\n  }\n}\n",
    "export function isCallable(value: any): value is CallableFunction {\n  return typeof value === \"function\";\n}\n",
    "export const CACHE_TTL_NEVER_EXPIRE = -1;\n"
  ],
  "mappings": ";AAAA;;;ACAO,SAAS,UAAU,CAAC,OAAuC;AAAA,EAChE,OAAO,OAAO,UAAU;AAAA;;;ADI1B,IAAM,sBAAoC;AAAA,EACxC,uBAAuB;AAAA,EACvB,OAAO,KAAK,KAAK;AACnB;AAAA;AAEO,MAAM,MAA8D;AAAA,EACjE,gBAAgD,IAAI;AAAA,EAC3C;AAAA,EACA;AAAA,EAIjB,WAAW,CAAC,SAA4C,gBAAwC;AAAA,IAC9F,MAAM,UAAU,WAAW,EAAE,cAAc,WAAY,UAAoC;AAAA,IAC3F,IAAI,WAAW,cAAc,WAAW,cAAc,SAAS;AAAA,MAC7D,KAAK,UAAU;AAAA,IACjB;AAAA,IAEA,KAAK,UAAU;AAAA,SACV;AAAA,SACA;AAAA,IACL;AAAA;AAAA,OAGY,eAAiB,CAAC,UAA0C;AAAA,IACxE,IAAI,CAAC,KAAK,SAAS;AAAA,MACjB;AAAA,IACF;AAAA,IAEA,OAAO,KAAK,QAAQ,SAAS,QAAQ;AAAA;AAAA,OAGzB,cAAgB,CAAC,UAAkB,OAAyB;AAAA,IACxE,IAAI,CAAC,KAAK,SAAS;AAAA,MACjB;AAAA,IACF;AAAA,IAEA,OAAO,KAAK,QAAQ,SAAY,UAAU,KAAK;AAAA;AAAA,OAGpC,IAAM,CACjB,UACA,aACA,UAAyC,CAAC,GAClB;AAAA,IACxB,MAAM,gBAAgB,KAAK,aAAa,OAAO;AAAA,IAG/C,MAAM,cAAc,KAAK,iBAAoB,QAAQ;AAAA,IACrD,IAAI,gBAAgB,WAAW;AAAA,MAC7B,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,aAAa,MAAM,KAAK,sBAAsB,WAAW;AAAA,IAC/D,IAAI,eAAe,WAAW;AAAA,MAC5B,MAAM,KAAK,WAAW,UAAU,YAAY,aAAa;AAAA,MAEzD,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,eAAe,MAAM,KAAK,kBAAqB,QAAQ;AAAA,IAC7D,IAAI,iBAAiB,WAAW;AAAA,MAC9B,MAAM,KAAK,WAAW,UAAU,cAAc,aAAa;AAAA,MAE3D,OAAO;AAAA,IACT;AAAA;AAAA,EAGM,YAAY,CAAC,SAA8D;AAAA,IACjF,OAAO;AAAA,MACL,OAAO,KAAK,QAAQ;AAAA,MACpB,uBAAuB,KAAK,QAAQ;AAAA,SACjC;AAAA,IACL;AAAA;AAAA,EAGM,gBAAmB,CAAC,UAAiC;AAAA,IAC3D,MAAM,SAAS,KAAK,cAAc,IAAI,QAAQ;AAAA,IAE9C,IAAI,UAAU,CAAC,KAAK,UAAU,OAAO,QAAQ,GAAG;AAAA,MAC9C,OAAO,OAAO;AAAA,IAChB;AAAA,IAEA;AAAA;AAAA,OAGY,kBAAoB,CAAC,UAA0C;AAAA,IAC3E,MAAM,SAAS,MAAM,KAAK,eAAqC,QAAQ;AAAA,IAEvE,IAAI,UAAU,CAAC,KAAK,UAAU,OAAO,QAAQ,GAAG;AAAA,MAC9C,KAAK,cAAc,IAAI,UAAU,MAAM;AAAA,MACvC,OAAO,OAAO;AAAA,IAChB;AAAA,IAEA;AAAA;AAAA,OAGY,sBAAwB,CAAC,aAAsD;AAAA,IAC3F,IAAI,gBAAgB,WAAW;AAAA,MAC7B;AAAA,IACF;AAAA,IAEA,IAAI,WAAW,WAAW,GAAG;AAAA,MAC3B,OAAO,MAAM,YAAY;AAAA,IAC3B;AAAA,IAEA,IAAI,UAAU,WAAW,GAAG;AAAA,MAC1B,OAAO,MAAM;AAAA,IACf;AAAA,IAEA,OAAO;AAAA;AAAA,OAGK,WAAa,CAAC,UAAkB,OAAU,SAA8C;AAAA,IACpG,MAAM,YAAY,KAAK,iBAAiB,OAAO,OAAO;AAAA,IAEtD,MAAM,KAAK,cAAc,UAAU,SAAS;AAAA,IAC5C,KAAK,cAAc,IAAI,UAAU,SAAS;AAAA;AAAA,EAGpC,gBAAmB,CAAC,OAAU,SAAqD;AAAA,IACzF,MAAM,MAAM,KAAK,IAAI;AAAA,IACrB,IAAI;AAAA,IACJ,IAAI,QAAQ,QAAQ,GAAG;AAAA,MACrB,YAAY;AAAA,IACd,EAAO;AAAA,MACL,YAAY,MAAM,QAAQ,QAAQ,QAAQ;AAAA;AAAA,IAG5C,OAAO;AAAA,MACL,MAAM;AAAA,MACN,UAAU;AAAA,QACR,WAAW;AAAA,QACX,OAAO,QAAQ;AAAA,QACf,uBAAuB,QAAQ;AAAA,QAC/B;AAAA,MACF;AAAA,IACF;AAAA;AAAA,EAGM,SAAS,CAAC,UAAmC;AAAA,IACnD,IAAI,CAAC,UAAU;AAAA,MACb,OAAO;AAAA,IACT;AAAA,IAEA,IAAI,SAAS,YAAY,GAAG;AAAA,MAC1B,OAAO;AAAA,IACT;AAAA,IAEA,MAAM,iBACJ,SAAS,cAAc,SAAS,aAAa,SAAS,QAAQ,SAAS,YAAY,SAAS,QAAQ;AAAA,IAEtG,IAAI,mBAAmB,WAAW;AAAA,MAChC,OAAO;AAAA,IACT;AAAA,IAEA,OAAO,KAAK,IAAI,IAAI;AAAA;AAExB;;AErKO,IAAM,yBAAyB;",
  "debugId": "46944600E0400D9A64756E2164756E21",
  "names": []
}

package/dist/cache/internal/types.d.ts

@@ -0,0 +1,8 @@
+import type { CacheMetadata } from "../types.ts";
+export type CacheWithMetadata<T = any> = {
+    data: T;
+    metadata: CacheMetadata;
+};
+export type CacheMetadataOptions = Pick<CacheMetadata, "ttlMs" | "expirationThresholdMs">;
+export type CacheOptions = CacheMetadataOptions & {};
+export type ValueLoader<T> = T | Promise<T> | (() => Promise<T>);

package/dist/cache/types.d.ts

@@ -0,0 +1,10 @@
+export interface ICacheAdapter {
+    getValue<T>(key: string): T | undefined | Promise<T | undefined>;
+    setValue<T>(key: string, value: T): void | Promise<void>;
+}
+export type CacheMetadata = {
+    createdAt: number;
+    ttlMs: number;
+    expiresAt: number;
+    expirationThresholdMs: number;
+};

package/dist/index.cjs

@@ -39,20 +39,163 @@ var __export = (target, all) => {
     });
 };
 
+// src/cache/index.ts
+var exports_cache = {};
+__export(exports_cache, {
+  Cache: () => Cache,
+  CACHE_TTL_NEVER_EXPIRE: () => CACHE_TTL_NEVER_EXPIRE
+});
+module.exports = __toCommonJS(exports_cache);
+
+// src/cache/cacheService.ts
+var import_types = require("node:util/types");
+
+// src/utils/isCallable.ts
+function isCallable(value) {
+  return typeof value === "function";
+}
+
+// src/cache/cacheService.ts
+var defaultCacheOptions = {
+  expirationThresholdMs: 0,
+  ttlMs: 60 * 60 * 1000
+};
+
+class Cache {
+  inMemoryCache = new Map;
+  options;
+  adapter;
+  constructor(adapter, defaultOptions) {
+    const options = adapter && !("getValue" in adapter) ? adapter : defaultOptions;
+    if (adapter && "getValue" in adapter && "setValue" in adapter) {
+      this.adapter = adapter;
+    }
+    this.options = {
+      ...defaultCacheOptions,
+      ...options
+    };
+  }
+  async getFromAdapter(cacheKey) {
+    if (!this.adapter) {
+      return;
+    }
+    return this.adapter.getValue(cacheKey);
+  }
+  async saveToAdapter(cacheKey, value) {
+    if (!this.adapter) {
+      return;
+    }
+    return this.adapter.setValue(cacheKey, value);
+  }
+  async get(cacheKey, valueLoader, options = {}) {
+    const mergedOptions = this.mergeOptions(options);
+    const cachedValue = this.tryGetFromMemory(cacheKey);
+    if (cachedValue !== undefined) {
+      return cachedValue;
+    }
+    const freshValue = await this.tryGetFromValueLoader(valueLoader);
+    if (freshValue !== undefined) {
+      await this.cacheValue(cacheKey, freshValue, mergedOptions);
+      return freshValue;
+    }
+    const adapterValue = await this.tryGetFromAdapter(cacheKey);
+    if (adapterValue !== undefined) {
+      await this.cacheValue(cacheKey, adapterValue, mergedOptions);
+      return adapterValue;
+    }
+  }
+  mergeOptions(options) {
+    return {
+      ttlMs: this.options.ttlMs,
+      expirationThresholdMs: this.options.expirationThresholdMs,
+      ...options
+    };
+  }
+  tryGetFromMemory(cacheKey) {
+    const cached = this.inMemoryCache.get(cacheKey);
+    if (cached && !this.isExpired(cached.metadata)) {
+      return cached.data;
+    }
+    return;
+  }
+  async tryGetFromAdapter(cacheKey) {
+    const cached = await this.getFromAdapter(cacheKey);
+    if (cached && !this.isExpired(cached.metadata)) {
+      this.inMemoryCache.set(cacheKey, cached);
+      return cached.data;
+    }
+    return;
+  }
+  async tryGetFromValueLoader(valueLoader) {
+    if (valueLoader === undefined) {
+      return;
+    }
+    if (isCallable(valueLoader)) {
+      return await valueLoader();
+    }
+    if (import_types.isPromise(valueLoader)) {
+      return await valueLoader;
+    }
+    return valueLoader;
+  }
+  async cacheValue(cacheKey, value, options) {
+    const cacheData = this.createCacheEntry(value, options);
+    await this.saveToAdapter(cacheKey, cacheData);
+    this.inMemoryCache.set(cacheKey, cacheData);
+  }
+  createCacheEntry(value, options) {
+    const now = Date.now();
+    let expiresAt;
+    if (options.ttlMs < 0) {
+      expiresAt = -1;
+    } else {
+      expiresAt = now + options.ttlMs - options.expirationThresholdMs;
+    }
+    return {
+      data: value,
+      metadata: {
+        createdAt: now,
+        ttlMs: options.ttlMs,
+        expirationThresholdMs: options.expirationThresholdMs,
+        expiresAt
+      }
+    };
+  }
+  isExpired(metadata) {
+    if (!metadata) {
+      return true;
+    }
+    if (metadata.expiresAt < 0) {
+      return false;
+    }
+    const expirationTime = metadata.expiresAt ?? (metadata.createdAt && metadata.ttlMs ? metadata.createdAt + metadata.ttlMs : undefined);
+    if (expirationTime === undefined) {
+      return true;
+    }
+    return Date.now() > expirationTime;
+  }
+}
+// src/cache/constants.ts
+var CACHE_TTL_NEVER_EXPIRE = -1;
 // src/index.ts
 var exports_src = {};
 __export(exports_src, {
   tryCatchAsync: () => tryCatchAsync,
   tryCatch: () => tryCatch,
+  sleep: () => sleep,
+  randomString: () => randomString,
   jsonParser: () => jsonParser,
+  isPrimitive: () => isPrimitive,
   isObject: () => isObject,
   isNullOrUndefined: () => isNullOrUndefined,
   isNullOrEmptyOrUndefined: () => isNullOrEmptyOrUndefined,
-  chunksToLines: () => chunksToLines
+  chunksToLines: () => chunksToLines,
+  Cache: () => Cache,
+  CACHE_TTL_NEVER_EXPIRE: () => CACHE_TTL_NEVER_EXPIRE
 });
 module.exports = __toCommonJS(exports_src);
 
-// src/chunksToLines.ts
+// src/utils/chunksToLines.ts
 async function* chunksToLines(chunks) {
   let previous = "";
   for await (const chunk of chunks) {
@@ -69,11 +212,20 @@ async function* chunksToLines(chunks) {
     yield previous;
   }
 }
-// src/isObject.ts
+// src/utils/isNullOrUndefined.ts
+var isNullOrUndefined = (value) => value === null || value === undefined;
+function isNullOrEmptyOrUndefined(value) {
+  return value === undefined || value === null || value === "" || value.toString().trim() === "";
+}
+// src/utils/isObject.ts
 function isObject(input) {
   return Object.prototype.toString.apply(input) === "[object Object]";
 }
-// src/jsonParser.ts
+// src/utils/isPrimitive.ts
+function isPrimitive(value) {
+  return typeof value !== "object" && typeof value !== "function" || value === null || value instanceof Date;
+}
+// src/utils/jsonParser.ts
 var import_secure_json_parse = __toESM(require("secure-json-parse"));
 function jsonParser(input) {
   try {
@@ -82,6 +234,18 @@ function jsonParser(input) {
     return { err };
   }
 }
+// src/utils/randomString.ts
+function randomString(length = 6) {
+  let result = "";
+  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  const charactersLength = characters.length;
+  for (let i = 0;i < length; i++) {
+    result += characters.charAt(Math.floor(Math.random() * charactersLength));
+  }
+  return result;
+}
+// src/utils/sleep.ts
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 // src/neverthrow/tryCatch.ts
 function tryCatch(fn) {
   try {
@@ -99,11 +263,6 @@ async function tryCatchAsync(promise) {
     return [undefined, error];
   }
 }
-// src/isNullOrUndefined.ts
-var isNullOrUndefined = (value) => value === null || value === undefined;
-function isNullOrEmptyOrUndefined(value) {
-  return value === undefined || value === null || value === "" || value.toString().trim() === "";
-}
 
-//# debugId=BE1349762FEF2BD064756E2164756E21
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/chunksToLines.ts", "../src/isObject.ts", "../src/jsonParser.ts", "../src/neverthrow/tryCatch.ts", "../src/isNullOrUndefined.ts"],
  "sourcesContent": [
    "/**\n * Converts an async iterable of string or Uint8Array chunks into an async iterable of lines.\n * Handles cases where lines may be split across multiple chunks.\n * Usage:\n * ```ts\n * import { pipeline } from \"node:stream/promises\";\n * import { createReadStream } from \"node:fs\";\n * import { chunksToLines } from \"@lukaskj/ts-utils\";\n *\n * const readStream = createReadStream(\"path/to/file.txt\", { encoding: \"utf-8\" });\n * await pipeline(readStream, chunksToLines, process.stdout).catch((err) => {\n *   console.error(err);\n *   process.exit(1);\n * });\n * ```\n * @param chunks\n */\nexport async function* chunksToLines(chunks: AsyncIterable<string | Uint8Array>) {\n  let previous = \"\";\n\n  for await (const chunk of chunks) {\n    previous += chunk;\n    let eolIndex: number;\n\n    // biome-ignore lint/suspicious/noAssignInExpressions: \"explanation\"\n    while ((eolIndex = previous.indexOf(\"\\n\")) >= 0) {\n      // this line includes the EOL\n      const line = previous.slice(0, eolIndex + 1);\n      yield line?.trim() ?? \"\";\n      previous = previous.slice(eolIndex + 1);\n    }\n  }\n\n  if (previous.length > 0) {\n    yield previous;\n  }\n}\n",
    "/**\n * Type guard that checks if the input is a plain JavaScript object.\n * @param {any} input - The value to check\n * @returns {boolean} True if the input is a plain object, false otherwise\n * @typeParam {Record<string, any>} Type guard narrows the input type to a string-keyed object\n */\nexport function isObject(input: any): input is Record<string, any> {\n  return Object.prototype.toString.apply(input) === \"[object Object]\";\n}\n",
    "import sjs from \"secure-json-parse\";\n\n/**\n * Safely parses JSON input using secure-json-parse with prototype pollution protection.\n * @param {any} input - The input to be parsed as JSON\n * @returns {{ value?: any, err?: Error }} An object containing either the parsed value or an error if parsing failed\n */\nexport function jsonParser(input: any) {\n  try {\n    return { value: sjs.parse(input, { protoAction: \"remove\" }) };\n  } catch (err) {\n    return { err };\n  }\n}\n",
    "// https://gist.github.com/t3dotgg/a486c4ae66d32bf17c09c73609dacc5b\n// Types for the result object with discriminated union\n// type Success<T> = {\n//   data: T;\n//   error: null;\n// };\n\n// type Failure<E> = {\n//   data: null;\n//   error: E;\n// };\n\n// export type Result<T, E = Error> = Success<T> | Failure<E>;\n\nexport type Result<T, E> = [undefined, E] | [T, undefined];\nexport type PromiseResult<T, E> = Promise<Result<T, E>>;\n\n/**\n * Wraps a synchronous function in a try-catch block and returns a Result tuple containing either the returned value or the caught error\n *\n * @template T - The type of the successful result value\n * @template E - The type of the error value, must extend Error\n * @param {() => T} fn - The function to be executed\n * @returns {Result<T, E>} A tuple containing either [data, undefined] or [undefined, error]\n *\n * @example\n * const [data, error] = tryCatch(() => someRiskyOperation());\n * if (error) {\n *   console.error(error);\n * } else {\n *   console.log(data);\n * }\n */\nexport function tryCatch<T, E extends Error>(fn: () => T): Result<T, E> {\n  try {\n    const data = fn();\n    return [data as T, undefined];\n  } catch (error) {\n    return [undefined, error as E];\n  }\n}\n\n/**\n * Wraps a Promise in a try-catch block and returns a Result object containing either the resolved data or the caught error\n *\n * @template T - The type of the successful result value\n * @template E - The type of the error value, defaults to Error\n * @param {Promise<T>} promise - The promise to be executed\n * @returns {Promise<Result<T, E>>} A Promise that resolves to a Result object containing either the data or error\n *\n * @example\n * const {data, error} = await tryCatchAsync(somePromise);\n * if (error) {\n *   console.error(result.error);\n * } else {\n *   console.log(data);\n * }\n */\nexport async function tryCatchAsync<T, E extends Error>(promise: Promise<T>): PromiseResult<T, E> {\n  try {\n    const data = await promise;\n    return [data as T, undefined];\n  } catch (error) {\n    return [undefined, error as E];\n  }\n}\n",
    "export const isNullOrUndefined = (value: any): value is null | undefined => value === null || value === undefined;\n\nexport function isNullOrEmptyOrUndefined(value?: any | null): value is null | undefined {\n  return value === undefined || value === null || value === \"\" || value.toString().trim() === \"\";\n}\n"
  ],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiBA,gBAAuB,aAAa,CAAC,QAA4C;AAAA,EAC/E,IAAI,WAAW;AAAA,EAEf,iBAAiB,SAAS,QAAQ;AAAA,IAChC,YAAY;AAAA,IACZ,IAAI;AAAA,IAGJ,QAAQ,WAAW,SAAS,QAAQ;AAAA,CAAI,MAAM,GAAG;AAAA,MAE/C,MAAM,OAAO,SAAS,MAAM,GAAG,WAAW,CAAC;AAAA,MAC3C,MAAM,MAAM,KAAK,KAAK;AAAA,MACtB,WAAW,SAAS,MAAM,WAAW,CAAC;AAAA,IACxC;AAAA,EACF;AAAA,EAEA,IAAI,SAAS,SAAS,GAAG;AAAA,IACvB,MAAM;AAAA,EACR;AAAA;;AC7BK,SAAS,QAAQ,CAAC,OAA0C;AAAA,EACjE,OAAO,OAAO,UAAU,SAAS,MAAM,KAAK,MAAM;AAAA;;ACPpC,IAAhB;AAOO,SAAS,UAAU,CAAC,OAAY;AAAA,EACrC,IAAI;AAAA,IACF,OAAO,EAAE,OAAO,iCAAI,MAAM,OAAO,EAAE,aAAa,SAAS,CAAC,EAAE;AAAA,IAC5D,OAAO,KAAK;AAAA,IACZ,OAAO,EAAE,IAAI;AAAA;AAAA;;ACsBV,SAAS,QAA4B,CAAC,IAA2B;AAAA,EACtE,IAAI;AAAA,IACF,MAAM,OAAO,GAAG;AAAA,IAChB,OAAO,CAAC,MAAW,SAAS;AAAA,IAC5B,OAAO,OAAO;AAAA,IACd,OAAO,CAAC,WAAW,KAAU;AAAA;AAAA;AAoBjC,eAAsB,aAAiC,CAAC,SAA0C;AAAA,EAChG,IAAI;AAAA,IACF,MAAM,OAAO,MAAM;AAAA,IACnB,OAAO,CAAC,MAAW,SAAS;AAAA,IAC5B,OAAO,OAAO;AAAA,IACd,OAAO,CAAC,WAAW,KAAU;AAAA;AAAA;;AC/D1B,IAAM,oBAAoB,CAAC,UAA0C,UAAU,QAAQ,UAAU;AAEjG,SAAS,wBAAwB,CAAC,OAA+C;AAAA,EACtF,OAAO,UAAU,aAAa,UAAU,QAAQ,UAAU,MAAM,MAAM,SAAS,EAAE,KAAK,MAAM;AAAA;",
  "debugId": "BE1349762FEF2BD064756E2164756E21",
  "names": []
}
+//# debugId=095D83D51A0E4FF764756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/cache/cacheService.ts", "../src/utils/isCallable.ts", "../src/cache/constants.ts", "../src/utils/chunksToLines.ts", "../src/utils/isNullOrUndefined.ts", "../src/utils/isObject.ts", "../src/utils/isPrimitive.ts", "../src/utils/jsonParser.ts", "../src/utils/randomString.ts", "../src/utils/sleep.ts", "../src/neverthrow/tryCatch.ts"],
  "sourcesContent": [
    "import { isPromise } from \"node:util/types\";\nimport { isCallable } from \"../utils/isCallable.ts\";\nimport type { CacheMetadataOptions, CacheOptions, CacheWithMetadata, ValueLoader } from \"./internal/types.ts\";\nimport type { CacheMetadata, ICacheAdapter } from \"./types.ts\";\n\nconst defaultCacheOptions: CacheOptions = {\n  expirationThresholdMs: 0,\n  ttlMs: 60 * 60 * 1000,\n};\n\nexport class Cache<TAdapter extends ICacheAdapter | undefined = undefined> {\n  private inMemoryCache: Map<string, CacheWithMetadata> = new Map();\n  private readonly options: CacheOptions;\n  private readonly adapter?: TAdapter;\n\n  constructor(defaultOptions?: Partial<CacheOptions>);\n  constructor(adapter?: TAdapter, defaultOptions?: Partial<CacheOptions>);\n  constructor(adapter?: TAdapter | Partial<CacheOptions>, defaultOptions?: Partial<CacheOptions>) {\n    const options = adapter && !(\"getValue\" in adapter) ? (adapter as Partial<CacheOptions>) : defaultOptions;\n    if (adapter && \"getValue\" in adapter && \"setValue\" in adapter) {\n      this.adapter = adapter as TAdapter;\n    }\n\n    this.options = {\n      ...defaultCacheOptions,\n      ...options,\n    };\n  }\n\n  private async getFromAdapter<T>(cacheKey: string): Promise<T | undefined> {\n    if (!this.adapter) {\n      return undefined;\n    }\n\n    return this.adapter.getValue(cacheKey);\n  }\n\n  private async saveToAdapter<T>(cacheKey: string, value: T): Promise<void> {\n    if (!this.adapter) {\n      return;\n    }\n\n    return this.adapter.setValue<T>(cacheKey, value);\n  }\n\n  public async get<T>(\n    cacheKey: string,\n    valueLoader?: ValueLoader<T>,\n    options: Partial<CacheMetadataOptions> = {},\n  ): Promise<T | undefined> {\n    const mergedOptions = this.mergeOptions(options);\n\n    // Try in-memory cache first\n    const cachedValue = this.tryGetFromMemory<T>(cacheKey);\n    if (cachedValue !== undefined) {\n      return cachedValue;\n    }\n\n    // Load fresh value from loader function first\n    const freshValue = await this.tryGetFromValueLoader(valueLoader);\n    if (freshValue !== undefined) {\n      await this.cacheValue(cacheKey, freshValue, mergedOptions);\n\n      return freshValue;\n    }\n\n    // Try adapter cache second\n    const adapterValue = await this.tryGetFromAdapter<T>(cacheKey);\n    if (adapterValue !== undefined) {\n      await this.cacheValue(cacheKey, adapterValue, mergedOptions);\n\n      return adapterValue;\n    }\n  }\n\n  private mergeOptions(options: Partial<CacheMetadataOptions>): CacheMetadataOptions {\n    return {\n      ttlMs: this.options.ttlMs,\n      expirationThresholdMs: this.options.expirationThresholdMs,\n      ...options,\n    };\n  }\n\n  private tryGetFromMemory<T>(cacheKey: string): T | undefined {\n    const cached = this.inMemoryCache.get(cacheKey);\n\n    if (cached && !this.isExpired(cached.metadata)) {\n      return cached.data as T;\n    }\n\n    return undefined;\n  }\n\n  private async tryGetFromAdapter<T>(cacheKey: string): Promise<T | undefined> {\n    const cached = await this.getFromAdapter<CacheWithMetadata<T>>(cacheKey);\n\n    if (cached && !this.isExpired(cached.metadata)) {\n      this.inMemoryCache.set(cacheKey, cached);\n      return cached.data;\n    }\n\n    return undefined;\n  }\n\n  private async tryGetFromValueLoader<T>(valueLoader?: ValueLoader<T>): Promise<T | undefined> {\n    if (valueLoader === undefined) {\n      return undefined;\n    }\n\n    if (isCallable(valueLoader)) {\n      return await valueLoader();\n    }\n\n    if (isPromise(valueLoader)) {\n      return await valueLoader;\n    }\n\n    return valueLoader;\n  }\n\n  private async cacheValue<T>(cacheKey: string, value: T, options: CacheMetadataOptions): Promise<void> {\n    const cacheData = this.createCacheEntry(value, options);\n\n    await this.saveToAdapter(cacheKey, cacheData);\n    this.inMemoryCache.set(cacheKey, cacheData);\n  }\n\n  private createCacheEntry<T>(value: T, options: CacheMetadataOptions): CacheWithMetadata<T> {\n    const now = Date.now();\n    let expiresAt: number;\n    if (options.ttlMs < 0) {\n      expiresAt = -1;\n    } else {\n      expiresAt = now + options.ttlMs - options.expirationThresholdMs;\n    }\n\n    return {\n      data: value,\n      metadata: {\n        createdAt: now,\n        ttlMs: options.ttlMs,\n        expirationThresholdMs: options.expirationThresholdMs,\n        expiresAt,\n      },\n    };\n  }\n\n  private isExpired(metadata?: CacheMetadata): boolean {\n    if (!metadata) {\n      return true;\n    }\n\n    if (metadata.expiresAt < 0) {\n      return false;\n    }\n\n    const expirationTime =\n      metadata.expiresAt ?? (metadata.createdAt && metadata.ttlMs ? metadata.createdAt + metadata.ttlMs : undefined);\n\n    if (expirationTime === undefined) {\n      return true;\n    }\n\n    return Date.now() > expirationTime;\n  }\n}\n",
    "export function isCallable(value: any): value is CallableFunction {\n  return typeof value === \"function\";\n}\n",
    "export const CACHE_TTL_NEVER_EXPIRE = -1;\n",
    "/**\n * Converts an async iterable of string or Uint8Array chunks into an async iterable of lines.\n * Handles cases where lines may be split across multiple chunks.\n * Usage:\n * ```ts\n * import { pipeline } from \"node:stream/promises\";\n * import { createReadStream } from \"node:fs\";\n * import { chunksToLines } from \"@lukaskj/ts-utils\";\n *\n * const readStream = createReadStream(\"path/to/file.txt\", { encoding: \"utf-8\" });\n * await pipeline(readStream, chunksToLines, process.stdout).catch((err) => {\n *   console.error(err);\n *   process.exit(1);\n * });\n * ```\n * @param chunks\n */\nexport async function* chunksToLines(chunks: AsyncIterable<string | Uint8Array>) {\n  let previous = \"\";\n\n  for await (const chunk of chunks) {\n    previous += chunk;\n    let eolIndex: number;\n\n    // biome-ignore lint/suspicious/noAssignInExpressions: \"explanation\"\n    while ((eolIndex = previous.indexOf(\"\\n\")) >= 0) {\n      // this line includes the EOL\n      const line = previous.slice(0, eolIndex + 1);\n      yield line?.trim() ?? \"\";\n      previous = previous.slice(eolIndex + 1);\n    }\n  }\n\n  if (previous.length > 0) {\n    yield previous;\n  }\n}\n",
    "export const isNullOrUndefined = (value: any): value is null | undefined => value === null || value === undefined;\n\nexport function isNullOrEmptyOrUndefined(value?: any | null): value is null | undefined {\n  return value === undefined || value === null || value === \"\" || value.toString().trim() === \"\";\n}\n",
    "/**\n * Type guard that checks if the input is a plain JavaScript object.\n * @param {any} input - The value to check\n * @returns {boolean} True if the input is a plain object, false otherwise\n * @typeParam {Record<string, any>} Type guard narrows the input type to a string-keyed object\n */\nexport function isObject(input: any): input is Record<string, any> {\n  return Object.prototype.toString.apply(input) === \"[object Object]\";\n}\n",
    "export function isPrimitive(value: unknown): boolean {\n  return (typeof value !== \"object\" && typeof value !== \"function\") || value === null || value instanceof Date;\n}\n",
    "import sjs from \"secure-json-parse\";\n\n/**\n * Safely parses JSON input using secure-json-parse with prototype pollution protection.\n * @param {any} input - The input to be parsed as JSON\n * @returns {{ value?: any, err?: Error }} An object containing either the parsed value or an error if parsing failed\n */\nexport function jsonParser(input: any) {\n  try {\n    return { value: sjs.parse(input, { protoAction: \"remove\" }) };\n  } catch (err) {\n    return { err };\n  }\n}\n",
    "export function randomString(length: number = 6): string {\n  let result = \"\";\n  const characters = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\";\n  const charactersLength = characters.length;\n  for (let i = 0; i < length; i++) {\n    result += characters.charAt(Math.floor(Math.random() * charactersLength));\n  }\n  return result;\n}\n",
    "export const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));\n",
    "// https://gist.github.com/t3dotgg/a486c4ae66d32bf17c09c73609dacc5b\n// Types for the result object with discriminated union\n// type Success<T> = {\n//   data: T;\n//   error: null;\n// };\n\n// type Failure<E> = {\n//   data: null;\n//   error: E;\n// };\n\n// export type Result<T, E = Error> = Success<T> | Failure<E>;\n\nexport type Result<T, E> = [undefined, E] | [T, undefined];\nexport type PromiseResult<T, E> = Promise<Result<T, E>>;\n\n/**\n * Wraps a synchronous function in a try-catch block and returns a Result tuple containing either the returned value or the caught error\n *\n * @template T - The type of the successful result value\n * @template E - The type of the error value, must extend Error\n * @param {() => T} fn - The function to be executed\n * @returns {Result<T, E>} A tuple containing either [data, undefined] or [undefined, error]\n *\n * @example\n * const [data, error] = tryCatch(() => someRiskyOperation());\n * if (error) {\n *   console.error(error);\n * } else {\n *   console.log(data);\n * }\n */\nexport function tryCatch<T, E extends Error>(fn: () => T): Result<T, E> {\n  try {\n    const data = fn();\n    return [data as T, undefined];\n  } catch (error) {\n    return [undefined, error as E];\n  }\n}\n\n/**\n * Wraps a Promise in a try-catch block and returns a Result object containing either the resolved data or the caught error\n *\n * @template T - The type of the successful result value\n * @template E - The type of the error value, defaults to Error\n * @param {Promise<T>} promise - The promise to be executed\n * @returns {Promise<Result<T, E>>} A Promise that resolves to a Result object containing either the data or error\n *\n * @example\n * const {data, error} = await tryCatchAsync(somePromise);\n * if (error) {\n *   console.error(result.error);\n * } else {\n *   console.log(data);\n * }\n */\nexport async function tryCatchAsync<T, E extends Error>(promise: Promise<T>): PromiseResult<T, E> {\n  try {\n    const data = await promise;\n    return [data as T, undefined];\n  } catch (error) {\n    return [undefined, error as E];\n  }\n}\n"
  ],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAA0B,IAA1B;;;ACAO,SAAS,UAAU,CAAC,OAAuC;AAAA,EAChE,OAAO,OAAO,UAAU;AAAA;;;ADI1B,IAAM,sBAAoC;AAAA,EACxC,uBAAuB;AAAA,EACvB,OAAO,KAAK,KAAK;AACnB;AAAA;AAEO,MAAM,MAA8D;AAAA,EACjE,gBAAgD,IAAI;AAAA,EAC3C;AAAA,EACA;AAAA,EAIjB,WAAW,CAAC,SAA4C,gBAAwC;AAAA,IAC9F,MAAM,UAAU,WAAW,EAAE,cAAc,WAAY,UAAoC;AAAA,IAC3F,IAAI,WAAW,cAAc,WAAW,cAAc,SAAS;AAAA,MAC7D,KAAK,UAAU;AAAA,IACjB;AAAA,IAEA,KAAK,UAAU;AAAA,SACV;AAAA,SACA;AAAA,IACL;AAAA;AAAA,OAGY,eAAiB,CAAC,UAA0C;AAAA,IACxE,IAAI,CAAC,KAAK,SAAS;AAAA,MACjB;AAAA,IACF;AAAA,IAEA,OAAO,KAAK,QAAQ,SAAS,QAAQ;AAAA;AAAA,OAGzB,cAAgB,CAAC,UAAkB,OAAyB;AAAA,IACxE,IAAI,CAAC,KAAK,SAAS;AAAA,MACjB;AAAA,IACF;AAAA,IAEA,OAAO,KAAK,QAAQ,SAAY,UAAU,KAAK;AAAA;AAAA,OAGpC,IAAM,CACjB,UACA,aACA,UAAyC,CAAC,GAClB;AAAA,IACxB,MAAM,gBAAgB,KAAK,aAAa,OAAO;AAAA,IAG/C,MAAM,cAAc,KAAK,iBAAoB,QAAQ;AAAA,IACrD,IAAI,gBAAgB,WAAW;AAAA,MAC7B,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,aAAa,MAAM,KAAK,sBAAsB,WAAW;AAAA,IAC/D,IAAI,eAAe,WAAW;AAAA,MAC5B,MAAM,KAAK,WAAW,UAAU,YAAY,aAAa;AAAA,MAEzD,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,eAAe,MAAM,KAAK,kBAAqB,QAAQ;AAAA,IAC7D,IAAI,iBAAiB,WAAW;AAAA,MAC9B,MAAM,KAAK,WAAW,UAAU,cAAc,aAAa;AAAA,MAE3D,OAAO;AAAA,IACT;AAAA;AAAA,EAGM,YAAY,CAAC,SAA8D;AAAA,IACjF,OAAO;AAAA,MACL,OAAO,KAAK,QAAQ;AAAA,MACpB,uBAAuB,KAAK,QAAQ;AAAA,SACjC;AAAA,IACL;AAAA;AAAA,EAGM,gBAAmB,CAAC,UAAiC;AAAA,IAC3D,MAAM,SAAS,KAAK,cAAc,IAAI,QAAQ;AAAA,IAE9C,IAAI,UAAU,CAAC,KAAK,UAAU,OAAO,QAAQ,GAAG;AAAA,MAC9C,OAAO,OAAO;AAAA,IAChB;AAAA,IAEA;AAAA;AAAA,OAGY,kBAAoB,CAAC,UAA0C;AAAA,IAC3E,MAAM,SAAS,MAAM,KAAK,eAAqC,QAAQ;AAAA,IAEvE,IAAI,UAAU,CAAC,KAAK,UAAU,OAAO,QAAQ,GAAG;AAAA,MAC9C,KAAK,cAAc,IAAI,UAAU,MAAM;AAAA,MACvC,OAAO,OAAO;AAAA,IAChB;AAAA,IAEA;AAAA;AAAA,OAGY,sBAAwB,CAAC,aAAsD;AAAA,IAC3F,IAAI,gBAAgB,WAAW;AAAA,MAC7B;AAAA,IACF;AAAA,IAEA,IAAI,WAAW,WAAW,GAAG;AAAA,MAC3B,OAAO,MAAM,YAAY;AAAA,IAC3B;AAAA,IAEA,IAAI,uBAAU,WAAW,GAAG;AAAA,MAC1B,OAAO,MAAM;AAAA,IACf;AAAA,IAEA,OAAO;AAAA;AAAA,OAGK,WAAa,CAAC,UAAkB,OAAU,SAA8C;AAAA,IACpG,MAAM,YAAY,KAAK,iBAAiB,OAAO,OAAO;AAAA,IAEtD,MAAM,KAAK,cAAc,UAAU,SAAS;AAAA,IAC5C,KAAK,cAAc,IAAI,UAAU,SAAS;AAAA;AAAA,EAGpC,gBAAmB,CAAC,OAAU,SAAqD;AAAA,IACzF,MAAM,MAAM,KAAK,IAAI;AAAA,IACrB,IAAI;AAAA,IACJ,IAAI,QAAQ,QAAQ,GAAG;AAAA,MACrB,YAAY;AAAA,IACd,EAAO;AAAA,MACL,YAAY,MAAM,QAAQ,QAAQ,QAAQ;AAAA;AAAA,IAG5C,OAAO;AAAA,MACL,MAAM;AAAA,MACN,UAAU;AAAA,QACR,WAAW;AAAA,QACX,OAAO,QAAQ;AAAA,QACf,uBAAuB,QAAQ;AAAA,QAC/B;AAAA,MACF;AAAA,IACF;AAAA;AAAA,EAGM,SAAS,CAAC,UAAmC;AAAA,IACnD,IAAI,CAAC,UAAU;AAAA,MACb,OAAO;AAAA,IACT;AAAA,IAEA,IAAI,SAAS,YAAY,GAAG;AAAA,MAC1B,OAAO;AAAA,IACT;AAAA,IAEA,MAAM,iBACJ,SAAS,cAAc,SAAS,aAAa,SAAS,QAAQ,SAAS,YAAY,SAAS,QAAQ;AAAA,IAEtG,IAAI,mBAAmB,WAAW;AAAA,MAChC,OAAO;AAAA,IACT;AAAA,IAEA,OAAO,KAAK,IAAI,IAAI;AAAA;AAExB;;AErKO,IAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;ACiBtC,gBAAuB,aAAa,CAAC,QAA4C;AAAA,EAC/E,IAAI,WAAW;AAAA,EAEf,iBAAiB,SAAS,QAAQ;AAAA,IAChC,YAAY;AAAA,IACZ,IAAI;AAAA,IAGJ,QAAQ,WAAW,SAAS,QAAQ;AAAA,CAAI,MAAM,GAAG;AAAA,MAE/C,MAAM,OAAO,SAAS,MAAM,GAAG,WAAW,CAAC;AAAA,MAC3C,MAAM,MAAM,KAAK,KAAK;AAAA,MACtB,WAAW,SAAS,MAAM,WAAW,CAAC;AAAA,IACxC;AAAA,EACF;AAAA,EAEA,IAAI,SAAS,SAAS,GAAG;AAAA,IACvB,MAAM;AAAA,EACR;AAAA;;ACnCK,IAAM,oBAAoB,CAAC,UAA0C,UAAU,QAAQ,UAAU;AAEjG,SAAS,wBAAwB,CAAC,OAA+C;AAAA,EACtF,OAAO,UAAU,aAAa,UAAU,QAAQ,UAAU,MAAM,MAAM,SAAS,EAAE,KAAK,MAAM;AAAA;;ACGvF,SAAS,QAAQ,CAAC,OAA0C;AAAA,EACjE,OAAO,OAAO,UAAU,SAAS,MAAM,KAAK,MAAM;AAAA;;ACP7C,SAAS,WAAW,CAAC,OAAyB;AAAA,EACnD,OAAQ,OAAO,UAAU,YAAY,OAAO,UAAU,cAAe,UAAU,QAAQ,iBAAiB;AAAA;;ACD1F,IAAhB;AAOO,SAAS,UAAU,CAAC,OAAY;AAAA,EACrC,IAAI;AAAA,IACF,OAAO,EAAE,OAAO,iCAAI,MAAM,OAAO,EAAE,aAAa,SAAS,CAAC,EAAE;AAAA,IAC5D,OAAO,KAAK;AAAA,IACZ,OAAO,EAAE,IAAI;AAAA;AAAA;;ACXV,SAAS,YAAY,CAAC,SAAiB,GAAW;AAAA,EACvD,IAAI,SAAS;AAAA,EACb,MAAM,aAAa;AAAA,EACnB,MAAM,mBAAmB,WAAW;AAAA,EACpC,SAAS,IAAI,EAAG,IAAI,QAAQ,KAAK;AAAA,IAC/B,UAAU,WAAW,OAAO,KAAK,MAAM,KAAK,OAAO,IAAI,gBAAgB,CAAC;AAAA,EAC1E;AAAA,EACA,OAAO;AAAA;;ACPF,IAAM,QAAQ,CAAC,OAAe,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,EAAE,CAAC;;ACiC9E,SAAS,QAA4B,CAAC,IAA2B;AAAA,EACtE,IAAI;AAAA,IACF,MAAM,OAAO,GAAG;AAAA,IAChB,OAAO,CAAC,MAAW,SAAS;AAAA,IAC5B,OAAO,OAAO;AAAA,IACd,OAAO,CAAC,WAAW,KAAU;AAAA;AAAA;AAoBjC,eAAsB,aAAiC,CAAC,SAA0C;AAAA,EAChG,IAAI;AAAA,IACF,MAAM,OAAO,MAAM;AAAA,IACnB,OAAO,CAAC,MAAW,SAAS;AAAA,IAC5B,OAAO,OAAO;AAAA,IACd,OAAO,CAAC,WAAW,KAAU;AAAA;AAAA;",
  "debugId": "095D83D51A0E4FF764756E2164756E21",
  "names": []
}

package/dist/index.d.ts

@@ -1,6 +1,10 @@
-export * from "./chunksToLines.ts";
-export * from "./isObject.ts";
-export * from "./jsonParser.ts";
-export * from "./neverthrow/tryCatch.ts";
 export * from "./types.ts";
-export * from "./isNullOrUndefined.ts";
+export * from "./utils/chunksToLines.ts";
+export * from "./utils/isNullOrUndefined.ts";
+export * from "./utils/isObject.ts";
+export * from "./utils/isPrimitive.ts";
+export * from "./utils/jsonParser.ts";
+export * from "./utils/randomString.ts";
+export * from "./utils/sleep.ts";
+export * from "./neverthrow/tryCatch.ts";
+export * from "./cache/index.ts";

package/dist/index.mjs

@@ -1,4 +1,134 @@
-// src/chunksToLines.ts
+// src/cache/cacheService.ts
+import { isPromise } from "node:util/types";
+
+// src/utils/isCallable.ts
+function isCallable(value) {
+  return typeof value === "function";
+}
+
+// src/cache/cacheService.ts
+var defaultCacheOptions = {
+  expirationThresholdMs: 0,
+  ttlMs: 60 * 60 * 1000
+};
+
+class Cache {
+  inMemoryCache = new Map;
+  options;
+  adapter;
+  constructor(adapter, defaultOptions) {
+    const options = adapter && !("getValue" in adapter) ? adapter : defaultOptions;
+    if (adapter && "getValue" in adapter && "setValue" in adapter) {
+      this.adapter = adapter;
+    }
+    this.options = {
+      ...defaultCacheOptions,
+      ...options
+    };
+  }
+  async getFromAdapter(cacheKey) {
+    if (!this.adapter) {
+      return;
+    }
+    return this.adapter.getValue(cacheKey);
+  }
+  async saveToAdapter(cacheKey, value) {
+    if (!this.adapter) {
+      return;
+    }
+    return this.adapter.setValue(cacheKey, value);
+  }
+  async get(cacheKey, valueLoader, options = {}) {
+    const mergedOptions = this.mergeOptions(options);
+    const cachedValue = this.tryGetFromMemory(cacheKey);
+    if (cachedValue !== undefined) {
+      return cachedValue;
+    }
+    const freshValue = await this.tryGetFromValueLoader(valueLoader);
+    if (freshValue !== undefined) {
+      await this.cacheValue(cacheKey, freshValue, mergedOptions);
+      return freshValue;
+    }
+    const adapterValue = await this.tryGetFromAdapter(cacheKey);
+    if (adapterValue !== undefined) {
+      await this.cacheValue(cacheKey, adapterValue, mergedOptions);
+      return adapterValue;
+    }
+  }
+  mergeOptions(options) {
+    return {
+      ttlMs: this.options.ttlMs,
+      expirationThresholdMs: this.options.expirationThresholdMs,
+      ...options
+    };
+  }
+  tryGetFromMemory(cacheKey) {
+    const cached = this.inMemoryCache.get(cacheKey);
+    if (cached && !this.isExpired(cached.metadata)) {
+      return cached.data;
+    }
+    return;
+  }
+  async tryGetFromAdapter(cacheKey) {
+    const cached = await this.getFromAdapter(cacheKey);
+    if (cached && !this.isExpired(cached.metadata)) {
+      this.inMemoryCache.set(cacheKey, cached);
+      return cached.data;
+    }
+    return;
+  }
+  async tryGetFromValueLoader(valueLoader) {
+    if (valueLoader === undefined) {
+      return;
+    }
+    if (isCallable(valueLoader)) {
+      return await valueLoader();
+    }
+    if (isPromise(valueLoader)) {
+      return await valueLoader;
+    }
+    return valueLoader;
+  }
+  async cacheValue(cacheKey, value, options) {
+    const cacheData = this.createCacheEntry(value, options);
+    await this.saveToAdapter(cacheKey, cacheData);
+    this.inMemoryCache.set(cacheKey, cacheData);
+  }
+  createCacheEntry(value, options) {
+    const now = Date.now();
+    let expiresAt;
+    if (options.ttlMs < 0) {
+      expiresAt = -1;
+    } else {
+      expiresAt = now + options.ttlMs - options.expirationThresholdMs;
+    }
+    return {
+      data: value,
+      metadata: {
+        createdAt: now,
+        ttlMs: options.ttlMs,
+        expirationThresholdMs: options.expirationThresholdMs,
+        expiresAt
+      }
+    };
+  }
+  isExpired(metadata) {
+    if (!metadata) {
+      return true;
+    }
+    if (metadata.expiresAt < 0) {
+      return false;
+    }
+    const expirationTime = metadata.expiresAt ?? (metadata.createdAt && metadata.ttlMs ? metadata.createdAt + metadata.ttlMs : undefined);
+    if (expirationTime === undefined) {
+      return true;
+    }
+    return Date.now() > expirationTime;
+  }
+}
+// src/cache/constants.ts
+var CACHE_TTL_NEVER_EXPIRE = -1;
+// src/utils/chunksToLines.ts
 async function* chunksToLines(chunks) {
   let previous = "";
   for await (const chunk of chunks) {
@@ -15,11 +145,20 @@ async function* chunksToLines(chunks) {
     yield previous;
   }
 }
-// src/isObject.ts
+// src/utils/isNullOrUndefined.ts
+var isNullOrUndefined = (value) => value === null || value === undefined;
+function isNullOrEmptyOrUndefined(value) {
+  return value === undefined || value === null || value === "" || value.toString().trim() === "";
+}
+// src/utils/isObject.ts
 function isObject(input) {
   return Object.prototype.toString.apply(input) === "[object Object]";
 }
-// src/jsonParser.ts
+// src/utils/isPrimitive.ts
+function isPrimitive(value) {
+  return typeof value !== "object" && typeof value !== "function" || value === null || value instanceof Date;
+}
+// src/utils/jsonParser.ts
 import sjs from "secure-json-parse";
 function jsonParser(input) {
   try {
@@ -28,6 +167,18 @@ function jsonParser(input) {
     return { err };
   }
 }
+// src/utils/randomString.ts
+function randomString(length = 6) {
+  let result = "";
+  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  const charactersLength = characters.length;
+  for (let i = 0;i < length; i++) {
+    result += characters.charAt(Math.floor(Math.random() * charactersLength));
+  }
+  return result;
+}
+// src/utils/sleep.ts
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 // src/neverthrow/tryCatch.ts
 function tryCatch(fn) {
   try {
@@ -45,20 +196,20 @@ async function tryCatchAsync(promise) {
     return [undefined, error];
   }
 }
-// src/isNullOrUndefined.ts
-var isNullOrUndefined = (value) => value === null || value === undefined;
-function isNullOrEmptyOrUndefined(value) {
-  return value === undefined || value === null || value === "" || value.toString().trim() === "";
-}
 export {
   tryCatchAsync,
   tryCatch,
+  sleep,
+  randomString,
   jsonParser,
+  isPrimitive,
   isObject,
   isNullOrUndefined,
   isNullOrEmptyOrUndefined,
-  chunksToLines
+  chunksToLines,
+  Cache,
+  CACHE_TTL_NEVER_EXPIRE
 };
 
-//# debugId=2F1D216C3D5C751D64756E2164756E21
-//# sourceMappingURL=data:application/json;base64,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
+//# debugId=2329ACCD00D0C99964756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/cache/cacheService.ts", "../src/utils/isCallable.ts", "../src/cache/constants.ts", "../src/utils/chunksToLines.ts", "../src/utils/isNullOrUndefined.ts", "../src/utils/isObject.ts", "../src/utils/isPrimitive.ts", "../src/utils/jsonParser.ts", "../src/utils/randomString.ts", "../src/utils/sleep.ts", "../src/neverthrow/tryCatch.ts"],
  "sourcesContent": [
    "import { isPromise } from \"node:util/types\";\nimport { isCallable } from \"../utils/isCallable.ts\";\nimport type { CacheMetadataOptions, CacheOptions, CacheWithMetadata, ValueLoader } from \"./internal/types.ts\";\nimport type { CacheMetadata, ICacheAdapter } from \"./types.ts\";\n\nconst defaultCacheOptions: CacheOptions = {\n  expirationThresholdMs: 0,\n  ttlMs: 60 * 60 * 1000,\n};\n\nexport class Cache<TAdapter extends ICacheAdapter | undefined = undefined> {\n  private inMemoryCache: Map<string, CacheWithMetadata> = new Map();\n  private readonly options: CacheOptions;\n  private readonly adapter?: TAdapter;\n\n  constructor(defaultOptions?: Partial<CacheOptions>);\n  constructor(adapter?: TAdapter, defaultOptions?: Partial<CacheOptions>);\n  constructor(adapter?: TAdapter | Partial<CacheOptions>, defaultOptions?: Partial<CacheOptions>) {\n    const options = adapter && !(\"getValue\" in adapter) ? (adapter as Partial<CacheOptions>) : defaultOptions;\n    if (adapter && \"getValue\" in adapter && \"setValue\" in adapter) {\n      this.adapter = adapter as TAdapter;\n    }\n\n    this.options = {\n      ...defaultCacheOptions,\n      ...options,\n    };\n  }\n\n  private async getFromAdapter<T>(cacheKey: string): Promise<T | undefined> {\n    if (!this.adapter) {\n      return undefined;\n    }\n\n    return this.adapter.getValue(cacheKey);\n  }\n\n  private async saveToAdapter<T>(cacheKey: string, value: T): Promise<void> {\n    if (!this.adapter) {\n      return;\n    }\n\n    return this.adapter.setValue<T>(cacheKey, value);\n  }\n\n  public async get<T>(\n    cacheKey: string,\n    valueLoader?: ValueLoader<T>,\n    options: Partial<CacheMetadataOptions> = {},\n  ): Promise<T | undefined> {\n    const mergedOptions = this.mergeOptions(options);\n\n    // Try in-memory cache first\n    const cachedValue = this.tryGetFromMemory<T>(cacheKey);\n    if (cachedValue !== undefined) {\n      return cachedValue;\n    }\n\n    // Load fresh value from loader function first\n    const freshValue = await this.tryGetFromValueLoader(valueLoader);\n    if (freshValue !== undefined) {\n      await this.cacheValue(cacheKey, freshValue, mergedOptions);\n\n      return freshValue;\n    }\n\n    // Try adapter cache second\n    const adapterValue = await this.tryGetFromAdapter<T>(cacheKey);\n    if (adapterValue !== undefined) {\n      await this.cacheValue(cacheKey, adapterValue, mergedOptions);\n\n      return adapterValue;\n    }\n  }\n\n  private mergeOptions(options: Partial<CacheMetadataOptions>): CacheMetadataOptions {\n    return {\n      ttlMs: this.options.ttlMs,\n      expirationThresholdMs: this.options.expirationThresholdMs,\n      ...options,\n    };\n  }\n\n  private tryGetFromMemory<T>(cacheKey: string): T | undefined {\n    const cached = this.inMemoryCache.get(cacheKey);\n\n    if (cached && !this.isExpired(cached.metadata)) {\n      return cached.data as T;\n    }\n\n    return undefined;\n  }\n\n  private async tryGetFromAdapter<T>(cacheKey: string): Promise<T | undefined> {\n    const cached = await this.getFromAdapter<CacheWithMetadata<T>>(cacheKey);\n\n    if (cached && !this.isExpired(cached.metadata)) {\n      this.inMemoryCache.set(cacheKey, cached);\n      return cached.data;\n    }\n\n    return undefined;\n  }\n\n  private async tryGetFromValueLoader<T>(valueLoader?: ValueLoader<T>): Promise<T | undefined> {\n    if (valueLoader === undefined) {\n      return undefined;\n    }\n\n    if (isCallable(valueLoader)) {\n      return await valueLoader();\n    }\n\n    if (isPromise(valueLoader)) {\n      return await valueLoader;\n    }\n\n    return valueLoader;\n  }\n\n  private async cacheValue<T>(cacheKey: string, value: T, options: CacheMetadataOptions): Promise<void> {\n    const cacheData = this.createCacheEntry(value, options);\n\n    await this.saveToAdapter(cacheKey, cacheData);\n    this.inMemoryCache.set(cacheKey, cacheData);\n  }\n\n  private createCacheEntry<T>(value: T, options: CacheMetadataOptions): CacheWithMetadata<T> {\n    const now = Date.now();\n    let expiresAt: number;\n    if (options.ttlMs < 0) {\n      expiresAt = -1;\n    } else {\n      expiresAt = now + options.ttlMs - options.expirationThresholdMs;\n    }\n\n    return {\n      data: value,\n      metadata: {\n        createdAt: now,\n        ttlMs: options.ttlMs,\n        expirationThresholdMs: options.expirationThresholdMs,\n        expiresAt,\n      },\n    };\n  }\n\n  private isExpired(metadata?: CacheMetadata): boolean {\n    if (!metadata) {\n      return true;\n    }\n\n    if (metadata.expiresAt < 0) {\n      return false;\n    }\n\n    const expirationTime =\n      metadata.expiresAt ?? (metadata.createdAt && metadata.ttlMs ? metadata.createdAt + metadata.ttlMs : undefined);\n\n    if (expirationTime === undefined) {\n      return true;\n    }\n\n    return Date.now() > expirationTime;\n  }\n}\n",
    "export function isCallable(value: any): value is CallableFunction {\n  return typeof value === \"function\";\n}\n",
    "export const CACHE_TTL_NEVER_EXPIRE = -1;\n",
    "/**\n * Converts an async iterable of string or Uint8Array chunks into an async iterable of lines.\n * Handles cases where lines may be split across multiple chunks.\n * Usage:\n * ```ts\n * import { pipeline } from \"node:stream/promises\";\n * import { createReadStream } from \"node:fs\";\n * import { chunksToLines } from \"@lukaskj/ts-utils\";\n *\n * const readStream = createReadStream(\"path/to/file.txt\", { encoding: \"utf-8\" });\n * await pipeline(readStream, chunksToLines, process.stdout).catch((err) => {\n *   console.error(err);\n *   process.exit(1);\n * });\n * ```\n * @param chunks\n */\nexport async function* chunksToLines(chunks: AsyncIterable<string | Uint8Array>) {\n  let previous = \"\";\n\n  for await (const chunk of chunks) {\n    previous += chunk;\n    let eolIndex: number;\n\n    // biome-ignore lint/suspicious/noAssignInExpressions: \"explanation\"\n    while ((eolIndex = previous.indexOf(\"\\n\")) >= 0) {\n      // this line includes the EOL\n      const line = previous.slice(0, eolIndex + 1);\n      yield line?.trim() ?? \"\";\n      previous = previous.slice(eolIndex + 1);\n    }\n  }\n\n  if (previous.length > 0) {\n    yield previous;\n  }\n}\n",
    "export const isNullOrUndefined = (value: any): value is null | undefined => value === null || value === undefined;\n\nexport function isNullOrEmptyOrUndefined(value?: any | null): value is null | undefined {\n  return value === undefined || value === null || value === \"\" || value.toString().trim() === \"\";\n}\n",
    "/**\n * Type guard that checks if the input is a plain JavaScript object.\n * @param {any} input - The value to check\n * @returns {boolean} True if the input is a plain object, false otherwise\n * @typeParam {Record<string, any>} Type guard narrows the input type to a string-keyed object\n */\nexport function isObject(input: any): input is Record<string, any> {\n  return Object.prototype.toString.apply(input) === \"[object Object]\";\n}\n",
    "export function isPrimitive(value: unknown): boolean {\n  return (typeof value !== \"object\" && typeof value !== \"function\") || value === null || value instanceof Date;\n}\n",
    "import sjs from \"secure-json-parse\";\n\n/**\n * Safely parses JSON input using secure-json-parse with prototype pollution protection.\n * @param {any} input - The input to be parsed as JSON\n * @returns {{ value?: any, err?: Error }} An object containing either the parsed value or an error if parsing failed\n */\nexport function jsonParser(input: any) {\n  try {\n    return { value: sjs.parse(input, { protoAction: \"remove\" }) };\n  } catch (err) {\n    return { err };\n  }\n}\n",
    "export function randomString(length: number = 6): string {\n  let result = \"\";\n  const characters = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\";\n  const charactersLength = characters.length;\n  for (let i = 0; i < length; i++) {\n    result += characters.charAt(Math.floor(Math.random() * charactersLength));\n  }\n  return result;\n}\n",
    "export const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));\n",
    "// https://gist.github.com/t3dotgg/a486c4ae66d32bf17c09c73609dacc5b\n// Types for the result object with discriminated union\n// type Success<T> = {\n//   data: T;\n//   error: null;\n// };\n\n// type Failure<E> = {\n//   data: null;\n//   error: E;\n// };\n\n// export type Result<T, E = Error> = Success<T> | Failure<E>;\n\nexport type Result<T, E> = [undefined, E] | [T, undefined];\nexport type PromiseResult<T, E> = Promise<Result<T, E>>;\n\n/**\n * Wraps a synchronous function in a try-catch block and returns a Result tuple containing either the returned value or the caught error\n *\n * @template T - The type of the successful result value\n * @template E - The type of the error value, must extend Error\n * @param {() => T} fn - The function to be executed\n * @returns {Result<T, E>} A tuple containing either [data, undefined] or [undefined, error]\n *\n * @example\n * const [data, error] = tryCatch(() => someRiskyOperation());\n * if (error) {\n *   console.error(error);\n * } else {\n *   console.log(data);\n * }\n */\nexport function tryCatch<T, E extends Error>(fn: () => T): Result<T, E> {\n  try {\n    const data = fn();\n    return [data as T, undefined];\n  } catch (error) {\n    return [undefined, error as E];\n  }\n}\n\n/**\n * Wraps a Promise in a try-catch block and returns a Result object containing either the resolved data or the caught error\n *\n * @template T - The type of the successful result value\n * @template E - The type of the error value, defaults to Error\n * @param {Promise<T>} promise - The promise to be executed\n * @returns {Promise<Result<T, E>>} A Promise that resolves to a Result object containing either the data or error\n *\n * @example\n * const {data, error} = await tryCatchAsync(somePromise);\n * if (error) {\n *   console.error(result.error);\n * } else {\n *   console.log(data);\n * }\n */\nexport async function tryCatchAsync<T, E extends Error>(promise: Promise<T>): PromiseResult<T, E> {\n  try {\n    const data = await promise;\n    return [data as T, undefined];\n  } catch (error) {\n    return [undefined, error as E];\n  }\n}\n"
  ],
  "mappings": "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",
  "debugId": "2329ACCD00D0C99964756E2164756E21",
  "names": []
}

package/dist/utils/isCallable.d.ts

@@ -0,0 +1 @@
+export declare function isCallable(value: any): value is CallableFunction;

package/dist/utils/isPromise.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @deprecated Use node:util/types::isPromise
+ * @param value unknown
+ * @returns
+ */
+export declare function isPromise<T = any>(value: unknown): value is Promise<T>;

package/dist/utils/sleep.d.ts

@@ -0,0 +1 @@
+export declare const sleep: (ms: number) => Promise<unknown>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lukaskj/ts-utils",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "module": "src/index.ts",
   "type": "module",
   "scripts": {
@@ -23,6 +23,7 @@
     "@faker-js/faker": "^9.9.0",
     "@types/bun": "latest",
     "@types/node": "^24.2.1",
+    "bun-mock-extended": "^3.0.5",
     "husky": "^9.1.7",
     "lint-staged": "^16.1.5",
     "typescript": "^5.9.2"
@@ -65,6 +66,16 @@
         "default": "./dist/colors/index.cjs",
         "types": "./dist/colors/index.d.ts"
       }
+    },
+    "./cache": {
+      "import": {
+        "default": "./dist/cache/index.mjs",
+        "types": "./dist/cache/index.d.ts"
+      },
+      "require": {
+        "default": "./dist/cache/index.cjs",
+        "types": "./dist/cache/index.d.ts"
+      }
     }
   },
   "engines": {