fynixui 1.0.10 → 1.0.12

package/{dist → 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[];
@@ -16,4 +16,3 @@ export interface ComponentContext {
 }
 export declare let activeContext: ComponentContext | null;
 export declare function setActiveContext(ctx: ComponentContext | null): void;
-//# sourceMappingURL=context.d.ts.map

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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,2 @@
+export { Button, PrimaryButton, SecondaryButton, SuccessButton, DangerButton, WarningButton, InfoButton, LightButton, DarkButton, LinkButton, } from "./button";
+export { Path } from "./path";

package/{dist → dist-types}/custom/path.d.ts

@@ -11,4 +11,3 @@ export declare function Path({ to, value, props: routeProps, ...attrs }: {
     };
     [key: string]: any;
 }): any;
-//# sourceMappingURL=path.d.ts.map

package/{dist → dist-types}/error/errorOverlay.d.ts

@@ -1,3 +1,2 @@
 export declare function showErrorOverlay(error: Error): void;
 export declare function removeErrorOverlay(): void;
-//# sourceMappingURL=errorOverlay.d.ts.map

package/{dist → dist-types}/fynix/index.d.ts

@@ -3,4 +3,3 @@ export * from "../router/router.js";
 export { default as createFynix } from "../router/router.js";
 export { Fynix } from "../runtime.js";
 export { For } from "../hooks/nixFor.js";
-//# sourceMappingURL=index.d.ts.map

package/{dist → dist-types}/hooks/nixAsync.d.ts

@@ -17,4 +17,3 @@ export declare function nixAsync<T>(promiseFactory: (signal: AbortSignal) => Pro
     cleanup: () => void;
     getCallId: () => number;
 };
-//# sourceMappingURL=nixAsync.d.ts.map

package/{dist → dist-types}/hooks/nixAsyncCache.d.ts

@@ -16,4 +16,3 @@ export declare function nixAsyncCached(key: any, promiseFactory: () => Promise<a
     cancel: () => void;
     clearCache: () => void;
 };
-//# sourceMappingURL=nixAsyncCache.d.ts.map

package/{dist → dist-types}/hooks/nixAsyncDebounce.d.ts

@@ -19,4 +19,3 @@ export declare function nixAsyncDebounce(promiseFactory: () => Promise<any>, opt
     run: () => void | Promise<any>;
     cancel: () => void;
 };
-//# sourceMappingURL=nixAsyncDebounce.d.ts.map

package/{dist → dist-types}/hooks/nixAsyncQuery.d.ts

@@ -13,4 +13,3 @@ export declare function nixAsyncQuery<T>(key: string, queryFn: (signal: AbortSig
     run: () => Promise<void>;
     cancel: () => void;
 };
-//# sourceMappingURL=nixAsyncQuery.d.ts.map

package/{dist → dist-types}/hooks/nixCallback.d.ts

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

package/{dist → dist-types}/hooks/nixComputed.d.ts

@@ -13,4 +13,3 @@ export declare function nixComputed<T>(computeFn: () => T): {
     _isNixState: true;
     _isComputed: true;
 };
-//# sourceMappingURL=nixComputed.d.ts.map

package/{dist → dist-types}/hooks/nixDebounce.d.ts

@@ -8,4 +8,3 @@ export type DebouncedFunction<T extends (...args: any[]) => any> = ((...args: Pa
     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 → dist-types}/hooks/nixEffect.d.ts

@@ -1,4 +1,3 @@
 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 → dist-types}/hooks/nixFor.d.ts

@@ -10,4 +10,3 @@ interface ForProps<T> {
 }
 export declare function For<T>(props: ForProps<T>): VNode;
 export {};
-//# sourceMappingURL=nixFor.d.ts.map

package/{dist → dist-types}/hooks/nixForm.d.ts

@@ -30,4 +30,3 @@ type FormState<T> = {
 };
 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 → dist-types}/hooks/nixFormAsync.d.ts

@@ -39,4 +39,3 @@ export declare function nixFormAsync<T extends Record<string, any> = Record<stri
     cache?: boolean;
 }): FormAsyncState<T, D, E>;
 export {};
-//# sourceMappingURL=nixFormAsync.d.ts.map

package/{dist → dist-types}/hooks/nixInterval.d.ts

@@ -1,2 +1 @@
 export declare function nixInterval(fn: () => void, ms: number, signal?: AbortSignal): () => void;
-//# sourceMappingURL=nixInterval.d.ts.map

package/{dist → dist-types}/hooks/nixLazy.d.ts

@@ -5,4 +5,3 @@ export declare function Suspense<T = any>({ fallback, children, }: {
     fallback: any;
     children: () => T;
 }): T | any;
-//# sourceMappingURL=nixLazy.d.ts.map

package/{dist → dist-types}/hooks/nixLazyAsync.d.ts

@@ -7,4 +7,3 @@ export declare function Suspense<T = any>({ fallback, children, }: {
     fallback: any;
     children: () => T;
 }): T | any;
-//# sourceMappingURL=nixLazyAsync.d.ts.map

package/{dist → dist-types}/hooks/nixLazyFormAsync.d.ts

@@ -47,4 +47,3 @@ export declare function nixLazyFormAsync<T extends Record<string, any> = Record<
     retry?: number;
 }): LazyFormAsyncReturn<T, D, E, P>;
 export {};
-//# sourceMappingURL=nixLazyFormAsync.d.ts.map

package/{dist → dist-types}/hooks/nixLocalStorage.d.ts

