elit 2.0.1 → 3.0.0

package/dist/types.d.ts

@@ -1,3 +1,452 @@
-export { B as BuildOptions, q as BuildResult, C as Child, u as Children, A as ClientConfig, G as DevServer, D as DevServerOptions, E as ElementFactory, I as HMRMessage, J as JsonNode, K as PreviewOptions, P as Props, F as ProxyConfig, R as RefCallback, v as RefObject, N as Router, w as State, O as StateManager, x as StateOptions, V as VNode, z as VNodeJson, y as VirtualListController, W as WorkerConfig } from './types-DOAdFFJB.js';
-import 'http';
-import 'ws';
+import { EventEmitter } from 'node:events';
+import { EventEmitter as EventEmitter$1 } from 'events';
+import { Server } from 'http';
+import { WebSocketServer } from 'ws';
+
+/**
+ * HTTP module with unified API across runtimes
+ * Ultra-optimized for maximum performance across Node.js, Bun, and Deno
+ *
+ * Performance optimizations:
+ * - Bun fast path: Zero class instantiation (object literals only)
+ * - Eliminated EventEmitter overhead for Bun/Deno
+ * - Zero-copy headers conversion
+ * - Inline response creation
+ * - Reduced object allocations
+ * - Direct closure capture (no resolver indirection)
+ */
+
+/**
+ * HTTP Headers type
+ */
+type IncomingHttpHeaders = Record<string, string | string[] | undefined>;
+type OutgoingHttpHeaders = Record<string, string | string[] | number>;
+/**
+ * IncomingMessage - Ultra-optimized for zero-copy operations
+ */
+declare class IncomingMessage extends EventEmitter {
+    method: string;
+    url: string;
+    headers: IncomingHttpHeaders;
+    statusCode?: number;
+    statusMessage?: string;
+    httpVersion: string;
+    rawHeaders: string[];
+    socket: any;
+    private _req;
+    constructor(req: any);
+    text(): Promise<string>;
+    json(): Promise<any>;
+}
+/**
+ * ServerResponse - Ultra-optimized write operations
+ */
+declare class ServerResponse extends EventEmitter {
+    statusCode: number;
+    statusMessage: string;
+    headersSent: boolean;
+    private _headers;
+    private _body;
+    private _resolve?;
+    private _finished;
+    private _nodeRes?;
+    constructor(_req?: IncomingMessage, nodeRes?: any);
+    setHeader(name: string, value: string | string[] | number): this;
+    getHeader(name: string): string | string[] | number | undefined;
+    getHeaders(): OutgoingHttpHeaders;
+    getHeaderNames(): string[];
+    hasHeader(name: string): boolean;
+    removeHeader(name: string): void;
+    writeHead(statusCode: number, statusMessage?: string | OutgoingHttpHeaders, headers?: OutgoingHttpHeaders): this;
+    write(chunk: any, encoding?: BufferEncoding | (() => void), callback?: () => void): boolean;
+    end(chunk?: any, encoding?: BufferEncoding | (() => void), callback?: () => void): this;
+    _setResolver(resolve: (response: Response) => void): void;
+}
+
+/**
+ * WebSocket module with unified API across runtimes
+ * Pure implementation without external dependencies
+ * - Node.js: uses native 'ws' module (built-in WebSocket implementation)
+ * - Bun: uses native WebSocket
+ * - Deno: uses native WebSocket
+ */
+
+/**
+ * WebSocket ready state
+ */
+declare enum ReadyState {
+    CONNECTING = 0,
+    OPEN = 1,
+    CLOSING = 2,
+    CLOSED = 3
+}
+/**
+ * WebSocket data types
+ */
+type Data = string | Buffer | ArrayBuffer | Buffer[];
+/**
+ * WebSocket send options
+ */
+interface SendOptions {
+    binary?: boolean;
+    compress?: boolean;
+    fin?: boolean;
+    mask?: boolean;
+}
+/**
+ * WebSocket class - Pure implementation
+ */
+declare class WebSocket extends EventEmitter$1 {
+    readyState: ReadyState;
+    url: string;
+    protocol: string;
+    extensions: string;
+    binaryType: 'nodebuffer' | 'arraybuffer' | 'fragments';
+    /** @internal */
+    _socket: any;
+    constructor(address: string | URL, protocols?: string | string[], _options?: any);
+    private _setupNativeSocket;
+    /**
+     * Send data through WebSocket
+     */
+    send(data: Data, options?: SendOptions | ((err?: Error) => void), callback?: (err?: Error) => void): void;
+    /**
+     * Close the WebSocket connection
+     */
+    close(code?: number, reason?: string | Buffer): void;
+    /**
+     * Pause the socket (no-op for native WebSocket)
+     */
+    pause(): void;
+    /**
+     * Resume the socket (no-op for native WebSocket)
+     */
+    resume(): void;
+    /**
+     * Send a ping frame (no-op for native WebSocket)
+     */
+    ping(_data?: Data, _mask?: boolean, callback?: (err?: Error) => void): void;
+    /**
+     * Send a pong frame (no-op for native WebSocket)
+     */
+    pong(_data?: Data, _mask?: boolean, callback?: (err?: Error) => void): void;
+    /**
+     * Terminate the connection
+     */
+    terminate(): void;
+    /**
+     * Get buffered amount
+     */
+    get bufferedAmount(): number;
+}
+
+/**
+ * Development server with HMR support
+ * Cross-runtime transpilation support
+ * - Node.js: uses esbuild
+ * - Bun: uses Bun.Transpiler
+ * - Deno: uses Deno.emit
+ */
+
+interface ServerRouteContext {
+    req: IncomingMessage;
+    res: ServerResponse;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    body: any;
+    headers: Record<string, string | string[] | undefined>;
+}
+type ServerRouteHandler = (ctx: ServerRouteContext) => void | Promise<void>;
+type Middleware = (ctx: ServerRouteContext, next: () => Promise<void>) => void | Promise<void>;
+declare class ServerRouter {
+    private routes;
+    private middlewares;
+    use(middleware: Middleware): this;
+    get: (path: string, handler: ServerRouteHandler) => this;
+    post: (path: string, handler: ServerRouteHandler) => this;
+    put: (path: string, handler: ServerRouteHandler) => this;
+    delete: (path: string, handler: ServerRouteHandler) => this;
+    patch: (path: string, handler: ServerRouteHandler) => this;
+    options: (path: string, handler: ServerRouteHandler) => this;
+    private addRoute;
+    private pathToRegex;
+    private parseQuery;
+    private parseBody;
+    handle(req: IncomingMessage, res: ServerResponse): Promise<boolean>;
+}
+type StateChangeHandler<T = any> = (value: T, oldValue: T) => void;
+interface SharedStateOptions<T = any> {
+    initial: T;
+    persist?: boolean;
+    validate?: (value: T) => boolean;
+}
+declare class SharedState<T = any> {
+    readonly key: string;
+    private _value;
+    private listeners;
+    private changeHandlers;
+    private options;
+    constructor(key: string, options: SharedStateOptions<T>);
+    get value(): T;
+    set value(newValue: T);
+    update(updater: (current: T) => T): void;
+    subscribe(ws: WebSocket): void;
+    unsubscribe(ws: WebSocket): void;
+    onChange(handler: StateChangeHandler<T>): () => void;
+    private broadcast;
+    private sendTo;
+    get subscriberCount(): number;
+    clear(): void;
+}
+declare class StateManager$1 {
+    private states;
+    create<T>(key: string, options: SharedStateOptions<T>): SharedState<T>;
+    get<T>(key: string): SharedState<T> | undefined;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+    subscribe(key: string, ws: WebSocket): void;
+    unsubscribe(key: string, ws: WebSocket): void;
+    unsubscribeAll(ws: WebSocket): void;
+    handleStateChange(key: string, value: any): void;
+    keys(): string[];
+    clear(): void;
+}
+
+/**
+ * Elit - Types and Interfaces
+ */
+interface VNode {
+    tagName: string;
+    props: Props;
+    children: Children;
+}
+type Child = VNode | string | number | boolean | null | undefined;
+type Children = Child[];
+interface Props {
+    [key: string]: any;
+    className?: string | string[];
+    class?: string | string[];
+    style?: Partial<CSSStyleDeclaration> | string;
+    dangerouslySetInnerHTML?: {
+        __html: string;
+    };
+    ref?: RefCallback | RefObject;
+    onClick?: (event: MouseEvent) => void;
+    onChange?: (event: Event) => void;
+    onInput?: (event: Event) => void;
+    onSubmit?: (event: Event) => void;
+    value?: string | number;
+    checked?: boolean;
+}
+type RefCallback = (element: HTMLElement | SVGElement) => void;
+interface RefObject {
+    current: HTMLElement | SVGElement | null;
+}
+interface State<T> {
+    value: T;
+    subscribe(fn: (value: T) => void): () => void;
+    destroy(): void;
+}
+interface StateOptions {
+    throttle?: number;
+    deep?: boolean;
+}
+interface VirtualListController {
+    render: () => void;
+    destroy: () => void;
+}
+interface JsonNode {
+    tag: string;
+    attributes?: Record<string, any>;
+    children?: JsonNode | JsonNode[] | string | number | boolean | null;
+}
+type VNodeJson = {
+    tagName: string;
+    props?: Record<string, any>;
+    children?: (VNodeJson | string | number | boolean | null)[];
+} | string | number | boolean | null;
+type ElementFactory = {
+    (...children: Child[]): VNode;
+    (props: Props | null, ...children: Child[]): VNode;
+};
+
+type Router = ServerRouter;
+type StateManager = StateManager$1;
+interface ClientConfig {
+    /** Root directory to serve files from */
+    root: string;
+    /** Base path for the client application (e.g., '/app1', '/app2') */
+    basePath: string;
+    /** Custom index file path (relative to root, e.g., './public/index.html') */
+    index?: string;
+    /** SSR render function - returns HTML VNode or string */
+    ssr?: () => Child | string;
+    /** Watch patterns for file changes */
+    watch?: string[];
+    /** Ignore patterns for file watching */
+    ignore?: string[];
+    /** Proxy configuration specific to this client */
+    proxy?: ProxyConfig[];
+    /** Worker scripts specific to this client */
+    worker?: WorkerConfig[];
+    /** API router for REST endpoints specific to this client */
+    api?: Router;
+    /** Custom middleware specific to this client */
+    middleware?: ((req: any, res: any, next: () => void) => void)[];
+    /** Server mode: 'dev' uses source files, 'preview' uses built files (default: 'dev') */
+    mode?: 'dev' | 'preview';
+}
+interface ProxyConfig {
+    /** Path prefix to match for proxying (e.g., '/api', '/graphql') */
+    context: string;
+    /** Target URL to proxy to (e.g., 'http://localhost:8080') */
+    target: string;
+    /** Change the origin of the host header to the target URL */
+    changeOrigin?: boolean;
+    /** Rewrite path before sending to target */
+    pathRewrite?: Record<string, string>;
+    /** Additional headers to add to the proxied request */
+    headers?: Record<string, string>;
+    /** Enable WebSocket proxying */
+    ws?: boolean;
+}
+interface WorkerConfig {
+    /** Worker script path relative to root directory */
+    path: string;
+    /** Worker name/identifier (optional, defaults to filename) */
+    name?: string;
+    /** Worker type: 'module' (ESM) or 'classic' (default: 'module') */
+    type?: 'module' | 'classic';
+}
+interface DevServerOptions {
+    /** Port to run the server on (default: 3000) */
+    port?: number;
+    /** Host to bind to (default: 'localhost') */
+    host?: string;
+    /** Root directory to serve files from */
+    root?: string;
+    /** Base path for the client application (e.g., '/app1', '/app2') */
+    basePath?: string;
+    /** Custom index file path (relative to root, e.g., './public/index.html') */
+    index?: string;
+    /** Array of client configurations - allows multiple clients on same port */
+    clients?: ClientConfig[];
+    /** Enable HTTPS (default: false) */
+    https?: boolean;
+    /** Open browser automatically (default: true) */
+    open?: boolean;
+    /** Watch patterns for file changes */
+    watch?: string[];
+    /** Ignore patterns for file watcher */
+    ignore?: string[];
+    /** Global worker scripts (applies to all clients) */
+    worker?: WorkerConfig[];
+    /** Enable logging (default: true) */
+    logging?: boolean;
+    /** Custom middleware */
+    middleware?: ((req: any, res: any, next: () => void) => void)[];
+    /** API router for REST endpoints */
+    api?: Router;
+    /** SSR render function - returns HTML VNode or string */
+    ssr?: () => Child | string;
+    /** Proxy configuration for API requests */
+    proxy?: ProxyConfig[];
+    /** Server mode: 'dev' uses source files, 'preview' uses built files (default: 'dev') */
+    mode?: 'dev' | 'preview';
+}
+interface DevServer {
+    /** HTTP server instance */
+    server: Server;
+    /** WebSocket server for HMR */
+    wss: WebSocketServer;
+    /** Server URL */
+    url: string;
+    /** Shared state manager */
+    state: StateManager;
+    /** Close the server */
+    close: () => Promise<void>;
+}
+interface HMRMessage {
+    type: 'update' | 'reload' | 'error' | 'connected';
+    path?: string;
+    timestamp?: number;
+    error?: string;
+}
+interface BuildOptions {
+    /** Entry file to build */
+    entry: string;
+    /** Output directory */
+    outDir?: string;
+    /** Output filename */
+    outFile?: string;
+    /** Enable minification */
+    minify?: boolean;
+    /** Generate sourcemap */
+    sourcemap?: boolean;
+    /** Target environment */
+    target?: 'es2015' | 'es2016' | 'es2017' | 'es2018' | 'es2019' | 'es2020' | 'es2021' | 'es2022' | 'esnext';
+    /** Output format */
+    format?: 'esm' | 'cjs' | 'iife';
+    /** Global name for IIFE format */
+    globalName?: string;
+    /** Target platform */
+    platform?: 'browser' | 'node' | 'neutral';
+    /** Base path for the application (injected into HTML) */
+    basePath?: string;
+    /** External dependencies (not bundled) */
+    external?: string[];
+    /** Enable tree shaking */
+    treeshake?: boolean;
+    /** Enable logging */
+    logging?: boolean;
+    /** Environment variables to inject (prefix with VITE_ for client access) */
+    env?: Record<string, string>;
+    /** Copy static files after build */
+    copy?: Array<{
+        from: string;
+        to: string;
+        transform?: (content: string, config: BuildOptions) => string;
+    }>;
+    /** Post-build hook */
+    onBuildEnd?: (result: BuildResult) => void | Promise<void>;
+}
+interface BuildResult {
+    /** Output file path */
+    outputPath: string;
+    /** Build time in milliseconds */
+    buildTime: number;
+    /** Output file size in bytes */
+    size: number;
+}
+interface PreviewOptions {
+    /** Port to run the preview server on (default: 4173) */
+    port?: number;
+    /** Host to bind to (default: 'localhost') */
+    host?: string;
+    /** Root directory to serve files from (default: dist or build.outDir) */
+    root?: string;
+    /** Base path for the application (e.g., '/app') */
+    basePath?: string;
+    /** Custom index file path (relative to root, e.g., './public/index.html') */
+    index?: string;
+    /** Array of client configurations - allows multiple clients on same port */
+    clients?: ClientConfig[];
+    /** Enable HTTPS (default: false) */
+    https?: boolean;
+    /** Open browser automatically (default: true) */
+    open?: boolean;
+    /** Enable logging (default: true) */
+    logging?: boolean;
+    /** Custom middleware */
+    middleware?: ((req: any, res: any, next: () => void) => void)[];
+    /** API router for REST endpoints */
+    api?: Router;
+    /** SSR render function - returns HTML VNode or string */
+    ssr?: () => Child | string;
+    /** Proxy configuration for API requests */
+    proxy?: ProxyConfig[];
+    /** Global worker scripts (applies to all clients) */
+    worker?: WorkerConfig[];
+}
+
+export type { BuildOptions, BuildResult, Child, Children, ClientConfig, DevServer, DevServerOptions, ElementFactory, HMRMessage, JsonNode, PreviewOptions, Props, ProxyConfig, RefCallback, RefObject, Router, State, StateManager, StateOptions, VNode, VNodeJson, VirtualListController, WorkerConfig };

