elit 3.6.6 → 3.6.8

package/dist/types.d.ts

@@ -1,3 +1,5 @@
+import { C as Child } from './types-BONVzPtp.js';
+export { a as Children, E as ElementFactory, J as JsonNode, P as Props, R as RefCallback, b as RefObject, S as State, c as StateOptions, V as VNode, d as VNodeJson, e as VirtualListController } from './types-BONVzPtp.js';
 import { EventEmitter } from 'node:events';
 import { EventEmitter as EventEmitter$1 } from 'events';
 import { Server as Server$1 } from 'http';
@@ -5,24 +7,6 @@ import { WebSocketServer } from 'ws';
 import { Server, AddressInfo } from 'net';
 import { SMTPServerOptions, SMTPServer } from 'smtp-server';
 
-/**
- * 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
  */
@@ -36,10 +20,11 @@ declare class IncomingMessage extends EventEmitter {
     rawHeaders: string[];
     socket: any;
     private _req;
-    constructor(req: any);
+    constructor(req: any, requestMethod?: string);
     text(): Promise<string>;
     json(): Promise<any>;
 }
+
 /**
  * ServerResponse - Ultra-optimized write operations
  */
@@ -69,12 +54,10 @@ declare class ServerResponse extends EventEmitter {
 }
 
 /**
- * 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
+ * HTTP Headers type
  */
+type IncomingHttpHeaders = Record<string, string | string[] | undefined>;
+type OutgoingHttpHeaders = Record<string, string | string[] | number>;
 
 /**
  * WebSocket ready state
@@ -85,6 +68,7 @@ declare enum ReadyState {
     CLOSING = 2,
     CLOSED = 3
 }
+
 /**
  * WebSocket data types
  */
@@ -98,8 +82,9 @@ interface SendOptions {
     fin?: boolean;
     mask?: boolean;
 }
