fynixui 1.0.0

package/dist/hooks/nixAsyncCache.js

@@ -0,0 +1,137 @@
+import { nixState } from "./nixState";
+const asyncCache = new Map();
+const CACHE_CLEANUP_INTERVAL = 60000;
+let cacheCleanupTimer = null;
+const startCacheCleanup = () => {
+    if (cacheCleanupTimer)
+        return;
+    cacheCleanupTimer = setInterval(() => {
+        const now = Date.now();
+        const entries = Array.from(asyncCache.entries());
+        for (const [key, entry] of entries) {
+            if (entry.timestamp && entry.ttl && now - entry.timestamp > entry.ttl) {
+                asyncCache.delete(key);
+            }
+        }
+        if (asyncCache.size === 0 && cacheCleanupTimer) {
+            clearInterval(cacheCleanupTimer);
+            cacheCleanupTimer = null;
+        }
+    }, CACHE_CLEANUP_INTERVAL);
+};
+export function nixAsyncCached(key, promiseFactory, options = {}) {
+    if (!promiseFactory || typeof promiseFactory !== "function") {
+        throw new Error("[nixAsyncCache] promiseFactory must be a function");
+    }
+    if (key == null) {
+        throw new Error("[nixAsyncCache] Key cannot be null or undefined");
+    }
+    if (options.validateKey && !options.validateKey(key)) {
+        throw new Error("[nixAsyncCache] Invalid cache key");
+    }
+    const { ttl = 300000, maxCacheSize = 100 } = options;
+    if (asyncCache.size >= maxCacheSize) {
+        const entries = Array.from(asyncCache.entries());
+        const entriesToRemove = Math.max(1, Math.floor(maxCacheSize * 0.1));
+        for (let i = 0; i < entriesToRemove; i++) {
+            const entry = entries[i];
+            if (entry) {
+                asyncCache.delete(entry[0]);
+            }
+        }
+    }
+    const data = nixState(null);
+    const error = nixState(null);
+    const loading = nixState(false);
+    let active = true;
+    let abortController = null;
+    startCacheCleanup();
+    const run = async () => {
+        if (!active)
+            return;
+        if (abortController) {
+            abortController.abort();
+        }
+        abortController = new AbortController();
+        loading.value = true;
+        error.value = null;
+        try {
+            if (asyncCache.has(key)) {
+                const cached = asyncCache.get(key);
+                const now = Date.now();
+                if (cached.timestamp && now - cached.timestamp > ttl) {
+                    asyncCache.delete(key);
+                }
+                else if (cached.data !== undefined) {
+                    data.value = cached.data;
+                    loading.value = false;
+                    return;
+                }
+                if (cached.promise) {
+                    try {
+                        const result = await cached.promise;
+                        if (!active || abortController?.signal.aborted)
+                            return;
+                        data.value = result;
+                        loading.value = false;
+                        return;
+                    }
+                    catch (e) {
+                        if (!active || abortController?.signal.aborted)
+                            return;
+                        error.value = e;
+                        loading.value = false;
+                        return;
+                    }
+                }
+            }
+            const promise = Promise.resolve().then(() => {
+                if (abortController?.signal.aborted) {
+                    throw new Error("Request was aborted");
+                }
+                return promiseFactory();
+            });
+            asyncCache.set(key, {
+                promise,
+                timestamp: Date.now(),
+                ttl,
+            });
+            const result = await promise;
+            if (!active || abortController?.signal.aborted)
+                return;
+            asyncCache.set(key, {
+                data: result,
+                timestamp: Date.now(),
+                ttl,
+            });
+            data.value = result;
+        }
+        catch (e) {
+            if (asyncCache.has(key)) {
+                const cached = asyncCache.get(key);
+                if (cached.promise && !cached.data) {
+                    asyncCache.delete(key);
+                }
+            }
+            if (!active || abortController?.signal.aborted)
+                return;
+            error.value = e;
+        }
+        finally {
+            if (active && !abortController?.signal.aborted) {
+                loading.value = false;
+            }
+        }
+    };
+    const cancel = () => {
+        active = false;
+        if (abortController) {
+            abortController.abort();
+            abortController = null;
+        }
+    };
+    const clearCache = () => {
+        asyncCache.delete(key);
+    };
+    return { data, error, loading, run, cancel, clearCache };
+}

