elit 3.6.5 → 3.6.7

package/dist/smtp-server.mjs

@@ -0,0 +1,100 @@
+import {createRequire as __createRequire} from 'module';const require = __createRequire(import.meta.url);
+
+// src/server/smtp-server/index.ts
+import { SMTPServer as SMTPServer2 } from "smtp-server";
+
+// src/server/smtp-server/constants.ts
+var DEFAULT_SMTP_PORT = 2525;
+var DEFAULT_SMTP_HOST = "127.0.0.1";
+
+// src/server/smtp-server/factory.ts
+import { SMTPServer } from "smtp-server";
+
+// src/server/smtp-server/config.ts
+function resolveSmtpServerConfig(config = {}) {
+  const { port = DEFAULT_SMTP_PORT, host = DEFAULT_SMTP_HOST, label, ...serverOptions } = config;
+  return {
+    ...serverOptions,
+    port,
+    host,
+    label
+  };
+}
+function normalizeSmtpServerConfigs(input) {
+  const configs = Array.isArray(input) ? input : input ? [input] : [];
+  return configs.map((config) => resolveSmtpServerConfig(config));
+}
+
+// src/server/smtp-server/lifecycle.ts
+function closeSmtpServer(server) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    };
+    const handleCloseError = (error) => {
+      const errorCode = error.code;
+      if (errorCode === "ERR_SERVER_NOT_RUNNING") {
+        finish();
+        return;
+      }
+      finish(error);
+    };
+    try {
+      server.close(() => finish());
+    } catch (error) {
+      handleCloseError(error);
+    }
+  });
+}
+
+// src/server/smtp-server/factory.ts
+function createSmtpServer(config = {}) {
+  const resolvedConfig = resolveSmtpServerConfig(config);
+  const { port, host, label: _label, ...serverOptions } = resolvedConfig;
+  const server = new SMTPServer(serverOptions);
+  return {
+    server,
+    config: resolvedConfig,
+    listen(callback) {
+      return callback ? server.listen(port, host, callback) : server.listen(port, host);
+    },
+    address() {
+      return server.server.address();
+    },
+    close() {
+      return closeSmtpServer(server);
+    }
+  };
+}
+function startSmtpServer(config = {}) {
+  const handle = createSmtpServer(config);
+  handle.listen();
+  return handle;
+}
+
+// src/server/smtp-server/index.ts
+var smtp_server_default = {
+  SMTPServer: SMTPServer2,
+  createSmtpServer,
+  startSmtpServer,
+  DEFAULT_SMTP_HOST,
+  DEFAULT_SMTP_PORT
+};
+export {
+  DEFAULT_SMTP_HOST,
+  DEFAULT_SMTP_PORT,
+  createSmtpServer,
+  smtp_server_default as default,
+  normalizeSmtpServerConfigs,
+  resolveSmtpServerConfig,
+  startSmtpServer
+};

package/dist/state-DvEkDehk.d.ts

