about-system 0.10.10 → 0.10.11

package/src/utils/network.ts

@@ -3,6 +3,7 @@
  * @module network
  */
 
+import http from "http";
 import https from "https";
 import {
   DEFAULT_IPINFO_TOKEN,
@@ -29,6 +30,7 @@ export interface IPInfo {
  * @interface IPAPIInfo
  */
 interface IPAPIInfo {
+  status?: string;
   query?: string;
   city?: string;
   isp?: string;
@@ -37,122 +39,139 @@ interface IPAPIInfo {
 }
 
 /**
- * Fetches IP geolocation information from ipinfo.io lite API
- * @param {string} token - IPInfo.io API token
- * @param {number} timeout - Request timeout in milliseconds
- * @returns {Promise<IPInfo>} IP information object or empty object on error
+ * GETs a URL and parses the body as JSON. Never rejects: resolves `null` on
+ * any error, on abort, or once `timeout` ms have passed in total — a hard
+ * deadline for the whole request, not a socket-idle timeout.
  */
-async function fetchFromIPInfo(
-  token: string = DEFAULT_IPINFO_TOKEN,
-  timeout: number = DEFAULT_NETWORK_TIMEOUT
-): Promise<IPInfo> {
+function getJSON(
+  url: string,
+  timeout: number,
+  signal?: AbortSignal
+): Promise<any> {
   return new Promise((resolve) => {
-    const url = `https://api.ipinfo.io/lite/8.8.8.8?token=${token}`;
+    if (signal?.aborted) return resolve(null);
 
-    const req = https.get(url, (res) => {
-      let data = "";
-      res.on("data", (chunk) => (data += chunk));
-      res.on("end", () => {
-        try {
-          const parsed = JSON.parse(data);
-          // ipinfo lite returns: { ip, city, region, country, org }
-          // Map to our standard IPInfo format
-          resolve({
-            ip: parsed.ip,
-            city: parsed.city,
-            hostname: parsed.hostname,
-            org: parsed.org,
-          });
-        } catch {
-          resolve({});
-        }
-      });
-    });
+    let settled = false;
+    let req: http.ClientRequest | undefined;
+    const finish = (value: any) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      resolve(value);
+    };
+    const onAbort = () => {
+      req?.destroy();
+      finish(null);
+    };
+    const timer = setTimeout(onAbort, timeout);
+    signal?.addEventListener("abort", onAbort);
 
-    req.on("error", () => resolve({}));
-    req.setTimeout(timeout, () => {
-      req.destroy();
-      resolve({});
-    });
+    try {
+      const get = url.startsWith("https:") ? https.get : http.get;
+      req = get(url, (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          try {
+            finish(JSON.parse(data));
+          } catch {
+            finish(null);
+          }
+        });
+        res.on("error", () => finish(null));
+      });
+      req.on("error", () => finish(null));
+    } catch {
+      finish(null);
+    }
   });
 }
 
 /**
- * Fetches IP geolocation information from ip-api.com (fallback)
- * @param {number} timeout - Request timeout in milliseconds
+ * Fetches IP information for this machine from the ipinfo.io lite API
+ * @param {string} token - IPInfo.io API token
+ * @param {number} timeout - Total request deadline in milliseconds
+ * @param {AbortSignal} signal - Abandons the request when aborted
  * @returns {Promise<IPInfo>} IP information object or empty object on error
  */
-async function fetchFromIPAPI(
-  timeout: number = DEFAULT_NETWORK_TIMEOUT
+export async function fetchFromIPInfo(
+  token: string = DEFAULT_IPINFO_TOKEN,
+  timeout: number = DEFAULT_NETWORK_TIMEOUT,
+  signal?: AbortSignal
 ): Promise<IPInfo> {
-  return new Promise((resolve) => {
-    const url = "http://ip-api.com/json/?fields=status,message,query,city,isp,org,as";
-
-    const req = https.get(url, (res) => {
-      let data = "";
-      res.on("data", (chunk) => (data += chunk));
-      res.on("end", () => {
-        try {
-          const parsed: IPAPIInfo = JSON.parse(data);
-          if (parsed.status === "success") {
-            // Map ip-api response to our standard IPInfo format
-            resolve({
-              ip: parsed.query,
-              city: parsed.city,
-              hostname: undefined,
-              org: parsed.org || parsed.isp || parsed.as,
-            });
-          } else {
-            resolve({});
-          }
-        } catch {
-          resolve({});
-        }
-      });
-    });
+  const parsed = await getJSON(
+    `https://api.ipinfo.io/lite/me?token=${token}`,
+    timeout,
+    signal
+  );
+  if (!parsed || typeof parsed !== "object") return {};
+  // ipinfo lite returns { ip, asn, as_name, country, ... } — no city.
+  const org =
+    parsed.org ?? (parsed.asn && parsed.as_name ? `${parsed.asn} ${parsed.as_name}` : undefined);
+  return {
+    ip: parsed.ip,
+    city: parsed.city,
+    hostname: parsed.hostname,
+    org,
+  };
+}
 
-    req.on("error", () => resolve({}));
-    req.setTimeout(timeout, () => {
-      req.destroy();
-      resolve({});
-    });
-  });
+/**
+ * Fetches IP geolocation information from ip-api.com (fallback). The free
+ * tier is plain HTTP only.
+ * @param {number} timeout - Total request deadline in milliseconds
+ * @param {AbortSignal} signal - Abandons the request when aborted
+ * @returns {Promise<IPInfo>} IP information object or empty object on error
+ */
+export async function fetchFromIPAPI(
+  timeout: number = DEFAULT_NETWORK_TIMEOUT,
+  signal?: AbortSignal
+): Promise<IPInfo> {
+  const parsed: IPAPIInfo | null = await getJSON(
+    "http://ip-api.com/json/?fields=status,message,query,city,isp,org,as",
+    timeout,
+    signal
+  );
+  if (!parsed || parsed.status !== "success") return {};
+  return {
+    ip: parsed.query,
+    city: parsed.city,
+    hostname: undefined,
+    org: parsed.org || parsed.isp || parsed.as,
+  };
 }
 
 /**
- * Fetches IP geolocation information using race between ipinfo.io and ip-api.com
- * Uses ipinfo.io lite endpoint first, falls back to ip-api.com if slower or fails
+ * Fetches IP information from ipinfo.io and ip-api.com in parallel and merges
+ * them: ipinfo.io wins per field, ip-api.com fills the gaps (ipinfo lite has
+ * no city). Both requests share the same deadline, so this never takes longer
+ * than `timeout`.
  * @param {string} token - IPInfo.io API token
- * @param {number} timeout - Request timeout in milliseconds
+ * @param {number} timeout - Total deadline in milliseconds
+ * @param {AbortSignal} signal - Abandons both requests when aborted
  * @returns {Promise<IPInfo>} IP information object or empty object on error
  */
 export async function fetchIPInfo(
   token: string = DEFAULT_IPINFO_TOKEN,
-  timeout: number = DEFAULT_NETWORK_TIMEOUT
+  timeout: number = DEFAULT_NETWORK_TIMEOUT,
+  signal?: AbortSignal
 ): Promise<IPInfo> {
-  // Race both services, use whichever responds first
-  const [ipinfoResult, ipapiResult] = await Promise.allSettled([
-    fetchFromIPInfo(token, timeout),
-    fetchFromIPAPI(timeout),
+  const [ipinfo, ipapi] = await Promise.all([
+    fetchFromIPInfo(token, timeout, signal),
+    fetchFromIPAPI(timeout, signal),
   ]);
 
-  // Prefer ipinfo.io result if successful and has data
-  if (ipinfoResult.status === "fulfilled" && ipinfoResult.value && ipinfoResult.value.ip) {
-    return ipinfoResult.value;
+  const merged: IPInfo = {};
+  for (const source of [ipapi, ipinfo]) {
+    for (const [key, value] of Object.entries(source)) {
+      if (value) merged[key as keyof IPInfo] = value;
+    }
   }
-
-  // Fall back to ip-api.com result if successful and has data
-  if (ipapiResult.status === "fulfilled" && ipapiResult.value && ipapiResult.value.ip) {
-    return ipapiResult.value;
-  }
-
-  // Return whichever has data, or empty object
-  if (ipinfoResult.status === "fulfilled" && ipinfoResult.value) {
-    return ipinfoResult.value;
+  // ipinfo answers over IPv6 when the machine has it; the short IPv4 address
+  // reads better in a one-line greeting, so keep ip-api's when it has one.
+  if (merged.ip?.includes(":") && ipapi.ip && !ipapi.ip.includes(":")) {
+    merged.ip = ipapi.ip;
   }
-  if (ipapiResult.status === "fulfilled" && ipapiResult.value) {
-    return ipapiResult.value;
-  }
-
-  return {};
-}
+  return merged;
+}

package/src/utils/utils.test.ts

@@ -22,6 +22,11 @@ vi.mock("https", () => ({
   get: httpsGet,
   default: { get: httpsGet },
 }));
+const httpGet = vi.hoisted(() => vi.fn());
+vi.mock("http", () => ({
+  get: httpGet,
+  default: { get: httpGet },
+}));
 
 import { commandExists, execCommand } from "./command";
 import { IS_LINUX, IS_MAC, IS_WINDOWS } from "./platform";
@@ -31,7 +36,9 @@ import { DEFAULT_IPINFO_TOKEN, DEFAULT_NETWORK_TIMEOUT } from "../cache/cache-co
 afterEach(() => {
   execSync.mockReset();
   httpsGet.mockReset();
+  httpGet.mockReset();
   vi.restoreAllMocks();
+  vi.useRealTimers();
 });
 
 describe("platform flags", () => {
@@ -118,24 +125,27 @@ describe("commandExists", () => {
   });
 });
 
-/** A fake `https.get` whose response body and failure mode a test controls. */
-function stubHttpsGet(behavior: (req: EventEmitter & { setTimeout: (ms: number, fn: () => void) => void; destroy: () => void }, onResponse: (res: EventEmitter) => void) => void) {
-  httpsGet.mockImplementation(
-    (_url: string, callback: (res: EventEmitter) => void) => {
-      const req = Object.assign(new EventEmitter(), {
-        setTimeout: vi.fn(),
-        destroy: vi.fn(),
-      });
-      queueMicrotask(() => behavior(req, callback));
-      return req;
-    },
-  );
-  return httpsGet;
+type FakeReq = EventEmitter & { destroy: () => void };
+
+/**
+ * A fake `get` (https or http) whose response a test controls. `behavior`
+ * runs on the next microtask; leave it empty to simulate a hung request.
+ */
+function stubGet(
+  get: typeof httpsGet,
+  behavior: (req: FakeReq, onResponse: (res: EventEmitter) => void) => void = () => {},
+) {
+  get.mockImplementation((_url: string, callback: (res: EventEmitter) => void) => {
+    const req: FakeReq = Object.assign(new EventEmitter(), { destroy: vi.fn() });
+    queueMicrotask(() => behavior(req, callback));
+    return req;
+  });
+  return get;
 }
 
 /** Emits a complete response body on the next tick. */
-const respondWith = (body: string) =>
-  stubHttpsGet((_req, onResponse) => {
+const respondWith = (get: typeof httpsGet, body: string) =>
+  stubGet(get, (_req, onResponse) => {
     const res = new EventEmitter();
     onResponse(res);
     res.emit("data", body);
@@ -144,57 +154,61 @@ const respondWith = (body: string) =>
 
 describe("fetchFromIPInfo", () => {
   it("parses the ipinfo.io lite payload", async () => {
-    respondWith(JSON.stringify({ ip: "1.2.3.4", city: "San Francisco", org: "AS123 Test ISP" }));
+    respondWith(httpsGet, JSON.stringify({ ip: "1.2.3.4", asn: "AS123", as_name: "Test ISP", country: "US" }));
 
     await expect(fetchFromIPInfo()).resolves.toEqual({
       ip: "1.2.3.4",
-      city: "San Francisco",
       org: "AS123 Test ISP",
     });
   });
 
-  it("sends request to ipinfo.io lite endpoint with token", async () => {
-    const get = respondWith("{}");
+  it("asks about this machine, not a fixed address", async () => {
+    const get = respondWith(httpsGet, "{}");
     await fetchFromIPInfo();
 
     expect(get.mock.calls[0][0]).toBe(
-      `https://api.ipinfo.io/lite/8.8.8.8?token=${DEFAULT_IPINFO_TOKEN}`,
+      `https://api.ipinfo.io/lite/me?token=${DEFAULT_IPINFO_TOKEN}`,
     );
   });
 
   it("resolves empty rather than rejecting on a malformed body", async () => {
-    respondWith("<html>gateway error</html>");
+    respondWith(httpsGet, "<html>gateway error</html>");
     await expect(fetchFromIPInfo()).resolves.toEqual({});
   });
 
   it("resolves empty rather than rejecting when the request errors", async () => {
-    stubHttpsGet((req) => req.emit("error", new Error("ENOTFOUND")));
+    stubGet(httpsGet, (req) => req.emit("error", new Error("ENOTFOUND")));
     await expect(fetchFromIPInfo()).resolves.toEqual({});
   });
 
-  it("arms a timeout that abandons the request", async () => {
-    let armed: { ms: number; fire: () => void } | undefined;
-    httpsGet.mockImplementation(() => {
-      const req = Object.assign(new EventEmitter(), {
-        setTimeout: (ms: number, fire: () => void) => {
-          armed = { ms, fire };
-        },
-        destroy: vi.fn(),
-      });
-      return req;
-    });
+  it("gives up after a hard 3 second deadline by default", async () => {
+    vi.useFakeTimers();
+    stubGet(httpsGet);
+    let done = false;
+    const pending = fetchFromIPInfo().then((r) => ((done = true), r));
 
-    const pending = fetchFromIPInfo(DEFAULT_IPINFO_TOKEN, 1234);
-    expect(armed?.ms).toBe(1234);
+    await vi.advanceTimersByTimeAsync(DEFAULT_NETWORK_TIMEOUT - 1);
+    expect(done).toBe(false);
+    await vi.advanceTimersByTimeAsync(1);
+    await expect(pending).resolves.toEqual({});
+    expect(DEFAULT_NETWORK_TIMEOUT).toBe(3000);
+    expect(httpsGet.mock.results[0].value.destroy).toHaveBeenCalled();
+  });
+
+  it("abandons the request when the signal aborts", async () => {
+    stubGet(httpsGet);
+    const controller = new AbortController();
+    const pending = fetchFromIPInfo(DEFAULT_IPINFO_TOKEN, 60_000, controller.signal);
 
-    armed?.fire();
+    controller.abort();
     await expect(pending).resolves.toEqual({});
+    expect(httpsGet.mock.results[0].value.destroy).toHaveBeenCalled();
   });
 });
 
 describe("fetchFromIPAPI", () => {
   it("parses the ip-api.com payload", async () => {
-    respondWith(JSON.stringify({
+    respondWith(httpGet, JSON.stringify({
       status: "success",
       query: "1.2.3.4",
       city: "San Francisco",
@@ -210,66 +224,51 @@ describe("fetchFromIPAPI", () => {
     });
   });
 
-  it("sends request to ip-api.com endpoint", async () => {
-    const get = respondWith('{"status":"success"}');
+  it("uses plain http, which is all ip-api.com's free tier serves", async () => {
+    const get = respondWith(httpGet, '{"status":"success"}');
     await fetchFromIPAPI();
 
     expect(get.mock.calls[0][0]).toBe(
       "http://ip-api.com/json/?fields=status,message,query,city,isp,org,as"
     );
+    expect(httpsGet).not.toHaveBeenCalled();
   });
 
   it("returns empty object on failed status", async () => {
-    respondWith(JSON.stringify({ status: "fail", message: "private range" }));
+    respondWith(httpGet, JSON.stringify({ status: "fail", message: "private range" }));
     await expect(fetchFromIPAPI()).resolves.toEqual({});
   });
 
   it("resolves empty rather than rejecting on a malformed body", async () => {
-    respondWith("<html>gateway error</html>");
+    respondWith(httpGet, "<html>gateway error</html>");
     await expect(fetchFromIPAPI()).resolves.toEqual({});
   });
 });
 
-describe("fetchIPInfo (race)", () => {
-  it("returns ipinfo result when it responds first with data", async () => {
-    let ipinfoResolve: (value: any) => void;
-    let ipapiResolve: (value: any) => void;
-
-    const ipinfoPromise = new Promise((resolve) => { ipinfoResolve = resolve; });
-    const ipapiPromise = new Promise((resolve) => { ipapiResolve = resolve; });
-
-    vi.spyOn(await import("./network"), "fetchFromIPInfo").mockReturnValue(ipinfoPromise);
-    vi.spyOn(await import("./network"), "fetchFromIPAPI").mockReturnValue(ipapiPromise);
-
-    const resultPromise = fetchIPInfo();
+describe("fetchIPInfo", () => {
+  it("prefers ipinfo per field and fills gaps from ip-api", async () => {
+    respondWith(httpsGet, JSON.stringify({ ip: "1.2.3.4", asn: "AS123", as_name: "Primary ISP" }));
+    respondWith(httpGet, JSON.stringify({ status: "success", query: "5.6.7.8", city: "New York", org: "AS456 Other" }));
 
-    // Resolve ipinfo first with data
-    ipinfoResolve!({ ip: "1.2.3.4", city: "San Francisco" });
-    ipapiResolve!({ ip: "5.6.7.8", city: "New York" });
-
-    await expect(resultPromise).resolves.toEqual({
+    await expect(fetchIPInfo()).resolves.toEqual({
       ip: "1.2.3.4",
-      city: "San Francisco",
+      city: "New York",
+      org: "AS123 Primary ISP",
     });
   });
 
-  it("falls back to ip-api when ipinfo fails", async () => {
-    let ipinfoResolve: (value: any) => void;
-    let ipapiResolve: (value: any) => void;
-
-    const ipinfoPromise = new Promise((resolve) => { ipinfoResolve = resolve; });
-    const ipapiPromise = new Promise((resolve) => { ipapiResolve = resolve; });
-
-    vi.spyOn(await import("./network"), "fetchFromIPInfo").mockReturnValue(ipinfoPromise);
-    vi.spyOn(await import("./network"), "fetchFromIPAPI").mockReturnValue(ipapiPromise);
+  it("prefers an IPv4 address over ipinfo's IPv6 one", async () => {
+    respondWith(httpsGet, JSON.stringify({ ip: "2600:1010::1", asn: "AS123", as_name: "Primary ISP" }));
+    respondWith(httpGet, JSON.stringify({ status: "success", query: "5.6.7.8", city: "New York" }));
 
-    const resultPromise = fetchIPInfo();
+    await expect(fetchIPInfo()).resolves.toMatchObject({ ip: "5.6.7.8" });
+  });
 
-    // Resolve ipinfo with empty, ipapi with data
-    ipinfoResolve!({});
-    ipapiResolve!({ ip: "5.6.7.8", city: "New York", org: "AS456 Fallback ISP" });
+  it("falls back to ip-api when ipinfo fails", async () => {
+    stubGet(httpsGet, (req) => req.emit("error", new Error("ECONNRESET")));
+    respondWith(httpGet, JSON.stringify({ status: "success", query: "5.6.7.8", city: "New York", org: "AS456 Fallback ISP" }));
 
-    await expect(resultPromise).resolves.toEqual({
+    await expect(fetchIPInfo()).resolves.toEqual({
       ip: "5.6.7.8",
       city: "New York",
       org: "AS456 Fallback ISP",
@@ -277,9 +276,19 @@ describe("fetchIPInfo (race)", () => {
   });
 
   it("returns empty when both fail", async () => {
-    vi.spyOn(await import("./network"), "fetchFromIPInfo").mockResolvedValue({});
-    vi.spyOn(await import("./network"), "fetchFromIPAPI").mockResolvedValue({});
+    stubGet(httpsGet, (req) => req.emit("error", new Error("ENOTFOUND")));
+    stubGet(httpGet, (req) => req.emit("error", new Error("ENOTFOUND")));
 
     await expect(fetchIPInfo()).resolves.toEqual({});
   });
+
+  it("never waits past the shared deadline when both hang", async () => {
+    vi.useFakeTimers();
+    stubGet(httpsGet);
+    stubGet(httpGet);
+    const pending = fetchIPInfo();
+
+    await vi.advanceTimersByTimeAsync(DEFAULT_NETWORK_TIMEOUT);
+    await expect(pending).resolves.toEqual({});
+  });
 });

package/dist/about-system-cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"about-system-cli.d.ts","sourceRoot":"","sources":["../src/about-system-cli.ts"],"names":[],"mappings":";AAoJA,iBAAe,iBAAiB,CAC9B,kBAAkB,GAAE,MAAM,EAAE,EAAE,GAAG,IAAW,GAC3C,OAAO,CAAC,IAAI,CAAC,CAqDf;AA8ED,iBAAS,oBAAoB,IAAI,IAAI,CAoGpC;AAoJD,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/cache/cache-config.d.ts

@@ -1,62 +0,0 @@
-/**
- * Cache configuration and constants
- * @module cache-config
- */
-/**
- * Cache file location in system's temporary directory
- * @constant
- */
-export declare const CACHE_FILE: string;
-/**
- * Cache duration configuration for different system information types
- * Values are in milliseconds
- *
- * @constant
- * @property {number} ip - IP information cache (10 minutes)
- * @property {number} cpu - CPU information cache (24 hours)
- * @property {number} gpu - GPU information cache (24 hours)
- * @property {number} os - OS information cache (24 hours)
- * @property {number} device - Device information cache (24 hours)
- * @property {number} kernel - Kernel information cache (1 hour)
- * @property {number} pacman - Package managers cache (10 minutes)
- * @property {number} ports - Open ports cache (5 minutes)
- * @property {number} containers - Docker containers cache (5 minutes)
- * @property {number} top_process - Top process cache (5 seconds)
- * @property {number} disk_used - Disk usage cache (1 minute)
- * @property {number} ram_used - RAM usage cache (10 seconds)
- * @property {number} services_running - Services cache (5 minutes)
- * @property {number} temperature - Temperature cache (30 seconds)
- * @property {number} battery - Battery status cache (1 minute)
- * @property {number} network_interfaces - Network interfaces cache (5 minutes)
- * @property {number} mount_points - Mount points cache (10 minutes)
- */
-export declare const CACHE_DURATION: {
-    ip: number;
-    cpu: number;
-    gpu: number;
-    os: number;
-    device: number;
-    kernel: number;
-    pacman: number;
-    ports: number;
-    containers: number;
-    top_process: number;
-    disk_used: number;
-    ram_used: number;
-    services_running: number;
-    temperature: number;
-    battery: number;
-    network_interfaces: number;
-    mount_points: number;
-};
-/**
- * Default IPInfo.io API token for geolocation
- * @constant
- */
-export declare const DEFAULT_IPINFO_TOKEN = "da2d6cc4baa5d1";
-/**
- * Default network request timeout in milliseconds
- * @constant
- */
-export declare const DEFAULT_NETWORK_TIMEOUT = 5000;
-//# sourceMappingURL=cache-config.d.ts.map

package/dist/cache/cache-config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache-config.d.ts","sourceRoot":"","sources":["../../src/cache/cache-config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH;;;GAGG;AACH,eAAO,MAAM,UAAU,QAAkD,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;CAkB1B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,mBAAmB,CAAC;AAErD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,OAAO,CAAC"}

package/dist/cache/cache.d.ts

@@ -1,53 +0,0 @@
-/**
- * Cache management utilities
- * @module cache
- */
-/**
- * Represents a cached value with timestamp
- * @interface CacheEntry
- */
-export interface CacheEntry {
-    /** The cached value */
-    value: any;
-    /** Unix timestamp when the value was cached */
-    timestamp: number;
-}
-/**
- * Cache storage structure
- * @interface Cache
- */
-export interface Cache {
-    [key: string]: CacheEntry;
-}
-/**
- * Loads cache from disk
- * @returns {Cache} Cached data or empty object if cache doesn't exist or is corrupted
- */
-export declare function loadCache(): Cache;
-/**
- * Saves cache to disk
- * @param {Cache} cache - Cache object to save
- */
-export declare function saveCache(cache: Cache): void;
-/**
- * Checks if a cache entry is still valid based on configured duration
- * @param {CacheEntry} cacheEntry - The cache entry to validate
- * @param {string} key - The key name to determine cache duration
- * @returns {boolean} True if cache is still valid
- */
-export declare function isCacheValid(cacheEntry: CacheEntry, key: string): boolean;
-/**
- * Retrieves a value from cache if valid
- * @param {Cache} cache - Cache object
- * @param {string} key - Key to retrieve
- * @returns {any} Cached value or null if not found/expired
- */
-export declare function getCachedValue(cache: Cache, key: string): any;
-/**
- * Stores a value in cache with current timestamp
- * @param {Cache} cache - Cache object
- * @param {string} key - Key to store under
- * @param {any} value - Value to cache
- */
-export declare function setCachedValue(cache: Cache, key: string, value: any): void;
-//# sourceMappingURL=cache.d.ts.map

package/dist/cache/cache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/cache/cache.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,uBAAuB;IACvB,KAAK,EAAE,GAAG,CAAC;IACX,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,MAAM,WAAW,KAAK;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;CAC3B;AAED;;;GAGG;AACH,wBAAgB,SAAS,IAAI,KAAK,CASjC;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAM5C;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAKzE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,GAAG,GAAG,CAQ7D;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI,CAK1E"}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC3E,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,QAAQ,EAAE,qBAAqB,EAAE,yBAAyB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC"}