fynixui 1.0.10

package/dist/hooks/nixComputed.js

@@ -0,0 +1,175 @@
+import { activeContext, setActiveContext } from "../context/context";
+export function nixComputed(computeFn) {
+    const ctx = activeContext;
+    if (!ctx)
+        throw new Error("nixComputed() called outside component");
+    if (typeof computeFn !== "function") {
+        throw new TypeError("[nixComputed] First argument must be a function");
+    }
+    const idx = ctx.hookIndex++;
+    if (!ctx.hooks[idx]) {
+        const subscribers = new Set();
+        const dependencies = new Set();
+        const unsubscribers = new Map();
+        let cachedValue;
+        let isStale = true;
+        let isDestroyed = false;
+        let isComputing = false;
+        function compute() {
+            if (isDestroyed)
+                return cachedValue;
+            if (isComputing) {
+                console.error("[nixComputed] Circular dependency detected");
+                return cachedValue;
+            }
+            isComputing = true;
+            const trackingContext = {
+                _accessedStates: new Set(),
+                hookIndex: 0,
+                hooks: [],
+                _subscriptions: new Set(),
+                _subscriptionCleanups: [],
+                effects: [],
+                cleanups: [],
+                _vnode: null,
+                version: 0,
+                props: {},
+                stateCleanups: [],
+                parent: null,
+                context: {},
+                rerender: () => { },
+                Component: null,
+                _isMounted: false,
+                _isRerendering: false,
+            };
+            const prevContext = activeContext;
+            try {
+                setActiveContext(trackingContext);
+                cachedValue = computeFn();
+                const oldDeps = Array.from(dependencies);
+                oldDeps.forEach((dep) => {
+                    if (!trackingContext._accessedStates.has(dep)) {
+                        if (unsubscribers.has(dep)) {
+                            try {
+                                unsubscribers.get(dep)();
+                            }
+                            catch (e) {
+                                console.error("[nixComputed] Error unsubscribing from old dependency:", e);
+                            }
+                            unsubscribers.delete(dep);
+                        }
+                        dependencies.delete(dep);
+                    }
+                });
+                trackingContext._accessedStates.forEach((state) => {
+                    if (!dependencies.has(state)) {
+                        const unsub = state.subscribe(() => {
+                            if (isDestroyed)
+                                return;
+                            isStale = true;
+                            const newValue = s.value;
+                            const subsArray = Array.from(subscribers);
+                            subsArray.forEach((fn) => {
+                                try {
+                                    fn(newValue);
+                                }
+                                catch (e) {
+                                    console.error("[nixComputed] Subscriber error:", e);
+                                    subscribers.delete(fn);
+                                }
+                            });
+                        });
+                        unsubscribers.set(state, unsub);
+                        dependencies.add(state);
+                    }
+                });
+                isStale = false;
+            }
+            catch (err) {
+                console.error("[nixComputed] Compute error:", err);
+                isStale = false;
+            }
+            finally {
+                setActiveContext(prevContext);
+                isComputing = false;
+            }
+            return cachedValue;
+        }
+        const s = {
+            get value() {
+                if (isDestroyed) {
+                    console.warn("[nixComputed] Accessing destroyed computed state");
+                    return cachedValue;
+                }
+                if (isStale) {
+                    compute();
+                }
+                if (activeContext && activeContext._accessedStates) {
+                    activeContext._accessedStates.add(s);
+                }
+                return cachedValue;
+            },
+            subscribe(fn) {
+                if (typeof fn !== "function") {
+                    console.error("[nixComputed] subscribe() requires a function");
+                    return () => { };
+                }
+                if (isDestroyed) {
+                    console.warn("[nixComputed] Cannot subscribe to destroyed computed state");
+                    return () => { };
+                }
+                const MAX_SUBSCRIBERS = 1000;
+                if (subscribers.size >= MAX_SUBSCRIBERS) {
+                    console.error("[nixComputed] Maximum subscriber limit reached");
+                    return () => { };
+                }
+                subscribers.add(fn);
+                return () => {
+                    subscribers.delete(fn);
+                };
+            },
+            cleanup() {
+                if (isDestroyed)
+                    return;
+                isDestroyed = true;
+                unsubscribers.forEach((unsub) => {
+                    try {
+                        unsub();
+                    }
+                    catch (e) {
+                        console.error("[nixComputed] Cleanup error:", e);
+                    }
+                });
+                unsubscribers.clear();
+                dependencies.clear();
+                subscribers.clear();
+                cachedValue = null;
+                console.log("[nixComputed] Computed state cleaned up");
+            },
+            getSubscriberCount() {
+                return subscribers.size;
+            },
+            getDependencyCount() {
+                return dependencies.size;
+            },
+            isDestroyed() {
+                return isDestroyed;
+            },
+            getDependencyInfo() {
+                return Array.from(dependencies).map((state) => ({
+                    state,
+                    hasCleanup: unsubscribers.has(state),
+                    isComputed: !!state._isComputed,
+                }));
+            },
+            _isNixState: true,
+            _isComputed: true,
+        };
+        compute();
+        ctx.hooks[idx] = s;
+        if (ctx.stateCleanups) {
+            ctx.stateCleanups.push(() => s.cleanup());
+        }
+    }
+    return ctx.hooks[idx];
+}

