Skip to content

Instantly share code, notes, and snippets.

@stevekrouse

stevekrouse/vt_environment.ts

Created May 26, 2023 17:22
Show Gist options
  • Save stevekrouse/d87a152586b02316f0ae99a136084596 to your computer and use it in GitHub Desktop.
Save stevekrouse/d87a152586b02316f0ae99a136084596 to your computer and use it in GitHub Desktop.
Download ZIP

Revisions

  1. stevekrouse created this gist May 26, 2023.
    531 changes: 531 additions & 0 deletions vt_environment.ts
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,531 @@
    declare global {
    const console: {
    log(...data: any[]): void;
    error(...data: any[]): void;
    debug(...data: any[]): void;
    info(...data: any[]): void;
    warn(...data: any[]): void;
    email(log: any, subject?: string | number): void;
    };

    type HeaderSuggestions = {
    "A-IM": string,
    "Accept": string,
    "Accept-Charset": string,
    "Accept-Datetime": string,
    "Accept-Encoding": string,
    "Accept-Language": string,
    "Access-Control-Request-Method,": string,
    "Access-Control-Request-Headers": string,
    "Authorization": string,
    "Cache-Control": string,
    "Connection": string,
    "Content-Encoding": string,
    "Content-Length": string,
    "Content-MD5": string,
    "Content-Type": string,
    "Cookie": string,
    "Date": string,
    "Expect": string,
    "Forwarded": string,
    "From": string,
    "Host": string,
    "HTTP2-Settings": string,
    "If-Match": string,
    "If-Modified-Since": string,
    "If-None-Match": string,
    "If-Range": string,
    "If-Unmodified-Since": string,
    "Max-Forwards": string,
    "Origin": string,
    "Pragma": string,
    "Prefer": string,
    "Proxy-Authorization": string,
    "Range": string,
    "Referer": string,
    "TE": string,
    "Trailer": string,
    "Transfer-Encoding": string,
    "User-Agent": string,
    "Upgrade": string,
    "Via": string,
    "Warning": string,
    [k: string]: string
    }

    type HeadersInit = [string, string][] | Record<string, string> | HeaderSuggestions; // | Headers;

    interface RequestInit {
    /** A BodyInit object or null to set request's body. */
    body?: any | null;
    /** A string indicating how the request will interact with the browser's cache to set request's cache. */
    cache?: any;
    /** A string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL. Sets request's credentials. */
    credentials?: any;
    /** A Headers object, an object literal, or an array of two-item arrays to set request's headers. */
    headers?: HeadersInit;
    /** A cryptographic hash of the resource to be fetched by request. Sets request's integrity. */
    integrity?: string;
    /** A boolean to set request's keepalive. */
    keepalive?: boolean;
    /** A string to set request's method. */
    method?: string;
    /** A string to indicate whether the request will use CORS, or will be restricted to same-origin URLs. Sets request's mode. */
    mode?: any;
    /** A string indicating whether request follows redirects, results in an error upon encountering a redirect, or returns the redirect (in an opaque fashion). Sets request's redirect. */
    redirect?: any;
    /** A string whose value is a same-origin URL, "about:client", or the empty string, to set request's referrer. */
    referrer?: string;
    /** A referrer policy to set request's referrerPolicy. */
    referrerPolicy?: any;
    /** An AbortSignal to set request's signal. */
    signal?: any | null;
    /** Can only be null. Used to disassociate request from any Window. */
    window?: null;
    }

    interface Body {
    readonly body: ReadableStream<Uint8Array> | null;
    readonly bodyUsed: boolean;
    arrayBuffer(): Promise<ArrayBuffer>;
    blob(): Promise<Blob>;
    formData(): Promise<FormData>;
    json(): Promise<any>;
    text(): Promise<string>;
    }

    interface Response extends Body {
    readonly headers: Headers;
    readonly ok: boolean;
    readonly redirected: boolean;
    readonly status: number;
    readonly statusText: string;
    readonly type: ResponseType;
    readonly url: string;
    clone(): Response;
    }

    declare var Response: {
    prototype: Response;
    new(body?: BodyInit | null, init?: ResponseInit): Response;
    error(): Response;
    redirect(url: string | URL, status?: number): Response;
    };

    function fetch(input: string, init?: RequestInit): Promise<Response>;

    class URLSearchParams implements Iterable<[string, string]> {
    constructor(init?: URLSearchParams | string | Record<string, string | ReadonlyArray<string>> | Iterable<[string, string]> | ReadonlyArray<[string, string]>);
    append(name: string, value: string): void;
    delete(name: string): void;
    entries(): IterableIterator<[string, string]>;
    forEach<TThis = this>(callback: (this: TThis, value: string, name: string, searchParams: URLSearchParams) => void, thisArg?: TThis): void;
    get(name: string): string | null;
    getAll(name: string): string[];
    has(name: string): boolean;
    keys(): IterableIterator<string>;
    set(name: string, value: string): void;
    sort(): void;
    toString(): string;
    values(): IterableIterator<string>;
    [Symbol.iterator](): IterableIterator<[string, string]>;
    }

    const parseXML: (xml: string) => any;

    type BufferEncoding = 'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex';
    type WithImplicitCoercion<T> =
    | T
    | {
    valueOf(): T;
    };
    interface BufferConstructor {
    new (str: string, encoding?: BufferEncoding): Buffer;
    new (size: number): Buffer;
    new (array: Uint8Array): Buffer;
    new (arrayBuffer: ArrayBuffer | SharedArrayBuffer): Buffer;
    new (array: ReadonlyArray<any>): Buffer;
    new (buffer: Buffer): Buffer;
    from(arrayBuffer: WithImplicitCoercion<ArrayBuffer | SharedArrayBuffer>, byteOffset?: number, length?: number): Buffer;
    from(data: Uint8Array | ReadonlyArray<number>): Buffer;
    from(data: WithImplicitCoercion<Uint8Array | ReadonlyArray<number> | string>): Buffer;
    from(
    str:
    | WithImplicitCoercion<string>
    | {
    [Symbol.toPrimitive](hint: 'string'): string;
    },
    encoding?: BufferEncoding
    ): Buffer;
    of(...items: number[]): Buffer;
    isBuffer(obj: any): obj is Buffer;
    isEncoding(encoding: string): encoding is BufferEncoding;
    byteLength(string: string | NodeJS.ArrayBufferView | ArrayBuffer | SharedArrayBuffer, encoding?: BufferEncoding): number;
    concat(list: ReadonlyArray<Uint8Array>, totalLength?: number): Buffer;
    compare(buf1: Uint8Array, buf2: Uint8Array): number;
    alloc(size: number, fill?: string | Buffer | number, encoding?: BufferEncoding): Buffer;
    allocUnsafe(size: number): Buffer;
    allocUnsafeSlow(size: number): Buffer;
    poolSize: number;
    }
    interface Buffer extends Uint8Array {
    write(string: string, encoding?: BufferEncoding): number;
    write(string: string, offset: number, encoding?: BufferEncoding): number;
    write(string: string, offset: number, length: number, encoding?: BufferEncoding): number;
    toString(encoding?: BufferEncoding, start?: number, end?: number): string;
    toJSON(): {
    type: 'Buffer';
    data: number[];
    };
    equals(otherBuffer: Uint8Array): boolean;
    compare(target: Uint8Array, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): number;
    copy(target: Uint8Array, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
    slice(start?: number, end?: number): Buffer;
    subarray(start?: number, end?: number): Buffer;
    writeBigInt64BE(value: bigint, offset?: number): number;
    writeBigInt64LE(value: bigint, offset?: number): number;
    writeBigUInt64BE(value: bigint, offset?: number): number;
    writeBigUint64BE(value: bigint, offset?: number): number;
    writeBigUInt64LE(value: bigint, offset?: number): number;
    writeBigUint64LE(value: bigint, offset?: number): number;
    writeUIntLE(value: number, offset: number, byteLength: number): number;
    writeUintLE(value: number, offset: number, byteLength: number): number;
    writeUIntBE(value: number, offset: number, byteLength: number): number;
    writeUintBE(value: number, offset: number, byteLength: number): number;
    writeIntLE(value: number, offset: number, byteLength: number): number;
    writeIntBE(value: number, offset: number, byteLength: number): number;
    readBigUInt64BE(offset?: number): bigint;
    readBigUint64BE(offset?: number): bigint;
    readBigUInt64LE(offset?: number): bigint;
    readBigUint64LE(offset?: number): bigint;
    readBigInt64BE(offset?: number): bigint;
    readBigInt64LE(offset?: number): bigint;
    readUIntLE(offset: number, byteLength: number): number;
    readUintLE(offset: number, byteLength: number): number;
    readUIntBE(offset: number, byteLength: number): number;
    readUintBE(offset: number, byteLength: number): number;
    readIntLE(offset: number, byteLength: number): number;
    readIntBE(offset: number, byteLength: number): number;
    readUInt8(offset?: number): number;
    readUint8(offset?: number): number;
    readUInt16LE(offset?: number): number;
    readUint16LE(offset?: number): number;
    readUInt16BE(offset?: number): number;
    readUint16BE(offset?: number): number;
    readUInt32LE(offset?: number): number;
    readUint32LE(offset?: number): number;
    readUInt32BE(offset?: number): number;
    readUint32BE(offset?: number): number;
    readInt8(offset?: number): number;
    readInt16LE(offset?: number): number;
    readInt16BE(offset?: number): number;
    readInt32LE(offset?: number): number;
    readInt32BE(offset?: number): number;
    readFloatLE(offset?: number): number;
    readFloatBE(offset?: number): number;
    readDoubleLE(offset?: number): number;
    readDoubleBE(offset?: number): number;
    reverse(): this;
    swap16(): Buffer;
    swap32(): Buffer;
    swap64(): Buffer;
    writeUInt8(value: number, offset?: number): number;
    writeUint8(value: number, offset?: number): number;
    writeUInt16LE(value: number, offset?: number): number;
    writeUint16LE(value: number, offset?: number): number;
    writeUInt16BE(value: number, offset?: number): number;
    writeUint16BE(value: number, offset?: number): number;
    writeUInt32LE(value: number, offset?: number): number;
    writeUint32LE(value: number, offset?: number): number;
    writeUInt32BE(value: number, offset?: number): number;
    writeUint32BE(value: number, offset?: number): number;
    writeInt8(value: number, offset?: number): number;
    writeInt16LE(value: number, offset?: number): number;
    writeInt16BE(value: number, offset?: number): number;
    writeInt32LE(value: number, offset?: number): number;
    writeInt32BE(value: number, offset?: number): number;
    writeFloatLE(value: number, offset?: number): number;
    writeFloatBE(value: number, offset?: number): number;
    writeDoubleLE(value: number, offset?: number): number;
    writeDoubleBE(value: number, offset?: number): number;
    fill(value: string | Uint8Array | number, offset?: number, end?: number, encoding?: BufferEncoding): this;
    indexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
    lastIndexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
    entries(): IterableIterator<[number, number]>;
    includes(value: string | number | Buffer, byteOffset?: number, encoding?: BufferEncoding): boolean;
    keys(): IterableIterator<number>;
    values(): IterableIterator<number>;
    }
    var Buffer: BufferConstructor;

    interface FeedOptions {
    title: string;
    description?: string | undefined;
    generator?: string | undefined;
    feed_url: string;
    site_url: string;
    image_url?: string | undefined;
    docs?: string | undefined;
    managingEditor?: string | undefined;
    webMaster?: string | undefined;
    copyright?: string | undefined;
    language?: string | undefined;
    categories?: string[] | undefined;
    pubDate?: Date | string | undefined;
    ttl?: number | undefined;
    hub?: string | undefined;
    custom_namespaces?: Object | undefined;
    custom_elements?: any[] | undefined;
    }

    interface EnclosureObject {
    url: string;
    file?: string | undefined;
    size?: number | undefined;
    type?: string | undefined;
    }

    interface ItemOptions {
    title: string;
    description: string;
    url: string;
    guid?: string | undefined;
    categories?: string[] | undefined;
    author?: string | undefined;
    date: Date | string;
    lat?: number | undefined;
    long?: number | undefined;
    custom_elements?: any[] | undefined;
    enclosure?: EnclosureObject | undefined;
    }

    interface XmlOptions {
    indent?: boolean | string | undefined;
    }

    class RSS {
    constructor(feedOptions: FeedOptions);
    item(itemOptions: ItemOptions): RSS;
    xml(): string;
    xml(xmlOptions: XmlOptions): string;
    }

    // this is manually kept in sync
    interface Interval {
    id: string,
    code: string,
    delay: number,
    author: string,
    registeredAt: Date,
    clearedAt: Date | undefined,
    lastRunAt: Date | undefined
    }

    interface ParsedQs { [key: string]: undefined | string | string[] | ParsedQs | ParsedQs[] }

    namespace express {
    interface Request {
    get(name: 'set-cookie'): string[] | undefined;
    get(name: string): string | undefined;
    header(name: 'set-cookie'): string[] | undefined;
    header(name: string): string | undefined;
    is(type: string | string[]): string | false | null;
    protocol: string;
    secure: boolean;
    ip: string;
    ips: string[];
    subdomains: string[];
    path: string;
    hostname: string;
    host: string;
    fresh: boolean;
    stale: boolean;
    xhr: boolean;
    body: any;
    cookies: any;
    method: string;
    params: Record<string, string>;
    query: ParsedQs;
    signedCookies: any;
    originalUrl: string;
    url: string;
    baseUrl: string;
    }

    interface Response {
    status(code: number): this;
    send(body?: any): this;
    json(body?: any): this;
    jsonp(body?: any): this;
    type(type: string): this;
    set(field: any): this;
    set(field: string, value?: string | string[]): this;
    get(field: string): string|undefined;
    redirect(url: string): void;
    redirect(status: number, url: string): void;
    redirect(url: string, status: number): void;
    end(cb?: () => void): this;
    end(chunk: any, cb?: () => void): this;
    end(chunk: any, encoding: BufferEncoding, cb?: () => void): this;
    }
    }

    declare namespace WebAssembly {
    interface CompileError extends Error {
    }

    var CompileError: {
    prototype: CompileError;
    new(message?: string): CompileError;
    (message?: string): CompileError;
    };

    /** [MDN Reference](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global) */
    interface Global {
    /** [MDN Reference](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global/value) */
    value: any;
    /** [MDN Reference](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global/valueOf) */
    valueOf(): any;
    }

    var Global: {
    prototype: Global;
    new(descriptor: GlobalDescriptor, v?: any): Global;
    };

    /** [MDN Reference](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance) */
    interface Instance {
    /** [MDN Reference](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance/exports) */
    readonly exports: Exports;
    }

    var Instance: {
    prototype: Instance;
    new(module: Module, importObject?: Imports): Instance;
    };

    interface LinkError extends Error {
    }

    var LinkError: {
    prototype: LinkError;
    new(message?: string): LinkError;
    (message?: string): LinkError;
    };

    /** [MDN Reference](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory) */
    interface Memory {
    /** [MDN Reference](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/buffer) */
    readonly buffer: ArrayBuffer;
    /** [MDN Reference](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/grow) */
    grow(delta: number): number;
    }

    var Memory: {
    prototype: Memory;
    new(descriptor: MemoryDescriptor): Memory;
    };

    /** [MDN Reference](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module) */
    interface Module {
    }

    var Module: {
    prototype: Module;
    new(bytes: BufferSource): Module;
    /** [MDN Reference](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/customSections) */
    customSections(moduleObject: Module, sectionName: string): ArrayBuffer[];
    /** [MDN Reference](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/exports) */
    exports(moduleObject: Module): ModuleExportDescriptor[];
    /** [MDN Reference](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/imports) */
    imports(moduleObject: Module): ModuleImportDescriptor[];
    };

    interface RuntimeError extends Error {
    }

    var RuntimeError: {
    prototype: RuntimeError;
    new(message?: string): RuntimeError;
    (message?: string): RuntimeError;
    };

    /** [MDN Reference](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table) */
    interface Table {
    /** [MDN Reference](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/length) */
    readonly length: number;
    /** [MDN Reference](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/get) */
    get(index: number): any;
    /** [MDN Reference](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/grow) */
    grow(delta: number, value?: any): number;
    /** [MDN Reference](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/set) */
    set(index: number, value?: any): void;
    }

    var Table: {
    prototype: Table;
    new(descriptor: TableDescriptor, value?: any): Table;
    };

    interface GlobalDescriptor {
    mutable?: boolean;
    value: ValueType;
    }

    interface MemoryDescriptor {
    initial: number;
    maximum?: number;
    shared?: boolean;
    }

    interface ModuleExportDescriptor {
    kind: ImportExportKind;
    name: string;
    }

    interface ModuleImportDescriptor {
    kind: ImportExportKind;
    module: string;
    name: string;
    }

    interface TableDescriptor {
    element: TableKind;
    initial: number;
    maximum?: number;
    }

    interface WebAssemblyInstantiatedSource {
    instance: Instance;
    module: Module;
    }

    type ImportExportKind = "function" | "global" | "memory" | "table";
    type TableKind = "anyfunc" | "externref";
    type ValueType = "anyfunc" | "externref" | "f32" | "f64" | "i32" | "i64" | "v128";
    type ExportValue = Function | Global | Memory | Table;
    type Exports = Record<string, ExportValue>;
    type ImportValue = ExportValue | number;
    type Imports = Record<string, ModuleImports>;
    type ModuleImports = Record<string, ImportValue>;
    /** [MDN Reference](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/compile) */
    function compile(bytes: BufferSource): Promise<Module>;
    /** [MDN Reference](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/compileStreaming) */
    function compileStreaming(source: Response | PromiseLike<Response>): Promise<Module>;
    /** [MDN Reference](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate) */
    function instantiate(bytes: BufferSource, importObject?: Imports): Promise<WebAssemblyInstantiatedSource>;
    function instantiate(moduleObject: Module, importObject?: Imports): Promise<Instance>;
    /** [MDN Reference](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiateStreaming) */
    function instantiateStreaming(source: Response | PromiseLike<Response>, importObject?: Imports): Promise<WebAssemblyInstantiatedSource>;
    /** [MDN Reference](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/validate) */
    function validate(bytes: BufferSource): boolean;
    }

    export type JsonPrimitive = string | number | boolean | null;
    export type JsonObject = {[Key in string]: JsonValue} & {[Key in string]?: JsonValue | undefined};
    export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
    export type JsonArray = JsonValue[] | readonly JsonValue[];
    }


    export {};