package/dist/types.js

@@ -1 +1,18 @@
-"use strict";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/ws.d.mts

@@ -0,0 +1,195 @@
+import { EventEmitter } from 'events';
+import { IncomingMessage } from './http.mjs';
+import 'node:events';
+
+/**
+ * WebSocket module with unified API across runtimes
+ * Pure implementation without external dependencies
+ * - Node.js: uses native 'ws' module (built-in WebSocket implementation)
+ * - Bun: uses native WebSocket
+ * - Deno: uses native WebSocket
+ */
+
+/**
+ * WebSocket ready state
+ */
+declare enum ReadyState {
+    CONNECTING = 0,
+    OPEN = 1,
+    CLOSING = 2,
+    CLOSED = 3
+}
+/**
+ * WebSocket close codes
+ */
+declare const CLOSE_CODES: {
+    readonly NORMAL: 1000;
+    readonly GOING_AWAY: 1001;
+    readonly PROTOCOL_ERROR: 1002;
+    readonly UNSUPPORTED_DATA: 1003;
+    readonly NO_STATUS: 1005;
+    readonly ABNORMAL: 1006;
+    readonly INVALID_DATA: 1007;
+    readonly POLICY_VIOLATION: 1008;
+    readonly MESSAGE_TOO_BIG: 1009;
+    readonly EXTENSION_REQUIRED: 1010;
+    readonly INTERNAL_ERROR: 1011;
+    readonly SERVICE_RESTART: 1012;
+    readonly TRY_AGAIN_LATER: 1013;
+    readonly BAD_GATEWAY: 1014;
+    readonly TLS_HANDSHAKE_FAIL: 1015;
+};
+/**
+ * WebSocket data types
+ */
+type Data = string | Buffer | ArrayBuffer | Buffer[];
+/**
+ * WebSocket send options
+ */
+interface SendOptions {
+    binary?: boolean;
+    compress?: boolean;
+    fin?: boolean;
+    mask?: boolean;
+}
+/**
+ * WebSocket server options
+ */
+interface ServerOptions {
+    host?: string;
+    port?: number;
+    backlog?: number;
+    server?: any;
+    verifyClient?: VerifyClientCallback;
+    handleProtocols?: (protocols: Set<string>, request: IncomingMessage) => string | false;
+    path?: string;
+    noServer?: boolean;
+    clientTracking?: boolean;
+    perMessageDeflate?: boolean | object;
+    maxPayload?: number;
+}
+/**
+ * Verify client callback
+ */
+type VerifyClientCallback = (info: {
+    origin: string;
+    secure: boolean;
+    req: IncomingMessage;
+}, callback?: (result: boolean, code?: number, message?: string) => void) => boolean | void;
+/**
+ * WebSocket class - Pure implementation
+ */
+declare class WebSocket extends EventEmitter {
+    readyState: ReadyState;
+    url: string;
+    protocol: string;
+    extensions: string;
+    binaryType: 'nodebuffer' | 'arraybuffer' | 'fragments';
+    /** @internal */
+    _socket: any;
+    constructor(address: string | URL, protocols?: string | string[], _options?: any);
+    private _setupNativeSocket;
+    /**
+     * Send data through WebSocket
+     */
+    send(data: Data, options?: SendOptions | ((err?: Error) => void), callback?: (err?: Error) => void): void;
+    /**
+     * Close the WebSocket connection
+     */
+    close(code?: number, reason?: string | Buffer): void;
+    /**
+     * Pause the socket (no-op for native WebSocket)
+     */
+    pause(): void;
+    /**
+     * Resume the socket (no-op for native WebSocket)
+     */
+    resume(): void;
+    /**
+     * Send a ping frame (no-op for native WebSocket)
+     */
+    ping(_data?: Data, _mask?: boolean, callback?: (err?: Error) => void): void;
+    /**
+     * Send a pong frame (no-op for native WebSocket)
+     */
+    pong(_data?: Data, _mask?: boolean, callback?: (err?: Error) => void): void;
+    /**
+     * Terminate the connection
+     */
+    terminate(): void;
+    /**
+     * Get buffered amount
+     */
+    get bufferedAmount(): number;
+}
+/**
+ * WebSocket Server - Server-side WebSocket implementation
+ */
+declare class WebSocketServer extends EventEmitter {
+    clients: Set<WebSocket>;
+    options: ServerOptions;
+    path: string;
+    private _httpServer;
+    constructor(options?: ServerOptions, callback?: () => void);
+    private _setupUpgradeHandler;
+    /**
+     * Handle HTTP upgrade for WebSocket
+     */
+    handleUpgrade(request: IncomingMessage, socket: any, _head: Buffer, callback: (client: WebSocket) => void): void;
+    private _createClientFromSocket;
+    private _parseFrame;
+    private _createFrame;
+    /**
+     * Close the server
+     */
+    close(callback?: (err?: Error) => void): void;
+    /**
+     * Check if server should handle request
+     */
+    shouldHandle(request: IncomingMessage): boolean;
+    /**
+     * Get server address
+     */
+    address(): {
+        port: number;
+        family: string;
+        address: string;
+    } | null;
+}
+/**
+ * Create WebSocket server
+ */
+declare function createWebSocketServer(options?: ServerOptions, callback?: () => void): WebSocketServer;
+/**
+ * Get current runtime
+ */
+declare function getRuntime(): 'node' | 'bun' | 'deno';
+/**
+ * Default export
+ */
+declare const _default: {
+    WebSocket: typeof WebSocket;
+    WebSocketServer: typeof WebSocketServer;
+    createWebSocketServer: typeof createWebSocketServer;
+    ReadyState: typeof ReadyState;
+    CLOSE_CODES: {
+        readonly NORMAL: 1000;
+        readonly GOING_AWAY: 1001;
+        readonly PROTOCOL_ERROR: 1002;
+        readonly UNSUPPORTED_DATA: 1003;
+        readonly NO_STATUS: 1005;
+        readonly ABNORMAL: 1006;
+        readonly INVALID_DATA: 1007;
+        readonly POLICY_VIOLATION: 1008;
+        readonly MESSAGE_TOO_BIG: 1009;
+        readonly EXTENSION_REQUIRED: 1010;
+        readonly INTERNAL_ERROR: 1011;
+        readonly SERVICE_RESTART: 1012;
+        readonly TRY_AGAIN_LATER: 1013;
+        readonly BAD_GATEWAY: 1014;
+        readonly TLS_HANDSHAKE_FAIL: 1015;
+    };
+    getRuntime: typeof getRuntime;
+};
+
+export { CLOSE_CODES, type Data, ReadyState, type SendOptions, type ServerOptions, type VerifyClientCallback, WebSocket, WebSocketServer, createWebSocketServer, _default as default, getRuntime };