elit 3.6.6 → 3.6.8

package/dist/state.d.ts

@@ -1,21 +1,5 @@
-import { State, VNode, Props, StateOptions, VirtualListController, Child } from './types.js';
-import 'node:events';
-import 'events';
-import 'http';
-import 'ws';
-import 'net';
-import 'smtp-server';
+import { V as VNode, S as State, c as StateOptions, e as VirtualListController, P as Props, C as Child } from './types-BONVzPtp.js';
 
-/**
- * Elit - State Management
- */
-
-type NativeBindingKind = 'value' | 'checked';
-interface NativeBindingMetadata<T = unknown> {
-    kind: NativeBindingKind;
-    state: State<T>;
-}
-declare const ELIT_NATIVE_BINDING: unique symbol;
 declare const createState: <T>(initial: T, options?: StateOptions) => State<T>;
 declare const computed: <T extends any[], R>(states: { [K in keyof T]: State<T[K]>; }, fn: (...values: T) => R) => State<R>;
 declare const effect: (fn: () => void) => void;
@@ -24,14 +8,20 @@ declare const renderChunked: (container: string | HTMLElement, vNodes: VNode[],
 declare const createVirtualList: <T>(container: HTMLElement, items: T[], renderItem: (item: T, index: number) => VNode, itemHeight?: number, bufferSize?: number) => VirtualListController;
 declare const lazy: <T extends any[], R>(loadFn: () => Promise<(...args: T) => R>) => (...args: T) => Promise<VNode | R>;
 declare const cleanupUnused: (root: HTMLElement) => number;
+
 declare const throttle: <T extends any[]>(fn: (...args: T) => void, delay: number) => (...args: T) => void;
 declare const debounce: <T extends any[]>(fn: (...args: T) => void, delay: number) => (...args: T) => void;
+
+type NativeBindingKind = 'value' | 'checked';
+interface NativeBindingMetadata<T = unknown> {
+    kind: NativeBindingKind;
+    state: State<T>;
+}
+declare const ELIT_NATIVE_BINDING: unique symbol;
 declare function bindValue<T extends string | number | string[]>(state: State<T>): Props;
 declare function bindChecked(state: State<boolean>): Props;
+
 type StateChangeCallback<T = any> = (value: T, oldValue: T) => void;
-/**
- * Shared State - syncs with elit-server
- */
 declare class SharedState<T = any> {
     readonly key: string;
     private wsUrl?;
@@ -40,78 +30,28 @@ declare class SharedState<T = any> {
     private pendingUpdates;
     private previousValue;
     constructor(key: string, defaultValue: T, wsUrl?: string | undefined);
-    /**
-     * Get current value
-     */
     get value(): T;
-    /**
-     * Set new value and sync to server
-     */
     set value(newValue: T);
-    /**
-     * Get the underlying Elit State (for reactive binding)
-     */
     get state(): State<T>;
-    /**
-     * Subscribe to changes (returns Elit State for reactive)
-     */
     onChange(callback: StateChangeCallback<T>): () => void;
-    /**
-     * Update value using a function
-     */
     update(updater: (current: T) => T): void;
-    /**
-     * Connect to WebSocket
-     */
     private connect;
-    /**
-     * Subscribe to server state
-     */
     private subscribe;
-    /**
-     * Handle message from server
-     */
     private handleMessage;
-    /**
-     * Send value to server
-     */
     private sendToServer;
-    /**
-     * Disconnect
-     */
     disconnect(): void;
-    /**
-     * Destroy state and cleanup
-     */
     destroy(): void;
 }
-/**
- * Create a shared state that syncs with elit-server
- */
 declare function createSharedState<T>(key: string, defaultValue: T, wsUrl?: string): SharedState<T>;
-/**
- * Shared State Manager for managing multiple shared states
- */
 declare class SharedStateManager {
     private states;
-    /**
-     * Create or get a shared state
-     */
     create<T>(key: string, defaultValue: T, wsUrl?: string): SharedState<T>;
-    /**
-     * Get existing state
-     */
     get<T>(key: string): SharedState<T> | undefined;
-    /**
-     * Delete a state
-     */
     delete(key: string): boolean;
-    /**
-     * Clear all states
-     */
     clear(): void;
 }
 declare const sharedStateManager: SharedStateManager;
+
 declare const reactive: <T>(state: State<T>, renderFn: (value: T) => VNode | Child | Child[]) => VNode;
 declare const reactiveAs: <T>(tagName: string, state: State<T>, renderFn: (value: T) => VNode | Child | Child[], props?: Props) => VNode;
 declare const text: (state: State<any> | any) => VNode | string;