elit 3.6.5 → 3.6.7

package/dist/types-BONVzPtp.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Elit core render and state contracts.
+ */
+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;
+};
+
+export type { Child as C, ElementFactory as E, JsonNode as J, Props as P, RefCallback as R, State as S, VNode as V, Children as a, RefObject as b, StateOptions as c, VNodeJson as d, VirtualListController as e };

package/dist/types-BR4wMiVx.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Elit core render and state contracts.
+ */
+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;
+}
+
+export type { Child as C, VNode as V };

package/dist/types-C4gKykuG.d.ts

@@ -0,0 +1,23 @@
+import { Server, AddressInfo } from 'net';
+import { SMTPServerOptions, SMTPServer } from 'smtp-server';
+
+interface ElitSMTPServerConfig extends SMTPServerOptions {
+    port?: number;
+    host?: string;
+    label?: string;
+}
+type ElitSMTPServerInput = ElitSMTPServerConfig | ElitSMTPServerConfig[] | undefined;
+interface ResolvedElitSMTPServerConfig extends SMTPServerOptions {
+    port: number;
+    host: string;
+    label?: string;
+}
+interface ElitSMTPServerHandle {
+    server: SMTPServer;
+    config: ResolvedElitSMTPServerConfig;
+    listen(callback?: () => void): Server;
+    address(): AddressInfo | string | null;
+    close(): Promise<void>;
+}
+
+export type { ElitSMTPServerConfig as E, ResolvedElitSMTPServerConfig as R, ElitSMTPServerHandle as a, ElitSMTPServerInput as b };

package/dist/types-CIhpN1-K.d.ts

@@ -0,0 +1,64 @@
+interface TestFunction {
+    (name: string, fn: () => void, timeout?: number): void;
+    skip: (name: string, fn: () => void, timeout?: number) => void;
+    only: (name: string, fn: () => void, timeout?: number) => void;
+    todo: (name: string, fn: () => void, timeout?: number) => void;
+}
+interface DescribeFunction {
+    (name: string, fn: () => void): void;
+    skip: (name: string, fn: () => void) => void;
+    only: (name: string, fn: () => void) => void;
+}
+interface MockFunction<T extends (...args: any[]) => any> {
+    (...args: Parameters<T>): ReturnType<T>;
+    _isMock: boolean;
+    _calls: Parameters<T>[];
+    _results: Array<{
+        type: 'return' | 'throw';
+        value: any;
+    }>;
+    _implementation: T | null;
+    mockImplementation(fn: T): MockFunction<T>;
+    mockReturnValue(value: ReturnType<T>): MockFunction<T>;
+    mockResolvedValue(value: ReturnType<T>): MockFunction<T>;
+    mockRejectedValue(value: any): MockFunction<T>;
+    restore(): void;
+    clear(): void;
+}
+interface TestMatchers<T> {
+    toBe(value: T): void;
+    toEqual(value: T): void;
+    toBeTruthy(): void;
+    toBeFalsy(): void;
+    toBeNull(): void;
+    toBeUndefined(): void;
+    toBeDefined(): void;
+    toBeGreaterThan(value: number): void;
+    toBeLessThan(value: number): void;
+    toContain(value: any): void;
+    toHaveLength(length: number): void;
+    toThrow(error?: any): void;
+    toMatch(pattern: RegExp | string): void;
+    toBeInstanceOf(classType: any): void;
+    toHaveProperty(path: string | string[], value?: any): void;
+    toBeCalled(): void;
+    toBeCalledTimes(times: number): void;
+    toBeCalledWith(...args: any[]): void;
+    lastReturnedWith(value: any): void;
+    not: TestMatchers<any>;
+    resolves: TestMatchers<any>;
+    rejects: TestMatchers<any>;
+}
+interface TestResult {
+    name: string;
+    status: 'pass' | 'fail' | 'skip' | 'todo';
+    duration: number;
+    error?: Error;
+    suite: string;
+    file?: string;
+    lineNumber?: number;
+    codeSnippet?: string;
+}
+type HookFunction = () => void | Promise<void>;
+
+export type { DescribeFunction as D, HookFunction as H, MockFunction as M, TestMatchers as T, TestFunction as a, TestResult as b };