package/dist/hooks/nixComputed.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../hooks/nixComputed.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\n/* ----------------------\r\n    nixComputed - Computed/Derived State\r\n    Memory Leaks & Security Issues Resolved\r\n---------------------- */\r\nimport { activeContext, setActiveContext } from \"../context/context\";\r\n\r\n/**\r\n * @template T\r\n * @typedef {Object} ComputedState\r\n * @property {T} value - Get the computed value (read-only)\r\n * @property {(fn: (value: T) => void) => (() => void)} subscribe - Subscribe to computed value changes\r\n * @property {() => void} cleanup - Cleanup all subscriptions and dependencies\r\n * @property {() => number} getSubscriberCount - Get number of active subscribers (debugging)\r\n * @property {() => number} getDependencyCount - Get number of tracked dependencies (debugging)\r\n * @property {() => boolean} isDestroyed - Check if computed state has been destroyed\r\n * @property {boolean} _isNixState - Internal flag (computed states behave like states)\r\n * @property {boolean} _isComputed - Internal flag to identify computed states\r\n */\r\n\r\n/**\r\n * Create a derived/computed state from other states.\r\n * Automatically tracks dependencies and updates when any dependency changes.\r\n *\r\n * @template T\r\n * @param {() => T} computeFn - Function that computes the derived value\r\n * @returns {ComputedState<T>} A reactive state object with the computed value\r\n *\r\n * @example\r\n * const count = nixState(5);\r\n * const doubled = nixComputed(() => count.value * 2);\r\n * console.log(doubled.value); // 10\r\n * count.value = 10;\r\n * console.log(doubled.value); // 20\r\n *\r\n * @example\r\n * // Multiple dependencies\r\n * const a = nixState(5);\r\n * const b = nixState(10);\r\n * const sum = nixComputed(() => a.value + b.value);\r\n * console.log(sum.value); // 15\r\n *\r\n * @example\r\n * // Conditional dependencies\r\n * const flag = nixState(true);\r\n * const x = nixState(1);\r\n * const y = nixState(2);\r\n * const result = nixComputed(() => flag.value ? x.value : y.value);\r\n *\r\n * @example\r\n * // With cleanup\r\n * const MyComponent = () => {\r\n *   const count = nixState(0);\r\n *   const doubled = nixComputed(() => count.value * 2);\r\n *\r\n *   nixEffect(() => {\r\n *     return () => {\r\n *       doubled.cleanup();\r\n *       count.cleanup();\r\n *     };\r\n *   }, []);\r\n * };\r\n *\r\n * @throws {Error} If called outside a component context\r\n * @throws {TypeError} If computeFn is not a function\r\n */\r\nexport function nixComputed<T>(computeFn: () => T): {\r\n  value: T;\r\n  subscribe: (fn: (value: T) => void) => () => void;\r\n  cleanup: () => void;\r\n  getSubscriberCount: () => number;\r\n  getDependencyCount: () => number;\r\n  isDestroyed: () => boolean;\r\n  getDependencyInfo: () => Array<{\r\n    state: any;\r\n    hasCleanup: boolean;\r\n    isComputed: boolean;\r\n  }>;\r\n  _isNixState: true;\r\n  _isComputed: true;\r\n} {\r\n  const ctx = activeContext as\r\n    | (typeof activeContext & {\r\n        hookIndex: number;\r\n        hooks: Array<any>;\r\n        stateCleanups?: Array<() => void>;\r\n      })\r\n    | undefined;\r\n  if (!ctx) throw new Error(\"nixComputed() called outside component\");\r\n\r\n  if (typeof computeFn !== \"function\") {\r\n    throw new TypeError(\"[nixComputed] First argument must be a function\");\r\n  }\r\n\r\n  const idx = ctx.hookIndex++;\r\n  if (!ctx.hooks[idx]) {\r\n    const subscribers: Set<(value: T) => void> = new Set();\r\n    const dependencies: Set<any> = new Set();\r\n    const unsubscribers: Map<any, () => void> = new Map();\r\n    let cachedValue: T;\r\n    let isStale = true;\r\n    let isDestroyed = false;\r\n    let isComputing = false;\r\n\r\n    function compute(): T {\r\n      if (isDestroyed) return cachedValue;\r\n      if (isComputing) {\r\n        console.error(\"[nixComputed] Circular dependency detected\");\r\n        return cachedValue;\r\n      }\r\n      isComputing = true;\r\n      // Provide all required properties for ComponentContext type\r\n      // Use type assertion for safety and future-proofing\r\n      const trackingContext = {\r\n        _accessedStates: new Set(),\r\n        hookIndex: 0,\r\n        hooks: [],\r\n        _subscriptions: new Set(),\r\n        _subscriptionCleanups: [],\r\n        effects: [],\r\n        cleanups: [],\r\n        _vnode: null,\r\n        version: 0,\r\n        props: {},\r\n        stateCleanups: [],\r\n        parent: null,\r\n        context: {},\r\n        rerender: () => {},\r\n        Component: null,\r\n        _isMounted: false,\r\n        _isRerendering: false,\r\n      } as any; // Use 'as any' to satisfy ComponentContext type\r\n      const prevContext = activeContext;\r\n      try {\r\n        setActiveContext(trackingContext);\r\n        cachedValue = computeFn();\r\n        const oldDeps = Array.from(dependencies);\r\n        oldDeps.forEach((dep) => {\r\n          if (!trackingContext._accessedStates.has(dep)) {\r\n            if (unsubscribers.has(dep)) {\r\n              try {\r\n                unsubscribers.get(dep)!();\r\n              } catch (e) {\r\n                console.error(\r\n                  \"[nixComputed] Error unsubscribing from old dependency:\",\r\n                  e\r\n                );\r\n              }\r\n              unsubscribers.delete(dep);\r\n            }\r\n            dependencies.delete(dep);\r\n          }\r\n        });\r\n        trackingContext._accessedStates.forEach((state: any) => {\r\n          if (!dependencies.has(state)) {\r\n            const unsub = state.subscribe(() => {\r\n              if (isDestroyed) return;\r\n\r\n              isStale = true;\r\n              // Get fresh value when dependency changes\r\n              const newValue = s.value;\r\n              const subsArray = Array.from(subscribers);\r\n              subsArray.forEach((fn) => {\r\n                try {\r\n                  fn(newValue);\r\n                } catch (e) {\r\n                  console.error(\"[nixComputed] Subscriber error:\", e);\r\n                  subscribers.delete(fn);\r\n                }\r\n              });\r\n            });\r\n            unsubscribers.set(state, unsub);\r\n            dependencies.add(state);\r\n          }\r\n        });\r\n        isStale = false;\r\n      } catch (err) {\r\n        console.error(\"[nixComputed] Compute error:\", err);\r\n        isStale = false;\r\n      } finally {\r\n        setActiveContext(prevContext);\r\n        isComputing = false;\r\n      }\r\n      return cachedValue;\r\n    }\r\n\r\n    // All cleanup functionality is now part of the s object below\r\n\r\n    const s = {\r\n      get value(): T {\r\n        if (isDestroyed) {\r\n          console.warn(\"[nixComputed] Accessing destroyed computed state\");\r\n          return cachedValue;\r\n        }\r\n        if (isStale) {\r\n          compute();\r\n        }\r\n        if (activeContext && (activeContext as any)._accessedStates) {\r\n          (activeContext as any)._accessedStates.add(s);\r\n        }\r\n        return cachedValue;\r\n      },\r\n      subscribe(fn: (value: T) => void): () => void {\r\n        if (typeof fn !== \"function\") {\r\n          console.error(\"[nixComputed] subscribe() requires a function\");\r\n          return () => {};\r\n        }\r\n        if (isDestroyed) {\r\n          console.warn(\r\n            \"[nixComputed] Cannot subscribe to destroyed computed state\"\r\n          );\r\n          return () => {};\r\n        }\r\n        const MAX_SUBSCRIBERS = 1000;\r\n        if (subscribers.size >= MAX_SUBSCRIBERS) {\r\n          console.error(\"[nixComputed] Maximum subscriber limit reached\");\r\n          return () => {};\r\n        }\r\n        subscribers.add(fn);\r\n        return () => {\r\n          subscribers.delete(fn);\r\n        };\r\n      },\r\n      cleanup(): void {\r\n        if (isDestroyed) return;\r\n        isDestroyed = true;\r\n        unsubscribers.forEach((unsub) => {\r\n          try {\r\n            unsub();\r\n          } catch (e) {\r\n            console.error(\"[nixComputed] Cleanup error:\", e);\r\n          }\r\n        });\r\n        unsubscribers.clear();\r\n        dependencies.clear();\r\n        subscribers.clear();\r\n        cachedValue = null as any as T;\r\n        console.log(\"[nixComputed] Computed state cleaned up\");\r\n      },\r\n      getSubscriberCount(): number {\r\n        return subscribers.size;\r\n      },\r\n      getDependencyCount(): number {\r\n        return dependencies.size;\r\n      },\r\n      isDestroyed(): boolean {\r\n        return isDestroyed;\r\n      },\r\n      getDependencyInfo(): Array<{\r\n        state: any;\r\n        hasCleanup: boolean;\r\n        isComputed: boolean;\r\n      }> {\r\n        return Array.from(dependencies).map((state) => ({\r\n          state,\r\n          hasCleanup: unsubscribers.has(state),\r\n          isComputed: !!state._isComputed,\r\n        }));\r\n      },\r\n      _isNixState: true as const,\r\n      _isComputed: true as const,\r\n    };\r\n\r\n    compute();\r\n    ctx.hooks[idx] = s;\r\n    if (ctx.stateCleanups) {\r\n      ctx.stateCleanups.push(() => s.cleanup());\r\n    }\r\n  }\r\n  return ctx.hooks[idx] as ReturnType<typeof nixComputed<T>>;\r\n}\r\n"],
+  "mappings": "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",
+  "names": ["compute"]
+}

