@fkn/lib 0.6.0 → 0.6.1

package/lib/webvpn/http.d.ts

@@ -1,180 +0,0 @@
-import type { IncomingHttpHeaders, OutgoingHttpHeaders, RequestOptions } from 'http';
-import { Stream } from 'stream';
-import { Buffer } from 'buffer';
-import { Socket as NetSocket, Server as NetServer } from './net';
-export declare const METHODS: string[];
-export declare const STATUS_CODES: Record<number, string>;
-export interface ParsedHead {
-    /** request only */
-    method?: string;
-    /** request only */
-    url?: string;
-    /** response only */
-    statusCode?: number;
-    /** response only */
-    statusMessage?: string;
-    httpVersionMajor: number;
-    httpVersionMinor: number;
-    httpVersion: string;
-    headers: IncomingHttpHeaders;
-    rawHeaders: string[];
-}
-interface ParserHandlers {
-    onHeaders: (head: ParsedHead) => void;
-    onBody: (chunk: Uint8Array) => void;
-    onComplete: () => void;
-}
-export declare class HTTPParser {
-    private readonly mode;
-    private readonly handlers;
-    private buf;
-    private state;
-    private framing;
-    private bodyRemaining;
-    private chunkState;
-    skipBody: boolean;
-    constructor(mode: 'request' | 'response', handlers: ParserHandlers);
-    execute(chunk: Uint8Array): void;
-    finish(): void;
-    private reset;
-    private parseHead;
-    private applyVersion;
-    private addHeader;
-    private setupBody;
-    private consumeBody;
-    private consumeChunked;
-}
-export declare class IncomingMessage extends Stream.Readable {
-    httpVersion: string;
-    httpVersionMajor: number;
-    httpVersionMinor: number;
-    headers: IncomingHttpHeaders;
-    rawHeaders: string[];
-    trailers: Record<string, string>;
-    rawTrailers: string[];
-    /** request only */
-    method?: string;
-    /** request only */
-    url?: string;
-    /** response only */
-    statusCode?: number;
-    /** response only */
-    statusMessage?: string;
-    complete: boolean;
-    socket: NetSocket;
-    constructor(socket: NetSocket);
-    get connection(): NetSocket;
-    _applyHead(head: ParsedHead): void;
-    _read(): void;
-    setTimeout(msecs: number, callback?: () => void): this;
-}
-declare abstract class OutgoingMessage extends Stream.Writable {
-    private _headerStore;
-    headersSent: boolean;
-    chunkedEncoding: boolean;
-    finished: boolean;
-    protected _bodyWritten: boolean;
-    abstract socket: NetSocket | null;
-    setHeader(name: string, value: number | string | readonly string[]): this;
-    getHeader(name: string): number | string | string[] | undefined;
-    getHeaderNames(): string[];
-    getHeaders(): OutgoingHttpHeaders;
-    hasHeader(name: string): boolean;
-    removeHeader(name: string): void;
-    protected _storeHeader(startLine: string): string;
-    protected abstract _shouldSendBody(): boolean;
-    protected abstract _implicitHeader(): void;
-    protected _writeToSocket(data: Buffer, callback: (error?: Error | null) => void): void;
-    write(chunk: unknown, encoding?: BufferEncoding | ((error: Error | null | undefined) => void), callback?: (error: Error | null | undefined) => void): boolean;
-    _write(chunk: Buffer, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
-    _final(callback: (error?: Error | null) => void): void;
-    end(chunk?: unknown, encoding?: BufferEncoding | (() => void), callback?: () => void): this;
-    protected _headBlock?: string;
-}
-export interface ServerResponseOptions {
-    req: IncomingMessage;
-}
-export declare class ServerResponse extends OutgoingMessage {
-    statusCode: number;
-    statusMessage?: string;
-    private _writeHeadCalled;
-    sendDate: boolean;
-    req: IncomingMessage;
-    socket: NetSocket | null;
-    _keepAlive: boolean;
-    constructor(req: IncomingMessage);
-    protected _shouldSendBody(): boolean;
-    writeHead(statusCode: number, statusMessage?: string | OutgoingHttpHeaders | OutgoingHttpHeaders[keyof OutgoingHttpHeaders][], headers?: OutgoingHttpHeaders): this;
-    private _appendHeader;
-    protected _implicitHeader(): void;
-    writeContinue(): void;
-    setTimeout(msecs: number, callback?: () => void): this;
-}
-export interface ClientRequestArgs extends RequestOptions {
-    host?: string;
-    hostname?: string;
-    port?: number | string;
-    path?: string;
-}
-export declare class ClientRequest extends OutgoingMessage {
-    method: string;
-    path: string;
-    host: string;
-    protocol: string;
-    socket: NetSocket;
-    /** alias retained for Node compatibility */
-    get connection(): NetSocket;
-    res: IncomingMessage | null;
-    aborted: boolean;
-    private _aborted;
-    constructor(options: ClientRequestArgs, callback?: (res: IncomingMessage) => void);
-    protected _shouldSendBody(): boolean;
-    protected _implicitHeader(): void;
-    private _attachResponseParser;
-    abort(): void;
-    destroy(error?: Error): this;
-    end(chunk?: unknown, encoding?: unknown, callback?: unknown): this;
-    protected _writeToSocket(data: Buffer, callback: (error?: Error | null) => void): void;
-    setTimeout(timeout: number, callback?: () => void): this;
-    setNoDelay(noDelay?: boolean): void;
-    setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
-}
-export type RequestListener = (req: IncomingMessage, res: ServerResponse) => void;
-declare class ServerImpl extends NetServer {
-    constructor(options?: object | RequestListener, requestListener?: RequestListener);
-    private _handleConnection;
-}
-export declare const Server: typeof ServerImpl;
-export type Server = ServerImpl;
-export declare class Agent {
-    maxSockets: number;
-    maxFreeSockets: number;
-    keepAlive: boolean;
-    options: Record<string, unknown>;
-    constructor(options?: Record<string, unknown>);
-    getName(options?: {
-        host?: string;
-        port?: number;
-        localAddress?: string;
-    }): string;
-    destroy(): void;
-}
-export declare const globalAgent: Agent;
-export declare const request: (...args: [options: string | URL | ClientRequestArgs, callback?: (res: IncomingMessage) => void] | [url: string | URL, options: ClientRequestArgs, callback?: (res: IncomingMessage) => void]) => ClientRequest;
-export declare const get: (...args: [options: string | URL | ClientRequestArgs, callback?: (res: IncomingMessage) => void] | [url: string | URL, options: ClientRequestArgs, callback?: (res: IncomingMessage) => void]) => ClientRequest;
-export declare const createServer: (options?: object | RequestListener, requestListener?: RequestListener) => Server;
-export declare const _default: {
-    METHODS: string[];
-    STATUS_CODES: Record<number, string>;
-    Agent: typeof Agent;
-    globalAgent: Agent;
-    Server: typeof ServerImpl;
-    ServerResponse: typeof ServerResponse;
-    IncomingMessage: typeof IncomingMessage;
-    ClientRequest: typeof ClientRequest;
-    OutgoingMessage: typeof OutgoingMessage;
-    createServer: typeof createServer;
-    request: typeof request;
-    get: typeof get;
-};
-export default _default;

package/lib/webvpn/index.d.ts

@@ -1 +0,0 @@
-export * from './utils';

package/lib/webvpn/net.d.ts

@@ -1,132 +0,0 @@
-import type { Socket as NetSocket, SocketConnectOpts, SocketConstructorOpts, Server as TCPServer, ServerOpts, ListenOptions, AddressInfo } from 'net';
-import type { Resolvers } from '../api';
-import { DuplexOptions, Stream } from 'stream';
-type WebVpnTcpSocket = Resolvers['cloud']['webvpn']['tcpSocket'];
-type WebVpnTcpSocketListener = Resolvers['cloud']['webvpn']['tcpSocketListener'];
-import { EventEmitter } from 'events';
-import { isIP, isIPv4, isIPv6 } from './utils';
-export declare class Socket extends Stream.Duplex implements NetSocket {
-    _localAddress?: {
-        address: string;
-        family: string;
-        port: number;
-    };
-    _remoteAddress?: {
-        address: string;
-        family: string;
-        port: number;
-    };
-    _webVPNTcpSocketPromise?: Promise<(Awaited<ReturnType<WebVpnTcpSocket>> & {
-        reader: ReadableStreamDefaultReader<Uint8Array>;
-        writer: WritableStreamDefaultWriter<Uint8Array>;
-    }) | undefined>;
-    constructor(options?: SocketConstructorOpts & DuplexOptions & {
-        connection?: ReturnType<WebVpnTcpSocket>;
-    });
-    __webvpn_tcp_socket_init__(connection: ReturnType<WebVpnTcpSocket>): Promise<(import("../../api/local-net").LocalTcpSocket & {
-        reader: ReadableStreamDefaultReader<Uint8Array>;
-        writer: WritableStreamDefaultWriter<Uint8Array>;
-    }) | undefined>;
-    /** STREAM IMPL */
-    _read(size: number): void;
-    _write(chunk: Uint8Array, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
-    /** SOCKET IMPL */
-    connect(options: SocketConnectOpts, connectionListener?: (() => void) | undefined): this;
-    connect(port: number, host: string, connectionListener?: (() => void) | undefined): this;
-    connect(port: number, connectionListener?: (() => void) | undefined): this;
-    connect(path: string, connectionListener?: (() => void) | undefined): this;
-    connect(port: unknown, host?: unknown, connectionListener?: unknown): this;
-    _end(chunk: any, cb?: () => void): this;
-    _end(chunk: any, encoding?: BufferEncoding, cb?: () => void): this;
-    _destroy(error?: Error | null | undefined): this;
-    destroySoon(): void;
-    resetAndDestroy(): this;
-    _timeoutMs?: number;
-    _timeoutTimer?: ReturnType<typeof setTimeout>;
-    _restartTimeoutTimer(): void;
-    setTimeout(timeout: number, callback?: (() => void) | undefined): this;
-    setNoDelay(noDelay?: boolean | undefined): this;
-    setKeepAlive(enable?: boolean | undefined, initialDelay?: number | undefined): this;
-    setSendBufferSize(size: number): this;
-    setRecvBufferSize(size: number): this;
-    _typeOfService?: number;
-    getTypeOfService(): number;
-    setTypeOfService(tos: number): this;
-    _setTcpOption(option: import('../../api/webvpn/tcp').TcpSocketOption): void;
-    write(buffer: Uint8Array | string, cb?: (err?: Error) => void): boolean;
-    write(str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error) => void): boolean;
-    address(): AddressInfo | {};
-    unref(): this;
-    ref(): this;
-    autoSelectFamilyAttemptedAddresses: string[];
-    bufferSize: number;
-    bytesRead: number;
-    bytesWritten: number;
-    connecting: boolean;
-    pending: boolean;
-    get localAddress(): string;
-    get localPort(): number;
-    get localFamily(): string;
-    readyState: 'opening' | 'open' | 'readOnly' | 'writeOnly' | 'closed';
-    get remoteAddress(): string;
-    get remotePort(): number;
-    get remoteFamily(): string;
-    timeout?: number | undefined;
-}
-interface EventEmitterOptions {
-    /**
-     * Enables automatic capturing of promise rejection.
-     */
-    captureRejections?: boolean | undefined;
-}
-export declare class Server extends EventEmitter implements TCPServer {
-    _localAddress?: {
-        address: string;
-        family: string;
-        port: number;
-    };
-    _webVPNTcpSocketListenerPromise?: Promise<Awaited<ReturnType<WebVpnTcpSocketListener>> | undefined>;
-    constructor(options?: ServerOpts & EventEmitterOptions & {
-        connection?: ReturnType<WebVpnTcpSocketListener>;
-    }, connectionListener?: (socket: Socket) => void);
-    __webvpn_tcp_socket_listener_init__(connection: ReturnType<WebVpnTcpSocketListener>): Promise<{
-        localAddress: string;
-        localFamily: "IPv4" | "IPv6";
-        localPort: number;
-        close: () => Promise<void>;
-    } | undefined>;
-    listen(port?: number | undefined, hostname?: string | undefined, backlog?: number | undefined, listeningListener?: (() => void) | undefined): this;
-    listen(port?: number | undefined, hostname?: string | undefined, listeningListener?: (() => void) | undefined): this;
-    listen(port?: number | undefined, backlog?: number | undefined, listeningListener?: (() => void) | undefined): this;
-    listen(port?: number | undefined, listeningListener?: (() => void) | undefined): this;
-    listen(path: string, backlog?: number | undefined, listeningListener?: (() => void) | undefined): this;
-    listen(path: string, listeningListener?: (() => void) | undefined): this;
-    listen(options: ListenOptions, listeningListener?: (() => void) | undefined): this;
-    listen(handle: any, backlog?: number | undefined, listeningListener?: (() => void) | undefined): this;
-    listen(handle: any, listeningListener?: (() => void) | undefined): this;
-    listen(port?: unknown, hostname?: unknown, backlog?: unknown, listeningListener?: unknown): this;
-    close(callback?: ((err?: Error | undefined) => void) | undefined): this;
-    address(): string | AddressInfo | null;
-    getConnections(cb: (error: Error | null, count: number) => void): this;
-    ref(): this;
-    unref(): this;
-    maxConnections: number;
-    connections: number;
-    listening: boolean;
-    [Symbol.asyncDispose](): Promise<void>;
-}
-export declare const connect: (options: SocketConnectOpts, connectionListener?: () => void) => Socket;
-export declare const createConnection: (options: SocketConnectOpts, connectionListener?: () => void) => Socket;
-export declare const createServer: (options?: ServerOpts | ((socket: Socket) => void), connectionListener?: (socket: Socket) => void) => Server;
-export { isIP, isIPv4, isIPv6 };
-export declare const _default: {
-    Socket: typeof Socket;
-    Server: typeof Server;
-    connect: typeof connect;
-    createConnection: typeof createConnection;
-    createServer: typeof createServer;
-    isIP: typeof isIP;
-    isIPv4: typeof isIPv4;
-    isIPv6: typeof isIPv6;
-};
-export default _default;

package/lib/webvpn/utils.d.ts

@@ -1,32 +0,0 @@
-import type { ListenOptions, SocketConnectOpts } from 'net';
-import { BindOptions } from 'dgram';
-export declare const textEncoder: TextEncoder;
-export declare const textDecoder: TextDecoder;
-export declare const isIPv4: (input: string) => boolean;
-export declare const isIPv6: (input: string) => boolean;
-export declare const isIP: (input: string) => 0 | 4 | 6;
-type TcpConnectArgs = [options: SocketConnectOpts, connectionListener?: () => void] | [port: number, host: string, connectionListener?: () => void] | [port: number, connectionListener?: () => void] | [path: string, connectionListener?: () => void];
-type TcpListenArgs = [port?: number, hostname?: string, backlog?: number, listeningListener?: (() => void)] | [port?: number, hostname?: string, listeningListener?: (() => void)] | [port?: number, backlog?: number, listeningListener?: (() => void)] | [port?: number, listeningListener?: (() => void)] | [path: string, backlog?: number, listeningListener?: (() => void)] | [path: string, listeningListener?: (() => void)] | [options: ListenOptions, listeningListener?: (() => void)] | [handle: any, backlog?: number, listeningListener?: (() => void)] | [handle: any, listeningListener?: (() => void)];
-export declare const normalizeNetArgs: <T extends TcpConnectArgs | TcpListenArgs>(...args: T) => {
-    port: number;
-    host: string | undefined;
-    callback: (() => void) | undefined;
-} | ((T[0] extends object ? T[0] : never) & {
-    callback: (() => void) | undefined;
-});
-export declare const normalizeDgramBindArgs: (...args: [port?: number, address?: string, callback?: () => void] | [port?: number, callback?: () => void] | [callback?: () => void] | [options: BindOptions, callback?: () => void]) => {
-    exclusive?: boolean | undefined;
-    fd?: number | undefined;
-    address: string | undefined;
-    port: number;
-    callback: (() => void) | undefined;
-};
-export declare const normalizeDgramSendArgs: (...args: [msg: string | readonly any[] | Uint8Array, port: number, address: string, callback: (error: Error | null, bytes: number) => void] | [msg: string | readonly any[] | Uint8Array, port: number, callback: (error: Error | null, bytes: number) => void] | [msg: string | readonly any[] | Uint8Array, callback: (error: Error | null, bytes: number) => void] | [msg: string | Uint8Array, offset: number, length: number, port: number, address: string, callback: (error: Error | null, bytes: number) => void] | [msg: string | Uint8Array, offset: number, length: number, port: number, callback: (error: Error | null, bytes: number) => void] | [msg: string | Uint8Array, offset: number, length: number, callback: (error: Error | null, bytes: number) => void]) => {
-    message: string | readonly any[] | Uint8Array<ArrayBufferLike>;
-    offset: number | ((error: Error | null, bytes: number) => void);
-    length: number;
-    port: number;
-    address: string | undefined;
-    callback: (() => void) | undefined;
-};
-export {};

package/sandbox.d.ts

@@ -1,7 +0,0 @@
-export declare const toBase36: (value: string) => string;
-export declare const sandboxOrigin: (uri: string) => string | undefined;
-export declare const parseAppPath: (path: string) => {
-    uri: string;
-    innerPath: string;
-} | undefined;
-export declare const parseSandboxOrigin: (origin: string) => string | undefined;