package/dist/hooks/nixAsyncCache.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../hooks/nixAsyncCache.ts"],
+  "sourcesContent": ["/* MIT License\r\n\r\n* Copyright (c) 2026 Resty Gonzales\r\n\r\nPermission is hereby granted, free of charge, to any person obtaining a copy\r\nof this software and associated documentation files (the \"Software\"), to deal\r\nin the Software without restriction, including without limitation the rights\r\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\ncopies of the Software, and to permit persons to whom the Software is\r\nfurnished to do so, subject to the following conditions:\r\n\r\nThe above copyright notice and this permission notice shall be included in all\r\ncopies or substantial portions of the Software.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n* SOFTWARE.\r\n */\r\nimport { nixState } from \"./nixState\";\r\n\r\nconst asyncCache: Map<\r\n  any,\r\n  {\r\n    data?: any;\r\n    promise?: Promise<any>;\r\n    timestamp?: number;\r\n    ttl?: number;\r\n  }\r\n> = new Map();\r\n\r\n// Cache cleanup to prevent memory leaks\r\nconst CACHE_CLEANUP_INTERVAL = 60000; // 1 minute\r\nlet cacheCleanupTimer: NodeJS.Timeout | null = null;\r\n\r\nconst startCacheCleanup = () => {\r\n  if (cacheCleanupTimer) return;\r\n\r\n  cacheCleanupTimer = setInterval(() => {\r\n    const now = Date.now();\r\n    const entries = Array.from(asyncCache.entries());\r\n\r\n    for (const [key, entry] of entries) {\r\n      if (entry.timestamp && entry.ttl && now - entry.timestamp > entry.ttl) {\r\n        asyncCache.delete(key);\r\n      }\r\n    }\r\n\r\n    // If cache is empty, stop cleanup timer\r\n    if (asyncCache.size === 0 && cacheCleanupTimer) {\r\n      clearInterval(cacheCleanupTimer);\r\n      cacheCleanupTimer = null;\r\n    }\r\n  }, CACHE_CLEANUP_INTERVAL);\r\n};\r\n\r\n/**\r\n * Cached async hook with enhanced security and memory management.\r\n *\r\n * @param {any} key - Cache key (must be serializable)\r\n * @param {() => Promise<any>} promiseFactory - Function that returns a promise\r\n * @param {object} options - Configuration options\r\n * @returns {object} Reactive state object with data, error, loading, and control methods\r\n */\r\n\r\nexport function nixAsyncCached(\r\n  key: any,\r\n  promiseFactory: () => Promise<any>,\r\n  options: {\r\n    ttl?: number; // Time to live in ms\r\n    maxCacheSize?: number;\r\n    validateKey?: (key: any) => boolean;\r\n  } = {}\r\n): {\r\n  data: { value: any };\r\n  error: { value: any };\r\n  loading: { value: boolean };\r\n  run: () => Promise<void>;\r\n  cancel: () => void;\r\n  clearCache: () => void;\r\n} {\r\n  // Input validation\r\n  if (!promiseFactory || typeof promiseFactory !== \"function\") {\r\n    throw new Error(\"[nixAsyncCache] promiseFactory must be a function\");\r\n  }\r\n\r\n  // Validate cache key\r\n  if (key == null) {\r\n    throw new Error(\"[nixAsyncCache] Key cannot be null or undefined\");\r\n  }\r\n\r\n  if (options.validateKey && !options.validateKey(key)) {\r\n    throw new Error(\"[nixAsyncCache] Invalid cache key\");\r\n  }\r\n\r\n  const { ttl = 300000, maxCacheSize = 100 } = options; // 5 min default TTL\r\n\r\n  // Enforce cache size limits to prevent memory attacks\r\n  if (asyncCache.size >= maxCacheSize) {\r\n    // Remove oldest entries\r\n    const entries = Array.from(asyncCache.entries());\r\n    const entriesToRemove = Math.max(1, Math.floor(maxCacheSize * 0.1)); // Remove 10%\r\n\r\n    for (let i = 0; i < entriesToRemove; i++) {\r\n      const entry = entries[i];\r\n      if (entry) {\r\n        asyncCache.delete(entry[0]);\r\n      }\r\n    }\r\n  }\r\n\r\n  const data = nixState(null) as { value: any };\r\n  const error = nixState(null) as { value: any };\r\n  const loading = nixState(false) as { value: boolean };\r\n\r\n  let active: boolean = true;\r\n  let abortController: AbortController | null = null;\r\n\r\n  startCacheCleanup();\r\n\r\n  const run = async (): Promise<void> => {\r\n    if (!active) return;\r\n\r\n    // Cancel previous request if still running\r\n    if (abortController) {\r\n      abortController.abort();\r\n    }\r\n\r\n    abortController = new AbortController();\r\n    loading.value = true;\r\n    error.value = null;\r\n\r\n    try {\r\n      // Cache hit with resolved data\r\n      if (asyncCache.has(key)) {\r\n        const cached = asyncCache.get(key)!;\r\n        const now = Date.now();\r\n\r\n        // Check TTL\r\n        if (cached.timestamp && now - cached.timestamp > ttl) {\r\n          asyncCache.delete(key);\r\n        } else if (cached.data !== undefined) {\r\n          data.value = cached.data;\r\n          loading.value = false;\r\n          return;\r\n        }\r\n\r\n        // Deduping: reuse in-flight promise if still valid\r\n        if (cached.promise) {\r\n          try {\r\n            const result = await cached.promise;\r\n            if (!active || abortController?.signal.aborted) return;\r\n            data.value = result;\r\n            loading.value = false;\r\n            return;\r\n          } catch (e) {\r\n            if (!active || abortController?.signal.aborted) return;\r\n            error.value = e;\r\n            loading.value = false;\r\n            return;\r\n          }\r\n        }\r\n      }\r\n\r\n      // Cache miss - create new promise\r\n      const promise = Promise.resolve().then(() => {\r\n        if (abortController?.signal.aborted) {\r\n          throw new Error(\"Request was aborted\");\r\n        }\r\n        return promiseFactory();\r\n      });\r\n\r\n      asyncCache.set(key, {\r\n        promise,\r\n        timestamp: Date.now(),\r\n        ttl,\r\n      });\r\n\r\n      const result = await promise;\r\n\r\n      if (!active || abortController?.signal.aborted) return;\r\n\r\n      // Cache successful result\r\n      asyncCache.set(key, {\r\n        data: result,\r\n        timestamp: Date.now(),\r\n        ttl,\r\n      });\r\n\r\n      data.value = result;\r\n    } catch (e) {\r\n      // Remove failed promise from cache\r\n      if (asyncCache.has(key)) {\r\n        const cached = asyncCache.get(key)!;\r\n        if (cached.promise && !cached.data) {\r\n          asyncCache.delete(key);\r\n        }\r\n      }\r\n\r\n      if (!active || abortController?.signal.aborted) return;\r\n      error.value = e;\r\n    } finally {\r\n      if (active && !abortController?.signal.aborted) {\r\n        loading.value = false;\r\n      }\r\n    }\r\n  };\r\n\r\n  const cancel = (): void => {\r\n    active = false;\r\n    if (abortController) {\r\n      abortController.abort();\r\n      abortController = null;\r\n    }\r\n  };\r\n\r\n  const clearCache = (): void => {\r\n    asyncCache.delete(key);\r\n  };\r\n\r\n  return { data, error, loading, run, cancel, clearCache };\r\n}\r\n"],
+  "mappings": "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",
+  "names": ["result"]
+}

