elit 3.0.8 → 3.1.0

package/dist/build.d.mts

@@ -0,0 +1,20 @@
+import { B as BuildOptions, a as BuildResult } from './server-BgWmjg9q.mjs';
+import './http.mjs';
+import 'node:events';
+import './ws.mjs';
+import 'events';
+import 'http';
+import 'ws';
+
+/**
+ * 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
+ */
+
+declare function build(options: BuildOptions): Promise<BuildResult>;
+
+export { BuildOptions, BuildResult, build };

package/dist/chokidar.d.mts

@@ -0,0 +1,134 @@
+import { EventEmitter } from 'events';
+
+/**
+ * File watcher module with unified API across runtimes
+ * Pure implementation without external dependencies
+ * Compatible with 'chokidar' package API
+ * - Node.js: uses native fs.watch
+ * - Bun: uses native fs.watch with enhancements
+ * - Deno: uses Deno.watchFs
+ */
+
+/**
+ * Watch options
+ */
+interface WatchOptions {
+    /**
+     * Indicates whether the process should continue to run as long as files are being watched.
+     * If set to false, the process will continue running even if the watcher is closed.
+     */
+    persistent?: boolean;
+    /**
+     * Indicates whether to watch files that don't have read permissions.
+     */
+    ignorePermissionErrors?: boolean;
+    /**
+     * A function that takes one parameter (the path of the file/directory)
+     * and returns true to ignore or false to watch.
+     */
+    ignored?: string | RegExp | ((path: string) => boolean);
+    /**
+     * If set to false, only the parent directory will be watched for new files.
+     */
+    ignoreInitial?: boolean;
+    /**
+     * If set to true, symlinks will be followed.
+     */
+    followSymlinks?: boolean;
+    /**
+     * Interval of file system polling (in milliseconds).
+     */
+    interval?: number;
+    /**
+     * Interval of file system polling for binary files (in milliseconds).
+     */
+    binaryInterval?: number;
+    /**
+     * If set to true, will provide fs.Stats object as second argument
+     * in add, addDir, and change events.
+     */
+    alwaysStat?: boolean;
+    /**
+     * If set, limits how many levels of subdirectories will be traversed.
+     */
+    depth?: number;
+    /**
+     * By default, add event fires when a file first appears on disk.
+     * Setting this will wait for the write to finish before firing.
+     */
+    awaitWriteFinish?: boolean | {
+        stabilityThreshold?: number;
+        pollInterval?: number;
+    };
+    /**
+     * If set to true, will use fs.watchFile() (polling) instead of fs.watch().
+     */
+    usePolling?: boolean;
+    /**
+     * Whether to use fsevents watching on macOS (if available).
+     */
+    useFsEvents?: boolean;
+    /**
+     * The base path to watch.
+     */
+    cwd?: string;
+    /**
+     * Whether to disable globbing.
+     */
+    disableGlobbing?: boolean;
+    /**
+     * Automatically filter out artifacts that occur when using editors.
+     */
+    atomic?: boolean | number;
+}
+/**
+ * FSWatcher class - Compatible with chokidar
+ */
+declare class FSWatcher extends EventEmitter {
+    private _watcher;
+    private _closed;
+    private _watched;
+    constructor(options?: WatchOptions);
+    options: WatchOptions;
+    /**
+     * Add paths to be watched
+     */
+    add(paths: string | string[]): FSWatcher;
+    /**
+     * Stop watching paths
+     */
+    unwatch(paths: string | string[]): FSWatcher;
+    /**
+     * Close the watcher
+     */
+    close(): Promise<void>;
+    /**
+     * Get watched paths
+     */
+    getWatched(): {
+        [directory: string]: string[];
+    };
+    /**
+     * Internal method to set native watcher
+     * @internal
+     */
+    _setWatcher(watcher: any): void;
+}
+/**
+ * Watch files and directories
+ */
+declare function watch(paths: string | string[], options?: WatchOptions): FSWatcher;
+/**
+ * Get current runtime
+ */
+declare function getRuntime(): 'node' | 'bun' | 'deno';
+/**
+ * Default export
+ */
+declare const _default: {
+    watch: typeof watch;
+    FSWatcher: typeof FSWatcher;
+    getRuntime: typeof getRuntime;
+};
+
+export { FSWatcher, type WatchOptions, _default as default, getRuntime, watch };

package/dist/cli.js

@@ -1412,10 +1412,11 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "elit",
-      version: "3.0.8",
+      version: "3.1.0",
       description: "Optimized lightweight library for creating DOM elements with reactive state",
       main: "dist/index.js",
       module: "dist/index.mjs",
