elit 3.0.1 → 3.0.2

package/dist/wss.d.ts

@@ -1,9 +1,3 @@
-import { EventEmitter } from 'events';
-import { IncomingMessage } from './http.js';
-import { WebSocket, ServerOptions, ReadyState } from './ws.js';
-export { CLOSE_CODES, Data } from './ws.js';
-import 'node:events';
-
 /**
  * WebSocket Secure (WSS) module with unified API across runtimes
  * Pure implementation without external dependencies
@@ -12,11 +6,13 @@ import 'node:events';
  * - Bun: uses native WebSocket with TLS
  * - Deno: uses native WebSocket with TLS
  */
-
+import { EventEmitter } from 'events';
+import type { IncomingMessage } from './http';
+import { WebSocket, ServerOptions, Data, ReadyState, CLOSE_CODES } from './ws';
 /**
  * WSS Server options (extends WebSocket ServerOptions with TLS)
  */
-interface WSSServerOptions extends ServerOptions {
+export interface WSSServerOptions extends ServerOptions {
     key?: string | Buffer;
     cert?: string | Buffer;
     ca?: string | Buffer;
@@ -28,13 +24,13 @@ interface WSSServerOptions extends ServerOptions {
 /**
  * WebSocket Secure client class
  */
-declare class WSSClient extends WebSocket {
+export declare class WSSClient extends WebSocket {
     constructor(address: string | URL, protocols?: string | string[], options?: any);
 }
 /**
  * WebSocket Secure Server class
  */
-declare class WSSServer extends EventEmitter {
+export declare class WSSServer extends EventEmitter {
     clients: Set<WebSocket>;
     options: WSSServerOptions;
     path: string;
@@ -66,16 +62,20 @@ declare class WSSServer extends EventEmitter {
 /**
  * Create WebSocket Secure client
  */
-declare function createWSSClient(address: string | URL, protocols?: string | string[], options?: any): WSSClient;
+export declare function createWSSClient(address: string | URL, protocols?: string | string[], options?: any): WSSClient;
 /**
  * Create WebSocket Secure server
  */
-declare function createWSSServer(options?: WSSServerOptions, callback?: () => void): WSSServer;
+export declare function createWSSServer(options?: WSSServerOptions, callback?: () => void): WSSServer;
 /**
  * Get current runtime
  */
-declare function getRuntime(): 'node' | 'bun' | 'deno';
-
+export declare function getRuntime(): 'node' | 'bun' | 'deno';
+/**
+ * Re-export types and constants from ws module
+ */
+export type { ServerOptions, Data };
+export { ReadyState, CLOSE_CODES };
 /**
  * Default export
  */
@@ -104,5 +104,5 @@ declare const _default: {
     };
     getRuntime: typeof getRuntime;
 };
-
-export { ReadyState, ServerOptions, WSSClient, WSSServer, type WSSServerOptions, createWSSClient, createWSSServer, _default as default, getRuntime };
+export default _default;
+//# sourceMappingURL=wss.d.ts.map

package/dist/wss.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wss.d.ts","sourceRoot":"","sources":["../src/wss.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAE9C,OAAO,EAAE,SAAS,EAAmB,aAAa,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,MAAM,CAAC;AAkChG;;GAEG;AACH,MAAM,WAAW,gBAAiB,SAAQ,aAAa;IAErD,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,WAAW,CAAC,EAAE,OAAO,CAAC;IAGtB,WAAW,CAAC,EAAE,GAAG,CAAC;CACnB;AAED;;GAEG;AACH,qBAAa,SAAU,SAAQ,SAAS;gBAC1B,OAAO,EAAE,MAAM,GAAG,GAAG,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,GAAG;CAOhF;AAED;;GAEG;AACH,qBAAa,SAAU,SAAQ,YAAY;IAClC,OAAO,EAAE,GAAG,CAAC,SAAS,CAAC,CAAa;IACpC,OAAO,EAAE,gBAAgB,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC;IAEpB,OAAO,CAAC,YAAY,CAAM;IAC1B,OAAO,CAAC,SAAS,CAAmB;gBAExB,OAAO,CAAC,EAAE,gBAAgB,EAAE,QAAQ,CAAC,EAAE,MAAM,IAAI;IA8B7D,OAAO,CAAC,YAAY;IA4BpB;;OAEG;IACH,aAAa,CAAC,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,GAAG,IAAI;IAM/G;;OAEG;IACH,YAAY,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO;IAU/C;;OAEG;IACH,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI;IAmB7C;;OAEG;IACH,OAAO,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;CASpE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,SAAS,CAE9G;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,gBAAgB,EAAE,QAAQ,CAAC,EAAE,MAAM,IAAI,GAAG,SAAS,CAE5F;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,MAAM,GAAG,KAAK,GAAG,MAAM,CAEpD;AAED;;GAEG;AACH,YAAY,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC;AACpC,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC;AAEnC;;GAEG;;;;;;;;;;;;;;;;;;;;;;;;;;AACH,wBAQE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "elit",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "description": "Optimized lightweight library for creating DOM elements with reactive state",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -101,7 +101,7 @@
     }
   },
   "scripts": {
-    "build": "tsup",
+    "build": "tsup && tsc --emitDeclarationOnly",
     "dev": "tsup --watch",
     "typecheck": "tsc --noEmit",
     "benchmark": "node benchmark/server-benchmark.js",
@@ -162,6 +162,7 @@
   },
   "files": [
     "dist",
+    "src",
     "README.md",
     "LICENSE"
   ]

package/src/build.ts

@@ -0,0 +1,337 @@
+/**
+ * Build module for bundling applications
+ * Pure implementation with cross-runtime support
+ * Compatible with standard build tools API
+ * - Node.js: uses esbuild
+ * - Bun: uses Bun.build
+ * - Deno: uses Deno.emit
+ */
+
+import { statSync, mkdirSync, readFileSync, writeFileSync, copyFileSync, existsSync } from './fs';
+import { resolve, join, basename, extname, dirname } from './path';
+import { runtime } from './runtime';
+import type { BuildOptions, BuildResult } from './types';
+
+/**
+ * Helper: Ensure directory exists (eliminates duplication in directory creation)
+ */
+function ensureDir(dirPath: string): void {
+    try {
+        mkdirSync(dirPath, { recursive: true });
+    } catch (error) {
+        // Directory might already exist
+    }
+}
+
+/**
+ * Helper: Calculate build time and size (eliminates duplication in build result)
+ */
+function calculateBuildMetrics(startTime: number, outputPath: string): { buildTime: number; size: number } {
+    const buildTime = Date.now() - startTime;
+    const stats = statSync(outputPath);
+    return { buildTime, size: stats.size };
+}
+
+/**
+ * Helper: Read file and ensure string output (eliminates duplication in file reading)
+ */
+function readFileAsString(filePath: string): string {
+    const contentBuffer = readFileSync(filePath, 'utf-8');
+    return typeof contentBuffer === 'string' ? contentBuffer : contentBuffer.toString('utf-8');
+}
+
+/**
+ * Helper: Get esbuild minify options (eliminates duplication in esbuild config)
+ */
+function getMinifyOptions(minify?: boolean): object {
+    return minify ? {
+        minifyWhitespace: true,
+        minifyIdentifiers: true,
+        minifySyntax: true,
+        legalComments: 'none',
+        mangleProps: /^_/,
+        keepNames: false
+    } : {};
+}
+
+/**
+ * Helper: Log build info (eliminates duplication in logging)
+ */
+function logBuildInfo(config: BuildOptions, outputPath: string): void {
+    console.log('\n🔨 Building...');
+    console.log(`  Entry:  ${config.entry}`);
+    console.log(`  Output: ${outputPath}`);
+    console.log(`  Format: ${config.format}`);
+    console.log(`  Target: ${config.target}`);
+}
+
+/**
+ * Helper: Log build success (eliminates duplication in success logging)
+ */
+function logBuildSuccess(buildTime: number, size: number): void {
+    console.log(`\n✅ Build successful!`);
+    console.log(`  Time: ${buildTime}ms`);
+    console.log(`  Size: ${formatBytes(size)}`);
+}
+
+const defaultOptions: Omit<BuildOptions, 'entry'> = {
+    outDir: 'dist',
+    minify: true,
+    sourcemap: false,
+    target: 'es2020',
+    format: 'esm',
+    treeshake: true,
+    logging: true,
+    external: []
+};
+
+export async function build(options: BuildOptions): Promise<BuildResult> {
+    const config = { ...defaultOptions, ...options };
+    const startTime = Date.now();
+
+    if (!config.entry) {
+        throw new Error('Entry file is required');
+    }
+
+    const entryPath = resolve(config.entry);
+    const outDir = resolve(config.outDir!);
+
+    // Determine output filename
+    let outFile = config.outFile;
+    if (!outFile) {
+        const baseName = basename(config.entry, extname(config.entry));
+        const ext = config.format === 'cjs' ? '.cjs' : '.js';
+        outFile = baseName + ext;
+    }
+
+    const outputPath = join(outDir, outFile);
+
+    // Ensure output directory exists
+    ensureDir(outDir);
+
+    if (config.logging) {
+        logBuildInfo(config, outputPath);
+    }
+
+    // Browser-only plugin for automatic client/server separation
+    const browserOnlyPlugin = {
+        name: 'browser-only',
+        setup(build: any) {
+            // External all Node.js built-in modules
+            build.onResolve({ filter: /^(node:.*|fs|path|http|https|url|os|child_process|net|tls|crypto|stream|util|events|buffer|zlib|readline|process|assert|constants|dns|domain|punycode|querystring|repl|string_decoder|sys|timers|tty|v8|vm)$/ }, () => {
+                return { path: 'node-builtin', external: true, sideEffects: false };
+            });
+
+            // External common server-side dependencies
+            build.onResolve({ filter: /^(chokidar|esbuild|mime-types|open|ws|fs\/promises)$/ }, () => {
+                return { path: 'server-dep', external: true, sideEffects: false };
+            });
+
+            // Intercept imports from elit server-side modules
+            build.onLoad({ filter: /[\\/](server|config|cli)\.ts$/ }, () => {
+                return {
+                    contents: 'export {}',
+                    loader: 'js',
+                };
+            });
+        },
+    };
+
+    try {
+        const platform = config.platform || (config.format === 'cjs' ? 'node' : 'browser');
+        const plugins = platform === 'browser' ? [browserOnlyPlugin] : [];
+
+        // Prepare environment variables for injection
+        const define: Record<string, string> = {};
+        if (config.env) {
+            Object.entries(config.env).forEach(([key, value]) => {
+                // Only inject variables prefixed with VITE_ to client code
+                if (key.startsWith('VITE_')) {
+                    define[`import.meta.env.${key}`] = JSON.stringify(value);
+                }
+            });
+            // Add MODE
+            if (config.env.MODE) {
+                define['import.meta.env.MODE'] = JSON.stringify(config.env.MODE);
+            }
+            // Add DEV/PROD flags
+            define['import.meta.env.DEV'] = JSON.stringify(config.env.MODE !== 'production');
+            define['import.meta.env.PROD'] = JSON.stringify(config.env.MODE === 'production');
+        }
+
+        let result: any;
+        let buildTime: number;
+        let size: number;
+
+        if (runtime === 'node') {
+            // Node.js - use esbuild
+            const { build: esbuild } = await import('esbuild');
+
+            result = await esbuild({
+                entryPoints: [entryPath],
+                bundle: true,
+                outfile: outputPath,
+                format: config.format,
+                target: config.target,
+                minify: config.minify,
+                sourcemap: config.sourcemap,
+                external: config.external,
+                treeShaking: config.treeshake,
+                globalName: config.globalName,
+                platform,
+                plugins,
+                define,
+                logLevel: config.logging ? 'info' : 'silent',
+                metafile: true,
+                // Additional optimizations
+                ...getMinifyOptions(config.minify)
+            });
+
+            ({ buildTime, size } = calculateBuildMetrics(startTime, outputPath));
+        } else if (runtime === 'bun') {
+            // Bun - use Bun.build
+            // @ts-ignore
+            result = await Bun.build({
+                entrypoints: [entryPath],
+                outdir: outDir,
+                target: 'bun',
+                format: config.format === 'cjs' ? 'cjs' : 'esm',
+                minify: config.minify,
+                sourcemap: config.sourcemap ? 'external' : 'none',
+                external: config.external,
+                naming: outFile,
+                define
+            });
+
+            if (!result.success) {
+                throw new Error('Bun build failed: ' + JSON.stringify(result.logs));
+            }
+
+            ({ buildTime, size } = calculateBuildMetrics(startTime, outputPath));
+        } else {
+            // Deno - use Deno.emit
+            // @ts-ignore
+            result = await Deno.emit(entryPath, {
+                bundle: 'module',
+                check: false,
+                compilerOptions: {
+                    target: config.target,
+                    module: config.format === 'cjs' ? 'commonjs' : 'esnext',
+                    sourceMap: config.sourcemap
+                }
+            });
+
+            // Write the bundled output
+            const bundledCode = result.files['deno:///bundle.js'];
+            if (bundledCode) {
+                // @ts-ignore
+                await Deno.writeTextFile(outputPath, bundledCode);
+            }
+
+            ({ buildTime, size } = calculateBuildMetrics(startTime, outputPath));
+        }
+
+        if (config.logging) {
+            logBuildSuccess(buildTime, size);
+
+            // Show metafile info (Node.js esbuild only)
+            if (runtime === 'node' && result.metafile) {
+                const inputs = Object.keys(result.metafile.inputs).length;
+                console.log(`  Files: ${inputs} input(s)`);
+
+                // Show largest modules
+                const outputKeys = Object.keys(result.metafile.outputs);
+                if (outputKeys.length > 0) {
+                    const mainOutput = result.metafile.outputs[outputKeys[0]];
+                    if (mainOutput && mainOutput.inputs) {
+                        const sortedInputs = Object.entries(mainOutput.inputs)
+                            .sort(([, a], [, b]) => {
+                                const aBytes = (a as any).bytesInOutput || 0;
+                                const bBytes = (b as any).bytesInOutput || 0;
+                                return bBytes - aBytes;
+                            })
+                            .slice(0, 5);
+
+                        if (sortedInputs.length > 0) {
+                            console.log('\n  📊 Top 5 largest modules:');
+                            sortedInputs.forEach(([file, info]) => {
+                                const fileName = file.split(/[/\\]/).pop() || file;
+                                const infoBytes = (info as any).bytesInOutput || 0;
+                                console.log(`     ${fileName.padEnd(30)} ${formatBytes(infoBytes)}`);
+                            });
+                        }
+                    }
+                }
+            }
+        }
+
+        const buildResult: BuildResult = {
+            outputPath,
+            buildTime,
+            size
+        };
+
+        // Handle copy files
+        if (config.copy && config.copy.length > 0) {
+            if (config.logging) {
+                console.log('\n📦 Copying files...');
+            }
+
+            for (const copyItem of config.copy) {
+                const fromPath = resolve(copyItem.from);
+                const toPath = resolve(outDir, copyItem.to);
+
+                // Ensure target directory exists
+                const targetDir = dirname(toPath);
+                if (!existsSync(targetDir)) {
+                    ensureDir(targetDir);
+                }
+
+                if (existsSync(fromPath)) {
+                    if (copyItem.transform) {
+                        // Read, transform, and write
+                        const content = readFileAsString(fromPath);
+                        const transformed = copyItem.transform(content, config);
+                        writeFileSync(toPath, transformed);
+                    } else {
+                        // Direct copy
+                        copyFileSync(fromPath, toPath);
+                    }
+
+                    if (config.logging) {
+                        console.log(`  ✓ ${copyItem.from} → ${copyItem.to}`);
+                    }
+                } else if (config.logging) {
+                    console.warn(`  ⚠ File not found: ${copyItem.from}`);
+                }
+            }
+        }
+
+        // Call post-build hook
+        if (config.onBuildEnd) {
+            await config.onBuildEnd(buildResult);
+        }
+
+        if (config.logging) {
+            console.log('');
+        }
+
+        return buildResult;
+    } catch (error) {
+        if (config.logging) {
+            console.error('\n❌ Build failed:');
+            console.error(error);
+        }
+        throw error;
+    }
+}
+
+function formatBytes(bytes: number): string {
+    if (bytes === 0) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+export type { BuildOptions, BuildResult } from './types';