package/dist/types-Ckj8md_j.d.ts

@@ -0,0 +1,84 @@
+interface CSSVariable {
+    name: string;
+    value: string;
+    toString(): string;
+}
+interface CSSRule {
+    selector: string;
+    styles: Record<string, string | number>;
+    nested?: CSSRule[];
+    type: 'tag' | 'class' | 'id' | 'pseudo-class' | 'pseudo-element' | 'name' | 'custom' | 'media' | 'attribute';
+}
+interface MediaRule {
+    type: string;
+    condition: string;
+    rules: CSSRule[];
+}
+interface KeyframeStep {
+    step: string | number;
+    styles: Record<string, string | number>;
+}
+interface Keyframes {
+    name: string;
+    steps: KeyframeStep[];
+}
+interface FontFace {
+    fontFamily: string;
+    src: string;
+    fontWeight?: string | number;
+    fontStyle?: string;
+    fontDisplay?: string;
+    unicodeRange?: string;
+}
+interface ContainerRule {
+    name?: string;
+    condition: string;
+    rules: CSSRule[];
+}
+interface SupportsRule {
+    condition: string;
+    rules: CSSRule[];
+}
+interface LayerRule {
+    name: string;
+    rules: CSSRule[];
+}
+interface StyleSelectorTarget {
+    tagName?: string;
+    classNames?: string[];
+    attributes?: Record<string, string | number | boolean>;
+    pseudoStates?: string[];
+    previousSiblings?: StyleSelectorTarget[];
+    nextSiblings?: StyleSelectorTarget[];
+    children?: StyleSelectorTarget[];
+    childIndex?: number;
+    siblingCount?: number;
+    sameTypeIndex?: number;
+    sameTypeCount?: number;
+    containerNames?: string[];
+    containerWidth?: number;
+    isContainer?: boolean;
+    isScopeReference?: boolean;
+}
+interface NativeStyleResolveOptions {
+    viewportWidth?: number;
+    viewportHeight?: number;
+    colorScheme?: 'light' | 'dark';
+    reducedMotion?: boolean;
+    mediaType?: 'screen' | 'print' | 'all';
+}
+interface CreateStyleStore {
+    variables: CSSVariable[];
+    rules: CSSRule[];
+    mediaRules: MediaRule[];
+    keyframes: Keyframes[];
+    fontFaces: FontFace[];
+    imports: string[];
+    containerRules: ContainerRule[];
+    supportsRules: SupportsRule[];
+    layerRules: LayerRule[];
+    layerOrder: string[];
+}
+type StyleRenderInput = CSSRule | CSSRule[] | MediaRule | Keyframes | ContainerRule | SupportsRule | LayerRule | undefined | null;
+
+export type { CSSRule as C, FontFace as F, KeyframeStep as K, LayerRule as L, MediaRule as M, NativeStyleResolveOptions as N, StyleSelectorTarget as S, CSSVariable as a, ContainerRule as b, Keyframes as c, SupportsRule as d, CreateStyleStore as e, StyleRenderInput as f };

package/dist/types-CpjQTAkX.d.ts

@@ -0,0 +1,24 @@
+import { V as VNode } from './types-BR4wMiVx.js';
+
+type RenderRuntimeTarget = 'web' | 'desktop' | 'mobile' | 'unknown';
+interface DesktopInteractionOutputOptions {
+    file?: string;
+    stdout?: boolean;
+    emitReady?: boolean;
+}
+interface DesktopRenderOptions {
+    title?: string;
+    width?: number;
+    height?: number;
+    center?: boolean;
+    icon?: string;
+    autoClose?: boolean;
+    interactionOutput?: DesktopInteractionOutputOptions;
+}
+interface CapturedRenderState {
+    rootElement: string | unknown;
+    target: RenderRuntimeTarget;
+    vNode: VNode;
+}
+
+export type { CapturedRenderState as C, DesktopRenderOptions as D, RenderRuntimeTarget as R, DesktopInteractionOutputOptions as a };

package/dist/types-D0LjrYjS.d.ts