package/dist/hooks/nixAsyncDebounce.d.ts

@@ -0,0 +1,22 @@
+export interface NixAsyncDebounceOptions {
+    delay?: number;
+    leading?: boolean;
+    trailing?: boolean;
+    maxWait?: number;
+    cache?: boolean;
+    signal?: AbortSignal;
+}
+export declare function nixAsyncDebounce(promiseFactory: () => Promise<any>, options?: NixAsyncDebounceOptions): {
+    data: {
+        value: any;
+    };
+    error: {
+        value: any;
+    };
+    loading: {
+        value: boolean;
+    };
+    run: () => void | Promise<any>;
+    cancel: () => void;
+};
+//# sourceMappingURL=nixAsyncDebounce.d.ts.map

package/dist/hooks/nixAsyncDebounce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nixAsyncDebounce.d.ts","sourceRoot":"","sources":["../../hooks/nixAsyncDebounce.ts"],"names":[],"mappings":"AA4CA,MAAM,WAAW,uBAAuB;IACtC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,wBAAgB,gBAAgB,CAC9B,cAAc,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,EAClC,OAAO,GAAE,uBAA4B,GACpC;IACD,IAAI,EAAE;QAAE,KAAK,EAAE,GAAG,CAAA;KAAE,CAAC;IACrB,KAAK,EAAE;QAAE,KAAK,EAAE,GAAG,CAAA;KAAE,CAAC;IACtB,OAAO,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IAC5B,GAAG,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAC/B,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB,CA8FA"}

package/dist/hooks/nixAsyncDebounce.js

@@ -0,0 +1,77 @@
+import { nixState } from "./nixState";
+export function nixAsyncDebounce(promiseFactory, options = {}) {
+    const data = nixState(null);
+    const error = nixState(null);
+    const loading = nixState(false);
+    const { delay = 300, leading = false, trailing = true, maxWait, cache = true, signal, } = options;
+    let lastResult = null;
+    let lastError = null;
+    let timerId = null;
+    let lastInvokeTime = 0;
+    let pendingPromise = null;
+    const invoke = async () => {
+        if (cache && lastResult !== null) {
+            data.value = lastResult;
+            error.value = lastError;
+            loading.value = false;
+            return lastResult;
+        }
+        loading.value = true;
+        error.value = null;
+        const abortController = new AbortController();
+        if (signal) {
+            signal.addEventListener("abort", () => {
+                abortController.abort();
+                cancel();
+            });
+        }
+        pendingPromise = promiseFactory();
+        try {
+            const result = await pendingPromise;
+            lastResult = result;
+            data.value = result;
+            return result;
+        }
+        catch (e) {
+            if (e.name !== "AbortError") {
+                lastError = e;
+                error.value = e;
+            }
+            throw e;
+        }
+        finally {
+            loading.value = false;
+            pendingPromise = null;
+            lastInvokeTime = Date.now();
+        }
+    };
+    const run = () => {
+        const now = Date.now();
+        const timeSinceLastInvoke = now - lastInvokeTime;
+        const remainingTime = delay - timeSinceLastInvoke;
+        const shouldInvokeLeading = leading && !timerId;
+        if (maxWait !== undefined && timeSinceLastInvoke >= maxWait) {
+            if (timerId)
+                clearTimeout(timerId);
+            timerId = null;
+            return invoke();
+        }
+        if (timerId)
+            clearTimeout(timerId);
+        if (shouldInvokeLeading)
+            return invoke();
+        if (trailing) {
+            timerId = setTimeout(() => {
+                timerId = null;
+                invoke();
+            }, remainingTime > 0 ? remainingTime : delay);
+        }
+    };
+    const cancel = () => {
+        if (timerId)
+            clearTimeout(timerId);
+        timerId = null;
+        pendingPromise = null;
+    };
+    return { data, error, loading, run, cancel };
+}