@@ -0,0 +1,195 @@
+import { I as IncomingMessage, S as ServerResponse } from './types-DAisuVr5.js';
+import { W as WebSocket } from './websocket-XfyK23zD.js';
+import { Server } from 'http';
+import { WebSocketServer } from 'ws';
+import { C as Child } from './types-BR4wMiVx.js';
+import { E as ElitSMTPServerConfig, a as ElitSMTPServerHandle } from './types-C4gKykuG.js';
+
+type Router = ServerRouter;
+type StateManager$1 = StateManager;
+type WebSocketConnection = WebSocket;
+type WebSocketRequest = IncomingMessage;
+interface WebSocketEndpointContext {
+    ws: WebSocketConnection;
+    req: WebSocketRequest;
+    path: string;
+    query: Record<string, string>;
+    headers: Record<string, string | string[] | undefined>;
+}
+type WebSocketEndpointHandler = (ctx: WebSocketEndpointContext) => void | Promise<void>;
+interface WebSocketEndpointConfig {
+    path: string;
+    handler: WebSocketEndpointHandler;
+}
+interface ClientConfig {
+    root: string;
+    fallbackRoot?: string;
+    basePath: string;
+    index?: string;
+    ssr?: () => Child | string;
+    watch?: string[];
+    ignore?: string[];
+    proxy?: ProxyConfig[];
+    worker?: WorkerConfig[];
+    api?: Router;
+    ws?: WebSocketEndpointConfig[];
+    smtp?: ElitSMTPServerConfig | ElitSMTPServerConfig[];
+    mode?: 'dev' | 'preview';
+}
+interface ProxyConfig {
+    context: string;
+    target: string;
+    changeOrigin?: boolean;
+    pathRewrite?: Record<string, string>;
+    headers?: Record<string, string>;
+    ws?: boolean;
+}
+interface WorkerConfig {
+    path: string;
+    name?: string;
+    type?: 'module' | 'classic';
+}
+interface DevServerOptions {
+    port?: number;
+    host?: string;
+    domain?: string;
+    root?: string;
+    fallbackRoot?: string;
+    basePath?: string;
+    index?: string;
+    clients?: ClientConfig[];
+    https?: boolean;
+    open?: boolean;
+    watch?: string[];
+    ignore?: string[];
+    worker?: WorkerConfig[];
+    logging?: boolean;
+    api?: Router;
+    ws?: WebSocketEndpointConfig[];
+    smtp?: ElitSMTPServerConfig | ElitSMTPServerConfig[];
+    ssr?: () => Child | string;
+    proxy?: ProxyConfig[];
+    mode?: 'dev' | 'preview';
+    env?: Record<string, string>;
+    standalone?: boolean;
+    outDir?: string;
+    outFile?: string;
+}
+interface DevServer {
+    server: Server;
+    wss: WebSocketServer;
+    smtpServers: ElitSMTPServerHandle[];
+    url: string;
+    state: StateManager$1;
+    close: () => Promise<void>;
+}
+interface PreviewOptions {
+    port?: number;
+    host?: string;
+    domain?: string;
+    root?: string;
+    basePath?: string;
+    index?: string;
+    clients?: ClientConfig[];
+    https?: boolean;
+    open?: boolean;
+    logging?: boolean;
+    api?: Router;
+    ws?: WebSocketEndpointConfig[];
+    smtp?: ElitSMTPServerConfig | ElitSMTPServerConfig[];
+    ssr?: () => Child | string;
+    proxy?: ProxyConfig[];
+    worker?: WorkerConfig[];
+    env?: Record<string, string>;
+    standalone?: boolean;
+    outFile?: string;
+}
+
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD' | 'ALL';
+interface ElitRequest extends IncomingMessage {
+    body?: any;
+    query?: Record<string, string>;
+    params?: Record<string, string>;
+}
+interface ElitResponse extends ServerResponse {
+    json(data: any, statusCode?: number): this;
+    send(data: any): this;
+    status(code: number): this;
+}
+interface ServerRouteContext {
+    req: ElitRequest;
+    res: ElitResponse;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    body: any;
+    headers: Record<string, string | string[] | undefined>;
+    user?: any;
+}
+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;
+    use(...args: Array<any>): this;
+    all: (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: ElitRequest, res: ServerResponse, next?: () => void) => any)>) => this;
+    get: (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: ElitRequest, res: ServerResponse, next?: () => void) => any)>) => this;
+    post: (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: ElitRequest, res: ServerResponse, next?: () => void) => any)>) => this;
+    put: (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: ElitRequest, res: ServerResponse, next?: () => void) => any)>) => this;
+    delete: (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: ElitRequest, res: ServerResponse, next?: () => void) => any)>) => this;
+    patch: (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: ElitRequest, res: ServerResponse, next?: () => void) => any)>) => this;
+    options: (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: ElitRequest, res: ServerResponse, next?: () => void) => any)>) => this;
+    head: (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: ElitRequest, res: ServerResponse, next?: () => void) => any)>) => this;
+    private toMiddleware;
+    private addRoute;
+    private pathToRegex;
+    private parseQuery;
+    listRoutes(): Array<{
+        method: string;
+        pattern: string;
+        paramNames: string[];
+        handler: string;
+    }>;
+    private parseBody;
+    handle(req: IncomingMessage, res: ServerResponse): Promise<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 {
+    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;
+}
+
+export { type DevServerOptions as D, type ElitRequest as E, type HttpMethod as H, type Middleware as M, type ProxyConfig as P, type ServerRouteContext as S, type DevServer as a, type ElitResponse as b, type ServerRouteHandler as c, ServerRouter as d, SharedState as e, type SharedStateOptions as f, type StateChangeHandler as g, StateManager as h, type PreviewOptions as i };