@bjoernboss/mws 1.0.0

package/dist/client.d.ts

@@ -0,0 +1,228 @@
+import * as libLog from "./log.js";
+import * as libBuilder from "./builder.js";
+import * as libCache from "./cache.js";
+import * as libBase from "./base.js";
+import * as libStream from "stream";
+import * as libUrl from "url";
+import * as libWs from "ws";
+import * as libHttp from "http";
+declare class ClientContext {
+    dropLogTag: () => void;
+    path: string;
+    translationCount: number;
+    busyCount: number;
+    headerPatchCount: number;
+    htmlPatchCount: number;
+    constructor(path: string, translationCount: number, busyCount: number, headerPatchCount: number, htmlPatchCount: number);
+}
+declare class ClientBase extends libLog.Logger {
+    private _config;
+    protected _path: string;
+    protected _translation: Record<string, string | null>[];
+    protected constructor(url: libUrl.URL, kind: string, config: BurntClientConfig);
+    protected constructor(client: ClientBase, kind: string, config: BurntClientConfig);
+    readonly url: libUrl.URL;
+    get path(): string;
+    get config(): BurntClientConfig;
+    isSubPathOf(base: string): boolean;
+    isInsideOf(base: string): boolean;
+    makePath(path: string): string;
+}
+export type HeaderPatch = (status: libBase.StatusType, headers: Record<string, string>) => void;
+export type HtmlPatch = (page: libBuilder.HtmlPage, status: libBase.StatusType, headers: Record<string, string>) => Promise<void>;
+export declare class ClientRequest extends ClientBase {
+    private _headerPatcher;
+    private _htmlPatcher;
+    private _state;
+    private _throughput;
+    private _native;
+    private _request;
+    private _cache;
+    private constructor();
+    private constructQuickResponse;
+    private failThroughput;
+    private updateThroughput;
+    private wrapSocketWriter;
+    private killNativeConnection;
+    private markAsBroken;
+    private badClientUsage;
+    private closeHeader;
+    private sendFullResponse;
+    private sendClientSetupHeader;
+    private sendClientWrite;
+    private sendClientData;
+    private receiveClientData;
+    _pushTranslation(map: Record<string, string | null>, identity: string): ClientContext | null;
+    _restoreSnapshot(snapshot: ClientContext): void;
+    static fromRequest(protocol: string, request: libHttp.IncomingMessage, response: libHttp.ServerResponse, options?: {
+        config?: BurntClientConfig | ClientConfig;
+        cache?: libCache.CacheHost | libCache.CacheConfig | libCache.BurntCacheConfig;
+    }): ClientRequest;
+    static fromUpgrade(protocol: string, request: libHttp.IncomingMessage, socket: libStream.Duplex, head: Buffer, options?: {
+        config?: BurntClientConfig | ClientConfig;
+        cache?: libCache.CacheHost | libCache.CacheConfig | libCache.BurntCacheConfig;
+        wss?: libWs.WebSocketServer;
+    }): ClientRequest;
+    finalizeConnection(): Promise<void>;
+    killConnection(reason: string): void;
+    get cache(): libCache.CacheHost;
+    get unhandled(): boolean;
+    get claimed(): boolean;
+    get responded(): Promise<void>;
+    get completed(): Promise<void>;
+    get headers(): libHttp.IncomingHttpHeaders;
+    get method(): string;
+    get isHead(): boolean;
+    getMediaType(): string;
+    getMediaTypeCharset(defEncoding: string): string;
+    requireMediaType(types: libBase.MediaType[] | libBase.MediaType, options?: {
+        noneIsFirst?: boolean;
+        headers?: Record<string, string>;
+    }): libBase.MediaType | null;
+    requireMethod(methods: string[] | string, options?: {
+        headExplicit?: boolean;
+        headers?: Record<string, string>;
+    }): string | null;
+    busyCheck(cb: () => boolean): void;
+    patchHeaders(cb: HeaderPatch): void;
+    patchHtmlPage(cb: HtmlPatch): void;
+    respondInternalError(reason: string, options?: {
+        headers?: Record<string, string>;
+    }): void;
+    respondForbidden(reason: string, options?: {
+        headers?: Record<string, string>;
+    }): void;
+    respond(content: string | Buffer | null, options?: {
+        media?: libBase.MediaType;
+        status?: libBase.StatusType;
+        headers?: Record<string, string>;
+        lightResponse?: boolean;
+    }): void;
+    respondOk(options?: {
+        message?: string;
+        headers?: Record<string, string>;
+    }): void;
+    respondCreated(target: string, options?: {
+        headers?: Record<string, string>;
+    }): void;
+    respondNotModified(options?: {
+        etag?: string;
+        lastModified?: string;
+        headers?: Record<string, string>;
+    }): void;
+    respondPreconditionFailed(reason: string, options?: {
+        etag?: string;
+        lastModified?: string;
+        headers?: Record<string, string>;
+    }): void;
+    respondBadRequest(reason: string, options?: {
+        headers?: Record<string, string>;
+    }): void;
+    respondRangeIssue(range: string, size: number, options?: {
+        headers?: Record<string, string>;
+    }): void;
+    respondConflict(conflict: string, options?: {
+        headers?: Record<string, string>;
+    }): void;
+    respondNotFound(options?: {
+        headers?: Record<string, string>;
+    }): void;
+    respondUnsupported(used: string, allowed: string, options?: {
+        headers?: Record<string, string>;
+    }): void;
+    respondMethodNotAllowed(method: string, allowed: string, options?: {
+        headers?: Record<string, string>;
+    }): void;
+    respondRequestTimeout(reason: string, options?: {
+        headers?: Record<string, string>;
+    }): void;
+    respondContentTooLarge(allowed: number, atLeastProvided: number, options?: {
+        headers?: Record<string, string>;
+    }): void;
+    respondUpdateRequired(upgrade: string, options?: {
+        headers?: Record<string, string>;
+    }): void;
+    respondSeeOther(target: string, options?: {
+        headers?: Record<string, string>;
+    }): void;
+    respondTemporaryRedirect(target: string, options?: {
+        headers?: Record<string, string>;
+    }): void;
+    respondPermanentRedirect(target: string, options?: {
+        headers?: Record<string, string>;
+    }): void;
+    respondHtml(page: libBuilder.HtmlPage, options?: {
+        status?: libBase.StatusType;
+        headers?: Record<string, string>;
+    }): Promise<void>;
+    respondData(options?: {
+        status?: libBase.StatusType;
+        media?: libBase.MediaType;
+        contentSize?: number;
+        dynamicEncode?: boolean;
+        headers?: Record<string, string>;
+    }): libStream.Writable;
+    tryRespondFile(filePath: string, options?: {
+        encoded?: string;
+        media?: libBase.MediaType;
+        headers?: Record<string, string>;
+        checkFreshness?: boolean;
+    }): Promise<boolean>;
+    receiveToFile(path: string, maxLength: number | null): Promise<void>;
+    receiveData(maxLength: number | null): libStream.Readable;
+    receiveAllBuffer(maxLength: number | null): Promise<Buffer>;
+    receiveAllText(encoding: string, maxLength: number | null): Promise<string>;
+    acceptWebSocket(): Promise<ClientSocket | null>;
+}
+export declare class ClientSocket extends ClientBase {
+    private _ws;
+    private _alive;
+    private _closing;
+    private _emitter;
+    private _extension;
+    private constructor();
+    private checkIsAlive;
+    private selfIsAlive;
+    private handleClosing;
+    static _fromRequest(ws: libWs.WebSocket, source: ClientRequest): ClientSocket;
+    send(data: string | Buffer): void;
+    close(): Promise<void>;
+    on<K extends keyof ClientSocketEvents>(event: K, listener: ClientSocketEvents[K]): ClientSocket;
+    off<K extends keyof ClientSocketEvents>(event: K, listener: ClientSocketEvents[K]): ClientSocket;
+    once<K extends keyof ClientSocketEvents>(event: K, listener: ClientSocketEvents[K]): ClientSocket;
+    private emitEventSync;
+}
+type ClientSocketEvents = {
+    'data': (data: Buffer) => void;
+    'close': () => void;
+};
+export interface ClientConfig {
+    serverName?: string;
+    commonHeaders?: Record<string, string>;
+    webSocketTimeout?: number;
+    webSocketAliveTimeout?: number;
+    killGraceTimeout?: number;
+    fileCacheControl?: string;
+    immutableCacheControl?: string;
+    responseCacheControl?: string;
+    throughputGrace?: number;
+    throughputThreshold?: number;
+    throughputWindow?: number;
+}
+export declare class BurntClientConfig {
+    readonly serverName: string;
+    readonly commonHeaders: Record<string, string>;
+    readonly webSocketTimeout: number;
+    readonly webSocketAliveTimeout: number;
+    readonly killGraceTimeout: number;
+    readonly fileCacheControl: string;
+    readonly immutableCacheControl: string;
+    readonly responseCacheControl: string;
+    readonly throughputGrace: number;
+    readonly throughputThreshold: number;
+    readonly throughputWindow: number;
+    constructor(config?: ClientConfig);
+    static from(config?: ClientConfig | BurntClientConfig): BurntClientConfig;
+}
+export {};
+//# sourceMappingURL=client.d.ts.map