package/dist/hooks/nixAsyncDebounce.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../hooks/nixAsyncDebounce.ts"],
+  "sourcesContent": ["/* MIT License\r\n\r\n* Copyright (c) 2026 Resty Gonzales\r\n\r\nPermission is hereby granted, free of charge, to any person obtaining a copy\r\nof this software and associated documentation files (the \"Software\"), to deal\r\nin the Software without restriction, including without limitation the rights\r\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\ncopies of the Software, and to permit persons to whom the Software is\r\nfurnished to do so, subject to the following conditions:\r\n\r\nThe above copyright notice and this permission notice shall be included in all\r\ncopies or substantial portions of the Software.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n* SOFTWARE.\r\n */\r\nimport { nixState } from \"./nixState\";\r\n\r\n/**\r\n * Debounced and cancellable async data fetcher with caching and deduping.\r\n *\r\n * @param {() => Promise<any>} promiseFactory - Async function that returns a promise.\r\n * @param {Object} [options={}] - Options for debounce, caching, and abort.\r\n * @param {number} [options.delay=300] - Debounce delay in ms.\r\n * @param {boolean} [options.leading=false] - Run on leading edge.\r\n * @param {boolean} [options.trailing=true] - Run on trailing edge.\r\n * @param {number} [options.maxWait] - Max wait time before forced invocation.\r\n * @param {boolean} [options.cache=true] - Enable caching of last result.\r\n * @param {AbortSignal} [options.signal] - Optional AbortSignal to cancel request.\r\n * @returns {Object} { data, error, loading, run, cancel }\r\n *\r\n * @example\r\n * const controller = new AbortController();\r\n * const { data, error, loading, run, cancel } = nixAsyncDebounce(\r\n *   () => fetch('/api/data').then(r => r.json()),\r\n *   { delay: 500, maxWait: 2000, leading: true, signal: controller.signal }\r\n * );\r\n */\r\nexport interface NixAsyncDebounceOptions {\r\n  delay?: number;\r\n  leading?: boolean;\r\n  trailing?: boolean;\r\n  maxWait?: number;\r\n  cache?: boolean;\r\n  signal?: AbortSignal;\r\n}\r\n\r\nexport function nixAsyncDebounce(\r\n  promiseFactory: () => Promise<any>,\r\n  options: NixAsyncDebounceOptions = {}\r\n): {\r\n  data: { value: any };\r\n  error: { value: any };\r\n  loading: { value: boolean };\r\n  run: () => void | Promise<any>;\r\n  cancel: () => void;\r\n} {\r\n  const data = nixState(null) as { value: any };\r\n  const error = nixState(null) as { value: any };\r\n  const loading = nixState(false) as { value: boolean };\r\n\r\n  const {\r\n    delay = 300,\r\n    leading = false,\r\n    trailing = true,\r\n    maxWait,\r\n    cache = true,\r\n    signal,\r\n  } = options;\r\n\r\n  let lastResult: any = null;\r\n  let lastError: any = null;\r\n  let timerId: ReturnType<typeof setTimeout> | null = null;\r\n  let lastInvokeTime: number = 0;\r\n  let pendingPromise: Promise<any> | null = null;\r\n\r\n  const invoke = async (): Promise<any> => {\r\n    if (cache && lastResult !== null) {\r\n      data.value = lastResult;\r\n      error.value = lastError;\r\n      loading.value = false;\r\n      return lastResult;\r\n    }\r\n\r\n    loading.value = true;\r\n    error.value = null;\r\n\r\n    const abortController = new AbortController();\r\n    if (signal) {\r\n      signal.addEventListener(\"abort\", () => {\r\n        abortController.abort();\r\n        cancel();\r\n      });\r\n    }\r\n\r\n    pendingPromise = promiseFactory();\r\n\r\n    try {\r\n      const result = await pendingPromise;\r\n      lastResult = result;\r\n      data.value = result;\r\n      return result;\r\n    } catch (e: any) {\r\n      if (e.name !== \"AbortError\") {\r\n        lastError = e;\r\n        error.value = e;\r\n      }\r\n      throw e;\r\n    } finally {\r\n      loading.value = false;\r\n      pendingPromise = null;\r\n      lastInvokeTime = Date.now();\r\n    }\r\n  };\r\n\r\n  const run = (): void | Promise<any> => {\r\n    const now = Date.now();\r\n    const timeSinceLastInvoke = now - lastInvokeTime;\r\n    const remainingTime = delay - timeSinceLastInvoke;\r\n\r\n    const shouldInvokeLeading = leading && !timerId;\r\n\r\n    if (maxWait !== undefined && timeSinceLastInvoke >= maxWait) {\r\n      if (timerId) clearTimeout(timerId);\r\n      timerId = null;\r\n      return invoke();\r\n    }\r\n\r\n    if (timerId) clearTimeout(timerId);\r\n\r\n    if (shouldInvokeLeading) return invoke();\r\n\r\n    if (trailing) {\r\n      timerId = setTimeout(\r\n        () => {\r\n          timerId = null;\r\n          invoke();\r\n        },\r\n        remainingTime > 0 ? remainingTime : delay\r\n      );\r\n    }\r\n  };\r\n\r\n  const cancel = (): void => {\r\n    if (timerId) clearTimeout(timerId);\r\n    timerId = null;\r\n    pendingPromise = null;\r\n  };\r\n\r\n  return { data, error, loading, run, cancel };\r\n}\r\n"],
+  "mappings": ";;AAsBA,SAAS,gBAAgB;AA+BlB,SAAS,iBACd,gBACA,UAAmC,CAAC,GAOpC;AACA,QAAM,OAAO,SAAS,IAAI;AAC1B,QAAM,QAAQ,SAAS,IAAI;AAC3B,QAAM,UAAU,SAAS,KAAK;AAE9B,QAAM;AAAA,IACJ,QAAQ;AAAA,IACR,UAAU;AAAA,IACV,WAAW;AAAA,IACX;AAAA,IACA,QAAQ;AAAA,IACR;AAAA,EACF,IAAI;AAEJ,MAAI,aAAkB;AACtB,MAAI,YAAiB;AACrB,MAAI,UAAgD;AACpD,MAAI,iBAAyB;AAC7B,MAAI,iBAAsC;AAE1C,QAAM,SAAS,mCAA0B;AACvC,QAAI,SAAS,eAAe,MAAM;AAChC,WAAK,QAAQ;AACb,YAAM,QAAQ;AACd,cAAQ,QAAQ;AAChB,aAAO;AAAA,IACT;AAEA,YAAQ,QAAQ;AAChB,UAAM,QAAQ;AAEd,UAAM,kBAAkB,IAAI,gBAAgB;AAC5C,QAAI,QAAQ;AACV,aAAO,iBAAiB,SAAS,MAAM;AACrC,wBAAgB,MAAM;AACtB,eAAO;AAAA,MACT,CAAC;AAAA,IACH;AAEA,qBAAiB,eAAe;AAEhC,QAAI;AACF,YAAM,SAAS,MAAM;AACrB,mBAAa;AACb,WAAK,QAAQ;AACb,aAAO;AAAA,IACT,SAAS,GAAQ;AACf,UAAI,EAAE,SAAS,cAAc;AAC3B,oBAAY;AACZ,cAAM,QAAQ;AAAA,MAChB;AACA,YAAM;AAAA,IACR,UAAE;AACA,cAAQ,QAAQ;AAChB,uBAAiB;AACjB,uBAAiB,KAAK,IAAI;AAAA,IAC5B;AAAA,EACF,GArCe;AAuCf,QAAM,MAAM,6BAA2B;AACrC,UAAM,MAAM,KAAK,IAAI;AACrB,UAAM,sBAAsB,MAAM;AAClC,UAAM,gBAAgB,QAAQ;AAE9B,UAAM,sBAAsB,WAAW,CAAC;AAExC,QAAI,YAAY,UAAa,uBAAuB,SAAS;AAC3D,UAAI,QAAS,cAAa,OAAO;AACjC,gBAAU;AACV,aAAO,OAAO;AAAA,IAChB;AAEA,QAAI,QAAS,cAAa,OAAO;AAEjC,QAAI,oBAAqB,QAAO,OAAO;AAEvC,QAAI,UAAU;AACZ,gBAAU;AAAA,QACR,MAAM;AACJ,oBAAU;AACV,iBAAO;AAAA,QACT;AAAA,QACA,gBAAgB,IAAI,gBAAgB;AAAA,MACtC;AAAA,IACF;AAAA,EACF,GA1BY;AA4BZ,QAAM,SAAS,6BAAY;AACzB,QAAI,QAAS,cAAa,OAAO;AACjC,cAAU;AACV,qBAAiB;AAAA,EACnB,GAJe;AAMf,SAAO,EAAE,MAAM,OAAO,SAAS,KAAK,OAAO;AAC7C;AAvGgB;",
+  "names": []
+}