+
 /**
- * WebSocket class - Pure implementation
+ * WebSocket class.
  */
 declare class WebSocket extends EventEmitter$1 {
     readyState: ReadyState;
@@ -112,47 +97,39 @@ declare class WebSocket extends EventEmitter$1 {
     constructor(address: string | URL, protocols?: string | string[], _options?: any);
     private _setupNativeSocket;
     /**
-     * Send data through WebSocket
+     * Send data through WebSocket.
      */
     send(data: Data, options?: SendOptions | ((err?: Error) => void), callback?: (err?: Error) => void): void;
     /**
-     * Close the WebSocket connection
+     * Close the WebSocket connection.
      */
     close(code?: number, reason?: string | Buffer): void;
     /**
-     * Pause the socket (no-op for native WebSocket)
+     * Pause the socket (no-op for native WebSocket).
      */
     pause(): void;
     /**
-     * Resume the socket (no-op for native WebSocket)
+     * Resume the socket (no-op for native WebSocket).
      */
     resume(): void;
     /**
-     * Send a ping frame (no-op for native WebSocket)
+     * 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)
+     * Send a pong frame (no-op for native WebSocket).
      */
     pong(_data?: Data, _mask?: boolean, callback?: (err?: Error) => void): void;
     /**
-     * Terminate the connection
+     * Terminate the connection.
      */
     terminate(): void;
     /**
-     * Get buffered amount
+     * Get buffered amount.
      */
     get bufferedAmount(): number;
 }
 
-/**
- * Development server with HMR support
- * Cross-runtime transpilation support
- * - Node.js: uses stripTypeScriptTypes with esbuild fallback
- * - Bun: uses Bun.Transpiler
- * - Deno: uses Deno.emit
- */
-
 interface ElitRequest extends IncomingMessage {
     body?: any;
     query?: Record<string, string>;
@@ -174,6 +151,13 @@ interface ServerRouteContext {
 }
 type ServerRouteHandler = (ctx: ServerRouteContext, next?: () => Promise<void>) => void | Promise<void>;
 type Middleware = (ctx: ServerRouteContext, next: () => Promise<void>) => void | Promise<void>;
+type StateChangeHandler<T = any> = (value: T, oldValue: T) => void;
+interface SharedStateOptions<T = any> {
+    initial: T;
+    persist?: boolean;
+    validate?: (value: T) => boolean;
+}
+
 declare class ServerRouter {
     private routes;
     private middlewares;
@@ -190,9 +174,6 @@ declare class ServerRouter {
     private addRoute;
     private pathToRegex;
     private parseQuery;
-    /**
-     * List all registered routes for debugging
-     */
     listRoutes(): Array<{
         method: string;
         pattern: string;
@@ -202,12 +183,7 @@ declare class ServerRouter {
     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;
@@ -240,10 +216,6 @@ declare class StateManager$1 {
     clear(): void;
 }
 
-/**
- * SMTP server helpers built on top of the smtp-server package.
- */
-
 interface ElitSMTPServerConfig extends SMTPServerOptions {
     port?: number;
     host?: string;
@@ -262,199 +234,84 @@ interface ElitSMTPServerHandle {
     close(): Promise<void>;
 }
 
-/**
- * Elit - Types and Interfaces
- */
-interface VNode {
-    tagName: string;
-    props: Props;
-    children: Children;
-}
-type Child = VNode | string | number | boolean | null | undefined | Child[];
-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 | string[];
-    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;
 type WebSocketConnection = WebSocket;
 type WebSocketRequest = IncomingMessage;
 interface WebSocketEndpointContext {
-    /** Accepted WebSocket connection */
     ws: WebSocketConnection;
-    /** Upgrade request metadata */
     req: WebSocketRequest;
-    /** Matched request path without query string */
     path: string;
-    /** Parsed query string values */
     query: Record<string, string>;
-    /** Request headers */
     headers: Record<string, string | string[] | undefined>;
 }
 type WebSocketEndpointHandler = (ctx: WebSocketEndpointContext) => void | Promise<void>;
 interface WebSocketEndpointConfig {
-    /** Path to listen for WebSocket upgrades (e.g., '/ws', '/chat') */
     path: string;
-    /** Connection handler invoked after a successful WebSocket upgrade */
     handler: WebSocketEndpointHandler;
 }
 interface ClientConfig {
-    /** Root directory to serve files from */
     root: string;
-    /** Optional fallback root used when the primary root is unavailable in packaged standalone runs */
     fallbackRoot?: 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;
-    /** WebSocket endpoints specific to this client */
     ws?: WebSocketEndpointConfig[];
-    /** SMTP listeners specific to this client */
     smtp?: ElitSMTPServerConfig | ElitSMTPServerConfig[];
-    /** 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;
-    /** Domain to map (e.g., 'idevcoder.com') - redirects domain traffic to this server's port */
     domain?: string;
-    /** Root directory to serve files from */
     root?: string;
-    /** Optional fallback root used when the primary root is unavailable in packaged standalone runs */
     fallbackRoot?: 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;
-    /** API router for REST endpoints */
+    /** Glob patterns for files that must never be served (e.g. ".env", ".env.*", "*.key"). Default blocks .env, .env.*, .git/**, and common secret files. */
+    blockFiles?: string[];
     api?: Router;
-    /** WebSocket endpoints */
     ws?: WebSocketEndpointConfig[];
-    /** SMTP listeners started alongside the HTTP server */
     smtp?: ElitSMTPServerConfig | ElitSMTPServerConfig[];
-    /** 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';
-    /** Environment variables to inject (prefix with VITE_ for client access) */
     env?: Record<string, string>;
-    /** Emit a bundled development server during elit build */
     standalone?: boolean;
-    /** Output directory for a bundled standalone development server (default: dev-dist) */
     outDir?: string;
-    /** Output filename for a bundled standalone development server (default: index.js) */
     outFile?: string;
 }
 interface DevServer {
-    /** HTTP server instance */
     server: Server$1;
-    /** WebSocket server for HMR */
     wss: WebSocketServer;
-    /** Managed SMTP listeners started from dev or preview config */
     smtpServers: ElitSMTPServerHandle[];
-    /** Server URL */
     url: string;
-    /** Shared state manager */
     state: StateManager;
-    /** Close the server */
     close: () => Promise<void>;
 }
 interface HMRMessage {
@@ -463,105 +320,65 @@ interface HMRMessage {
     timestamp?: number;
     error?: string;
 }
+interface PreviewOptions {
+    port?: number;
+    host?: string;
+    domain?: string;
+    root?: string;
+    basePath?: string;
+    index?: string;
+    clients?: ClientConfig[];
+    https?: boolean;
+    open?: boolean;
+    logging?: boolean;
+    /** Glob patterns for files that must never be served (e.g. ".env", ".env.*", "*.key"). Default blocks .env, .env.*, .git/**, and common secret files. */
+    blockFiles?: string[];
+    api?: Router;
+    ws?: WebSocketEndpointConfig[];
+    smtp?: ElitSMTPServerConfig | ElitSMTPServerConfig[];
+    ssr?: () => Child | string;
+    proxy?: ProxyConfig[];
+    worker?: WorkerConfig[];
+    env?: Record<string, string>;
+    standalone?: boolean;
+    outFile?: 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[];
-    /** Module resolution options */
     resolve?: {
-        /** Alias imports to other paths or modules */
         alias?: Record<string, 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>;
-    /** Emit a standalone preview server bundle after the client build */
     standalonePreview?: boolean;
-    /** Emit a standalone development server bundle after the client build */
     standaloneDev?: boolean;
-    /** Output filename for the standalone development server bundle (default: index.js) */
     standaloneDevOutFile?: string;
-    /** Output filename for the standalone preview server bundle (default: index.js) */
     standalonePreviewOutFile?: string;
 }
 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;
-    /** Domain to map (e.g., 'idevcoder.com') - redirects domain traffic to this server's port */
-    domain?: 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;
-    /** API router for REST endpoints */
-    api?: Router;
-    /** WebSocket endpoints */
-    ws?: WebSocketEndpointConfig[];
-    /** SMTP listeners started alongside the preview server */
-    smtp?: ElitSMTPServerConfig | ElitSMTPServerConfig[];
-    /** 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[];
-    /** Environment variables to inject (prefix with VITE_ for client access) */
-    env?: Record<string, string>;
-    /** Emit a bundled preview server during elit build */
-    standalone?: boolean;
-    /** Output filename for the standalone preview server bundle (default: index.js) */
-    outFile?: string;
-}
+
 type TestEnvironment = 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime';
 type TestCoverageProvider = 'v8' | 'istanbul';
 type TestCoverageReporter = 'text' | 'json' | 'html' | 'lcov' | 'lcovonly' | 'coverage-final.json' | 'clover';
@@ -615,4 +432,4 @@ interface TestOptions {
     env?: Record<string, string>;
 }
 
-export type { BuildOptions, BuildResult, Child, Children, ClientConfig, DevServer, DevServerOptions, ElementFactory, HMRMessage, JsonNode, PreviewOptions, Props, ProxyConfig, RefCallback, RefObject, Router, State, StateManager, StateOptions, TestCoverageOptions, TestCoverageProvider, TestCoverageReporter, TestEnvironment, TestOptions, VNode, VNodeJson, VirtualListController, WebSocketConnection, WebSocketEndpointConfig, WebSocketEndpointContext, WebSocketEndpointHandler, WebSocketRequest, WorkerConfig };
+export { type BuildOptions, type BuildResult, Child, type ClientConfig, type DevServer, type DevServerOptions, type HMRMessage, type PreviewOptions, type ProxyConfig, type Router, type StateManager, type TestCoverageOptions, type TestCoverageProvider, type TestCoverageReporter, type TestEnvironment, type TestOptions, type WebSocketConnection, type WebSocketEndpointConfig, type WebSocketEndpointContext, type WebSocketEndpointHandler, type WebSocketRequest, type WorkerConfig };

package/dist/universal.cjs

@@ -17,7 +17,7 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/universal.ts
+// src/shares/universal.ts
 var universal_exports = {};
 __export(universal_exports, {
   createUniversalBridgeProps: () => createUniversalBridgeProps,

package/dist/universal.d.ts

@@ -1,10 +1,4 @@
-import { Props } from './types.js';
-import 'node:events';
-import 'events';
-import 'http';
-import 'ws';
-import 'net';
-import 'smtp-server';
+import { P as Props } from './types-BONVzPtp.js';
 
 type UniversalPayload = string | number | boolean | null | UniversalPayload[] | {
     [key: string]: UniversalPayload;

package/dist/universal.js

@@ -1,6 +1,6 @@
 "use strict";
 (() => {
-  // src/universal.ts
+  // src/shares/universal.ts
   function serializePayload(payload) {
     if (payload === void 0) return void 0;
     return JSON.stringify(payload);

package/dist/universal.mjs

@@ -1,4 +1,4 @@
-// src/universal.ts
+// src/shares/universal.ts
 function serializePayload(payload) {
   if (payload === void 0) return void 0;
   return JSON.stringify(payload);

package/dist/websocket-BLBEAnhp.d.ts

@@ -0,0 +1,119 @@
+import { EventEmitter } from 'events';
+import { I as IncomingMessage } from './types-DPOgoGs-.js';
+
+/**
+ * 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;
+}
+/**
+ * Verify client callback
+ */
+type VerifyClientCallback = (info: {
+    origin: string;
+    secure: boolean;
+    req: IncomingMessage;
+}, callback?: (result: boolean, code?: number, message?: string) => void) => boolean | void;
+/**
+ * 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;
+}
+
+/**
+ * WebSocket class.
+ */
+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;
+}
+
+export { CLOSE_CODES as C, type Data as D, ReadyState as R, type ServerOptions as S, type VerifyClientCallback as V, WebSocket as W, type SendOptions as a };