+      browser: "dist/index.mjs",
       types: "dist/index.d.ts",
       bin: {
         elit: "./dist/cli.js"
@@ -1423,6 +1424,7 @@ var require_package = __commonJS({
       exports: {
         ".": {
           types: "./dist/index.d.ts",
+          browser: "./dist/index.mjs",
           import: "./dist/index.mjs",
           require: "./dist/index.js"
         },
@@ -3073,6 +3075,9 @@ async function findSpecialDir(startDir, targetDir) {
   return null;
 }
 var importMapCache = /* @__PURE__ */ new Map();
+function clearImportMapCache() {
+  importMapCache.clear();
+}
 async function generateExternalImportMaps(rootDir, basePath = "") {
   const cacheKey = `${rootDir}:${basePath}`;
   if (importMapCache.has(cacheKey)) {
@@ -3470,6 +3475,9 @@ function createDevServer(options) {
   const config = { ...defaultOptions, ...options };
   const wsClients = /* @__PURE__ */ new Set();
   const stateManager = new StateManager();
+  if (config.mode === "dev") {
+    clearImportMapCache();
+  }
   const clientsToNormalize = config.clients?.length ? config.clients : config.root ? [{ root: config.root, basePath: config.basePath || "", index: config.index, ssr: config.ssr, api: config.api, proxy: config.proxy, mode: config.mode }] : null;
   if (!clientsToNormalize) throw new Error('DevServerOptions must include either "clients" array or "root" directory');
   const normalizedClients = clientsToNormalize.map((client) => {
@@ -3532,6 +3540,14 @@ function createDevServer(options) {
       const handled = await config.api.handle(req, res);
       if (handled) return;
     }
+    if (url.startsWith("/api") && ["POST", "PUT", "PATCH", "DELETE"].includes(req.method || "")) {
+      if (!res.headersSent) {
+        if (config.logging) console.log(`[405] ${req.method} ${url} - Method not allowed`);
+        res.writeHead(405, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Method Not Allowed", message: "No API route found for this request" }));
+      }
+      return;
+    }
     let filePath;
     if (url === "/" && matchedClient.ssr && !matchedClient.index) {
       return await serveSSR(res, matchedClient);

package/dist/dom.d.mts

@@ -0,0 +1,87 @@
+import { Props, Children, VNode, Child, StateOptions, State, VirtualListController, JsonNode, VNodeJson } from './types.mjs';
+import 'node:events';
+import 'events';
+import 'http';
+import 'ws';
+
+/**
+ * Elit - DomNode Core Class
+ */
+
+declare class DomNode {
+    private elementCache;
+    createElement(tagName: string, props?: Props, children?: Children): VNode;
+    renderToDOM(vNode: Child, parent: HTMLElement | SVGElement | DocumentFragment): void;
+    render(rootElement: string | HTMLElement, vNode: VNode): HTMLElement;
+    batchRender(rootElement: string | HTMLElement, vNodes: VNode[]): HTMLElement;
+    renderChunked(rootElement: string | HTMLElement, vNodes: VNode[], chunkSize?: number, onProgress?: (current: number, total: number) => void): HTMLElement;
+    renderToHead(...vNodes: Array<VNode | VNode[]>): HTMLHeadElement | null;
+    addStyle(cssText: string): HTMLStyleElement;
+    addMeta(attrs: Record<string, string>): HTMLMetaElement;
+    addLink(attrs: Record<string, string>): HTMLLinkElement;
+    setTitle(text: string): string;
+    createState<T>(initialValue: T, options?: StateOptions): State<T>;
+    computed<T extends any[], R>(states: {
+        [K in keyof T]: State<T[K]>;
+    }, computeFn: (...values: T) => R): State<R>;
+    effect(stateFn: () => void): void;
+    createVirtualList<T>(container: HTMLElement, items: T[], renderItem: (item: T, index: number) => VNode, itemHeight?: number, bufferSize?: number): VirtualListController;
+    lazy<T extends any[], R>(loadFn: () => Promise<(...args: T) => R>): (...args: T) => Promise<R | VNode>;
+    cleanupUnusedElements(root: HTMLElement): number;
+    renderToString(vNode: Child, options?: {
+        pretty?: boolean;
+        indent?: number;
+    }): string;
+    private resolveStateValue;
+    private isReactiveWrapper;
+    private unwrapReactive;
+    private escapeHtml;
+    private isSelfClosingTag;
+    private propsToAttributes;
+    private styleToString;
+    private isState;
+    private reactiveNodes;
+    private createReactiveChild;
+    jsonToVNode(json: JsonNode | string | number | boolean | null | undefined | State<any>): Child;
+    vNodeJsonToVNode(json: VNodeJson | State<any>): Child;
+    renderJson(rootElement: string | HTMLElement, json: JsonNode): HTMLElement;
+    renderVNode(rootElement: string | HTMLElement, json: VNodeJson): HTMLElement;
+    renderJsonToString(json: JsonNode, options?: {
+        pretty?: boolean;
+        indent?: number;
+    }): string;
+    renderVNodeToString(json: VNodeJson, options?: {
+        pretty?: boolean;
+        indent?: number;
+    }): string;
+    renderToHTMLDocument(vNode: Child, options?: {
+        title?: string;
+        meta?: Array<Record<string, string>>;
+        links?: Array<Record<string, string>>;
+        scripts?: Array<{
+            src?: string;
+            content?: string;
+            async?: boolean;
+            defer?: boolean;
+            type?: string;
+        }>;
+        styles?: Array<{
+            href?: string;
+            content?: string;
+        }>;
+        lang?: string;
+        head?: string;
+        bodyAttrs?: Record<string, string>;
+        pretty?: boolean;
+    }): string;
+    getElementCache(): WeakMap<Element, boolean>;
+}
+declare const dom: DomNode;
+declare const render: (rootElement: string | HTMLElement, vNode: VNode) => HTMLElement;
+declare const renderToString: (vNode: Child, options?: {
+    pretty?: boolean;
+    indent?: number;
+}) => string;
+declare const mount: (rootElement: string | HTMLElement, vNode: VNode) => HTMLElement;
+
+export { DomNode, dom, mount, render, renderToString };

package/dist/el.d.mts

@@ -0,0 +1,207 @@
+import { ElementFactory } from './types.mjs';
+import 'node:events';
+import 'events';
+import 'http';
+import 'ws';
+
+/**
+ * Elit - Element Factories
+ */
+
+declare const createElementFactory: (tag: string) => ElementFactory;
+declare const tags: readonly ["html", "head", "body", "title", "base", "link", "meta", "style", "address", "article", "aside", "footer", "header", "h1", "h2", "h3", "h4", "h5", "h6", "main", "nav", "section", "blockquote", "dd", "div", "dl", "dt", "figcaption", "figure", "hr", "li", "ol", "p", "pre", "ul", "a", "abbr", "b", "bdi", "bdo", "br", "cite", "code", "data", "dfn", "em", "i", "kbd", "mark", "q", "rp", "rt", "ruby", "s", "samp", "small", "span", "strong", "sub", "sup", "time", "u", "wbr", "area", "audio", "img", "map", "track", "video", "embed", "iframe", "object", "param", "picture", "portal", "source", "canvas", "noscript", "script", "del", "ins", "caption", "col", "colgroup", "table", "tbody", "td", "tfoot", "th", "thead", "tr", "button", "datalist", "fieldset", "form", "input", "label", "legend", "meter", "optgroup", "option", "output", "progress", "select", "textarea", "details", "dialog", "menu", "summary", "slot", "template"];
+declare const svgTags: readonly ["svg", "circle", "rect", "path", "line", "polyline", "polygon", "ellipse", "g", "text", "tspan", "defs", "linearGradient", "radialGradient", "stop", "pattern", "mask", "clipPath", "use", "symbol", "marker", "image", "foreignObject", "animate", "animateTransform", "animateMotion", "set", "filter", "feBlend", "feColorMatrix", "feComponentTransfer", "feComposite", "feConvolveMatrix", "feDiffuseLighting", "feDisplacementMap", "feFlood", "feGaussianBlur", "feMorphology", "feOffset", "feSpecularLighting", "feTile", "feTurbulence"];
+declare const mathTags: readonly ["math", "mi", "mn", "mo", "ms", "mtext", "mrow", "mfrac", "msqrt", "mroot", "msub", "msup"];
+type Elements = {
+    [K in typeof tags[number]]: ElementFactory;
+} & {
+    [K in typeof svgTags[number] as `svg${Capitalize<K>}`]: ElementFactory;
+} & {
+    [K in typeof mathTags[number] as `math${Capitalize<K>}`]: ElementFactory;
+} & {
+    varElement: ElementFactory;
+};
+declare const elements: Partial<Elements>;
+declare const html: ElementFactory;
+declare const head: ElementFactory;
+declare const body: ElementFactory;
+declare const title: ElementFactory;
+declare const base: ElementFactory;
+declare const link: ElementFactory;
+declare const meta: ElementFactory;
+declare const style: ElementFactory;
+declare const address: ElementFactory;
+declare const article: ElementFactory;
+declare const aside: ElementFactory;
+declare const footer: ElementFactory;
+declare const header: ElementFactory;
+declare const h1: ElementFactory;
+declare const h2: ElementFactory;
+declare const h3: ElementFactory;
+declare const h4: ElementFactory;
+declare const h5: ElementFactory;
+declare const h6: ElementFactory;
+declare const main: ElementFactory;
+declare const nav: ElementFactory;
+declare const section: ElementFactory;
+declare const blockquote: ElementFactory;
+declare const dd: ElementFactory;
+declare const div: ElementFactory;
+declare const dl: ElementFactory;
+declare const dt: ElementFactory;
+declare const figcaption: ElementFactory;
+declare const figure: ElementFactory;
+declare const hr: ElementFactory;
+declare const li: ElementFactory;
+declare const ol: ElementFactory;
+declare const p: ElementFactory;
+declare const pre: ElementFactory;
+declare const ul: ElementFactory;
+declare const a: ElementFactory;
+declare const abbr: ElementFactory;
+declare const b: ElementFactory;
+declare const bdi: ElementFactory;
+declare const bdo: ElementFactory;
+declare const br: ElementFactory;
+declare const cite: ElementFactory;
+declare const code: ElementFactory;
+declare const data: ElementFactory;
+declare const dfn: ElementFactory;
+declare const em: ElementFactory;
+declare const i: ElementFactory;
+declare const kbd: ElementFactory;
+declare const mark: ElementFactory;
+declare const q: ElementFactory;
+declare const rp: ElementFactory;
+declare const rt: ElementFactory;
+declare const ruby: ElementFactory;
+declare const s: ElementFactory;
+declare const samp: ElementFactory;
+declare const small: ElementFactory;
+declare const span: ElementFactory;
+declare const strong: ElementFactory;
+declare const sub: ElementFactory;
+declare const sup: ElementFactory;
+declare const time: ElementFactory;
+declare const u: ElementFactory;
+declare const wbr: ElementFactory;
+declare const area: ElementFactory;
+declare const audio: ElementFactory;
+declare const img: ElementFactory;
+declare const map: ElementFactory;
+declare const track: ElementFactory;
+declare const video: ElementFactory;
+declare const embed: ElementFactory;
+declare const iframe: ElementFactory;
+declare const object: ElementFactory;
+declare const param: ElementFactory;
+declare const picture: ElementFactory;
+declare const portal: ElementFactory;
+declare const source: ElementFactory;
+declare const canvas: ElementFactory;
+declare const noscript: ElementFactory;
+declare const script: ElementFactory;
+declare const del: ElementFactory;
+declare const ins: ElementFactory;
+declare const caption: ElementFactory;
+declare const col: ElementFactory;
+declare const colgroup: ElementFactory;
+declare const table: ElementFactory;
+declare const tbody: ElementFactory;
+declare const td: ElementFactory;
+declare const tfoot: ElementFactory;
+declare const th: ElementFactory;
+declare const thead: ElementFactory;
+declare const tr: ElementFactory;
+declare const button: ElementFactory;
+declare const datalist: ElementFactory;
+declare const fieldset: ElementFactory;
+declare const form: ElementFactory;
+declare const input: ElementFactory;
+declare const label: ElementFactory;
+declare const legend: ElementFactory;
+declare const meter: ElementFactory;
+declare const optgroup: ElementFactory;
+declare const option: ElementFactory;
+declare const output: ElementFactory;
+declare const progress: ElementFactory;
+declare const select: ElementFactory;
+declare const textarea: ElementFactory;
+declare const details: ElementFactory;
+declare const dialog: ElementFactory;
+declare const menu: ElementFactory;
+declare const summary: ElementFactory;
+declare const slot: ElementFactory;
+declare const template: ElementFactory;
+declare const svgSvg: ElementFactory;
+declare const svgCircle: ElementFactory;
+declare const svgRect: ElementFactory;
+declare const svgPath: ElementFactory;
+declare const svgLine: ElementFactory;
+declare const svgPolyline: ElementFactory;
+declare const svgPolygon: ElementFactory;
+declare const svgEllipse: ElementFactory;
+declare const svgG: ElementFactory;
+declare const svgText: ElementFactory;
+declare const svgTspan: ElementFactory;
+declare const svgDefs: ElementFactory;
+declare const svgLinearGradient: ElementFactory;
+declare const svgRadialGradient: ElementFactory;
+declare const svgStop: ElementFactory;
+declare const svgPattern: ElementFactory;
+declare const svgMask: ElementFactory;
+declare const svgClipPath: ElementFactory;
+declare const svgUse: ElementFactory;
+declare const svgSymbol: ElementFactory;
+declare const svgMarker: ElementFactory;
+declare const svgImage: ElementFactory;
+declare const svgForeignObject: ElementFactory;
+declare const svgAnimate: ElementFactory;
+declare const svgAnimateTransform: ElementFactory;
+declare const svgAnimateMotion: ElementFactory;
+declare const svgSet: ElementFactory;
+declare const svgFilter: ElementFactory;
+declare const svgFeBlend: ElementFactory;
+declare const svgFeColorMatrix: ElementFactory;
+declare const svgFeComponentTransfer: ElementFactory;
+declare const svgFeComposite: ElementFactory;
+declare const svgFeConvolveMatrix: ElementFactory;
+declare const svgFeDiffuseLighting: ElementFactory;
+declare const svgFeDisplacementMap: ElementFactory;
+declare const svgFeFlood: ElementFactory;
+declare const svgFeGaussianBlur: ElementFactory;
+declare const svgFeMorphology: ElementFactory;
+declare const svgFeOffset: ElementFactory;
+declare const svgFeSpecularLighting: ElementFactory;
+declare const svgFeTile: ElementFactory;
+declare const svgFeTurbulence: ElementFactory;
+declare const mathMath: ElementFactory;
+declare const mathMi: ElementFactory;
+declare const mathMn: ElementFactory;
+declare const mathMo: ElementFactory;
+declare const mathMs: ElementFactory;
+declare const mathMtext: ElementFactory;
+declare const mathMrow: ElementFactory;
+declare const mathMfrac: ElementFactory;
+declare const mathMsqrt: ElementFactory;
+declare const mathMroot: ElementFactory;
+declare const mathMsub: ElementFactory;
+declare const mathMsup: ElementFactory;
+declare const varElement: ElementFactory;
+declare const el: Partial<Elements>;
+
+declare const doc: any;
+declare const getEl: any;
+declare const getEls: any;
+declare const createEl: any;
+declare const createSvgEl: any;
+declare const createMathEl: any;
+declare const fragment: any;
+declare const textNode: any;
+declare const commentNode: any;
+declare const getElId: any;
+declare const getElClass: any;
+declare const getElTag: any;
+declare const getElName: any;
+
+export { a, abbr, address, area, article, aside, audio, b, base, bdi, bdo, blockquote, body, br, button, canvas, caption, cite, code, col, colgroup, commentNode, createEl, createElementFactory, createMathEl, createSvgEl, data, datalist, dd, del, details, dfn, dialog, div, dl, doc, dt, el, elements, em, embed, fieldset, figcaption, figure, footer, form, fragment, getEl, getElClass, getElId, getElName, getElTag, getEls, h1, h2, h3, h4, h5, h6, head, header, hr, html, i, iframe, img, input, ins, kbd, label, legend, li, link, main, map, mark, mathMath, mathMfrac, mathMi, mathMn, mathMo, mathMroot, mathMrow, mathMs, mathMsqrt, mathMsub, mathMsup, mathMtext, menu, meta, meter, nav, noscript, object, ol, optgroup, option, output, p, param, picture, portal, pre, progress, q, rp, rt, ruby, s, samp, script, section, select, slot, small, source, span, strong, style, sub, summary, sup, svgAnimate, svgAnimateMotion, svgAnimateTransform, svgCircle, svgClipPath, svgDefs, svgEllipse, svgFeBlend, svgFeColorMatrix, svgFeComponentTransfer, svgFeComposite, svgFeConvolveMatrix, svgFeDiffuseLighting, svgFeDisplacementMap, svgFeFlood, svgFeGaussianBlur, svgFeMorphology, svgFeOffset, svgFeSpecularLighting, svgFeTile, svgFeTurbulence, svgFilter, svgForeignObject, svgG, svgImage, svgLine, svgLinearGradient, svgMarker, svgMask, svgPath, svgPattern, svgPolygon, svgPolyline, svgRadialGradient, svgRect, svgSet, svgStop, svgSvg, svgSymbol, svgText, svgTspan, svgUse, table, tbody, td, template, textNode, textarea, tfoot, th, thead, time, title, tr, track, u, ul, varElement, video, wbr };