package/dist/hooks/nixAsyncQuery.d.ts

@@ -0,0 +1,16 @@
+export declare function nixAsyncQuery<T>(key: string, queryFn: (signal: AbortSignal) => Promise<T>, options?: {
+    ttl?: number;
+}): {
+    data: {
+        value: T | null;
+    };
+    error: {
+        value: Error | null;
+    };
+    loading: {
+        value: boolean;
+    };
+    run: () => Promise<void>;
+    cancel: () => void;
+};
+//# sourceMappingURL=nixAsyncQuery.d.ts.map

package/dist/hooks/nixAsyncQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nixAsyncQuery.d.ts","sourceRoot":"","sources":["../../hooks/nixAsyncQuery.ts"],"names":[],"mappings":"AAsEA,wBAAgB,aAAa,CAAC,CAAC,EAC7B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,EAC5C,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAO,GAC7B;IACD,IAAI,EAAE;QAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAA;KAAE,CAAC;IAC1B,KAAK,EAAE;QAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;KAAE,CAAC;IAC/B,OAAO,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IAC5B,GAAG,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB,CA+FA"}

package/dist/hooks/nixAsyncQuery.js

@@ -0,0 +1,87 @@
+import { nixState } from "./nixState";
+const asyncCache = new Map();
+export function nixAsyncQuery(key, queryFn, options = {}) {
+    const data = nixState(null);
+    const error = nixState(null);
+    const loading = nixState(false);
+    const ttl = options.ttl ?? 0;
+    let active = true;
+    let callId = 0;
+    const run = async () => {
+        const id = ++callId;
+        loading.value = true;
+        error.value = null;
+        const now = Date.now();
+        const cached = asyncCache.get(key);
+        if (cached?.data &&
+            (!ttl ||
+                (typeof cached.timestamp === "number" && now - cached.timestamp < ttl))) {
+            data.value = cached.data;
+            loading.value = false;
+            return;
+        }
+        if (cached?.promise) {
+            try {
+                const result = await cached.promise;
+                if (!active || id !== callId)
+                    return;
+                const safeResult = typeof result === "object" && result !== null
+                    ? JSON.parse(JSON.stringify(result))
+                    : result;
+                data.value = safeResult;
+            }
+            catch (e) {
+                if (!active || id !== callId)
+                    return;
+                error.value = e instanceof Error ? e : new Error(String(e));
+            }
+            finally {
+                if (active && id === callId)
+                    loading.value = false;
+            }
+            return;
+        }
+        const controller = new AbortController();
+        const promise = (async () => {
+            try {
+                const result = await queryFn(controller.signal);
+                asyncCache.set(key, {
+                    data: result,
+                    timestamp: Date.now(),
+                });
+                return result;
+            }
+            catch (e) {
+                asyncCache.delete(key);
+                throw e instanceof Error ? e : new Error(String(e));
+            }
+        })();
+        asyncCache.set(key, { promise, controller });
+        try {
+            const result = await promise;
+            if (!active || id !== callId)
+                return;
+            const safeResult = typeof result === "object" && result !== null
+                ? JSON.parse(JSON.stringify(result))
+                : result;
+            data.value = safeResult;
+        }
+        catch (e) {
+            if (!active || id !== callId)
+                return;
+            error.value = e instanceof Error ? e : new Error(String(e));
+        }
+        finally {
+            if (active && id === callId)
+                loading.value = false;
+        }
+    };
+    const cancel = () => {
+        active = false;
+        const cached = asyncCache.get(key);
+        if (cached?.controller) {
+            cached.controller.abort();
+        }
+    };
+    return { data, error, loading, run, cancel };
+}

