@fynixorg/ui 1.0.8 → 1.0.10

package/dist/plugins/vite-plugin-res.js

@@ -2,89 +2,29 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 import { transform } from "esbuild";
 function fynix() {
-  const failedFiles = /* @__PURE__ */ new Set();
-  const COMPILE_SUCCESS_COLOR = "\x1B[32m";
-  const COMPILE_ERROR_COLOR = "\x1B[31m";
-  const RESET_COLOR = "\x1B[0m";
-  const BOLD = "\x1B[1m";
   return {
-    name: "vite-plugin-fynix",
+    name: "vite-plugin-res",
     enforce: "pre",
     async transform(code, id) {
-      if (!/\.(js|fnx)$/.test(id) || /node_modules/.test(id)) {
+      if (!id.includes("/src/"))
         return null;
-      }
-      try {
-        const result = await transform(code, {
-          loader: "tsx",
-          jsxFactory: "Fynix",
-          jsxFragment: "Fynix.Fragment",
-          sourcemap: true,
-          sourcefile: id,
-          target: "es2020"
-        });
-        if (failedFiles.has(id)) {
-          failedFiles.delete(id);
-          const fileName = id.split("/").pop();
-          const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString();
-          console.log(
-            `${COMPILE_SUCCESS_COLOR}\u2713${RESET_COLOR} ${BOLD}${fileName}${RESET_COLOR} ${COMPILE_SUCCESS_COLOR}compiled successfully!${RESET_COLOR} ${timestamp}`
-          );
-        }
-        return {
-          code: result.code,
-          map: result.map
-        };
-      } catch (error) {
-        failedFiles.add(id);
-        const lines = code.split("\n");
-        const errorLine = error.location?.line || 1;
-        const errorColumn = error.location?.column || 0;
-        const start = Math.max(0, errorLine - 4);
-        const end = Math.min(lines.length, errorLine + 3);
-        const codeFrame = lines.slice(start, end).map((line, i) => {
-          const lineNum = start + i + 1;
-          const isErrorLine = lineNum === errorLine;
-          const prefix = isErrorLine ? "> " : "  ";
-          const formattedLine = `${prefix}${lineNum.toString().padStart(4)} | ${line}`;
-          if (isErrorLine && errorColumn > 0) {
-            const pointer = " ".repeat(prefix.length + 6 + errorColumn) + "^";
-            return `${formattedLine}
-${pointer}`;
-          }
-          return formattedLine;
-        }).join("\n");
-        const fileName = id.split("/").pop();
-        const errorMessage = `
-${COMPILE_ERROR_COLOR}\u2717 Fynix Transform Error${RESET_COLOR} in ${BOLD}${fileName}${RESET_COLOR}
-
-${error.text || error.message}
-
-${codeFrame}
-        `.trim();
-        console.error(errorMessage);
-        const viteError = Object.assign(
-          new Error(error.text || error.message),
-          {
-            id,
-            plugin: "vite-plugin-fynix",
-            loc: {
-              file: id,
-              line: errorLine,
-              column: errorColumn
-            },
-            frame: codeFrame
-          }
-        );
-        this.error(viteError);
-      }
+      if (!id.endsWith(".ts") && !id.endsWith(".js") && !id.endsWith(".fnx"))
+        return null;
+      this.addWatchFile(id);
+      const result = await transform(code, {
+        loader: "jsx",
+        jsxFactory: "Fynix",
+        jsxFragment: "Fynix.Fragment",
+        sourcemap: true,
+        sourcefile: id
+      });
+      return {
+        code: result.code,
+        map: result.map
+      };
     },
     handleHotUpdate({ file, server }) {
-      if (/\.(js|fnx)$/.test(file) && !/node_modules/.test(file)) {
-        server.ws.send({
-          type: "custom",
-          event: "fynix:clear-overlay"
-        });
+      if (file.endsWith(".ts") || file.endsWith(".js") || file.endsWith(".fnx")) {
         server.ws.send({ type: "full-reload" });
         return [];
       }
@@ -92,7 +32,4 @@ ${codeFrame}
   };
 }
 __name(fynix, "fynix");
-export {
-  fynix
-};
 //# sourceMappingURL=vite-plugin-res.js.map

package/dist/plugins/vite-plugin-res.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../plugins/vite-plugin-res.js"],
-  "sourcesContent": ["/**\r\n * @fileoverview Vite plugin for Fynix JSX transformation.\r\n * Transforms JSX syntax to Fynix function calls using esbuild.\r\n * Integrates with Fynix's error overlay system.\r\n */\r\n\r\nimport { transform } from \"esbuild\";\r\n\r\n/**\r\n * Vite plugin for transforming Fynix JSX files.\r\n * Automatically transforms .js and .fnx files.\r\n *\r\n * @returns {Object} Vite plugin object\r\n *\r\n * @example\r\n * // vite.config.js\r\n * import { defineConfig } from 'vite';\r\n * import { fynix } from '@fynixorg/ui/plugins/vite-plugin-fynix';\r\n *\r\n * export default defineConfig({\r\n *   plugins: [fynix()]\r\n * });\r\n */\r\nexport function fynix() {\r\n  const failedFiles = new Set();\r\n  const COMPILE_SUCCESS_COLOR = \"\\x1b[32m\"; // Green\r\n  const COMPILE_ERROR_COLOR = \"\\x1b[31m\"; // Red\r\n  const RESET_COLOR = \"\\x1b[0m\";\r\n  const BOLD = \"\\x1b[1m\";\r\n\r\n  return {\r\n    name: \"vite-plugin-fynix\",\r\n    enforce: \"pre\",\r\n\r\n    async transform(code, id) {\r\n      // Only transform .js and .fnx files, exclude node_modules\r\n      if (!/\\.(js|fnx)$/.test(id) || /node_modules/.test(id)) {\r\n        return null;\r\n      }\r\n\r\n      try {\r\n        const result = await transform(code, {\r\n          loader: \"tsx\",\r\n          jsxFactory: \"Fynix\",\r\n          jsxFragment: \"Fynix.Fragment\",\r\n          sourcemap: true,\r\n          sourcefile: id,\r\n          target: \"es2020\",\r\n        });\r\n\r\n        // Check if this file previously failed\r\n        if (failedFiles.has(id)) {\r\n          failedFiles.delete(id);\r\n          const fileName = id.split(\"/\").pop();\r\n          const timestamp = new Date().toLocaleTimeString();\r\n\r\n          console.log(\r\n            `${COMPILE_SUCCESS_COLOR}\u2713${RESET_COLOR} ` +\r\n              `${BOLD}${fileName}${RESET_COLOR} ` +\r\n              `${COMPILE_SUCCESS_COLOR}compiled successfully!${RESET_COLOR} ` +\r\n              `${timestamp}`,\r\n          );\r\n        }\r\n\r\n        return {\r\n          code: result.code,\r\n          map: result.map,\r\n        };\r\n      } catch (error) {\r\n        // Mark this file as failed\r\n        failedFiles.add(id);\r\n\r\n        // Create a detailed error with code frame\r\n        const lines = code.split(\"\\n\");\r\n        const errorLine = error.location?.line || 1;\r\n        const errorColumn = error.location?.column || 0;\r\n\r\n        // Show 3 lines before and after the error\r\n        const start = Math.max(0, errorLine - 4);\r\n        const end = Math.min(lines.length, errorLine + 3);\r\n\r\n        const codeFrame = lines\r\n          .slice(start, end)\r\n          .map((line, i) => {\r\n            const lineNum = start + i + 1;\r\n            const isErrorLine = lineNum === errorLine;\r\n            const prefix = isErrorLine ? \"> \" : \"  \";\r\n            const formattedLine = `${prefix}${lineNum.toString().padStart(4)} | ${line}`;\r\n\r\n            if (isErrorLine && errorColumn > 0) {\r\n              const pointer = \" \".repeat(prefix.length + 6 + errorColumn) + \"^\";\r\n              return `${formattedLine}\\n${pointer}`;\r\n            }\r\n            return formattedLine;\r\n          })\r\n          .join(\"\\n\");\r\n\r\n        const fileName = id.split(\"/\").pop();\r\n        const errorMessage = `\r\n${COMPILE_ERROR_COLOR}\u2717 Fynix Transform Error${RESET_COLOR} in ${BOLD}${fileName}${RESET_COLOR}\r\n\r\n${error.text || error.message}\r\n\r\n${codeFrame}\r\n        `.trim();\r\n\r\n        // Log to terminal\r\n        console.error(errorMessage);\r\n\r\n        // Create error object for Vite's error overlay\r\n        const viteError = Object.assign(\r\n          new Error(error.text || error.message),\r\n          {\r\n            id: id,\r\n            plugin: \"vite-plugin-fynix\",\r\n            loc: {\r\n              file: id,\r\n              line: errorLine,\r\n              column: errorColumn,\r\n            },\r\n            frame: codeFrame,\r\n          },\r\n        );\r\n\r\n        this.error(viteError);\r\n      }\r\n    },\r\n\r\n    handleHotUpdate({ file, server }) {\r\n      // Only reload for .js and .fnx files, exclude node_modules\r\n      if (/\\.(js|fnx)$/.test(file) && !/node_modules/.test(file)) {\r\n        // Clear Fynix error overlay on HMR\r\n        server.ws.send({\r\n          type: \"custom\",\r\n          event: \"fynix:clear-overlay\",\r\n        });\r\n\r\n        // Full reload for Fynix components\r\n        server.ws.send({ type: \"full-reload\" });\r\n        return [];\r\n      }\r\n    },\r\n  };\r\n}\r\n"],
-  "mappings": "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",
+  "sourcesContent": ["import { transform } from \"esbuild\";\r\nfunction fynix() {\r\n  return {\r\n    name: \"vite-plugin-res\",\r\n    enforce: \"pre\",\r\n    async transform(code, id) {\r\n      if (!id.includes(\"/src/\")) return null;\r\n      if (!id.endsWith(\".ts\") && !id.endsWith(\".js\") && !id.endsWith(\".fnx\"))\r\n        return null;\r\n      this.addWatchFile(id);\r\n      const result = await transform(code, {\r\n        loader: \"jsx\",\r\n        jsxFactory: \"Fynix\",\r\n        jsxFragment: \"Fynix.Fragment\",\r\n        sourcemap: true,\r\n        sourcefile: id,\r\n      });\r\n      return {\r\n        code: result.code,\r\n        map: result.map,\r\n      };\r\n    },\r\n    handleHotUpdate({ file, server }) {\r\n      if (\r\n        file.endsWith(\".ts\") ||\r\n        file.endsWith(\".js\") ||\r\n        file.endsWith(\".fnx\")\r\n      ) {\r\n        server.ws.send({ type: \"full-reload\" });\r\n        return [];\r\n      }\r\n    },\r\n  };\r\n}\r\n"],
+  "mappings": ";;AAAA,SAAS,iBAAiB;AAC1B,SAAS,QAAQ;AACf,SAAO;AAAA,IACL,MAAM;AAAA,IACN,SAAS;AAAA,IACT,MAAM,UAAU,MAAM,IAAI;AACxB,UAAI,CAAC,GAAG,SAAS,OAAO;AAAG,eAAO;AAClC,UAAI,CAAC,GAAG,SAAS,KAAK,KAAK,CAAC,GAAG,SAAS,KAAK,KAAK,CAAC,GAAG,SAAS,MAAM;AACnE,eAAO;AACT,WAAK,aAAa,EAAE;AACpB,YAAM,SAAS,MAAM,UAAU,MAAM;AAAA,QACnC,QAAQ;AAAA,QACR,YAAY;AAAA,QACZ,aAAa;AAAA,QACb,WAAW;AAAA,QACX,YAAY;AAAA,MACd,CAAC;AACD,aAAO;AAAA,QACL,MAAM,OAAO;AAAA,QACb,KAAK,OAAO;AAAA,MACd;AAAA,IACF;AAAA,IACA,gBAAgB,EAAE,MAAM,OAAO,GAAG;AAChC,UACE,KAAK,SAAS,KAAK,KACnB,KAAK,SAAS,KAAK,KACnB,KAAK,SAAS,MAAM,GACpB;AACA,eAAO,GAAG,KAAK,EAAE,MAAM,cAAc,CAAC;AACtC,eAAO,CAAC;AAAA,MACV;AAAA,IACF;AAAA,EACF;AACF;AAhCS;",
   "names": []
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fynixorg/ui",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "type": "module",
   "description": "Core package for Fynix UI framework.",
   "main": "dist/fynix/index.js",
@@ -40,7 +40,8 @@
   },
   "files": [
     "dist/",
-    "types/"
+    "types/",
+    "runtime.d.ts"
   ],
   "keywords": [
     "fynix",

package/runtime.d.ts

@@ -0,0 +1,83 @@
+// Type definitions for Fynix Runtime
+// This file provides TypeScript support for the Fynix framework
+
+/// <reference path="./types/jsx.d.ts" />
+/// <reference path="./types/global.d.ts" />
+
+export const TEXT: unique symbol;
+export const Fragment: unique symbol;
+
+export interface VNode {
+  type: string | symbol | ((props: any) => any);
+  props: Record<string, any>;
+  key: string | number | null;
+  _domNode?: Node;
+  _rendered?: VNode;
+  _state?: any;
+}
+
+export type Element = 
+  | VNode
+  | string 
+  | number 
+  | boolean 
+  | null 
+  | undefined
+  | Element[];
+
+export type ComponentFunction<P = {}> = (props: P) => Element;
+
+export function Fynix(
+  type: string | symbol | ComponentFunction,
+  props?: Record<string, any> | null,
+  ...children: any[]
+): VNode;
+
+export namespace Fynix {
+  export function Fragment(props: { children?: any }): any;
+}
+
+export const h: typeof Fynix;
+
+export function createTextVNode(text: string | number | any): VNode;
+
+export function mount(
+  AppComponent: ComponentFunction,
+  root: string | Element,
+  hydrate?: boolean,
+  props?: Record<string, any>
+): void;
+
+export function renderComponent(
+  Component: ComponentFunction,
+  props?: Record<string, any>
+): VNode;
+
+// Hooks
+export function nixState<T>(initialValue: T): any;
+export function nixStore<T extends Record<string, any>>(initialState: T): any;
+export function nixComputed<T>(fn: () => T): any;
+export function nixRef<T = any>(initial?: T): { current: T };
+export function nixEffect(fn: () => void | (() => void), deps?: any[]): void;
+export function nixEffectAlways(fn: () => void | (() => void)): void;
+export function nixEffectOnce(fn: () => void | (() => void)): void;
+export function nixInterval(callback: () => void, delay: number): void;
+export function nixMemo<T>(fn: () => T, deps?: any[]): T;
+export function nixCallback<T extends (...args: any[]) => any>(fn: T, deps?: any[]): T;
+export function nixPrevious<T>(value: T): T | undefined;
+export function nixAsync<T>(fn: (signal: AbortSignal) => Promise<T>): any;
+export function nixAsyncCached<T>(fn: () => Promise<T>, cacheKey?: string): any;
+export function nixAsyncDebounce<T>(fn: () => Promise<T>, delay: number): any;
+export function nixAsyncQuery<T>(queryKey: any, queryFn: () => Promise<T>, options?: any): any;
+export function nixDebounce<T extends (...args: any[]) => any>(fn: T, delay: number): T;
+export function nixLocalStorage<T>(key: string, initialValue: T): any;
+export function nixLazy(loader: () => Promise<any>): any;
+export function nixLazyAsync(loader: () => Promise<any>): any;
+export function nixForm<T extends Record<string, any>>(initialValues: T, options?: any): any;
+export function nixFormAsync<T extends Record<string, any>>(initialValues: T, options?: any): any;
+export function nixLazyFormAsync<T extends Record<string, any>>(loader: () => Promise<any>, options?: any): any;
+
+// Components
+export const Suspense: any;
+export const Path: any;
+export const Button: any;

package/dist/build.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/context/context.d.ts

@@ -1,99 +0,0 @@
-/**
- * Set the active component context.
- * Called internally by the runtime when entering/exiting component rendering.
- *
- * @param {ComponentContext|null} ctx - The component context to set as active, or null to clear
- * @returns {void}
- *
- * @example
- * // Internal usage in runtime
- * setActiveContext(componentContext);
- * const result = Component(props);
- * setActiveContext(null);
- */
-export function setActiveContext(ctx: ComponentContext | null): void;
-/**
- * @fileoverview Component context management for Fynix framework.
- * Tracks the currently rendering component to enable hooks to access component state.
- */
-/**
- * @typedef {Object} ComponentContext
- * @property {Array<any>} hooks - Array of hook states
- * @property {number} hookIndex - Current hook index during render
- * @property {Array<Function>} effects - Array of effect cleanup functions
- * @property {Array<Function>} cleanups - Array of cleanup functions
- * @property {Array<Function>} [stateCleanups] - Array of state cleanup functions
- * @property {Object} _vnode - Associated virtual node
- * @property {Set<any>} _accessedStates - Set of states accessed during render
- * @property {Set<any>} _subscriptions - Set of active subscriptions
- * @property {Array<Function>} _subscriptionCleanups - Array of subscription cleanup functions
- * @property {number} version - Component version for tracking updates
- * @property {Function|null} rerender - Function to trigger component re-render
- * @property {Function} Component - Component function
- * @property {boolean} _isMounted - Whether component is mounted
- * @property {boolean} _isRerendering - Whether component is currently re-rendering
- */
-/**
- * The currently active component context.
- * This is set during component rendering to allow hooks to access the component's state.
- * @type {ComponentContext|null}
- */
-export let activeContext: ComponentContext | null;
-export type ComponentContext = {
-    /**
-     * - Array of hook states
-     */
-    hooks: Array<any>;
-    /**
-     * - Current hook index during render
-     */
-    hookIndex: number;
-    /**
-     * - Array of effect cleanup functions
-     */
-    effects: Array<Function>;
-    /**
-     * - Array of cleanup functions
-     */
-    cleanups: Array<Function>;
-    /**
-     * - Array of state cleanup functions
-     */
-    stateCleanups?: Array<Function>;
-    /**
-     * - Associated virtual node
-     */
-    _vnode: any;
-    /**
-     * - Set of states accessed during render
-     */
-    _accessedStates: Set<any>;
-    /**
-     * - Set of active subscriptions
-     */
-    _subscriptions: Set<any>;
-    /**
-     * - Array of subscription cleanup functions
-     */
-    _subscriptionCleanups: Array<Function>;
-    /**
-     * - Component version for tracking updates
-     */
-    version: number;
-    /**
-     * - Function to trigger component re-render
-     */
-    rerender: Function | null;
-    /**
-     * - Component function
-     */
-    Component: Function;
-    /**
-     * - Whether component is mounted
-     */
-    _isMounted: boolean;
-    /**
-     * - Whether component is currently re-rendering
-     */
-    _isRerendering: boolean;
-};

package/dist/custom/button.d.ts

@@ -1,62 +0,0 @@
-/**
- * @typedef {Object} ButtonProps
- * @property {string} [value=""] - Button text content
- * @property {string} [type="button"] - Button type (button, submit, reset)
- * @property {boolean} [disabled=false] - Whether button is disabled
- * @property {string} [rc] - Reactive class attribute (Fynix-specific)
- * @property {string} [class] - CSS class names
- * @property {(this: HTMLElement, event: MouseEvent) => void} [r-click] - Click event handler
- */
-/**
- * Button component for Fynix applications.
- * Renders a native HTML button element with Fynix event handling.
- *
- * @param {ButtonProps & Record<string, any>} props - Component props
- * @returns {VNode} Button element virtual node
- *
- * @example
- * // Basic button
- * <Button value="Click Me" />
- *
- * @example
- * // With click handler
- * <Button
- *   value="Submit"
- *   r-click={() => console.log('Clicked!')}
- * />
- *
- * @example
- * // Submit button with styling
- * <Button
- *   value="Save"
- *   type="submit"
- *   rc="px-4 py-2 bg-blue-500 text-white rounded"
- * />
- */
-export function Button({ value, ...props }: ButtonProps & Record<string, any>): VNode;
-export type ButtonProps = {
-    /**
-     * - Button text content
-     */
-    value?: string;
-    /**
-     * - Button type (button, submit, reset)
-     */
-    type?: string;
-    /**
-     * - Whether button is disabled
-     */
-    disabled?: boolean;
-    /**
-     * - Reactive class attribute (Fynix-specific)
-     */
-    rc?: string;
-    /**
-     * - CSS class names
-     */
-    class?: string;
-    /**
-     * - Click event handler
-     */
-    "r-click"?: (this: HTMLElement, event: MouseEvent) => void;
-};

package/dist/custom/index.d.ts

@@ -1,2 +0,0 @@
-export { Button } from "./button";
-export { Path } from "./path";

package/dist/custom/path.d.ts

@@ -1,71 +0,0 @@
-/**
- * SPA navigation link component for Fynix router.
- * Automatically handles client-side navigation and prop passing between routes.
- *
- * @param {PathProps & Record<string, any>} options - Component props
- * @returns {VNode} Anchor element virtual node
- *
- * @example
- * // Basic navigation
- * <Path to="/about" value="About Us" />
- *
- * @example
- * // Navigate with props
- * <Path
- *   to="/user/123"
- *   value="View Profile"
- *   props={{ userId: 123, fromSearch: true }}
- * />
- *
- * @example
- * // External link
- * <Path
- *   to="https://github.com"
- *   value="GitHub"
- *   target="_blank"
- *   rel="noopener noreferrer"
- * />
- *
- * @example
- * // With styling
- * <Path
- *   to="/dashboard"
- *   value="Dashboard"
- *   rc="px-4 py-2 bg-blue-500 text-white rounded"
- * />
- */
-export function Path({ to, value, props: routeProps, ...attrs }: PathProps & Record<string, any>): VNode;
-export type PathProps = {
-    /**
-     * - URL to navigate to (relative or absolute)
-     */
-    to?: string;
-    /**
-     * - Link text content
-     */
-    value?: string;
-    /**
-     * - Props to pass to the destination route component
-     */
-    props?: Record<string, any>;
-    /**
-     * - Link target (_blank, _self, etc.)
-     */
-    target?: string;
-    /**
-     * - Link relationship (noopener, noreferrer, etc.)
-     */
-    rel?: string;
-    /**
-     * - Reactive class attribute (Fynix-specific)
-     */
-    rc?: string;
-    /**
-     * - CSS class names
-     */
-    class?: string;
-    /**
-     * - Element ID
-     */
-    id?: string;
-};

package/dist/error/errorOverlay.d.ts

@@ -1,26 +0,0 @@
-/**
- * @fileoverview Development error overlay for Fynix applications.
- * Displays runtime errors in a user-friendly overlay during development.
- */
-/**
- * Display an error overlay with error details.
- * Shows error message, stack trace, and a close button.
- *
- * @param {Error} error - The error object to display
- * @returns {void}
- *
- * @example
- * try {
- *   // some code
- * } catch (err) {
- *   showErrorOverlay(err);
- * }
- */
-export function showErrorOverlay(error: Error): void;
-/**
- * Remove the error overlay from the DOM.
- * Fades out the overlay before removing it.
- *
- * @returns {void}
- */
-export function removeErrorOverlay(): void;

package/dist/fynix/index.d.ts

@@ -1,4 +0,0 @@
-export * from "../runtime.js";
-export * from "../router/router.js";
-export { Fynix } from "../runtime.js";
-export { default as createFynix } from "../router/router.js";

package/dist/hooks/nixAsync.d.ts

@@ -1,13 +0,0 @@
-/**
- * Async state helper with AbortController support.
- *
- * @template T
- * @param {(signal: AbortSignal) => Promise<T>} promiseFactory
- */
-export function nixAsync<T>(promiseFactory: (signal: AbortSignal) => Promise<T>): {
-    data: import("./nixState").NixState;
-    error: import("./nixState").NixState;
-    loading: import("./nixState").NixState;
-    run: () => Promise<void>;
-    cancel: () => void;
-};

package/dist/hooks/nixAsyncCache.d.ts

@@ -1,7 +0,0 @@
-export function nixAsyncCached(key: any, promiseFactory: any): {
-    data: import("./nixState").NixState;
-    error: import("./nixState").NixState;
-    loading: import("./nixState").NixState;
-    run: () => Promise<void>;
-    cancel: () => void;
-};

package/dist/hooks/nixAsyncDebounce.d.ts

@@ -1,28 +0,0 @@
-/**
- * Debounced and cancellable async data fetcher with caching and deduping.
- *
- * @param {() => Promise<any>} promiseFactory - Async function that returns a promise.
- * @param {Object} [options={}] - Options for debounce, caching, and abort.
- * @param {number} [options.delay=300] - Debounce delay in ms.
- * @param {boolean} [options.leading=false] - Run on leading edge.
- * @param {boolean} [options.trailing=true] - Run on trailing edge.
- * @param {number} [options.maxWait] - Max wait time before forced invocation.
- * @param {boolean} [options.cache=true] - Enable caching of last result.
- * @param {AbortSignal} [options.signal] - Optional AbortSignal to cancel request.
- * @returns {Object} { data, error, loading, run, cancel }
- *
- * @example
- * const controller = new AbortController();
- * const { data, error, loading, run, cancel } = nixAsyncDebounce(
- *   () => fetch('/api/data').then(r => r.json()),
- *   { delay: 500, maxWait: 2000, leading: true, signal: controller.signal }
- * );
- */
-export function nixAsyncDebounce(promiseFactory: () => Promise<any>, options?: {
-    delay?: number;
-    leading?: boolean;
-    trailing?: boolean;
-    maxWait?: number;
-    cache?: boolean;
-    signal?: AbortSignal;
-}): any;

package/dist/hooks/nixAsyncQuery.d.ts

@@ -1,40 +0,0 @@
-/**
- * Unified async query helper with:
- * - AbortController cancellation
- * - Request deduping
- * - Shared caching
- *
- * @template T
- * @param {string} key
- * Unique cache key representing the request
- *
- * @param {(signal: AbortSignal) => Promise<T>} queryFn
- * Function that performs the async operation
- *
- * @param {{
- *   ttl?: number
- * }} [options]
- *
- * @returns {{
- *   data: { value: T | null },
- *   error: { value: Error | null },
- *   loading: { value: boolean },
- *   run: () => Promise<void>,
- *   cancel: () => void
- * }}
- */
-export 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;
-};

package/dist/hooks/nixCallback.d.ts

@@ -1,30 +0,0 @@
-/**
- * Memoizes a callback function based on a dependency array.
- * Similar to React's useCallback.
- *
- * @param {Function} fn
- * Function to memoize. Should be pure and not mutate external state.
- *
- * @param {Array<any>} [deps=[]]
- * Dependency array. Callback identity changes only when deps change.
- *
- * @returns {Function}
- * Memoized callback function.
- *
- * @throws {Error}
- * If called outside of a component context.
- *
- * @example
- * const onClick = nixCallback(() => {
- *   console.log(count.value);
- * }, [count.value]);
- *
- * @security
- * - Avoids JSON.stringify to prevent crashes on circular references
- * - Limits dependency array size to prevent performance abuse
- *
- * @memory
- * - Does not allocate large temporary strings
- * - Reuses function reference when deps are unchanged
- */
-export function nixCallback(fn: Function, deps?: Array<any>): Function;

package/dist/hooks/nixComputed.d.ts

@@ -1,93 +0,0 @@
-/**
- * @template T
- * @typedef {Object} ComputedState
- * @property {T} value - Get the computed value (read-only)
- * @property {(fn: (value: T) => void) => (() => void)} subscribe - Subscribe to computed value changes
- * @property {() => void} cleanup - Cleanup all subscriptions and dependencies
- * @property {() => number} getSubscriberCount - Get number of active subscribers (debugging)
- * @property {() => number} getDependencyCount - Get number of tracked dependencies (debugging)
- * @property {() => boolean} isDestroyed - Check if computed state has been destroyed
- * @property {boolean} _isNixState - Internal flag (computed states behave like states)
- * @property {boolean} _isComputed - Internal flag to identify computed states
- */
-/**
- * Create a derived/computed state from other states.
- * Automatically tracks dependencies and updates when any dependency changes.
- *
- * @template T
- * @param {() => T} computeFn - Function that computes the derived value
- * @returns {ComputedState<T>} A reactive state object with the computed value
- *
- * @example
- * const count = nixState(5);
- * const doubled = nixComputed(() => count.value * 2);
- * console.log(doubled.value); // 10
- * count.value = 10;
- * console.log(doubled.value); // 20
- *
- * @example
- * // Multiple dependencies
- * const a = nixState(5);
- * const b = nixState(10);
- * const sum = nixComputed(() => a.value + b.value);
- * console.log(sum.value); // 15
- *
- * @example
- * // Conditional dependencies
- * const flag = nixState(true);
- * const x = nixState(1);
- * const y = nixState(2);
- * const result = nixComputed(() => flag.value ? x.value : y.value);
- *
- * @example
- * // With cleanup
- * const MyComponent = () => {
- *   const count = nixState(0);
- *   const doubled = nixComputed(() => count.value * 2);
- *
- *   nixEffect(() => {
- *     return () => {
- *       doubled.cleanup();
- *       count.cleanup();
- *     };
- *   }, []);
- * };
- *
- * @throws {Error} If called outside a component context
- * @throws {TypeError} If computeFn is not a function
- */
-export function nixComputed<T>(computeFn: () => T): ComputedState<T>;
-export type ComputedState<T> = {
-    /**
-     * - Get the computed value (read-only)
-     */
-    value: T;
-    /**
-     * - Subscribe to computed value changes
-     */
-    subscribe: (fn: (value: T) => void) => (() => void);
-    /**
-     * - Cleanup all subscriptions and dependencies
-     */
-    cleanup: () => void;
-    /**
-     * - Get number of active subscribers (debugging)
-     */
-    getSubscriberCount: () => number;
-    /**
-     * - Get number of tracked dependencies (debugging)
-     */
-    getDependencyCount: () => number;
-    /**
-     * - Check if computed state has been destroyed
-     */
-    isDestroyed: () => boolean;
-    /**
-     * - Internal flag (computed states behave like states)
-     */
-    _isNixState: boolean;
-    /**
-     * - Internal flag to identify computed states
-     */
-    _isComputed: boolean;
-};

package/dist/hooks/nixDebounce.d.ts

@@ -1,32 +0,0 @@
-/**
- * @fileoverview Debounce utility function with advanced options.
- * Supports leading/trailing edge invocation, maxWait, and AbortController.
- */
-/**
- * Debounce a function with options for leading, trailing, maxWait, and AbortController support.
- *
- * @param {Function} fn - The function to debounce
- * @param {number} [delay=300] - Delay in milliseconds
- * @param {Object} [options={}] - Debounce options
- * @param {boolean} [options.leading=false] - Invoke on the leading edge
- * @param {boolean} [options.trailing=true] - Invoke on the trailing edge
- * @param {number} [options.maxWait] - Maximum wait time before forced invocation
- * @param {AbortSignal} [options.signal] - Optional AbortSignal to cancel pending calls
- * @returns {Function} Debounced function with `.cancel()` method
- *
- * @example
- * const controller = new AbortController();
- * const debounced = nixDebounce(() => console.log('Hello'), 500, {
- *   leading: true,
- *   maxWait: 2000,
- *   signal: controller.signal
- * });
- * debounced();
- * controller.abort(); // Cancel pending invocation
- */
-export function nixDebounce(fn: Function, delay?: number, options?: {
-    leading?: boolean;
-    trailing?: boolean;
-    maxWait?: number;
-    signal?: AbortSignal;
-}): Function;

package/dist/hooks/nixEffect.d.ts

@@ -1,64 +0,0 @@
-/**
- * Execute side effects in a component with automatic cleanup.
- * Similar to React's useEffect.
- *
- * @param {() => (void | (() => void))} effect - Effect function, optionally returns cleanup function
- * @param {Array<any>} [deps=[]] - Dependency array. Effect re-runs when dependencies change.
- *
- * @example
- * // Run once on mount
- * nixEffect(() => {
- *   console.log('Component mounted');
- *   return () => console.log('Component unmounted');
- * }, []);
- *
- * @example
- * // Run when count changes
- * const count = nixState(0);
- * nixEffect(() => {
- *   console.log('Count is:', count.value);
- * }, [count.value]);
- *
- * @example
- * // Timer with cleanup
- * nixEffect(() => {
- *   const timer = setInterval(() => console.log('tick'), 1000);
- *   return () => clearInterval(timer);
- * }, []);
- *
- * @example
- * // Event listener with cleanup
- * nixEffect(() => {
- *   const handler = (e) => console.log('clicked', e);
- *   document.addEventListener('click', handler);
- *   return () => document.removeEventListener('click', handler);
- * }, []);
- *
- * @throws {Error} If called outside a component context
- */
-export function nixEffect(effect: () => (void | (() => void)), deps?: Array<any>): void;
-/**
- * Run an effect only once on component mount.
- * Convenience wrapper around nixEffect.
- *
- * @param {() => (void | (() => void))} effect - Effect function
- *
- * @example
- * nixEffectOnce(() => {
- *   console.log('Mounted');
- *   return () => console.log('Unmounted');
- * });
- */
-export function nixEffectOnce(effect: () => (void | (() => void))): void;
-/**
- * Run an effect every time the component renders.
- * Use with caution - can cause performance issues.
- *
- * @param {() => (void | (() => void))} effect - Effect function
- *
- * @example
- * nixEffectAlways(() => {
- *   console.log('Component rendered');
- * });
- */
-export function nixEffectAlways(effect: () => (void | (() => void))): void;

package/dist/hooks/nixForm.d.ts

@@ -1,15 +0,0 @@
-/**
- * Reactive form handler with validation, reactive state, and safe async submit.
- *
- * @param {Object} [initialValues={}] - Initial values for form fields.
- * @param {Object} [validationRules={}] - Validation rules for fields.
- * @returns {Object} Form utilities: values, errors, touched, isSubmitting, isValid,
- *   handleChange, handleBlur, handleSubmit, reset, getFieldProps, cancelSubmit
- *
- * @example
- * const form = nixForm({ email: "" }, {
- *   email: { required: true, pattern: /^\S+@\S+$/, message: "Invalid email" }
- * });
- * form.handleSubmit(async (values) => { await api.submit(values); });
- */
-export function nixForm(initialValues?: any, validationRules?: any): any;

package/dist/hooks/nixFormAsync.d.ts

@@ -1,20 +0,0 @@
-/**
- * Full-featured reactive form with debounced async API submission.
- *
- * @param {Object} [initialValues={}] - Initial field values.
- * @param {Object} [validationRules={}] - Validation rules for each field.
- * @param {Object} [options={}] - Async submit options.
- * @param {number} [options.delay=300] - Debounce delay in ms.
- * @param {boolean} [options.leading=false] - Invoke submit on leading edge.
- * @param {boolean} [options.trailing=true] - Invoke submit on trailing edge.
- * @param {number} [options.maxWait] - Maximum wait time before forced invocation.
- * @param {boolean} [options.cache=true] - Cache last submission result.
- * @returns {Object} Form API with state, validation, and debounced async submission.
- */
-export function nixFormAsync(initialValues?: any, validationRules?: any, options?: {
-    delay?: number;
-    leading?: boolean;
-    trailing?: boolean;
-    maxWait?: number;
-    cache?: boolean;
-}): any;

package/dist/hooks/nixInterval.d.ts

@@ -1,26 +0,0 @@
-/**
- * @fileoverview Safe interval utility with automatic cleanup support.
- * Provides AbortController integration for cancellable intervals.
- */
-/**
- * Safe interval with automatic cleanup support and optional AbortController.
- * Must be called within a component and cleaned up on unmount.
- *
- * @param {() => void} fn - Function to run at each interval
- * @param {number} ms - Interval duration in milliseconds
- * @param {AbortSignal} [signal] - Optional AbortSignal to cancel the interval
- * @returns {() => void} Cleanup function to stop the interval
- *
- * @example
- * const cancel = nixInterval(() => console.log('tick'), 1000);
- * // stop interval
- * cancel();
- *
- * @example
- * const controller = new AbortController();
- * nixInterval(() => console.log('tick'), 1000, controller.signal);
- * controller.abort(); // automatically clears interval
- *
- * @throws {TypeError} If fn is not a function or ms is not a non-negative number
- */
-export function nixInterval(fn: () => void, ms: number, signal?: AbortSignal): () => void;

package/dist/hooks/nixLazy.d.ts

@@ -1,19 +0,0 @@
-/**
- * Lazy-load a module/component with caching.
- *
- * @param {() => Promise<any>} importFn - Function that returns a dynamic import.
- * @returns {Function} Component wrapper for lazy-loaded module.
- */
-export function nixLazy(importFn: () => Promise<any>): Function;
-/**
- * Suspense-like wrapper for lazy components.
- *
- * @param {Object} props
- * @param {any} props.fallback - Element to render while loading.
- * @param {Function} props.children - Function returning child component.
- * @returns {any} Rendered fallback or child.
- */
-export function Suspense({ fallback, children }: {
-    fallback: any;
-    children: Function;
-}): any;

package/dist/hooks/nixLazyAsync.d.ts

@@ -1,26 +0,0 @@
-/**
- * Lazy-load a module/component with caching, retry, and abort support.
- *
- * @param {() => Promise<any>} importFn - Function returning a dynamic import.
- * @param {Object} [options={}] - Options for lazy loading.
- * @param {number} [options.retry=0] - Number of retry attempts on failure.
- * @returns {Function} Component wrapper for lazy-loaded module.
- *
- * @example
- * const LazyComp = nixLazyAsync(() => import("./MyComponent"), { retry: 2 });
- */
-export function nixLazyAsync(importFn: () => Promise<any>, options?: {
-    retry?: number;
-}): Function;
-/**
- * Suspense wrapper to catch pending promises and render fallback.
- *
- * @param {Object} props
- * @param {any} props.fallback - Element to render while loading.
- * @param {Function} props.children - Function returning child component.
- * @returns {any} Rendered fallback or child component.
- */
-export function Suspense({ fallback, children }: {
-    fallback: any;
-    children: Function;
-}): any;

package/dist/hooks/nixLazyFormAsync.d.ts

@@ -1,29 +0,0 @@
-/**
- * Lazy-load a form component and manage its state with debounced async submissions.
- *
- * @param {() => Promise<any>} importFn - Function returning a dynamic import of the form component.
- * @param {Object} [formOptions={}] - Initial values and validation rules.
- * @param {Object} [formOptions.initialValues={}] - Initial field values.
- * @param {Object} [formOptions.validationRules={}] - Validation rules per field.
- * @param {Object} [submitOptions={}] - Debounce and async submission options.
- * @param {number} [submitOptions.delay=300] - Debounce delay.
- * @param {boolean} [submitOptions.leading=false] - Invoke submit on leading edge.
- * @param {boolean} [submitOptions.trailing=true] - Invoke submit on trailing edge.
- * @param {number} [submitOptions.maxWait] - Max wait before forced submission.
- * @param {boolean} [submitOptions.cache=true] - Cache last submission result.
- * @param {Object} [lazyOptions={}] - Options for lazy-loaded component import.
- * @param {number} [lazyOptions.retry=0] - Retry count for lazy-loaded component import.
- * @returns {Object} Lazy-loaded form component and reactive form API.
- */
-export function nixLazyFormAsync(importFn: () => Promise<any>, formOptions?: {
-    initialValues?: any;
-    validationRules?: any;
-}, submitOptions?: {
-    delay?: number;
-    leading?: boolean;
-    trailing?: boolean;
-    maxWait?: number;
-    cache?: boolean;
-}, lazyOptions?: {
-    retry?: number;
-}): any;

package/dist/hooks/nixLocalStorage.d.ts

@@ -1,22 +0,0 @@
-/**
- * Reactive wrapper around localStorage with safe JSON parsing/stringifying.
- * Automatically persists state changes to localStorage.
- *
- * @template T
- * @param {string} key - LocalStorage key
- * @param {T} initial - Initial value if key does not exist
- * @returns {{ value: T, set: (v: T) => void }} Object with value getter and setter
- *
- * @example
- * const theme = nixLocalStorage('theme', 'light');
- * console.log(theme.value); // 'light' or stored value
- * theme.set('dark'); // Updates state and localStorage
- *
- * @example
- * const user = nixLocalStorage('user', { name: '', age: 0 });
- * user.set({ name: 'John', age: 30 });
- */
-export function nixLocalStorage<T>(key: string, initial: T): {
-    value: T;
-    set: (v: T) => void;
-};

package/dist/hooks/nixMemo.d.ts

@@ -1,8 +0,0 @@
-/**
- * Memoize a value based on dependencies, similar to React's useMemo.
- *
- * @param {() => any} factory - Function to compute the memoized value
- * @param {Array<any>} deps - Dependency array
- * @returns {any} Memoized value
- */
-export function nixMemo(factory: () => any, deps?: Array<any>): any;

package/dist/hooks/nixPrevious.d.ts

@@ -1,18 +0,0 @@
-/**
- * Returns the previous value of a variable across renders.
- * Useful for detecting changes and implementing undo functionality.
- *
- * @template T
- * @param {T} val - Current value
- * @returns {T | undefined} Previous value (undefined on first render)
- *
- * @example
- * const count = nixState(0);
- * const prevCount = nixPrevious(count.value);
- *
- * // prevCount will be undefined on first render
- * // then will hold the previous value on subsequent renders
- *
- * @throws {Error} If called outside a component context
- */
-export function nixPrevious<T>(val: T): T | undefined;

package/dist/hooks/nixRef.d.ts

@@ -1,10 +0,0 @@
-/**
- * Returns a mutable ref object that persists across renders.
- * Similar to React's useRef.
- *
- * @param {any} initial - Initial value for the ref
- * @returns {{ current: any }} Ref object
- */
-export function nixRef(initial?: any): {
-    current: any;
-};

package/dist/hooks/nixState.d.ts

@@ -1,73 +0,0 @@
-/**
- * Creates a reactive state value that triggers component re-renders when changed.
- * Must be called within a component function.
- *
- * @param {any} initial - The initial value for the state
- * @returns {NixState} A reactive state object with value getter/setter and subscription methods
- *
- * @typedef {Object} NixState
- * @property {any} value - Get/set the current state value. Getting tracks the dependency, setting triggers subscribers.
- * @property {(fn: Function) => Function} subscribe - Subscribe to state changes. Returns unsubscribe function.
- * @property {() => void} cleanup - Cleanup all subscriptions to prevent memory leaks
- * @property {() => number} getSubscriberCount - Get number of active subscribers (debugging)
- * @property {() => boolean} isDestroyed - Check if state has been destroyed
- * @property {() => Object} asReadOnly - Get read-only version of the state
- * @property {boolean} _isNixState - Internal flag to identify nixState objects
- *
- * @example
- * const Counter = () => {
- *   const count = nixState(0);
- *
- *   return h("div", {},
- *     h("p", {}, "Count: ", count),
- *     h("button", { "r-click": () => count.value++ }, "Increment")
- *   );
- * };
- *
- * @example
- * // With cleanup
- * const MyComponent = () => {
- *   const state = nixState(0);
- *
- *   nixEffect(() => {
- *     return () => state.cleanup(); // Clean up on unmount
- *   }, []);
- * };
- *
- * @throws {Error} If called outside a component context
- */
-export function nixState(initial: any): NixState;
-/**
- * Creates a reactive state value that triggers component re-renders when changed.
- * Must be called within a component function.
- */
-export type NixState = {
-    /**
-     * - Get/set the current state value. Getting tracks the dependency, setting triggers subscribers.
-     */
-    value: any;
-    /**
-     * - Subscribe to state changes. Returns unsubscribe function.
-     */
-    subscribe: (fn: Function) => Function;
-    /**
-     * - Cleanup all subscriptions to prevent memory leaks
-     */
-    cleanup: () => void;
-    /**
-     * - Get number of active subscribers (debugging)
-     */
-    getSubscriberCount: () => number;
-    /**
-     * - Check if state has been destroyed
-     */
-    isDestroyed: () => boolean;
-    /**
-     * - Get read-only version of the state
-     */
-    asReadOnly: () => any;
-    /**
-     * - Internal flag to identify nixState objects
-     */
-    _isNixState: boolean;
-};

package/dist/hooks/nixStore.d.ts

@@ -1,9 +0,0 @@
-/**
- * Reactive store hook with subscription support.
- * Memory-safe: cleans up subscribers on component unmount.
- *
- * @param {string} path - Optional path identifier
- * @param {any} initial - Initial value
- * @returns {Object} Reactive store object with get/set/subscribe
- */
-export function nixStore(path: string, initial: any): any;

package/dist/plugins/vite-plugin-res.d.ts

@@ -1,16 +0,0 @@
-/**
- * Vite plugin for transforming Fynix JSX files.
- * Automatically transforms .js and .fnx files.
- *
- * @returns {Object} Vite plugin object
- *
- * @example
- * // vite.config.js
- * import { defineConfig } from 'vite';
- * import { fynix } from '@fynixorg/ui/plugins/vite-plugin-fynix';
- *
- * export default defineConfig({
- *   plugins: [fynix()]
- * });
- */
-export function fynix(): any;

package/dist/router/router.d.ts

@@ -1,53 +0,0 @@
-/**
- * @typedef {Object} FynixRouter
- * @property {function(string=): void} mountRouter - Mount router to DOM element
- * @property {function(string, Object=): void} navigate - Navigate to path with props
- * @property {function(string, Object=): void} replace - Replace current path
- * @property {function(): void} back - Navigate back
- * @property {function(): void} cleanup - Cleanup router instance
- * @property {Object} routes - Static routes map
- * @property {Array} dynamicRoutes - Dynamic routes array
- */
-/**
- * Fynix Router Factory
- * @returns {FynixRouter}
- */
-export default function createFynix(): FynixRouter;
-/**
- * Helper: Set props for links
- */
-export function setLinkProps(key: any, props: any): void;
-/**
- * Helper: Clear link props
- */
-export function clearLinkProps(key: any): void;
-export type FynixRouter = {
-    /**
-     * - Mount router to DOM element
-     */
-    mountRouter: (arg0: string | undefined) => void;
-    /**
-     * - Navigate to path with props
-     */
-    navigate: (arg0: string, arg1: any | undefined) => void;
-    /**
-     * - Replace current path
-     */
-    replace: (arg0: string, arg1: any | undefined) => void;
-    /**
-     * - Navigate back
-     */
-    back: () => void;
-    /**
-     * - Cleanup router instance
-     */
-    cleanup: () => void;
-    /**
-     * - Static routes map
-     */
-    routes: any;
-    /**
-     * - Dynamic routes array
-     */
-    dynamicRoutes: any[];
-};

package/dist/runtime.d.ts

@@ -1,91 +0,0 @@
-/**
- * Create a virtual text node, supporting reactive state.
- * @param {string|number|object} text
- * @returns {object} vnode
- */
-export function createTextVNode(text: string | number | object): object;
-/**
- * Create a virtual DOM node (element, fragment, or component).
- * @param {string|function|symbol} type
- * @param {object} [props={}]
- * @param  {...any} children
- * @returns {object} vnode
- */
-export function h(type: string | Function | symbol, props?: object, ...children: any[]): object;
-export namespace h {
-    function Fragment({ children }: {
-        children: any;
-    }): any;
-}
-/**
- * Safely render a component
- * @param {function} Component
- * @param {object} props
- * @returns {object} vnode
- */
-export function renderComponent(Component: Function, props?: object): object;
-/**
- * Patch a parent DOM node based on oldVNode -> newVNode changes
- * @param {Node} parent
- * @param {object|string|number} newVNode
- * @param {object|string|number} oldVNode
- * @returns {Promise<void>}
- */
-export function patch(parent: Node, newVNode: object | string | number, oldVNode: object | string | number): Promise<void>;
-/**
- * Mount the app component to a root DOM node
- * @param {function} AppComponent
- * @param {string|Element} root
- * @param {boolean} [hydrate=false]
- * @param {object} [props={}]
- */
-export function mount(AppComponent: Function, root: string | Element, hydrate?: boolean, props?: object): void;
-/**
- * Symbol for text nodes
- * @type {symbol}
- */
-export const TEXT: symbol;
-/**
- * Symbol for fragments
- * @type {symbol}
- */
-export const Fragment: symbol;
-/**
- * Create a virtual DOM node (element, fragment, or component).
- * @param {string|function|symbol} type
- * @param {object} [props={}]
- * @param  {...any} children
- * @returns {object} vnode
- */
-export function Fynix(type: string | Function | symbol, props?: object, ...children: any[]): object;
-export namespace Fynix {
-    import Fragment = h.Fragment;
-    export { Fragment };
-}
-import { nixState } from "./hooks/nixState";
-import { nixEffect } from "./hooks/nixEffect";
-import { nixStore } from "./hooks/nixStore";
-import { nixInterval } from "./hooks/nixInterval";
-import { nixAsync } from "./hooks/nixAsync";
-import { nixCallback } from "./hooks/nixCallback";
-import { nixComputed } from "./hooks/nixComputed";
-import { nixMemo } from "./hooks/nixMemo";
-import { nixDebounce } from "./hooks/nixDebounce";
-import { nixPrevious } from "./hooks/nixPrevious";
-import { nixLocalStorage } from "./hooks/nixLocalStorage";
-import { nixRef } from "./hooks/nixRef";
-import { nixLazy } from "./hooks/nixLazy.js";
-import { Suspense } from "./hooks/nixLazy.js";
-import { nixForm } from "./hooks/nixForm.js";
-import { nixAsyncCached } from "./hooks/nixAsyncCache";
-import { nixAsyncDebounce } from "./hooks/nixAsyncDebounce";
-import { nixAsyncQuery } from "./hooks/nixAsyncQuery";
-import { nixEffectAlways } from "./hooks/nixEffect";
-import { nixEffectOnce } from "./hooks/nixEffect";
-import { nixFormAsync } from "./hooks/nixFormAsync";
-import { nixLazyAsync } from "./hooks/nixLazyAsync";
-import { nixLazyFormAsync } from "./hooks/nixLazyFormAsync";
-import { Path } from "./custom/index.js";
-import { Button } from "./custom/index.js";
-import createFynix from "./router/router.js";
-export { nixState, nixEffect, nixStore, nixInterval, nixAsync, nixCallback, nixComputed, nixMemo, nixDebounce, nixPrevious, nixLocalStorage, nixRef, nixLazy, Suspense, nixForm, nixAsyncCached, nixAsyncDebounce, nixAsyncQuery, nixEffectAlways, nixEffectOnce, nixFormAsync, nixLazyAsync, nixLazyFormAsync, Path, Button, createFynix };