@@ -5,4 +5,3 @@ export declare function nixLocalStorage<T>(key: string, initial: T): {
     getSize: () => number;
     isValid: () => boolean;
 };
-//# sourceMappingURL=nixLocalStorage.d.ts.map

package/{dist → dist-types}/hooks/nixMemo.d.ts

@@ -1,2 +1 @@
 export declare function nixMemo<T>(factory: () => T, deps?: any[]): T | undefined;
-//# sourceMappingURL=nixMemo.d.ts.map

package/{dist → dist-types}/hooks/nixPrevious.d.ts

@@ -1,2 +1 @@
 export declare function nixPrevious<T>(val: T): T | undefined;
-//# sourceMappingURL=nixPrevious.d.ts.map

package/{dist → dist-types}/hooks/nixRef.d.ts

@@ -1,4 +1,3 @@
 export declare function nixRef<T = any>(initial?: T): {
     current: T;
 };
-//# sourceMappingURL=nixRef.d.ts.map

package/{dist → dist-types}/hooks/nixState.d.ts

@@ -12,4 +12,3 @@ export declare function nixState<T>(initial: T): {
     };
     _isNixState: true;
 };
-//# sourceMappingURL=nixState.d.ts.map

package/{dist → dist-types}/hooks/nixStore.d.ts

@@ -7,4 +7,3 @@ export declare function nixStore<T = any>(path: string, initial: T): {
     isDestroyed: () => boolean;
     _isNixState: boolean;
 };
-//# sourceMappingURL=nixStore.d.ts.map

package/{dist → dist-types}/plugins/vite-plugin-res.d.ts

@@ -35,4 +35,3 @@ export default function fynixPlugin(options?: FynixPluginOptions): {
 };
 export { fynixPlugin };
 export type { FynixPluginOptions };
-//# sourceMappingURL=vite-plugin-res.d.ts.map

package/{dist → 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,13 +42,10 @@ 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;
 export declare function clearLinkProps(key: string): void;
-//# sourceMappingURL=router.d.ts.map

package/dist-types/runtime.d.ts

@@ -0,0 +1,200 @@
+type Priority = "immediate" | "high" | "normal" | "low" | "idle";
+type EffectTag = "PLACEMENT" | "UPDATE" | "DELETION" | null;
+interface FynixFiber {
+    type: string | symbol | ComponentFunction;
+    props: VNodeProps;
+    key: string | number | null;
+    child: FynixFiber | null;
+    sibling: FynixFiber | null;
+    parent: FynixFiber | null;
+    alternate: FynixFiber | null;
+    effectTag: EffectTag;
+    updatePriority: Priority;
+    _domNode: Node | null;
+    ctx: ComponentContext | null;
+    _vnode: VNode | null;
+}
+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;
+}
+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;
+}
+export interface ComponentFunction {
+    (props: any): VNode | Promise<VNode>;
+}
+interface ReactiveState<T> {
+    value: T;
+    _isNixState: boolean;
+    subscribe(callback: () => void): () => void;
+}
+interface ComponentContext {
+    hooks: any[];
+    hookIndex: number;
+    effects: Array<() => void | (() => void)>;
+    cleanups: Array<() => void>;
+    _vnode: VNode | null;
+    _fiber: FynixFiber | null;
+    _accessedStates: Set<ReactiveState<any>>;
+    _subscriptions: Set<ReactiveState<any>>;
+    _subscriptionCleanups: Array<() => void>;
+    version: number;
+    rerender: (() => void) | null;
+    Component: ComponentFunction;
+    _isMounted: boolean;
+    _isRerendering: boolean;
+    _rerenderTimeout: ReturnType<typeof setTimeout> | null;
+}
+import { Button, Path } from "./custom/index";
+import { nixAsync } from "./hooks/nixAsync";
+import { nixAsyncCached } from "./hooks/nixAsyncCache";
+import { nixAsyncDebounce } from "./hooks/nixAsyncDebounce";
+import { nixAsyncQuery } from "./hooks/nixAsyncQuery";
+import { nixCallback } from "./hooks/nixCallback";
+import { nixComputed } from "./hooks/nixComputed";
+import { nixDebounce } from "./hooks/nixDebounce";
+import { nixEffect, nixEffectAlways, nixEffectOnce } from "./hooks/nixEffect";
+import { nixForm } from "./hooks/nixForm";
+import { nixFormAsync } from "./hooks/nixFormAsync";
+import { nixInterval } from "./hooks/nixInterval";
+import { nixLazy, Suspense } from "./hooks/nixLazy";
+import { nixLazyAsync } from "./hooks/nixLazyAsync";
+import { nixLazyFormAsync } from "./hooks/nixLazyFormAsync";
+import { nixLocalStorage } from "./hooks/nixLocalStorage";
+import { nixMemo } from "./hooks/nixMemo";
+import { nixPrevious } from "./hooks/nixPrevious";
+import { nixRef } from "./hooks/nixRef";
+import { nixState } from "./hooks/nixState";
+import { nixStore } from "./hooks/nixStore";
+import createFynix from "./router/router";
+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 nextWork;
+    private deletions;
+    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 unmountFiber;
+    private runEffects;
+    private vnodeToFiber;
+    private cloneFiber;
+    private findDomParent;
+    private findNearestDom;
+    private findNextDomSibling;
+}
+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, onRollback?: () => void): {
+        commit: () => void;
+        rollback: () => void;
+    };
+    private set;
+}
+export declare function useHierarchicalStore(): HierarchicalStore;
+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 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, };