package/dist/hooks/nixAsyncQuery.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../hooks/nixAsyncQuery.ts"],
+  "sourcesContent": ["/* MIT License\r\n\r\n* Copyright (c) 2026 Resty Gonzales\r\n\r\nPermission is hereby granted, free of charge, to any person obtaining a copy\r\nof this software and associated documentation files (the \"Software\"), to deal\r\nin the Software without restriction, including without limitation the rights\r\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\ncopies of the Software, and to permit persons to whom the Software is\r\nfurnished to do so, subject to the following conditions:\r\n\r\nThe above copyright notice and this permission notice shall be included in all\r\ncopies or substantial portions of the Software.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n* SOFTWARE.\r\n */\r\nimport { nixState } from \"./nixState\";\r\n\r\n/**\r\n * Global async cache.\r\n * key -> {\r\n *   data?: any,\r\n *   error?: Error,\r\n *   promise?: Promise<any>,\r\n *   controller?: AbortController,\r\n *   timestamp?: number\r\n * }\r\n */\r\nconst asyncCache: Map<\r\n  string,\r\n  {\r\n    data?: any;\r\n    error?: Error;\r\n    promise?: Promise<any>;\r\n    controller?: AbortController;\r\n    timestamp?: number;\r\n  }\r\n> = new Map();\r\n\r\n/**\r\n * Unified async query helper with:\r\n * - AbortController cancellation\r\n * - Request deduping\r\n * - Shared caching\r\n *\r\n * @template T\r\n * @param {string} key\r\n * Unique cache key representing the request\r\n *\r\n * @param {(signal: AbortSignal) => Promise<T>} queryFn\r\n * Function that performs the async operation\r\n *\r\n * @param {{\r\n *   ttl?: number\r\n * }} [options]\r\n *\r\n * @returns {{\r\n *   data: { value: T | null },\r\n *   error: { value: Error | null },\r\n *   loading: { value: boolean },\r\n *   run: () => Promise<void>,\r\n *   cancel: () => void\r\n * }}\r\n */\r\nexport function nixAsyncQuery<T>(\r\n  key: string,\r\n  queryFn: (signal: AbortSignal) => Promise<T>,\r\n  options: { ttl?: number } = {}\r\n): {\r\n  data: { value: T | null };\r\n  error: { value: Error | null };\r\n  loading: { value: boolean };\r\n  run: () => Promise<void>;\r\n  cancel: () => void;\r\n} {\r\n  const data = nixState(null) as { value: T | null };\r\n  const error = nixState(null) as { value: Error | null };\r\n  const loading = nixState(false) as { value: boolean };\r\n\r\n  const ttl: number = options.ttl ?? 0;\r\n  let active: boolean = true;\r\n  let callId: number = 0;\r\n\r\n  const run = async (): Promise<void> => {\r\n    const id = ++callId;\r\n    loading.value = true;\r\n    error.value = null;\r\n\r\n    const now = Date.now();\r\n    const cached = asyncCache.get(key);\r\n\r\n    // Serve fresh cached data\r\n    if (\r\n      cached?.data &&\r\n      (!ttl ||\r\n        (typeof cached.timestamp === \"number\" && now - cached.timestamp < ttl))\r\n    ) {\r\n      data.value = cached.data;\r\n      loading.value = false;\r\n      return;\r\n    }\r\n\r\n    //  Deduping: reuse in-flight request\r\n    if (cached?.promise) {\r\n      try {\r\n        const result = await cached.promise;\r\n        if (!active || id !== callId) return;\r\n        // Sanitize result before storing in state\r\n        const safeResult =\r\n          typeof result === \"object\" && result !== null\r\n            ? JSON.parse(JSON.stringify(result))\r\n            : result;\r\n        data.value = safeResult;\r\n      } catch (e: any) {\r\n        if (!active || id !== callId) return;\r\n        error.value = e instanceof Error ? e : new Error(String(e));\r\n      } finally {\r\n        if (active && id === callId) loading.value = false;\r\n      }\r\n      return;\r\n    }\r\n\r\n    // New request\r\n    const controller = new AbortController();\r\n    const promise = (async () => {\r\n      try {\r\n        const result = await queryFn(controller.signal);\r\n        asyncCache.set(key, {\r\n          data: result,\r\n          timestamp: Date.now(),\r\n        });\r\n        return result;\r\n      } catch (e) {\r\n        asyncCache.delete(key);\r\n        throw e instanceof Error ? e : new Error(String(e));\r\n      }\r\n    })();\r\n\r\n    asyncCache.set(key, { promise, controller });\r\n\r\n    try {\r\n      const result = await promise;\r\n      if (!active || id !== callId) return;\r\n      // Sanitize result before storing in state\r\n      const safeResult =\r\n        typeof result === \"object\" && result !== null\r\n          ? JSON.parse(JSON.stringify(result))\r\n          : result;\r\n      data.value = safeResult;\r\n    } catch (e: any) {\r\n      if (!active || id !== callId) return;\r\n      error.value = e instanceof Error ? e : new Error(String(e));\r\n    } finally {\r\n      if (active && id === callId) loading.value = false;\r\n    }\r\n  };\r\n\r\n  /**\r\n   * Cancels in-flight request and prevents state updates.\r\n   */\r\n  const cancel = (): void => {\r\n    active = false;\r\n    const cached = asyncCache.get(key);\r\n    if (cached?.controller) {\r\n      cached.controller.abort();\r\n    }\r\n  };\r\n\r\n  return { data, error, loading, run, cancel };\r\n}\r\n"],
+  "mappings": ";;AAsBA,SAAS,gBAAgB;AAYzB,MAAM,aASF,oBAAI,IAAI;AA2BL,SAAS,cACd,KACA,SACA,UAA4B,CAAC,GAO7B;AACA,QAAM,OAAO,SAAS,IAAI;AAC1B,QAAM,QAAQ,SAAS,IAAI;AAC3B,QAAM,UAAU,SAAS,KAAK;AAE9B,QAAM,MAAc,QAAQ,OAAO;AACnC,MAAI,SAAkB;AACtB,MAAI,SAAiB;AAErB,QAAM,MAAM,mCAA2B;AACrC,UAAM,KAAK,EAAE;AACb,YAAQ,QAAQ;AAChB,UAAM,QAAQ;AAEd,UAAM,MAAM,KAAK,IAAI;AACrB,UAAM,SAAS,WAAW,IAAI,GAAG;AAGjC,QACE,QAAQ,SACP,CAAC,OACC,OAAO,OAAO,cAAc,YAAY,MAAM,OAAO,YAAY,MACpE;AACA,WAAK,QAAQ,OAAO;AACpB,cAAQ,QAAQ;AAChB;AAAA,IACF;AAGA,QAAI,QAAQ,SAAS;AACnB,UAAI;AACF,cAAM,SAAS,MAAM,OAAO;AAC5B,YAAI,CAAC,UAAU,OAAO,OAAQ;AAE9B,cAAM,aACJ,OAAO,WAAW,YAAY,WAAW,OACrC,KAAK,MAAM,KAAK,UAAU,MAAM,CAAC,IACjC;AACN,aAAK,QAAQ;AAAA,MACf,SAAS,GAAQ;AACf,YAAI,CAAC,UAAU,OAAO,OAAQ;AAC9B,cAAM,QAAQ,aAAa,QAAQ,IAAI,IAAI,MAAM,OAAO,CAAC,CAAC;AAAA,MAC5D,UAAE;AACA,YAAI,UAAU,OAAO,OAAQ,SAAQ,QAAQ;AAAA,MAC/C;AACA;AAAA,IACF;AAGA,UAAM,aAAa,IAAI,gBAAgB;AACvC,UAAM,WAAW,YAAY;AAC3B,UAAI;AACF,cAAM,SAAS,MAAM,QAAQ,WAAW,MAAM;AAC9C,mBAAW,IAAI,KAAK;AAAA,UAClB,MAAM;AAAA,UACN,WAAW,KAAK,IAAI;AAAA,QACtB,CAAC;AACD,eAAO;AAAA,MACT,SAAS,GAAG;AACV,mBAAW,OAAO,GAAG;AACrB,cAAM,aAAa,QAAQ,IAAI,IAAI,MAAM,OAAO,CAAC,CAAC;AAAA,MACpD;AAAA,IACF,GAAG;AAEH,eAAW,IAAI,KAAK,EAAE,SAAS,WAAW,CAAC;AAE3C,QAAI;AACF,YAAM,SAAS,MAAM;AACrB,UAAI,CAAC,UAAU,OAAO,OAAQ;AAE9B,YAAM,aACJ,OAAO,WAAW,YAAY,WAAW,OACrC,KAAK,MAAM,KAAK,UAAU,MAAM,CAAC,IACjC;AACN,WAAK,QAAQ;AAAA,IACf,SAAS,GAAQ;AACf,UAAI,CAAC,UAAU,OAAO,OAAQ;AAC9B,YAAM,QAAQ,aAAa,QAAQ,IAAI,IAAI,MAAM,OAAO,CAAC,CAAC;AAAA,IAC5D,UAAE;AACA,UAAI,UAAU,OAAO,OAAQ,SAAQ,QAAQ;AAAA,IAC/C;AAAA,EACF,GAxEY;AA6EZ,QAAM,SAAS,6BAAY;AACzB,aAAS;AACT,UAAM,SAAS,WAAW,IAAI,GAAG;AACjC,QAAI,QAAQ,YAAY;AACtB,aAAO,WAAW,MAAM;AAAA,IAC1B;AAAA,EACF,GANe;AAQf,SAAO,EAAE,MAAM,OAAO,SAAS,KAAK,OAAO;AAC7C;AAzGgB;",
+  "names": []
+}

