elysia 1.4.28 → 2.0.0-beta.0

package/dist/utils.d.ts

@@ -1,209 +1,180 @@
-import type { Sucrose } from './sucrose';
-import type { LifeCycleStore, MaybeArray, InputSchema, LifeCycleType, HookContainer, Replace, SchemaValidator, AnyLocalHook, SSEPayload, Prettify } from './types';
-import { ElysiaFile } from './universal/file';
-export declare const replaceUrlPath: (url: string, pathname: string) => string;
-export declare const isClass: (v: Object) => boolean;
-export declare const mergeDeep: <A extends Record<string, any>, B extends Record<string, any>>(target: A, source: B, options?: {
-    skipKeys?: string[];
-    override?: boolean;
-    mergeArray?: boolean;
-    seen?: WeakSet<object>;
-}) => A & B;
-export declare const mergeCookie: <const A extends Object, const B extends Object>(a: A, b: B) => A & B;
-export declare const mergeObjectArray: <T extends HookContainer>(a: T | T[] | undefined, b: T | T[] | undefined) => T[] | undefined;
-export declare const primitiveHooks: readonly ["start", "request", "parse", "transform", "resolve", "beforeHandle", "afterHandle", "mapResponse", "afterResponse", "trace", "error", "stop", "body", "headers", "params", "query", "response", "type", "detail"];
-export declare const mergeResponse: (a: InputSchema["response"], b: InputSchema["response"]) => string | import("@sinclair/typebox").TSchema | import("./types").StandardSchemaV1Like<unknown, unknown> | {
-    [x: number]: string | import("./types").AnySchema;
-} | undefined;
-export declare const mergeSchemaValidator: (a?: SchemaValidator | null, b?: SchemaValidator | null) => SchemaValidator;
-export declare const mergeHook: (a?: Partial<LifeCycleStore>, b?: AnyLocalHook) => LifeCycleStore;
-export declare const lifeCycleToArray: (a: LifeCycleStore) => LifeCycleStore;
-export declare const hasHeaderShorthand: boolean;
-export declare const hasSetImmediate: boolean;
-export declare const checksum: (s: string) => number;
-export declare const injectChecksum: (checksum: number | undefined, x: MaybeArray<HookContainer> | undefined) => HookContainer | HookContainer[] | undefined;
-export declare const mergeLifeCycle: (a: Partial<LifeCycleStore>, b: Partial<LifeCycleStore | AnyLocalHook>, checksum?: number) => LifeCycleStore;
-export declare const asHookType: (fn: HookContainer, inject: LifeCycleType, { skipIfHasType }: {
-    skipIfHasType?: boolean;
-}) => HookContainer;
-export declare const filterGlobalHook: (hook: AnyLocalHook) => AnyLocalHook;
-export declare const StatusMap: {
-    readonly Continue: 100;
-    readonly 'Switching Protocols': 101;
-    readonly Processing: 102;
-    readonly 'Early Hints': 103;
-    readonly OK: 200;
-    readonly Created: 201;
-    readonly Accepted: 202;
-    readonly 'Non-Authoritative Information': 203;
-    readonly 'No Content': 204;
-    readonly 'Reset Content': 205;
-    readonly 'Partial Content': 206;
-    readonly 'Multi-Status': 207;
-    readonly 'Already Reported': 208;
-    readonly 'Multiple Choices': 300;
-    readonly 'Moved Permanently': 301;
-    readonly Found: 302;
-    readonly 'See Other': 303;
-    readonly 'Not Modified': 304;
-    readonly 'Temporary Redirect': 307;
-    readonly 'Permanent Redirect': 308;
-    readonly 'Bad Request': 400;
-    readonly Unauthorized: 401;
-    readonly 'Payment Required': 402;
-    readonly Forbidden: 403;
-    readonly 'Not Found': 404;
-    readonly 'Method Not Allowed': 405;
-    readonly 'Not Acceptable': 406;
-    readonly 'Proxy Authentication Required': 407;
-    readonly 'Request Timeout': 408;
-    readonly Conflict: 409;
-    readonly Gone: 410;
-    readonly 'Length Required': 411;
-    readonly 'Precondition Failed': 412;
-    readonly 'Payload Too Large': 413;
-    readonly 'URI Too Long': 414;
-    readonly 'Unsupported Media Type': 415;
-    readonly 'Range Not Satisfiable': 416;
-    readonly 'Expectation Failed': 417;
-    readonly "I'm a teapot": 418;
-    readonly 'Enhance Your Calm': 420;
-    readonly 'Misdirected Request': 421;
-    readonly 'Unprocessable Content': 422;
-    readonly Locked: 423;
-    readonly 'Failed Dependency': 424;
-    readonly 'Too Early': 425;
-    readonly 'Upgrade Required': 426;
-    readonly 'Precondition Required': 428;
-    readonly 'Too Many Requests': 429;
-    readonly 'Request Header Fields Too Large': 431;
-    readonly 'Unavailable For Legal Reasons': 451;
-    readonly 'Internal Server Error': 500;
-    readonly 'Not Implemented': 501;
-    readonly 'Bad Gateway': 502;
-    readonly 'Service Unavailable': 503;
-    readonly 'Gateway Timeout': 504;
-    readonly 'HTTP Version Not Supported': 505;
-    readonly 'Variant Also Negotiates': 506;
-    readonly 'Insufficient Storage': 507;
-    readonly 'Loop Detected': 508;
-    readonly 'Not Extended': 510;
-    readonly 'Network Authentication Required': 511;
+import { AnyLocalHook, AppHook, ElysiaFormData, EventFn, EventScope, GuardSchemaType, InputSchema, Macro, MaybeArray, Prettify, SSEPayload } from "./types.js";
+import { Context } from "./context.js";
+import { AnySchema, StandardSchemaV1Like } from "./type/types.js";
+
+//#region src/utils.d.ts
+type DeriveEntry = Function | readonly [Function, 'mapDerive'];
+declare const nullObject: () => any;
+declare const mapDeriveEntry: (fn: Function) => DeriveEntry;
+declare const deriveEntryFn: (entry: DeriveEntry) => any;
+declare const isMapDeriveEntry: (entry: DeriveEntry) => boolean;
+declare function isEmpty<T extends Object>(obj: T): boolean;
+declare const isNotEmpty: <T extends Object>(obj?: T) => boolean | undefined;
+/**
+ * @internal Generational cache eviction at cap, drop the oldest half.
+ *
+ * `map.delete(oldest)` per insert leaks ~1KB/eviction on JSC in ~1/3 of
+ * processes (churned bucket cells permanently grow the heap and are never
+ * reclaimed); clear + reinsert of the newest half measures clean and
+ * amortizes to O(1) per insertion.
+ */
+declare function evictOldestHalf(cache: Map<any, any>): void;
+declare function fnv1a(str: string): number;
+/**
+ * Maps each lifecycle/derive function to the hash of the named plugin it was
+ * first registered on. Used by `.use()` to dedup absorbed hooks: if a fn's
+ * origin is already in `parent.#apps`, the parent has already absorbed that
+ * named plugin via another path and should skip re-adding the fn.
+ *
+ * Anonymous plugins (no name) don't tag their fns - there's no hash to dedup
+ * by, so their fns always propagate.
+ */
+declare const fnOrigin: WeakMap<Function, number>;
+declare const macroOrigin: WeakMap<object | Function, number>;
+declare const isLocalScope: (s: EventScope | undefined) => s is "local" | undefined;
+/**
+ * Linked-list representation of the scope/global hook chain of a route
+ *
+ * Each `.use()` that propagates extends the parent instance's chain
+ * by one node; routes absorbed in that `.use()` snapshot the head pointer
+ *
+ * - O(1) per stamp, O(N) memory per instance regardless of route count
+ *
+ * shapes:
+ * 1. "standard" node: `added` + `parent` set, `combine`/`over` undefined
+ * 2. "combine" node: `combine` + `over` set, `added`/`parent` undefined
+ *
+ * Combine nodes appear at multi-level absorption (parent.use(child) when
+ * child's routes already had their own chain): they link two sibling chains
+ * without flattening - `over` is walked first (older / outer context),
+ * then `combine` (newer / inner context)
+ *
+ * Use with {@link flattenChain} to walk tail-first and reconstruct
+ * flat `Partial<AppHook>` at compile time
+ */
+type ChainNode = {
+  added: Partial<AppHook>;
+  parent: ChainNode | undefined;
+  refs: boolean;
+  scope?: EventScope;
+  propagated?: boolean;
+  owner?: object;
+} | {
+  combine: ChainNode;
+  over: ChainNode | undefined;
+  refs: boolean;
 };
-export declare const InvertedStatusMap: { [K in keyof StatusMap as StatusMap[K]]: K; };
-export type StatusMap = typeof StatusMap;
-export type InvertedStatusMap = typeof InvertedStatusMap;
-export declare const signCookie: (val: string, secret: string | null) => Promise<string>;
-export declare const unsignCookie: (input: string, secret: string | null) => Promise<string | false>;
-export declare const insertStandaloneValidator: <const Name extends keyof InputSchema>(hook: {
-    standaloneValidator: InputSchema[];
-}, name: Name, value: InputSchema[Name]) => void;
-export declare const isNumericString: (message: string | number) => boolean;
-export declare class PromiseGroup implements PromiseLike<void> {
-    onError: (error: any) => void;
-    onFinally: () => void;
-    root: Promise<any> | null;
-    promises: Promise<any>[];
-    constructor(onError?: (error: any) => void, onFinally?: () => void);
-    /**
-     * The number of promises still being awaited.
-     */
-    get size(): number;
-    /**
-     * Add a promise to the group.
-     * @returns The promise that was added.
-     */
-    add<T>(promise: Promise<T>): Promise<T>;
-    private drain;
-    then<TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
+interface CompactBeforeHandleChunk {
+  parent?: CompactBeforeHandleChunk;
+  values: readonly Function[];
 }
-export declare const fnToContainer: (fn: MaybeArray<Function | HookContainer>, 
-/** Only add subType to non contained fn */
-subType?: HookContainer["subType"]) => MaybeArray<HookContainer>;
-export declare const localHookToLifeCycleStore: (a: AnyLocalHook) => LifeCycleStore;
-export declare const lifeCycleToFn: (a: Partial<LifeCycleStore>) => AnyLocalHook;
-export declare const cloneInference: (inference: Sucrose.Inference) => {
-    body: boolean;
-    cookie: boolean;
-    headers: boolean;
-    query: boolean;
-    set: boolean;
-    server: boolean;
-    path: boolean;
-    route: boolean;
-    url: boolean;
-};
+interface CompactBeforeHandlePrefix {
+  tail?: CompactBeforeHandleChunk;
+  length: number;
+  previous?: CompactBeforeHandlePrefix;
+  added: readonly Function[];
+}
+declare const isCompactBeforeHandleOnly: (hook: Partial<AppHook> | undefined) => boolean;
+declare function compactBeforeHandleConflicts(hook: Partial<AppHook> | undefined): boolean;
+declare function compactBeforeHandlePrefix(start: ChainNode | undefined): CompactBeforeHandlePrefix | undefined;
+/**
+ * Walk the chain tail-first into a fresh `Partial<AppHook>`
+ *
+ * Explicit-stack walk (no recursion) so it works uniformly for linear
+ * chains and combine nodes without risking stack overflow on deep chains
+ */
+declare function flattenChain(start: ChainNode | undefined, keep?: (s: EventScope | undefined) => boolean, stopAt?: ChainNode, resolveAdded?: (node: ChainNode) => Partial<AppHook> | undefined): Partial<AppHook> | undefined;
+declare const macroEpoch: () => number;
+declare const invalidateMacroEpoch: () => void;
+/** Drop this root's flattened-chain memo. Recomputable on next compile. */
+declare function clearFlattenChainMemo(root: object): void;
+declare function flattenChainMemo(root: object, start: ChainNode | undefined, resolveAdded?: (node: ChainNode) => Partial<AppHook> | undefined): Partial<AppHook> | undefined;
+declare function flattenChainMemoReadonly(root: object, start: ChainNode | undefined, resolveAdded?: (node: ChainNode) => Partial<AppHook> | undefined): Partial<AppHook> | undefined;
 /**
  *
  * @param url URL to redirect to
  * @param HTTP status code to send,
  */
-export declare const redirect: (url: string, status?: 301 | 302 | 303 | 307 | 308) => Response;
-export type redirect = typeof redirect;
-export declare const ELYSIA_FORM_DATA: unique symbol;
-export type ELYSIA_FORM_DATA = typeof ELYSIA_FORM_DATA;
-type IsTuple<T> = T extends readonly any[] ? number extends T['length'] ? false : true : false;
-export type ElysiaFormData<T extends Record<keyof any, unknown>> = FormData & {
-    [ELYSIA_FORM_DATA]: Replace<T, Blob | ElysiaFile, File> extends infer A ? {
-        [key in keyof A]: IsTuple<A[key]> extends true ? A[key][number] extends Blob | ElysiaFile ? File[] : A[key] : A[key];
-    } : T;
-};
-export declare const ELYSIA_REQUEST_ID: unique symbol;
-export type ELYSIA_REQUEST_ID = typeof ELYSIA_REQUEST_ID;
-export declare const form: <const T extends Record<keyof any, unknown>>(items: T) => ElysiaFormData<T>;
+declare const redirect: (url: string, status?: 301 | 302 | 303 | 307 | 308) => Response;
+type redirect = typeof redirect;
+/**
+ * Build `FormData` from a `form()` object, skipping the internal `~ely-form`
+ * marker that flags the object as a form.
+ */
+declare function formToFormData(value: Record<keyof any, unknown>): FormData;
 /**
- * Generates a random ID for schema identification.
+ * Return a `multipart/form-data` response.
  *
- * Uses crypto.randomUUID() when available, with a Math.random() fallback
- * for environments where crypto.randomUUID() throws an error
- * (e.g., Cloudflare Workers global scope).
+ * @example
+ * ```ts
+ * import { Elysia, form, file } from 'elysia'
  *
- * @see https://developers.cloudflare.com/workers/runtime-apis/handlers/
+ * new Elysia().get('/', () =>
+ * 	form({
+ * 		name: 'Tea Party',
+ * 		images: [file('1.webp'), file('2.webp')]
+ * 	})
+ * )
+ * ```
  */
-export declare const randomId: () => string;
-export declare const deduplicateChecksum: <T extends Function>(array: HookContainer<T>[]) => HookContainer<T>[];
+declare const form: <const T extends Record<keyof any, unknown>>(value: T) => ElysiaFormData<T>;
+declare const getLoosePath: (path: string) => string;
 /**
- * Since it's a plugin, which means that ephemeral is demoted to volatile.
- * Which  means there's no volatile and all previous ephemeral become volatile
- * We can just promote back without worry
+ * Certify a byte stream for direct Response body pass-through.
+ *
+ * The returned Response owns this exact stream. Cancel it through the response
+ * body reader; preserving identity means Elysia does not install a second
+ * request-signal reader after the body is locked.
  */
-export declare const promoteEvent: (events?: (HookContainer | Function)[], as?: "scoped" | "global") => void;
-export declare const getLoosePath: (path: string) => string;
-export declare const isNotEmpty: (obj?: Object) => boolean;
-export declare const encodePath: (path: string, { dynamic }?: {
-    dynamic?: boolean | undefined;
-}) => string;
-export declare const supportPerMethodInlineHandler: boolean;
+declare function bytes<T extends ReadableStream<Uint8Array>>(stream: T): T;
+declare const isByteStream: (value: unknown) => value is ReadableStream<Uint8Array>;
 type FormatSSEPayload<T = unknown> = T extends string ? {
-    readonly data: T;
+  readonly data: T;
 } : Prettify<SSEPayload<T>>;
+declare const sse: <const T extends string | SSEPayload | Generator | AsyncGenerator | ReadableStream>(_payload: T) => T extends string ? {
+  readonly data: T;
+} : T extends SSEPayload ? T : T extends ReadableStream<infer A> ? ReadableStream<FormatSSEPayload<A>> : T extends Generator<infer A, infer B, infer C> ? Generator<FormatSSEPayload<A>, B, C> : T extends AsyncGenerator<infer A, infer B_1, infer C_1> ? AsyncGenerator<FormatSSEPayload<A>, B_1, C_1> : T;
+declare const constantTimeEqual: (a: string, b: string) => boolean;
+declare const isRecordNumber: (x: Record<keyof object, unknown> | undefined) => x is Record<number, unknown>;
+declare function mergeResponse(a: InputSchema['response'], b: InputSchema['response']): string | {
+  '~kind': string;
+} | {
+  '~unsafe': unknown;
+} | {
+  '~refine': unknown;
+} | {
+  '~codec': unknown;
+} | StandardSchemaV1Like<unknown, unknown> | Record<number, string | AnySchema> | undefined;
 /**
- * Return a Server Sent Events (SSE) payload
- *
- * @example
- * ```ts
- * import { sse } from 'elysia'
+ * a is mutable, b is immutable
  *
- * new Elysia()
- *   .get('/sse', function*() {
- *     yield sse('Hello, world!')
- *     yield sse({
- *       event: 'message',
- *       data: { message: 'This is a JSON object' }
- *     })
- *   }
+ * If both are arrays, mutates a by pushing/appending b
  */
-export declare const sse: <const T extends string | SSEPayload | Generator | AsyncGenerator | ReadableStream>(_payload: T) => T extends string ? {
-    readonly data: T;
-} : T extends SSEPayload ? T : T extends ReadableStream<infer A> ? ReadableStream<FormatSSEPayload<A>> : T extends Generator<infer A, infer B, infer C> ? Generator<FormatSSEPayload<A>, B, C> : T extends AsyncGenerator<infer A, infer B_1, infer C_1> ? AsyncGenerator<FormatSSEPayload<A>, B_1, C_1> : T;
-export declare function getResponseLength(response: Response): Promise<number>;
-export declare const emptySchema: {
-    readonly headers: true;
-    readonly cookie: true;
-    readonly query: true;
-    readonly params: true;
-    readonly body: true;
-    readonly response: true;
-};
-export declare function deepClone<T>(source: T, weak?: WeakMap<object, any>): T;
-export {};
+declare function mergeArray<A extends MaybeArray<unknown> | undefined, B extends MaybeArray<unknown> | undefined>(a: A, b: B, reverse?: boolean): (A extends unknown[] ? A : []) | (B extends unknown[] ? B : []);
+declare const schemaProperties: Set<string>;
+declare const eventProperties: Set<string>;
+declare function hookToGuard(a: Partial<AppHook & Macro> & {
+  schema?: GuardSchemaType;
+}): Partial<AppHook & Macro>;
+declare function coalesceSchemas(existing: any[], incoming: any[]): void;
+declare function mergeHook(a: Partial<AppHook>, b: Partial<AppHook> | undefined, reverse?: boolean, dedup?: boolean): Partial<AppHook>;
+declare const createErrorEventHandler: (fn: EventFn<"error">, error: Error) => (context: Context) => unknown;
+declare function mergeDeep<A extends Record<string, any>, B extends Record<string, any>>(target: A, source: B, skipKeys?: string[], override?: boolean, mergeArray?: boolean, seen?: WeakSet<object>, cloneAdopt?: {
+  map?: WeakMap<object, any>;
+}): A & B;
+declare const isBlob: (value: unknown) => value is Blob;
+declare function cloneHook<T extends Partial<AnyLocalHook> | Partial<AppHook>>(src: T): T;
+declare function clonePlainDeep<T>(value: T, seen?: WeakMap<object, any>): T;
+declare function guardNonPlainLeaves(target: Record<string, unknown>, source: Record<string, unknown>): void;
+declare function joinPath(base: string, path: string): string;
+declare function pushField<K extends keyof any>(target: Record<K, unknown>, key: K, item: unknown, defaultArray?: boolean): void;
+declare const requestId: any;
+declare function replaceUrlPath(url: string, path: string): string;
+declare function clonePlainDecorators<T extends Record<string, unknown>>(source: T, seen?: WeakMap<object, any>): T;
+declare function prefix<T extends string, Models extends Record<string, AnySchema>>(prefix: T, models: Models): { [k in keyof Models as `${T}.${k & string}`]: Models[k] };
+declare namespace prefix {
+  var capitalize: <T extends string, Models extends Record<string, AnySchema>>(prefix: T, models: Models) => { [k in keyof Models as `${T}.${Capitalize<k & string>}`]: Models[k] };
+}
+declare function serializeMacroSeed(_key: string, value: unknown): unknown;
+//#endregion
+export { ChainNode, CompactBeforeHandleChunk, CompactBeforeHandlePrefix, DeriveEntry, bytes, clearFlattenChainMemo, cloneHook, clonePlainDecorators, clonePlainDeep, coalesceSchemas, compactBeforeHandleConflicts, compactBeforeHandlePrefix, constantTimeEqual, createErrorEventHandler, deriveEntryFn, eventProperties, evictOldestHalf, flattenChain, flattenChainMemo, flattenChainMemoReadonly, fnOrigin, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isByteStream, isCompactBeforeHandleOnly, isEmpty, isLocalScope, isMapDeriveEntry, isNotEmpty, isRecordNumber, joinPath, macroEpoch, macroOrigin, mapDeriveEntry, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, replaceUrlPath, requestId, schemaProperties, serializeMacroSeed, sse };