package/dist/hooks/nixDebounce.d.ts

@@ -0,0 +1,11 @@
+export interface NixDebounceOptions {
+    leading?: boolean;
+    trailing?: boolean;
+    maxWait?: number;
+    signal?: AbortSignal;
+}
+export type DebouncedFunction<T extends (...args: any[]) => any> = ((...args: Parameters<T>) => void) & {
+    cancel: () => void;
+};
+export declare function nixDebounce<T extends (...args: any[]) => any>(fn: T, delay?: number, options?: NixDebounceOptions): DebouncedFunction<T>;
+//# sourceMappingURL=nixDebounce.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nixDebounce.d.ts","sourceRoot":"","sources":["../../hooks/nixDebounce.ts"],"names":[],"mappings":"AAiDA,MAAM,WAAW,kBAAkB;IACjC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,IAAI,CAAC,CAClE,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KACnB,IAAI,CAAC,GAAG;IACX,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB,CAAC;AAEF,wBAAgB,WAAW,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAC3D,EAAE,EAAE,CAAC,EACL,KAAK,GAAE,MAAY,EACnB,OAAO,GAAE,kBAAuB,GAC/B,iBAAiB,CAAC,CAAC,CAAC,CA8DtB"}

package/dist/hooks/nixDebounce.js

@@ -0,0 +1,55 @@
+export function nixDebounce(fn, delay = 300, options = {}) {
+    let timerId = null;
+    let lastInvokeTime = 0;
+    let lastArgs = null;
+    let lastThis = null;
+    const { leading = false, trailing = true, maxWait, signal } = options;
+    if (signal) {
+        signal.addEventListener("abort", () => {
+            if (timerId) {
+                clearTimeout(timerId);
+                timerId = null;
+            }
+            lastArgs = null;
+            lastThis = null;
+        });
+    }
+    const invoke = () => {
+        lastInvokeTime = Date.now();
+        if (lastArgs) {
+            fn.apply(lastThis, lastArgs);
+            lastArgs = lastThis = null;
+        }
+    };
+    const debounced = function (...args) {
+        const now = Date.now();
+        lastArgs = args;
+        lastThis = this;
+        const shouldInvokeLeading = leading && !timerId;
+        const timeSinceLastInvoke = now - lastInvokeTime;
+        const remainingTime = delay - timeSinceLastInvoke;
+        if (maxWait !== undefined && timeSinceLastInvoke >= maxWait) {
+            if (timerId)
+                clearTimeout(timerId);
+            timerId = null;
+            invoke();
+            return;
+        }
+        if (timerId)
+            clearTimeout(timerId);
+        if (shouldInvokeLeading) {
+            invoke();
+        }
+        if (trailing) {
+            timerId = setTimeout(invoke, remainingTime > 0 ? remainingTime : delay);
+        }
+    };
+    debounced.cancel = () => {
+        if (timerId)
+            clearTimeout(timerId);
+        timerId = null;
+        lastArgs = null;
+        lastThis = null;
+    };
+    return debounced;
+}