package/dist/hooks/nixCallback.d.ts

@@ -0,0 +1,2 @@
+export declare function nixCallback<T extends (...args: any[]) => any>(fn: T, deps?: any[]): T;
+//# sourceMappingURL=nixCallback.d.ts.map

package/dist/hooks/nixCallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nixCallback.d.ts","sourceRoot":"","sources":["../../hooks/nixCallback.ts"],"names":[],"mappings":"AAqDA,wBAAgB,WAAW,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAC3D,EAAE,EAAE,CAAC,EACL,IAAI,GAAE,GAAG,EAAO,GACf,CAAC,CAiCH"}

package/dist/hooks/nixCallback.js

@@ -0,0 +1,34 @@
+import { activeContext } from "../context/context";
+export function nixCallback(fn, deps = []) {
+    const ctx = activeContext;
+    if (!ctx)
+        throw new Error("nixCallback() called outside component");
+    if (typeof fn !== "function") {
+        console.error("[nixCallback] First argument must be a function");
+        return fn;
+    }
+    if (!Array.isArray(deps)) {
+        console.error("[nixCallback] Second argument must be an array");
+        deps = [];
+    }
+    const MAX_DEPS = 100;
+    if (deps.length > MAX_DEPS) {
+        console.warn(`[nixCallback] Dependency array too large (${deps.length}). Limited to ${MAX_DEPS}.`);
+        deps = deps.slice(0, MAX_DEPS);
+    }
+    const idx = ctx.hookIndex++;
+    const prev = ctx.hooks[idx];
+    if (!prev || !shallowArrayEqual(prev.deps, deps)) {
+        ctx.hooks[idx] = { value: fn, deps };
+    }
+    return ctx.hooks[idx].value;
+}
+function shallowArrayEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (!Object.is(a[i], b[i]))
+            return false;
+    }
+    return true;
+}

