@fynixorg/ui 1.0.7 → 1.0.9

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 };