@@ -0,0 +1,14 @@
+interface HMRClient {
+    enabled: boolean;
+    reload: () => void;
+    accept: (callback?: () => void) => void;
+    decline: () => void;
+    dispose: (callback: () => void) => void;
+}
+declare global {
+    interface Window {
+        __ELIT_HMR__: HMRClient;
+    }
+}
+
+export type { HMRClient as H };

package/dist/types-DAisuVr5.d.ts

@@ -0,0 +1,75 @@
+import { EventEmitter } from 'node:events';
+
+/**
+ * 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, requestMethod?: string);
+    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;
+    json(data: any, statusCode?: number): this;
+    send(data: any): this;
+    status(code: number): this;
+}
+
+/**
+ * HTTP Headers type
+ */
+type IncomingHttpHeaders = Record<string, string | string[] | undefined>;
+type OutgoingHttpHeaders = Record<string, string | string[] | number>;
+/**
+ * Request listener type
+ */
+type RequestListener = (req: IncomingMessage, res: ServerResponse) => void;
+/**
+ * Request options
+ */
+interface RequestOptions {
+    method?: string;
+    headers?: OutgoingHttpHeaders;
+    timeout?: number;
+    signal?: AbortSignal;
+}
+/**
+ * Server options
+ */
+interface ServerOptions {
+    IncomingMessage?: typeof IncomingMessage;
+    ServerResponse?: typeof ServerResponse;
+}
+
+export { IncomingMessage as I, type OutgoingHttpHeaders as O, type RequestOptions as R, ServerResponse as S, type RequestListener as a, type ServerOptions as b, type IncomingHttpHeaders as c };

package/dist/types-tJn88E1N.d.ts

