fynixui 1.0.11 → 1.0.13

package/dist-types/context/context.d.ts

@@ -4,7 +4,7 @@ export interface ComponentContext {
     effects: Function[];
     cleanups: Function[];
     stateCleanups?: Function[];
-    _vnode: object;
+    _vnode: object | null;
     _accessedStates: Set<any>;
     _subscriptions: Set<any>;
     _subscriptionCleanups: Function[];

package/dist-types/custom/DataTable.d.ts

@@ -0,0 +1,54 @@
+type TableVariant = "primary" | "secondary" | "success" | "danger" | "warning" | "info" | "light" | "dark";
+type ActionHandler<T = any> = (row: T, index: number) => void;
+export interface ColumnDef<T = any> {
+    key: keyof T | string;
+    label: string;
+    style?: Record<string, string>;
+    class?: string;
+    render?: (value: any, row: T, index: number) => any;
+}
+export interface ActionsDef<T = any> {
+    view?: ActionHandler<T> | false;
+    edit?: ActionHandler<T> | false;
+    delete?: ActionHandler<T> | false;
+    extra?: Array<{
+        label: string;
+        handler: ActionHandler<T>;
+        style?: Record<string, string>;
+        class?: string;
+    }>;
+}
+export interface DataTableProps<T = any> {
+    columns: ColumnDef<T>[];
+    data: T[];
+    actions?: ActionsDef<T>;
+    variant?: TableVariant;
+    outline?: boolean;
+    striped?: boolean;
+    hoverable?: boolean;
+    bordered?: boolean;
+    style?: Record<string, string>;
+    class?: string;
+    tableStyle?: Record<string, string>;
+    tableClass?: string;
+    rc?: string;
+    [key: string]: any;
+}
+export declare function DataTable<T = any>({ columns, data, actions, style: wrapStyle, class: wrapClass, tableStyle, tableClass, rc, ...rest }: DataTableProps<T>): any;
+export declare const PrimaryDataTable: <T>(p: DataTableProps<T>) => any;
+export declare const SecondaryDataTable: <T>(p: DataTableProps<T>) => any;
+export declare const SuccessDataTable: <T>(p: DataTableProps<T>) => any;
+export declare const DangerDataTable: <T>(p: DataTableProps<T>) => any;
+export declare const WarningDataTable: <T>(p: DataTableProps<T>) => any;
+export declare const InfoDataTable: <T>(p: DataTableProps<T>) => any;
+export declare const LightDataTable: <T>(p: DataTableProps<T>) => any;
+export declare const DarkDataTable: <T>(p: DataTableProps<T>) => any;
+export declare const OutlinePrimaryDataTable: <T>(p: DataTableProps<T>) => any;
+export declare const OutlineSecondaryDataTable: <T>(p: DataTableProps<T>) => any;
+export declare const OutlineSuccessDataTable: <T>(p: DataTableProps<T>) => any;
+export declare const OutlineDangerDataTable: <T>(p: DataTableProps<T>) => any;
+export declare const OutlineWarningDataTable: <T>(p: DataTableProps<T>) => any;
+export declare const OutlineInfoDataTable: <T>(p: DataTableProps<T>) => any;
+export declare const OutlineLightDataTable: <T>(p: DataTableProps<T>) => any;
+export declare const OutlineDarkDataTable: <T>(p: DataTableProps<T>) => any;
+export {};

package/dist-types/custom/button.d.ts

@@ -1 +1,35 @@
-export declare function Button({ value, ...props }: Record<string, any>): any;
+type ButtonVariant = "primary" | "secondary" | "success" | "danger" | "warning" | "info" | "light" | "dark" | "link";
+type ButtonSize = "sm" | "md" | "lg";
+interface ButtonProps {
+    value?: string;
+    type?: "button" | "submit" | "reset";
+    disabled?: boolean;
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    outline?: boolean;
+    style?: Record<string, string>;
+    class?: string;
+    rc?: string;
+    "r-click"?: (this: HTMLElement, event: MouseEvent) => void;
+    [key: string]: any;
+}
+export declare function Button({ value, ...props }: ButtonProps): any;
+export declare const PrimaryButton: (p: ButtonProps) => any;
+export declare const SecondaryButton: (p: ButtonProps) => any;
+export declare const SuccessButton: (p: ButtonProps) => any;
+export declare const DangerButton: (p: ButtonProps) => any;
+export declare const WarningButton: (p: ButtonProps) => any;
+export declare const InfoButton: (p: ButtonProps) => any;
+export declare const LightButton: (p: ButtonProps) => any;
+export declare const DarkButton: (p: ButtonProps) => any;
+export declare const LinkButton: (p: ButtonProps) => any;
+export declare const OutlinePrimaryButton: (p: ButtonProps) => any;
+export declare const OutlineSecondaryButton: (p: ButtonProps) => any;
+export declare const OutlineSuccessButton: (p: ButtonProps) => any;
+export declare const OutlineDangerButton: (p: ButtonProps) => any;
+export declare const OutlineWarningButton: (p: ButtonProps) => any;
+export declare const OutlineInfoButton: (p: ButtonProps) => any;
+export declare const OutlineLightButton: (p: ButtonProps) => any;
+export declare const OutlineDarkButton: (p: ButtonProps) => any;
+export declare const OutlineLinkButton: (p: ButtonProps) => any;
+export {};

package/dist-types/custom/index.d.ts

@@ -1,2 +1,3 @@
-export { Button } from "./button";
+export { Button, PrimaryButton, SecondaryButton, SuccessButton, DangerButton, WarningButton, InfoButton, LightButton, DarkButton, LinkButton, } from "./button";
+export { DataTable, PrimaryDataTable, SecondaryDataTable, SuccessDataTable, DangerDataTable, WarningDataTable, InfoDataTable, LightDataTable, DarkDataTable, OutlinePrimaryDataTable, OutlineSecondaryDataTable, OutlineSuccessDataTable, OutlineDangerDataTable, OutlineWarningDataTable, OutlineInfoDataTable, OutlineLightDataTable, OutlineDarkDataTable, } from "./DataTable";
 export { Path } from "./path";

package/dist-types/hooks/nixFor.d.ts

@@ -2,7 +2,7 @@ import { VNode } from "../types/fnx";
 interface ReactiveState<T> {
     value: T;
     _isNixState: boolean;
-    subscribe(callback: (value: T) => void): () => void;
+    subscribe(callback: () => void): () => void;
 }
 interface ForProps<T> {
     each: T[] | ReactiveState<T[]>;

package/dist-types/router/router.d.ts

@@ -1,13 +1,16 @@
-interface NestedRoute {
+interface LocationSignal {
     path: string;
-    component: ComponentFunction;
-    children?: NestedRoute[];
-    layout?: ComponentFunction;
-    keepAlive?: boolean;
+    params: Record<string, string>;
+    search: string;
 }
-interface ComponentFunction {
-    (props: any): any;
+declare class LocationManager {
+    private current;
+    private subscribers;
+    get value(): LocationSignal;
+    set value(newLocation: LocationSignal);
+    subscribe(callback: (location: LocationSignal) => void): () => void;
 }
+export declare const location: LocationManager;
 interface RouteComponent {
     (props: any): any;
     props?: Record<string, any> | (() => Record<string, any>);
@@ -28,6 +31,9 @@ interface DynamicRoute {
     component: RouteComponent;
     params: string[];
 }
+interface FynixRouterOptions {
+    lazy?: boolean;
+}
 interface FynixRouter {
     mountRouter(selector?: string): void;
     navigate(path: string, props?: Record<string, any>): void;
@@ -36,11 +42,9 @@ interface FynixRouter {
     cleanup(): void;
     routes: Record<string, RouteComponent>;
     dynamicRoutes: DynamicRoute[];
-    preloadRoute?(path: string): Promise<void>;
     clearCache?(): void;
-    enableNestedRouting?(routes: NestedRoute[]): void;
 }
-declare function createFynix(): FynixRouter;
+declare function createFynix(options?: FynixRouterOptions): FynixRouter;
 export { createFynix };
 export default createFynix;
 export declare function setLinkProps(key: string, props: Record<string, any>): void;

package/dist-types/runtime.d.ts

@@ -1,37 +1,40 @@
 type Priority = "immediate" | "high" | "normal" | "low" | "idle";
+type EffectTag = "PLACEMENT" | "UPDATE" | "DELETION" | null;
 interface FynixFiber {
     type: string | symbol | ComponentFunction;
-    props: any;
+    props: VNodeProps;
     key: string | number | null;
     child: FynixFiber | null;
     sibling: FynixFiber | null;
     parent: FynixFiber | null;
     alternate: FynixFiber | null;
-    effectTag: "PLACEMENT" | "UPDATE" | "DELETION" | null;
+    effectTag: EffectTag;
     updatePriority: Priority;
-    _domNode?: Node | null;
-    _rendered?: FynixFiber | null;
-    hooks?: any[];
-    context?: ComponentContext;
+    _domNode: Node | null;
+    ctx: ComponentContext | null;
+    _vnode: VNode | null;
 }
-type VNodeType = string | symbol | ComponentFunction;
-type VNodeChild = VNode | string | number | boolean | null | undefined;
-type VNodeChildren = VNodeChild | VNodeChild[];
-interface VNodeProps {
+export type VNodeType = string | symbol | ComponentFunction;
+export type VNodeChild = VNode | string | number | boolean | null | undefined;
+export type VNodeChildren = VNodeChild | VNodeChild[];
+export interface VNodeProps {
     children?: VNode[];
     key?: string | number | null;
     [key: string]: any;
 }
-interface VNode {
+export interface VNode {
     type: VNodeType;
     props: VNodeProps;
     key: string | number | null;
     _domNode?: Node | null;
+    _fiber?: FynixFiber | null;
     _rendered?: VNode | null;
+    _fragmentStart?: Node | null;
+    _fragmentEnd?: Node | null;
     _state?: ReactiveState<any> | null;
     _cleanup?: (() => void) | null;
 }
-interface ComponentFunction {
+export interface ComponentFunction {
     (props: any): VNode | Promise<VNode>;
 }
 interface ReactiveState<T> {
@@ -44,7 +47,8 @@ interface ComponentContext {
     hookIndex: number;
     effects: Array<() => void | (() => void)>;
     cleanups: Array<() => void>;
-    _vnode: VNode;
+    _vnode: VNode | null;
+    _fiber: FynixFiber | null;
     _accessedStates: Set<ReactiveState<any>>;
     _subscriptions: Set<ReactiveState<any>>;
     _subscriptionCleanups: Array<() => void>;
@@ -53,6 +57,7 @@ interface ComponentContext {
     Component: ComponentFunction;
     _isMounted: boolean;
     _isRerendering: boolean;
+    _rerenderTimeout: ReturnType<typeof setTimeout> | null;
 }
 import { Button, Path } from "./custom/index";
 import { nixAsync } from "./hooks/nixAsync";
@@ -76,48 +81,121 @@ import { nixRef } from "./hooks/nixRef";
 import { nixState } from "./hooks/nixState";
 import { nixStore } from "./hooks/nixStore";
 import createFynix from "./router/router";
-declare class FiberRenderer {
-    private workInProgressRoot;
-    private nextUnitOfWork;
-    private currentRoot;
+type AsyncBatchingStore = {
+    isBatching: boolean;
+    callbacks: Array<() => void>;
+};
+export declare function batchUpdates(fn: () => void): void;
+export declare function isCurrentlyBatching(): boolean;
+export interface ErrorHandlerConfig {
+    onRenderError?: (error: Error, component?: ComponentFunction) => boolean;
+    onAsyncError?: (error: Error) => boolean;
+    onCommitError?: (error: Error, fiber?: FynixFiber) => boolean;
+    logToConsole?: boolean;
+    showOverlay?: boolean;
+}
+export declare function configureErrorHandling(config: Partial<ErrorHandlerConfig>): void;
+export declare function getErrorConfig(): ErrorHandlerConfig;
+export interface PerformanceProfileConfig {
+    enabled?: boolean;
+    logMeasurements?: boolean;
+    slowRenderThreshold?: number;
+    onMetrics?: (metrics: PerformanceMetrics) => void;
+}
+export interface PerformanceMetrics {
+    renderTime: number;
+    commitTime: number;
+    totalTime: number;
+    updateCount: number;
+    fiberCount: number;
+    componentName?: string;
+    timestamp: number;
+}
+export declare function enablePerformanceProfiling(config: PerformanceProfileConfig): void;
+export declare function getPerfConfig(): PerformanceProfileConfig;
+export declare const TEXT: unique symbol;
+export declare const Fragment: unique symbol;
+export declare const BOOLEAN_ATTRS: Set<string>;
+export declare const DOM_PROPERTIES: Set<string>;
+export declare const DANGEROUS_HTML_PROPS: Set<string>;
+export declare const DANGEROUS_PROTOCOLS: Set<string>;
+export declare const SAFE_PROTOCOLS: Set<string>;
+export declare function createTextVNode(text: any): VNode;
+export declare function h(type: VNodeType, props?: VNodeProps | null, ...children: VNodeChildren[]): VNode;
+export declare namespace h {
+    var Fragment: ({ children }: {
+        children?: VNode[];
+    }) => VNode[];
+}
+export declare const Fynix: typeof h;
+declare class FiberReconciler {
+    private wipRoot;
+    private wipEntry;
+    private nextWork;
     private deletions;
-    scheduleWork(fiber: FynixFiber): void;
-    workLoop(deadline: number): void;
-    performUnitOfWork(fiber: FynixFiber): FynixFiber | null;
+    mountRoot(vnode: VNode, container: Element): void;
+    scheduleUpdate(fiber: FynixFiber, priority?: Priority): void;
+    private scheduleRender;
+    private workLoop;
+    private performWork;
+    private updateComponentFiber;
+    private updateHostFiber;
     private reconcileChildren;
     private commitRoot;
     private commitWork;
     private commitDeletion;
-    private updateDom;
+    private unmountFiber;
+    private runEffects;
+    private vnodeToFiber;
+    private cloneFiber;
+    private findDomParent;
+    private findNearestDom;
+    private findNextDomSibling;
 }
-export declare function useFiberRenderer(): FiberRenderer;
+declare const fiberReconciler: FiberReconciler;
+export declare const __debug__: {
+    getSchedulerState: () => {
+        isScheduled: boolean;
+        isWorking: boolean;
+        currentPriority: Priority;
+        queueSize: number;
+        batchedUpdatesSize: number;
+        idCounter: number;
+    };
+    getQueueMetrics: () => {
+        pending: number;
+        batched: number;
+        isActive: boolean;
+        currentPriority: Priority;
+    };
+    getFiberReconciler: () => FiberReconciler;
+    getErrorConfig: () => ErrorHandlerConfig;
+    getPerfConfig: () => PerformanceProfileConfig;
+    collectGarbage: () => void;
+    clearSchedulerQueue: () => void;
+    getAsyncContext: () => {
+        currentBatchStore: AsyncBatchingStore | null;
+        batchingStorageAvailable: boolean;
+    };
+};
 declare class HierarchicalStore {
     private root;
     private selectorCache;
     private stateSnapshot;
     select<T>(selector: (state: any) => T): T;
-    optimisticUpdate<T>(path: string, update: T, rollback?: () => void): {
+    optimisticUpdate<T>(path: string, update: T, onRollback?: () => void): {
         commit: () => void;
         rollback: () => void;
     };
-    private getState;
-    private get;
     private set;
-    private clearRollback;
-    private invalidateSelectors;
 }
 export declare function useHierarchicalStore(): HierarchicalStore;
-export declare const TEXT: unique symbol;
-export declare const Fragment: unique symbol;
-export declare function createTextVNode(text: any): VNode;
-export declare function h(type: VNodeType, props?: VNodeProps | null, ...children: VNodeChildren[]): VNode;
-export declare namespace h {
-    var Fragment: ({ children }: {
-        children?: VNode[];
-    }) => VNode[];
-}
-export declare const Fynix: typeof h;
+declare function mount(AppComponent: ComponentFunction, root: string | Element, props?: any): void;
+declare function hydrate(AppComponent: ComponentFunction, root: string | Element, props?: any): void;
+export declare function memo(Component: ComponentFunction, propsAreEqual?: (oldProps: any, newProps: any) => boolean): ComponentFunction;
 export declare function renderComponent(Component: ComponentFunction, props?: any): VNode;
-export declare function patch(parent: Node, newVNode: VNode | string | number | null | undefined, oldVNode: VNode | string | number | null | undefined): Promise<void>;
-export declare function mount(AppComponent: ComponentFunction, root: string | Element, props?: any): void;
-export { Button, createFynix, nixAsync, nixAsyncCached, nixAsyncDebounce, nixAsyncQuery, nixCallback, nixComputed, nixDebounce, nixEffect, nixEffectAlways, nixEffectOnce, nixForm, nixFormAsync, nixInterval, nixLazy, nixLazyAsync, nixLazyFormAsync, nixLocalStorage, nixMemo, nixPrevious, nixRef, nixState, nixStore, Path, Suspense, };
+export declare function ErrorBoundary({ fallback, children, }: {
+    fallback: (error: Error) => VNode;
+    children?: VNode[];
+}): VNode;
+export { Button, createFynix, nixAsync, nixAsyncCached, nixAsyncDebounce, nixAsyncQuery, nixCallback, nixComputed, nixDebounce, nixEffect, nixEffectAlways, nixEffectOnce, nixForm, nixFormAsync, nixInterval, nixLazy, nixLazyAsync, nixLazyFormAsync, nixLocalStorage, nixMemo, nixPrevious, nixRef, nixState, nixStore, Path, Suspense, mount, hydrate, fiberReconciler, };