package/dist/hooks/nixCallback.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../hooks/nixCallback.ts"],
+  "sourcesContent": ["/* MIT License\r\n\r\n* Copyright (c) 2026 Resty Gonzales\r\n\r\nPermission is hereby granted, free of charge, to any person obtaining a copy\r\nof this software and associated documentation files (the \"Software\"), to deal\r\nin the Software without restriction, including without limitation the rights\r\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\ncopies of the Software, and to permit persons to whom the Software is\r\nfurnished to do so, subject to the following conditions:\r\n\r\nThe above copyright notice and this permission notice shall be included in all\r\ncopies or substantial portions of the Software.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n* SOFTWARE.\r\n */\r\nimport { activeContext } from \"../context/context\";\r\n\r\n/**\r\n * Memoizes a callback function based on a dependency array.\r\n * Similar to React's useCallback.\r\n *\r\n * @param {Function} fn\r\n * Function to memoize. Should be pure and not mutate external state.\r\n *\r\n * @param {Array<any>} [deps=[]]\r\n * Dependency array. Callback identity changes only when deps change.\r\n *\r\n * @returns {Function}\r\n * Memoized callback function.\r\n *\r\n * @throws {Error}\r\n * If called outside of a component context.\r\n *\r\n * @example\r\n * const onClick = nixCallback(() => {\r\n *   console.log(count.value);\r\n * }, [count.value]);\r\n *\r\n * @security\r\n * - Avoids JSON.stringify to prevent crashes on circular references\r\n * - Limits dependency array size to prevent performance abuse\r\n *\r\n * @memory\r\n * - Does not allocate large temporary strings\r\n * - Reuses function reference when deps are unchanged\r\n */\r\nexport function nixCallback<T extends (...args: any[]) => any>(\r\n  fn: T,\r\n  deps: any[] = []\r\n): T {\r\n  const ctx = activeContext as {\r\n    hookIndex: number;\r\n    hooks: Array<{ value: T; deps: any[] } | undefined>;\r\n  };\r\n  if (!ctx) throw new Error(\"nixCallback() called outside component\");\r\n\r\n  if (typeof fn !== \"function\") {\r\n    console.error(\"[nixCallback] First argument must be a function\");\r\n    return fn;\r\n  }\r\n\r\n  if (!Array.isArray(deps)) {\r\n    console.error(\"[nixCallback] Second argument must be an array\");\r\n    deps = [];\r\n  }\r\n\r\n  const MAX_DEPS = 100;\r\n  if (deps.length > MAX_DEPS) {\r\n    console.warn(\r\n      `[nixCallback] Dependency array too large (${deps.length}). Limited to ${MAX_DEPS}.`\r\n    );\r\n    deps = deps.slice(0, MAX_DEPS);\r\n  }\r\n\r\n  const idx: number = ctx.hookIndex++;\r\n  const prev: { value: T; deps: any[] } | undefined = ctx.hooks[idx];\r\n\r\n  if (!prev || !shallowArrayEqual(prev.deps, deps)) {\r\n    ctx.hooks[idx] = { value: fn, deps };\r\n  }\r\n\r\n  return ctx.hooks[idx]!.value;\r\n}\r\n\r\n/**\r\n * Shallow comparison for dependency arrays.\r\n *\r\n * @param {Array<any>} a\r\n * @param {Array<any>} b\r\n * @returns {boolean}\r\n */\r\nfunction shallowArrayEqual(a: any[], b: any[]): boolean {\r\n  if (a.length !== b.length) return false;\r\n  for (let i = 0; i < a.length; i++) {\r\n    if (!Object.is(a[i], b[i])) return false;\r\n  }\r\n  return true;\r\n}\r\n"],
+  "mappings": ";;AAsBA,SAAS,qBAAqB;AA+BvB,SAAS,YACd,IACA,OAAc,CAAC,GACZ;AACH,QAAM,MAAM;AAIZ,MAAI,CAAC,IAAK,OAAM,IAAI,MAAM,wCAAwC;AAElE,MAAI,OAAO,OAAO,YAAY;AAC5B,YAAQ,MAAM,iDAAiD;AAC/D,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,MAAM,QAAQ,IAAI,GAAG;AACxB,YAAQ,MAAM,gDAAgD;AAC9D,WAAO,CAAC;AAAA,EACV;AAEA,QAAM,WAAW;AACjB,MAAI,KAAK,SAAS,UAAU;AAC1B,YAAQ;AAAA,MACN,6CAA6C,KAAK,MAAM,iBAAiB,QAAQ;AAAA,IACnF;AACA,WAAO,KAAK,MAAM,GAAG,QAAQ;AAAA,EAC/B;AAEA,QAAM,MAAc,IAAI;AACxB,QAAM,OAA8C,IAAI,MAAM,GAAG;AAEjE,MAAI,CAAC,QAAQ,CAAC,kBAAkB,KAAK,MAAM,IAAI,GAAG;AAChD,QAAI,MAAM,GAAG,IAAI,EAAE,OAAO,IAAI,KAAK;AAAA,EACrC;AAEA,SAAO,IAAI,MAAM,GAAG,EAAG;AACzB;AApCgB;AA6ChB,SAAS,kBAAkB,GAAU,GAAmB;AACtD,MAAI,EAAE,WAAW,EAAE,OAAQ,QAAO;AAClC,WAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;AACjC,QAAI,CAAC,OAAO,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,EAAG,QAAO;AAAA,EACrC;AACA,SAAO;AACT;AANS;",
+  "names": []
+}

package/dist/hooks/nixComputed.d.ts

@@ -0,0 +1,16 @@
+export declare function nixComputed<T>(computeFn: () => T): {
+    value: T;
+    subscribe: (fn: (value: T) => void) => () => void;
+    cleanup: () => void;
+    getSubscriberCount: () => number;
+    getDependencyCount: () => number;
+    isDestroyed: () => boolean;
+    getDependencyInfo: () => Array<{
+        state: any;
+        hasCleanup: boolean;
+        isComputed: boolean;
+    }>;
+    _isNixState: true;
+    _isComputed: true;
+};
+//# sourceMappingURL=nixComputed.d.ts.map

package/dist/hooks/nixComputed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nixComputed.d.ts","sourceRoot":"","sources":["../../hooks/nixComputed.ts"],"names":[],"mappings":"AAuFA,wBAAgB,WAAW,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,GAAG;IAClD,KAAK,EAAE,CAAC,CAAC;IACT,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;IAClD,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,kBAAkB,EAAE,MAAM,MAAM,CAAC;IACjC,kBAAkB,EAAE,MAAM,MAAM,CAAC;IACjC,WAAW,EAAE,MAAM,OAAO,CAAC;IAC3B,iBAAiB,EAAE,MAAM,KAAK,CAAC;QAC7B,KAAK,EAAE,GAAG,CAAC;QACX,UAAU,EAAE,OAAO,CAAC;QACpB,UAAU,EAAE,OAAO,CAAC;KACrB,CAAC,CAAC;IACH,WAAW,EAAE,IAAI,CAAC;IAClB,WAAW,EAAE,IAAI,CAAC;CACnB,CA8LA"}