@@ -0,0 +1,242 @@
+import { D as DevServerOptions, i as PreviewOptions } from './state-DvEkDehk.js';
+import { B as BuildOptions } from './contracts-D7KIS-TK.js';
+import { a as TestOptions } from './contracts-BeW9k0yZ.js';
+
+interface ElitConfig {
+    /** Development server configuration */
+    dev?: DevServerOptions;
+    /** Build configuration - supports single build or multiple builds */
+    build?: BuildOptions | BuildOptions[];
+    /** Preview server configuration */
+    preview?: PreviewOptions;
+    /** Test configuration */
+    test?: TestOptions;
+    /** Desktop command configuration */
+    desktop?: DesktopConfig;
+    /** Mobile command configuration */
+    mobile?: MobileConfig;
+    /** Process manager configuration */
+    pm?: PmConfig;
+    /** WAPK packaging configuration */
+    wapk?: WapkConfig;
+}
+type MobileMode = 'native' | 'hybrid';
+type DesktopMode = 'native' | 'hybrid';
+type PmRuntimeName = 'node' | 'bun' | 'deno';
+type PmRestartPolicy = 'always' | 'on-failure' | 'never';
+interface PmHealthCheckConfig {
+    /** HTTP endpoint polled while the process is online */
+    url?: string;
+    /** Delay before the first health check in milliseconds */
+    gracePeriod?: number;
+    /** Interval between health checks in milliseconds */
+    interval?: number;
+    /** Per-request timeout in milliseconds */
+    timeout?: number;
+    /** Consecutive failed checks before the process is restarted */
+    maxFailures?: number;
+}
+interface PmAppConfig {
+    /** Unique process name used by elit pm list/stop/restart */
+    name: string;
+    /** Shell command to execute, for example: npm start */
+    script?: string;
+    /** JavaScript or TypeScript entry file executed by the selected runtime */
+    file?: string;
+    /** Packaged .wapk file or remote archive source executed through elit wapk run */
+    wapk?: string;
+    /** Runtime used for file or wapk targets */
+    runtime?: PmRuntimeName;
+    /** Working directory for the managed process */
+    cwd?: string;
+    /** Extra environment variables injected into the process */
+    env?: Record<string, string | number | boolean>;
+    /** Disable automatic restart when the process exits */
+    autorestart?: boolean;
+    /** Delay between restart attempts in milliseconds */
+    restartDelay?: number;
+    /** Maximum restart attempts before marking the process as errored */
+    maxRestarts?: number;
+    /** Password forwarded to elit wapk run for locked archives */
+    password?: string;
+    /** Extra WAPK run settings, including direct Google Drive access and live-sync options */
+    wapkRun?: WapkRunConfig;
+    /** Restart strategy used after the child process exits */
+    restartPolicy?: PmRestartPolicy;
+    /** Minimum healthy uptime before restart attempt counters reset */
+    minUptime?: number;
+    /** Restart the process when watched files change */
+    watch?: boolean;
+    /** Files or directories watched when watch mode is enabled */
+    watchPaths?: string[];
+    /** Glob-like patterns ignored by watch mode */
+    watchIgnore?: string[];
+    /** Debounce delay before restarting after a file change */
+    watchDebounce?: number;
+    /** Optional HTTP health checks for long-running services */
+    healthCheck?: PmHealthCheckConfig;
+}
+interface PmConfig {
+    /** Directory used to store pm metadata and log files (default: ./.elit/pm) */
+    dataDir?: string;
+    /** File used by pm save/resurrect (default: <dataDir>/dump.json) */
+    dumpFile?: string;
+    /** Managed applications available to elit pm start */
+    apps?: PmAppConfig[];
+}
+interface MobileConfig {
+    /** Project directory for native mobile artifacts */
+    cwd?: string;
+    /** Native app bundle identifier */
+    appId?: string;
+    /** Native app display name */
+    appName?: string;
+    /** Built web assets directory synced into native projects */
+    webDir?: string;
+    /** Mobile runtime mode: native uses generated UI, hybrid keeps the WebView shell active */
+    mode?: MobileMode;
+    /** Mobile app icon image path (recommended: .png or .webp) */
+    icon?: string;
+    /** Android permissions written to AndroidManifest uses-permission tags */
+    permissions?: string[];
+    /** Platform-specific Android CLI defaults */
+    android?: MobileAndroidConfig;
+    /** Platform-specific iOS CLI defaults */
+    ios?: MobileIosConfig;
+    /** Optional native UI generation targets using the same Elit syntax */
+    native?: MobileNativeConfig;
+}
+interface MobileAndroidConfig {
+    /** Default Android device/emulator id used when --target is omitted */
+    target?: string;
+}
+interface MobileIosConfig {
+    /** Default iOS simulator name, UDID, booted alias, or full xcodebuild destination */
+    target?: string;
+}
+interface MobileNativeConfig {
+    /** Elit entry file that exports a VNode tree or zero-argument factory */
+    entry?: string;
+    /** Explicit export name to read from the native entry module */
+    exportName?: string;
+    /** Android-specific native generation options */
+    android?: MobileNativeAndroidConfig;
+    /** iOS-specific native generation options */
+    ios?: MobileNativeIosConfig;
+}
+interface MobileNativeAndroidConfig {
+    /** Disable Android native code generation while keeping iOS enabled */
+    enabled?: boolean;
+    /** Kotlin package name for generated native screen files */
+    packageName?: string;
+    /** Output file path for generated Compose screen, relative to mobile.cwd */
+    output?: string;
+}
+interface MobileNativeIosConfig {
+    /** Disable iOS native code generation while keeping Android enabled */
+    enabled?: boolean;
+    /** Output file path for generated SwiftUI file, relative to mobile.cwd */
+    output?: string;
+}
+interface DesktopConfig {
+    /** Desktop runtime mode: native prefers desktop.native.entry and hybrid prefers desktop.entry */
+    mode?: DesktopMode;
+    /** Desktop entry file used when the CLI command omits <entry> in hybrid mode */
+    entry?: string;
+    /** Optional prebuilt hybrid desktop runtime binary path, relative to the current project when not absolute */
+    binaryPath?: string;
+    /** Optional Cargo target directory override for desktop runtime builds */
+    cargoTargetDir?: string;
+    /** Optional native desktop entry defaults */
+    native?: DesktopNativeConfig;
+    /** Optional prebuilt native desktop runtime binary path, relative to the current project when not absolute */
+    nativeBinaryPath?: string;
+    /** Native desktop runtime: quickjs, bun, node, deno */
+    runtime?: 'quickjs' | 'bun' | 'node' | 'deno';
+    /** Desktop entry compiler: auto, none, esbuild, tsx, tsup */
+    compiler?: 'auto' | 'none' | 'esbuild' | 'tsx' | 'tsup';
+    /** Build or run with release desktop runtime */
+    release?: boolean;
+    /** Desktop build output directory */
+    outDir?: string;
+    /** Desktop build target platform */
+    platform?: 'windows' | 'win' | 'windows-arm' | 'win-arm' | 'linux' | 'linux-musl' | 'linux-arm' | 'macos' | 'mac' | 'darwin' | 'macos-arm' | 'mac-arm';
+    /** Desktop WAPK mode defaults */
+    wapk?: {
+        /** Packaged runtime to execute inside desktop mode */
+        runtime?: 'node' | 'bun' | 'deno';
+        /** Polling interval for WAPK live sync */
+        syncInterval?: number;
+        /** Use event-driven file watcher for WAPK live sync */
+        useWatcher?: boolean;
+        /** Use release desktop runtime binary */
+        release?: boolean;
+    };
+}
+interface DesktopNativeConfig {
+    /** Elit entry file used when desktop.mode is native or --mode native is passed */
+    entry?: string;
+    /** Explicit export name to read from the desktop native entry module */
+    exportName?: string;
+}
+interface WapkLockConfig {
+    /** Plain-text password used to encrypt the archive */
+    password?: string;
+}
+interface WapkLiveSyncConfig {
+    /** Polling interval for live sync writes back into the archive */
+    syncInterval?: number;
+    /** Use event-driven file watching for local workdir changes */
+    useWatcher?: boolean;
+    /** Pull archive changes back into the temp workdir */
+    watchArchive?: boolean;
+    /** Polling interval for reading external archive changes */
+    archiveSyncInterval?: number;
+}
+interface WapkGoogleDriveConfig {
+    /** Google Drive file id for the remote .wapk archive */
+    fileId?: string;
+    /** OAuth access token used for Google Drive API calls */
+    accessToken?: string;
+    /** Environment variable name that contains the OAuth access token */
+    accessTokenEnv?: string;
+    /** Include supportsAllDrives=true when accessing shared drive files */
+    supportsAllDrives?: boolean;
+}
+interface WapkRunConfig extends WapkLiveSyncConfig {
+    /** Default archive file used by elit wapk run when no file argument is provided */
+    file?: string;
+    /** Remote Google Drive archive used by elit wapk run */
+    googleDrive?: WapkGoogleDriveConfig;
+    /** Create an online Elit Run shared session instead of starting the local runtime */
+    online?: boolean;
+    /** Elit Run base URL used when online hosting targets a non-default origin */
+    onlineUrl?: string;
+    /** Default runtime override used by elit wapk run */
+    runtime?: 'node' | 'bun' | 'deno';
+    /** Default password used to unlock a locked archive at runtime */
+    password?: string;
+}
+interface WapkConfig {
+    name?: string;
+    version?: string;
+    runtime?: string;
+    engine?: string;
+    entry?: string;
+    scripts?: Record<string, string>;
+    /** Stable logical app identifier embedded into the WAPK header */
+    appId?: string;
+    /** Stable publisher or owner identifier embedded into the WAPK header */
+    publisherId?: string;
+    port?: number;
+    env?: Record<string, string | number | boolean>;
+    desktop?: Record<string, unknown>;
+    lock?: WapkLockConfig;
+    run?: WapkRunConfig;
+}
+/**
+ * Helper function for type-safe config definition
+ */
+declare function defineConfig(config: ElitConfig): ElitConfig;
+
+export { type DesktopConfig as D, type ElitConfig as E, type MobileAndroidConfig as M, type PmAppConfig as P, type WapkConfig as W, type DesktopMode as a, type DesktopNativeConfig as b, type MobileConfig as c, type MobileIosConfig as d, type MobileMode as e, type MobileNativeAndroidConfig as f, type MobileNativeConfig as g, type MobileNativeIosConfig as h, type PmConfig as i, type PmHealthCheckConfig as j, type PmRestartPolicy as k, type PmRuntimeName as l, type WapkGoogleDriveConfig as m, type WapkLiveSyncConfig as n, type WapkLockConfig as o, type WapkRunConfig as p, defineConfig as q };