package/dist/hooks/nixDebounce.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../hooks/nixDebounce.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\n/**\r\n * @fileoverview Debounce utility function with advanced options.\r\n * Supports leading/trailing edge invocation, maxWait, and AbortController.\r\n */\r\n\r\n/**\r\n * Debounce a function with options for leading, trailing, maxWait, and AbortController support.\r\n *\r\n * @param {Function} fn - The function to debounce\r\n * @param {number} [delay=300] - Delay in milliseconds\r\n * @param {Object} [options={}] - Debounce options\r\n * @param {boolean} [options.leading=false] - Invoke on the leading edge\r\n * @param {boolean} [options.trailing=true] - Invoke on the trailing edge\r\n * @param {number} [options.maxWait] - Maximum wait time before forced invocation\r\n * @param {AbortSignal} [options.signal] - Optional AbortSignal to cancel pending calls\r\n * @returns {Function} Debounced function with `.cancel()` method\r\n *\r\n * @example\r\n * const controller = new AbortController();\r\n * const debounced = nixDebounce(() => console.log('Hello'), 500, {\r\n *   leading: true,\r\n *   maxWait: 2000,\r\n *   signal: controller.signal\r\n * });\r\n * debounced();\r\n * controller.abort(); // Cancel pending invocation\r\n */\r\nexport interface NixDebounceOptions {\r\n  leading?: boolean;\r\n  trailing?: boolean;\r\n  maxWait?: number;\r\n  signal?: AbortSignal;\r\n}\r\n\r\nexport type DebouncedFunction<T extends (...args: any[]) => any> = ((\r\n  ...args: Parameters<T>\r\n) => void) & {\r\n  cancel: () => void;\r\n};\r\n\r\nexport function nixDebounce<T extends (...args: any[]) => any>(\r\n  fn: T,\r\n  delay: number = 300,\r\n  options: NixDebounceOptions = {}\r\n): DebouncedFunction<T> {\r\n  let timerId: ReturnType<typeof setTimeout> | null = null;\r\n  let lastInvokeTime = 0;\r\n  let lastArgs: Parameters<T> | null = null;\r\n  let lastThis: any = null;\r\n\r\n  const { leading = false, trailing = true, maxWait, signal } = options;\r\n\r\n  if (signal) {\r\n    signal.addEventListener(\"abort\", () => {\r\n      if (timerId) {\r\n        clearTimeout(timerId);\r\n        timerId = null;\r\n      }\r\n      lastArgs = null;\r\n      lastThis = null;\r\n    });\r\n  }\r\n\r\n  const invoke = () => {\r\n    lastInvokeTime = Date.now();\r\n    if (lastArgs) {\r\n      fn.apply(lastThis, lastArgs);\r\n      lastArgs = lastThis = null;\r\n    }\r\n  };\r\n\r\n  const debounced = function (this: unknown, ...args: Parameters<T>) {\r\n    const now = Date.now();\r\n    lastArgs = args;\r\n    lastThis = this;\r\n\r\n    const shouldInvokeLeading = leading && !timerId;\r\n    const timeSinceLastInvoke = now - lastInvokeTime;\r\n    const remainingTime = delay - timeSinceLastInvoke;\r\n\r\n    if (maxWait !== undefined && timeSinceLastInvoke >= maxWait) {\r\n      if (timerId) clearTimeout(timerId);\r\n      timerId = null;\r\n      invoke();\r\n      return;\r\n    }\r\n\r\n    if (timerId) clearTimeout(timerId);\r\n\r\n    if (shouldInvokeLeading) {\r\n      invoke();\r\n    }\r\n\r\n    if (trailing) {\r\n      timerId = setTimeout(invoke, remainingTime > 0 ? remainingTime : delay);\r\n    }\r\n  } as DebouncedFunction<T>;\r\n\r\n  debounced.cancel = () => {\r\n    if (timerId) clearTimeout(timerId);\r\n    timerId = null;\r\n    lastArgs = null;\r\n    lastThis = null;\r\n  };\r\n\r\n  return debounced;\r\n}\r\n"],
+  "mappings": ";;AA8DO,SAAS,YACd,IACA,QAAgB,KAChB,UAA8B,CAAC,GACT;AACtB,MAAI,UAAgD;AACpD,MAAI,iBAAiB;AACrB,MAAI,WAAiC;AACrC,MAAI,WAAgB;AAEpB,QAAM,EAAE,UAAU,OAAO,WAAW,MAAM,SAAS,OAAO,IAAI;AAE9D,MAAI,QAAQ;AACV,WAAO,iBAAiB,SAAS,MAAM;AACrC,UAAI,SAAS;AACX,qBAAa,OAAO;AACpB,kBAAU;AAAA,MACZ;AACA,iBAAW;AACX,iBAAW;AAAA,IACb,CAAC;AAAA,EACH;AAEA,QAAM,SAAS,6BAAM;AACnB,qBAAiB,KAAK,IAAI;AAC1B,QAAI,UAAU;AACZ,SAAG,MAAM,UAAU,QAAQ;AAC3B,iBAAW,WAAW;AAAA,IACxB;AAAA,EACF,GANe;AAQf,QAAM,YAAY,mCAA4B,MAAqB;AACjE,UAAM,MAAM,KAAK,IAAI;AACrB,eAAW;AACX,eAAW;AAEX,UAAM,sBAAsB,WAAW,CAAC;AACxC,UAAM,sBAAsB,MAAM;AAClC,UAAM,gBAAgB,QAAQ;AAE9B,QAAI,YAAY,UAAa,uBAAuB,SAAS;AAC3D,UAAI,QAAS,cAAa,OAAO;AACjC,gBAAU;AACV,aAAO;AACP;AAAA,IACF;AAEA,QAAI,QAAS,cAAa,OAAO;AAEjC,QAAI,qBAAqB;AACvB,aAAO;AAAA,IACT;AAEA,QAAI,UAAU;AACZ,gBAAU,WAAW,QAAQ,gBAAgB,IAAI,gBAAgB,KAAK;AAAA,IACxE;AAAA,EACF,GAzBkB;AA2BlB,YAAU,SAAS,MAAM;AACvB,QAAI,QAAS,cAAa,OAAO;AACjC,cAAU;AACV,eAAW;AACX,eAAW;AAAA,EACb;AAEA,SAAO;AACT;AAlEgB;",
+  "names": []
+}

package/dist/hooks/nixEffect.d.ts

@@ -0,0 +1,4 @@
+export declare function nixEffect(effect: () => void | (() => void), deps?: any[]): void;
+export declare function nixEffectOnce(effect: () => void | (() => void)): void;
+export declare function nixEffectAlways(effect: () => void | (() => void)): void;
+//# sourceMappingURL=nixEffect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nixEffect.d.ts","sourceRoot":"","sources":["../../hooks/nixEffect.ts"],"names":[],"mappings":"AAmEA,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,EACjC,IAAI,GAAE,GAAG,EAAO,GACf,IAAI,CAyDN;AAgCD,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAErE;AAaD,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAUvE"}

package/dist/hooks/nixEffect.js

@@ -0,0 +1,75 @@
+import { activeContext } from "../context/context";
+export function nixEffect(effect, deps = []) {
+    const ctx = activeContext;
+    if (!ctx)
+        throw new Error("nixEffect() called outside component");
+    if (typeof effect !== "function") {
+        console.error("[nixEffect] First argument must be a function");
+        return;
+    }
+    if (!Array.isArray(deps)) {
+        console.error("[nixEffect] Second argument must be an array");
+        deps = [];
+    }
+    const MAX_DEPS = 100;
+    if (deps.length > MAX_DEPS) {
+        console.warn(`[nixEffect] 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];
+    const hasChanged = !prev || !shallowArrayEqual(prev.deps, deps);
+    if (hasChanged) {
+        if (prev?.cleanup) {
+            try {
+                if (typeof prev.cleanup === "function") {
+                    prev.cleanup();
+                }
+            }
+            catch (err) {
+                console.error("[nixEffect] Cleanup error:", err);
+            }
+        }
+        let cleanup;
+        try {
+            cleanup = effect();
+            if (cleanup !== undefined && typeof cleanup !== "function") {
+                console.warn("[nixEffect] Effect should return undefined or a cleanup function");
+                cleanup = undefined;
+            }
+        }
+        catch (err) {
+            console.error("[nixEffect] Effect error:", err);
+            cleanup = undefined;
+        }
+        ctx.hooks[idx] = { deps, cleanup };
+        if (cleanup && typeof cleanup === "function") {
+            if (!ctx.cleanups)
+                ctx.cleanups = [];
+            ctx.cleanups.push(cleanup);
+        }
+    }
+}
+function shallowArrayEqual(arr1, arr2) {
+    if (arr1.length !== arr2.length)
+        return false;
+    for (let i = 0; i < arr1.length; i++) {
+        if (!Object.is(arr1[i], arr2[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+export function nixEffectOnce(effect) {
+    return nixEffect(effect, []);
+}
+export function nixEffectAlways(effect) {
+    const ctx = activeContext;
+    if (!ctx)
+        throw new Error("nixEffectAlways() called outside component");
+    if (typeof effect !== "function") {
+        console.error("[nixEffectAlways] Argument must be a function");
+        return;
+    }
+    return nixEffect(effect, [ctx.version]);
+}

package/dist/hooks/nixEffect.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../hooks/nixEffect.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\n/* ----------------------\r\n    nixEffect - Side Effects Hook\r\n    Memory Leaks & Security Issues Resolved\r\n---------------------- */\r\nimport { activeContext } from \"../context/context\";\r\n\r\n/**\r\n * Execute side effects in a component with automatic cleanup and security enhancements.\r\n * Similar to React's useEffect but with enhanced security and memory leak prevention.\r\n *\r\n * @param {() => (void | (() => void))} effect - Effect function, optionally returns cleanup function\r\n * @param {Array<any>} [deps=[]] - Dependency array. Effect re-runs when dependencies change.\r\n * @param {object} [options={}] - Configuration options\r\n *\r\n * @example\r\n * // Run once on mount\r\n * nixEffect(() => {\r\n *   console.log('Component mounted');\r\n *   return () => console.log('Component unmounted');\r\n * }, []);\r\n *\r\n * @example\r\n * // Run when count changes with timeout\r\n * const count = nixState(0);\r\n * nixEffect(() => {\r\n *   console.log('Count is:', count.value);\r\n * }, [count.value], { timeout: 5000 });\r\n *\r\n * @example\r\n * // Timer with cleanup\r\n * nixEffect(() => {\r\n *   const timer = setInterval(() => console.log('tick'), 1000);\r\n *   return () => clearInterval(timer);\r\n * }, []);\r\n *\r\n * @example\r\n * // Event listener with cleanup\r\n * nixEffect(() => {\r\n *   const handler = (e) => console.log('clicked', e);\r\n *   document.addEventListener('click', handler);\r\n *   return () => document.removeEventListener('click', handler);\r\n * }, []);\r\n *\r\n * @throws {Error} If called outside a component context\r\n */\r\nexport function nixEffect(\r\n  effect: () => void | (() => void),\r\n  deps: any[] = []\r\n): void {\r\n  const ctx = activeContext as\r\n    | (typeof activeContext & {\r\n        hookIndex: number;\r\n        hooks: Array<any>;\r\n        cleanups?: Array<() => void>;\r\n      })\r\n    | undefined;\r\n  if (!ctx) throw new Error(\"nixEffect() called outside component\");\r\n\r\n  if (typeof effect !== \"function\") {\r\n    console.error(\"[nixEffect] First argument must be a function\");\r\n    return;\r\n  }\r\n  if (!Array.isArray(deps)) {\r\n    console.error(\"[nixEffect] Second argument must be an array\");\r\n    deps = [];\r\n  }\r\n  const MAX_DEPS = 100;\r\n  if (deps.length > MAX_DEPS) {\r\n    console.warn(\r\n      `[nixEffect] Dependency array too large (${deps.length}). Limited to ${MAX_DEPS}.`\r\n    );\r\n    deps = deps.slice(0, MAX_DEPS);\r\n  }\r\n  const idx = ctx.hookIndex++;\r\n  const prev = ctx.hooks[idx];\r\n  const hasChanged = !prev || !shallowArrayEqual(prev.deps, deps);\r\n  if (hasChanged) {\r\n    if (prev?.cleanup) {\r\n      try {\r\n        if (typeof prev.cleanup === \"function\") {\r\n          prev.cleanup();\r\n        }\r\n      } catch (err) {\r\n        console.error(\"[nixEffect] Cleanup error:\", err);\r\n      }\r\n    }\r\n    let cleanup: void | (() => void);\r\n    try {\r\n      cleanup = effect();\r\n      if (cleanup !== undefined && typeof cleanup !== \"function\") {\r\n        console.warn(\r\n          \"[nixEffect] Effect should return undefined or a cleanup function\"\r\n        );\r\n        cleanup = undefined;\r\n      }\r\n    } catch (err) {\r\n      console.error(\"[nixEffect] Effect error:\", err);\r\n      cleanup = undefined;\r\n    }\r\n    ctx.hooks[idx] = { deps, cleanup };\r\n    if (cleanup && typeof cleanup === \"function\") {\r\n      if (!ctx.cleanups) ctx.cleanups = [];\r\n      ctx.cleanups.push(cleanup);\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Shallow comparison of two arrays for dependency checking.\r\n * More reliable and secure than JSON.stringify.\r\n *\r\n * @param {Array<any>} arr1 - First array\r\n * @param {Array<any>} arr2 - Second array\r\n * @returns {boolean} True if arrays are shallowly equal\r\n */\r\nfunction shallowArrayEqual(arr1: any[], arr2: any[]): boolean {\r\n  if (arr1.length !== arr2.length) return false;\r\n  for (let i = 0; i < arr1.length; i++) {\r\n    if (!Object.is(arr1[i], arr2[i])) {\r\n      return false;\r\n    }\r\n  }\r\n  return true;\r\n}\r\n\r\n/**\r\n * Run an effect only once on component mount.\r\n * Convenience wrapper around nixEffect.\r\n *\r\n * @param {() => (void | (() => void))} effect - Effect function\r\n *\r\n * @example\r\n * nixEffectOnce(() => {\r\n *   console.log('Mounted');\r\n *   return () => console.log('Unmounted');\r\n * });\r\n */\r\nexport function nixEffectOnce(effect: () => void | (() => void)): void {\r\n  return nixEffect(effect, []);\r\n}\r\n\r\n/**\r\n * Run an effect every time the component renders.\r\n * Use with caution - can cause performance issues.\r\n *\r\n * @param {() => (void | (() => void))} effect - Effect function\r\n *\r\n * @example\r\n * nixEffectAlways(() => {\r\n *   console.log('Component rendered');\r\n * });\r\n */\r\nexport function nixEffectAlways(effect: () => void | (() => void)): void {\r\n  const ctx = activeContext as\r\n    | (typeof activeContext & { version: any })\r\n    | undefined;\r\n  if (!ctx) throw new Error(\"nixEffectAlways() called outside component\");\r\n  if (typeof effect !== \"function\") {\r\n    console.error(\"[nixEffectAlways] Argument must be a function\");\r\n    return;\r\n  }\r\n  return nixEffect(effect, [ctx.version]);\r\n}\r\n"],
+  "mappings": ";;AA0BA,SAAS,qBAAqB;AAyCvB,SAAS,UACd,QACA,OAAc,CAAC,GACT;AACN,QAAM,MAAM;AAOZ,MAAI,CAAC,IAAK,OAAM,IAAI,MAAM,sCAAsC;AAEhE,MAAI,OAAO,WAAW,YAAY;AAChC,YAAQ,MAAM,+CAA+C;AAC7D;AAAA,EACF;AACA,MAAI,CAAC,MAAM,QAAQ,IAAI,GAAG;AACxB,YAAQ,MAAM,8CAA8C;AAC5D,WAAO,CAAC;AAAA,EACV;AACA,QAAM,WAAW;AACjB,MAAI,KAAK,SAAS,UAAU;AAC1B,YAAQ;AAAA,MACN,2CAA2C,KAAK,MAAM,iBAAiB,QAAQ;AAAA,IACjF;AACA,WAAO,KAAK,MAAM,GAAG,QAAQ;AAAA,EAC/B;AACA,QAAM,MAAM,IAAI;AAChB,QAAM,OAAO,IAAI,MAAM,GAAG;AAC1B,QAAM,aAAa,CAAC,QAAQ,CAAC,kBAAkB,KAAK,MAAM,IAAI;AAC9D,MAAI,YAAY;AACd,QAAI,MAAM,SAAS;AACjB,UAAI;AACF,YAAI,OAAO,KAAK,YAAY,YAAY;AACtC,eAAK,QAAQ;AAAA,QACf;AAAA,MACF,SAAS,KAAK;AACZ,gBAAQ,MAAM,8BAA8B,GAAG;AAAA,MACjD;AAAA,IACF;AACA,QAAI;AACJ,QAAI;AACF,gBAAU,OAAO;AACjB,UAAI,YAAY,UAAa,OAAO,YAAY,YAAY;AAC1D,gBAAQ;AAAA,UACN;AAAA,QACF;AACA,kBAAU;AAAA,MACZ;AAAA,IACF,SAAS,KAAK;AACZ,cAAQ,MAAM,6BAA6B,GAAG;AAC9C,gBAAU;AAAA,IACZ;AACA,QAAI,MAAM,GAAG,IAAI,EAAE,MAAM,QAAQ;AACjC,QAAI,WAAW,OAAO,YAAY,YAAY;AAC5C,UAAI,CAAC,IAAI,SAAU,KAAI,WAAW,CAAC;AACnC,UAAI,SAAS,KAAK,OAAO;AAAA,IAC3B;AAAA,EACF;AACF;AA5DgB;AAsEhB,SAAS,kBAAkB,MAAa,MAAsB;AAC5D,MAAI,KAAK,WAAW,KAAK,OAAQ,QAAO;AACxC,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,QAAI,CAAC,OAAO,GAAG,KAAK,CAAC,GAAG,KAAK,CAAC,CAAC,GAAG;AAChC,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;AARS;AAsBF,SAAS,cAAc,QAAyC;AACrE,SAAO,UAAU,QAAQ,CAAC,CAAC;AAC7B;AAFgB;AAeT,SAAS,gBAAgB,QAAyC;AACvE,QAAM,MAAM;AAGZ,MAAI,CAAC,IAAK,OAAM,IAAI,MAAM,4CAA4C;AACtE,MAAI,OAAO,WAAW,YAAY;AAChC,YAAQ,MAAM,+CAA+C;AAC7D;AAAA,EACF;AACA,SAAO,UAAU,QAAQ,CAAC,IAAI,OAAO,CAAC;AACxC;AAVgB;",
+  "names": []
+}

package/dist/hooks/nixFor.d.ts

@@ -0,0 +1,13 @@
+import { VNode } from "../types/fnx";
+interface ReactiveState<T> {
+    value: T;
+    _isNixState: boolean;
+    subscribe(callback: (value: T) => void): () => void;
+}
+interface ForProps<T> {
+    each: T[] | ReactiveState<T[]>;
+    children?: ((item: T, index: number) => VNode) | ((item: T, index: number) => VNode)[];
+}
+export declare function For<T>(props: ForProps<T>): VNode;
+export {};
+//# sourceMappingURL=nixFor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nixFor.d.ts","sourceRoot":"","sources":["../../hooks/nixFor.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAErC,UAAU,aAAa,CAAC,CAAC;IACrB,KAAK,EAAE,CAAC,CAAC;IACT,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;CACvD;AAED,UAAU,QAAQ,CAAC,CAAC;IAChB,IAAI,EAAE,CAAC,EAAE,GAAG,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC;IAC/B,QAAQ,CAAC,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,KAAK,CAAC,EAAE,CAAC;CAC1F;AAkBD,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,KAAK,CAoDhD"}

package/dist/hooks/nixFor.js

@@ -0,0 +1,43 @@
+import { Fragment } from "../runtime";
+export function For(props) {
+    let items = [];
+    if (props.each && typeof props.each === "object" && "_isNixState" in props.each) {
+        items = props.each.value;
+    }
+    else if (Array.isArray(props.each)) {
+        items = props.each;
+    }
+    let renderer;
+    if (typeof props.children === "function") {
+        renderer = props.children;
+    }
+    else if (Array.isArray(props.children)) {
+        const firstChild = props.children[0];
+        if (typeof firstChild === "function") {
+            renderer = firstChild;
+        }
+    }
+    if (!renderer) {
+        if (items.length > 0) {
+            console.warn("[Fynix] <For> expects a function as its child. Received:", typeof props.children);
+        }
+        return { type: Fragment, props: { children: [] }, key: null };
+    }
+    const mapped = items.map((item, index) => {
+        try {
+            return renderer(item, index);
+        }
+        catch (error) {
+            console.error(`[Fynix] Error rendering item at index ${index}:`, error);
+            return {
+                type: "div",
+                props: {
+                    children: ["Error rendering item"],
+                    style: "color: red;"
+                },
+                key: index
+            };
+        }
+    });
+    return { type: Fragment, props: { children: mapped }, key: null };
+}

package/dist/hooks/nixFor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../hooks/nixFor.ts"],
+  "sourcesContent": ["/* MIT License\r\n* Copyright (c) 2026 Resty Gonzales\r\n*/\r\n\r\nimport { Fragment } from \"../runtime\";\r\nimport { VNode } from \"../types/fnx\";\r\n\r\ninterface ReactiveState<T> {\r\n    value: T;\r\n    _isNixState: boolean;\r\n    subscribe(callback: (value: T) => void): () => void;\r\n}\r\n\r\ninterface ForProps<T> {\r\n    each: T[] | ReactiveState<T[]>;\r\n    children?: ((item: T, index: number) => VNode) | ((item: T, index: number) => VNode)[];\r\n}\r\n\r\n/**\r\n * <For> Component\r\n *\r\n * A reactive list iteration component that efficiently renders items from an array or reactive state.\r\n *\r\n * @example\r\n * ```tsx\r\n * <For each={items}>\r\n *   {(item, index) => <div key={index}>{item.name}</div>}\r\n * </For>\r\n * ```\r\n *\r\n * @param props - Component properties\r\n * @param props.each - The array or reactive state of array to iterate over\r\n * @param props.children - Render function that receives (item, index) and returns a VNode\r\n */\r\nexport function For<T>(props: ForProps<T>): VNode {\r\n    // Extract items from reactive state or plain array\r\n    let items: T[] = [];\r\n\r\n    if (props.each && typeof props.each === \"object\" && \"_isNixState\" in props.each) {\r\n        // Access .value to subscribe to reactive state\r\n        items = (props.each as ReactiveState<T[]>).value;\r\n    } else if (Array.isArray(props.each)) {\r\n        items = props.each;\r\n    }\r\n\r\n    // Get the renderer function\r\n    // In Fynix's JSX transform, children passed as {() => ...} becomes props.children directly\r\n    let renderer: ((item: T, index: number) => VNode) | undefined;\r\n\r\n    // Handle both direct function and array of children (depends on JSX transform)\r\n    if (typeof props.children === \"function\") {\r\n        renderer = props.children;\r\n    } else if (Array.isArray(props.children)) {\r\n        // If JSX transform wraps it in an array, get first element\r\n        const firstChild = props.children[0];\r\n        if (typeof firstChild === \"function\") {\r\n            renderer = firstChild as (item: T, index: number) => VNode;\r\n        }\r\n    }\r\n\r\n    if (!renderer) {\r\n        if (items.length > 0) {\r\n            console.warn(\"[Fynix] <For> expects a function as its child. Received:\", typeof props.children);\r\n        }\r\n        return { type: Fragment, props: { children: [] }, key: null };\r\n    }\r\n\r\n    // Map items to VNodes\r\n    const mapped = items.map((item, index) => {\r\n        try {\r\n            return renderer!(item, index);\r\n        } catch (error) {\r\n            console.error(`[Fynix] Error rendering item at index ${index}:`, error);\r\n            // Return a safe fallback\r\n            return {\r\n                type: \"div\",\r\n                props: {\r\n                    children: [\"Error rendering item\"],\r\n                    style: \"color: red;\"\r\n                },\r\n                key: index\r\n            } as VNode;\r\n        }\r\n    });\r\n\r\n    return { type: Fragment, props: { children: mapped }, key: null };\r\n}"],
+  "mappings": ";;AAIA,SAAS,gBAAgB;AA8BlB,SAAS,IAAO,OAA2B;AAE9C,MAAI,QAAa,CAAC;AAElB,MAAI,MAAM,QAAQ,OAAO,MAAM,SAAS,YAAY,iBAAiB,MAAM,MAAM;AAE7E,YAAS,MAAM,KAA4B;AAAA,EAC/C,WAAW,MAAM,QAAQ,MAAM,IAAI,GAAG;AAClC,YAAQ,MAAM;AAAA,EAClB;AAIA,MAAI;AAGJ,MAAI,OAAO,MAAM,aAAa,YAAY;AACtC,eAAW,MAAM;AAAA,EACrB,WAAW,MAAM,QAAQ,MAAM,QAAQ,GAAG;AAEtC,UAAM,aAAa,MAAM,SAAS,CAAC;AACnC,QAAI,OAAO,eAAe,YAAY;AAClC,iBAAW;AAAA,IACf;AAAA,EACJ;AAEA,MAAI,CAAC,UAAU;AACX,QAAI,MAAM,SAAS,GAAG;AAClB,cAAQ,KAAK,4DAA4D,OAAO,MAAM,QAAQ;AAAA,IAClG;AACA,WAAO,EAAE,MAAM,UAAU,OAAO,EAAE,UAAU,CAAC,EAAE,GAAG,KAAK,KAAK;AAAA,EAChE;AAGA,QAAM,SAAS,MAAM,IAAI,CAAC,MAAM,UAAU;AACtC,QAAI;AACA,aAAO,SAAU,MAAM,KAAK;AAAA,IAChC,SAAS,OAAO;AACZ,cAAQ,MAAM,yCAAyC,KAAK,KAAK,KAAK;AAEtE,aAAO;AAAA,QACH,MAAM;AAAA,QACN,OAAO;AAAA,UACH,UAAU,CAAC,sBAAsB;AAAA,UACjC,OAAO;AAAA,QACX;AAAA,QACA,KAAK;AAAA,MACT;AAAA,IACJ;AAAA,EACJ,CAAC;AAED,SAAO,EAAE,MAAM,UAAU,OAAO,EAAE,UAAU,OAAO,GAAG,KAAK,KAAK;AACpE;AApDgB;",
+  "names": []
+}

package/dist/hooks/nixForm.d.ts

@@ -0,0 +1,33 @@
+import { nixComputed } from "./nixComputed.js";
+import { nixState } from "./nixState.js";
+type ValidationRule<T> = {
+    required?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: RegExp;
+    custom?: (value: any, values: T) => boolean;
+    message?: string;
+};
+type ValidationRules<T> = {
+    [K in keyof T]?: ValidationRule<T>;
+};
+type FormState<T> = {
+    values: ReturnType<typeof nixState<T>>;
+    errors: ReturnType<typeof nixState<Partial<Record<keyof T, string>>>>;
+    touched: ReturnType<typeof nixState<Partial<Record<keyof T, boolean>>>>;
+    isSubmitting: ReturnType<typeof nixState<boolean>>;
+    isValid: ReturnType<typeof nixComputed<boolean>>;
+    handleChange: (fieldName: keyof T, value: any) => void;
+    handleBlur: (fieldName: keyof T) => void;
+    handleSubmit: (onSubmit: (values: T, signal: AbortSignal) => Promise<void>) => Promise<void>;
+    cancelSubmit: () => void;
+    reset: () => void;
+    getFieldProps: (fieldName: keyof T) => {
+        value: any;
+        "r-input": (e: any) => void;
+        "r-blur": () => void;
+    };
+};
+export declare function nixForm<T extends Record<string, any> = Record<string, any>>(initialValues?: T, validationRules?: ValidationRules<T>): FormState<T>;
+export {};
+//# sourceMappingURL=nixForm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nixForm.d.ts","sourceRoot":"","sources":["../../hooks/nixForm.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,KAAK,cAAc,CAAC,CAAC,IAAI;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,KAAK,OAAO,CAAC;IAC5C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,KAAK,eAAe,CAAC,CAAC,IAAI;KACvB,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC;CACnC,CAAC;AAEF,KAAK,SAAS,CAAC,CAAC,IAAI;IAClB,MAAM,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;IACvC,MAAM,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IACtE,OAAO,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;IACxE,YAAY,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;IACnD,OAAO,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;IACjD,YAAY,EAAE,CAAC,SAAS,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;IACvD,UAAU,EAAE,CAAC,SAAS,EAAE,MAAM,CAAC,KAAK,IAAI,CAAC;IACzC,YAAY,EAAE,CACZ,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,KACxD,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,CAAC,KAAK;QACrC,KAAK,EAAE,GAAG,CAAC;QACX,SAAS,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;QAC5B,QAAQ,EAAE,MAAM,IAAI,CAAC;KACtB,CAAC;CACH,CAAC;AAgBF,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACzE,aAAa,GAAE,CAAW,EAC1B,eAAe,GAAE,eAAe,CAAC,CAAC,CAA4B,GAC7D,SAAS,CAAC,CAAC,CAAC,CA2Id"}

package/dist/hooks/nixForm.js

@@ -0,0 +1,123 @@
+import { nixComputed } from "./nixComputed.js";
+import { nixState } from "./nixState.js";
+export function nixForm(initialValues = {}, validationRules = {}) {
+    const values = nixState({ ...initialValues });
+    const errors = nixState({});
+    const touched = nixState({});
+    const isSubmitting = nixState(false);
+    const isValid = nixComputed(() => Object.keys(errors.value).length === 0);
+    let abortController = null;
+    function validate(fieldName, value) {
+        const rules = validationRules[fieldName];
+        if (!rules)
+            return null;
+        if (rules.required && !value) {
+            return rules.message || `${String(fieldName)} is required`;
+        }
+        if (rules.minLength && value.length < rules.minLength) {
+            return (rules.message ||
+                `${String(fieldName)} must be at least ${rules.minLength} characters`);
+        }
+        if (rules.maxLength && value.length > rules.maxLength) {
+            return (rules.message ||
+                `${String(fieldName)} must be at most ${rules.maxLength} characters`);
+        }
+        if (rules.pattern && !rules.pattern.test(value)) {
+            return rules.message || `${String(fieldName)} is invalid`;
+        }
+        if (rules.custom && !rules.custom(value, values.value)) {
+            return rules.message || `${String(fieldName)} is invalid`;
+        }
+        return null;
+    }
+    function handleChange(fieldName, value) {
+        values.value = { ...values.value, [fieldName]: value };
+        if (touched.value[fieldName]) {
+            const error = validate(fieldName, value);
+            if (error) {
+                errors.value = { ...errors.value, [fieldName]: error };
+            }
+            else {
+                const newErrors = { ...errors.value };
+                delete newErrors[fieldName];
+                errors.value = newErrors;
+            }
+        }
+    }
+    function handleBlur(fieldName) {
+        touched.value = { ...touched.value, [fieldName]: true };
+        const error = validate(fieldName, values.value[fieldName]);
+        if (error) {
+            errors.value = { ...errors.value, [fieldName]: error };
+        }
+    }
+    function validateAll() {
+        const newErrors = {};
+        Object.keys(validationRules).forEach((fieldName) => {
+            const error = validate(fieldName, values.value[fieldName]);
+            if (error)
+                newErrors[fieldName] = error;
+        });
+        errors.value = newErrors;
+        return Object.keys(newErrors).length === 0;
+    }
+    async function handleSubmit(onSubmit) {
+        const allTouched = Object.keys(validationRules).reduce((acc, key) => {
+            acc[key] = true;
+            return acc;
+        }, {});
+        touched.value = allTouched;
+        if (!validateAll())
+            return;
+        if (abortController)
+            abortController.abort();
+        abortController = new AbortController();
+        const signal = abortController.signal;
+        isSubmitting.value = true;
+        try {
+            await onSubmit(values.value, signal);
+        }
+        catch (err) {
+            if (err.name !== "AbortError") {
+                console.error("[nixForm] Submission error:", err);
+            }
+        }
+        finally {
+            if (!signal.aborted)
+                isSubmitting.value = false;
+        }
+    }
+    function cancelSubmit() {
+        if (abortController) {
+            abortController.abort();
+            abortController = null;
+        }
+    }
+    function reset() {
+        values.value = { ...initialValues };
+        errors.value = {};
+        touched.value = {};
+        isSubmitting.value = false;
+        cancelSubmit();
+    }
+    function getFieldProps(fieldName) {
+        return {
+            value: values.value[fieldName] || "",
+            "r-input": (e) => handleChange(fieldName, e.target.value),
+            "r-blur": () => handleBlur(fieldName),
+        };
+    }
+    return {
+        values,
+        errors,
+        touched,
+        isSubmitting,
+        isValid,
+        handleChange,
+        handleBlur,
+        handleSubmit,
+        cancelSubmit,
+        reset,
+        getFieldProps,
+    };
+}