@zappdev/cli 0.1.0 → 0.2.0

package/native/src/cli/node_modules/undici-types/mock-interceptor.d.ts

@@ -0,0 +1,93 @@
+import { IncomingHttpHeaders } from './header'
+import Dispatcher from './dispatcher';
+import { BodyInit, Headers } from './fetch'
+
+export {
+  Interceptable,
+  MockInterceptor,
+  MockScope
+}
+
+/** The scope associated with a mock dispatch. */
+declare class MockScope<TData extends object = object> {
+  constructor(mockDispatch: MockInterceptor.MockDispatch<TData>);
+  /** Delay a reply by a set amount of time in ms. */
+  delay(waitInMs: number): MockScope<TData>;
+  /** Persist the defined mock data for the associated reply. It will return the defined mock data indefinitely. */
+  persist(): MockScope<TData>;
+  /** Define a reply for a set amount of matching requests. */
+  times(repeatTimes: number): MockScope<TData>;
+}
+
+/** The interceptor for a Mock. */
+declare class MockInterceptor {
+  constructor(options: MockInterceptor.Options, mockDispatches: MockInterceptor.MockDispatch[]);
+  /** Mock an undici request with the defined reply. */
+  reply<TData extends object = object>(replyOptionsCallback: MockInterceptor.MockReplyOptionsCallback<TData>): MockScope<TData>;
+  reply<TData extends object = object>(
+    statusCode: number,
+    data?: TData | Buffer | string | MockInterceptor.MockResponseDataHandler<TData>,
+    responseOptions?: MockInterceptor.MockResponseOptions
+  ): MockScope<TData>;
+  /** Mock an undici request by throwing the defined reply error. */
+  replyWithError<TError extends Error = Error>(error: TError): MockScope;
+  /** Set default reply headers on the interceptor for subsequent mocked replies. */
+  defaultReplyHeaders(headers: IncomingHttpHeaders): MockInterceptor;
+  /** Set default reply trailers on the interceptor for subsequent mocked replies. */
+  defaultReplyTrailers(trailers: Record<string, string>): MockInterceptor;
+  /** Set automatically calculated content-length header on subsequent mocked replies. */
+  replyContentLength(): MockInterceptor;
+}
+
+declare namespace MockInterceptor {
+  /** MockInterceptor options. */
+  export interface Options {
+    /** Path to intercept on. */
+    path: string | RegExp | ((path: string) => boolean);
+    /** Method to intercept on. Defaults to GET. */
+    method?: string | RegExp | ((method: string) => boolean);
+    /** Body to intercept on. */
+    body?: string | RegExp | ((body: string) => boolean);
+    /** Headers to intercept on. */
+    headers?: Record<string, string | RegExp | ((body: string) => boolean)> | ((headers: Record<string, string>) => boolean);
+    /** Query params to intercept on */
+    query?: Record<string, any>;
+  }
+  export interface MockDispatch<TData extends object = object, TError extends Error = Error> extends Options {
+    times: number | null;
+    persist: boolean;
+    consumed: boolean;
+    data: MockDispatchData<TData, TError>;
+  }
+  export interface MockDispatchData<TData extends object = object, TError extends Error = Error> extends MockResponseOptions {
+    error: TError | null;
+    statusCode?: number;
+    data?: TData | string;
+  }
+  export interface MockResponseOptions {
+    headers?: IncomingHttpHeaders;
+    trailers?: Record<string, string>;
+  }
+
+  export interface MockResponseCallbackOptions {
+    path: string;
+    method: string;
+    headers?: Headers | Record<string, string>;
+    origin?: string;
+    body?: BodyInit | Dispatcher.DispatchOptions['body'] | null;
+    maxRedirections?: number;
+  }
+
+  export type MockResponseDataHandler<TData extends object = object> = (
+    opts: MockResponseCallbackOptions
+  ) => TData | Buffer | string;
+
+  export type MockReplyOptionsCallback<TData extends object = object> = (
+    opts: MockResponseCallbackOptions
+  ) => { statusCode: number, data?: TData | Buffer | string, responseOptions?: MockResponseOptions }
+}
+
+interface Interceptable extends Dispatcher {
+  /** Intercepts any matching requests that use the same origin as this mock client. */
+  intercept(options: MockInterceptor.Options): MockInterceptor;
+}

package/native/src/cli/node_modules/undici-types/mock-pool.d.ts

@@ -0,0 +1,25 @@
+import Pool from './pool'
+import MockAgent from './mock-agent'
+import { Interceptable, MockInterceptor } from './mock-interceptor'
+import Dispatcher from './dispatcher'
+
+export default MockPool
+
+/** MockPool extends the Pool API and allows one to mock requests. */
+declare class MockPool extends Pool implements Interceptable {
+  constructor(origin: string, options: MockPool.Options);
+  /** Intercepts any matching requests that use the same origin as this mock pool. */
+  intercept(options: MockInterceptor.Options): MockInterceptor;
+  /** Dispatches a mocked request. */
+  dispatch(options: Dispatcher.DispatchOptions, handlers: Dispatcher.DispatchHandlers): boolean;
+  /** Closes the mock pool and gracefully waits for enqueued requests to complete. */
+  close(): Promise<void>;
+}
+
+declare namespace MockPool {
+  /** MockPool options. */
+  export interface Options extends Pool.Options {
+    /** The agent to associate this MockPool with. */
+    agent: MockAgent;
+  }
+}

package/native/src/cli/node_modules/undici-types/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "undici-types",
+  "version": "6.21.0",
+  "description": "A stand-alone types package for Undici",
+  "homepage": "https://undici.nodejs.org",
+  "bugs": {
+    "url": "https://github.com/nodejs/undici/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nodejs/undici.git"
+  },
+  "license": "MIT",
+  "types": "index.d.ts",
+  "files": [
+    "*.d.ts"
+  ],
+  "contributors": [
+    {
+      "name": "Daniele Belardi",
+      "url": "https://github.com/dnlup",
+      "author": true
+    },
+    {
+      "name": "Ethan Arrowood",
+      "url": "https://github.com/ethan-arrowood",
+      "author": true
+    },
+    {
+      "name": "Matteo Collina",
+      "url": "https://github.com/mcollina",
+      "author": true
+    },
+    {
+      "name": "Matthew Aitken",
+      "url": "https://github.com/KhafraDev",
+      "author": true
+    },
+    {
+      "name": "Robert Nagy",
+      "url": "https://github.com/ronag",
+      "author": true
+    },
+    {
+      "name": "Szymon Marczak",
+      "url": "https://github.com/szmarczak",
+      "author": true
+    },
+    {
+      "name": "Tomas Della Vedova",
+      "url": "https://github.com/delvedor",
+      "author": true
+    }
+  ]
+}

package/native/src/cli/node_modules/undici-types/patch.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+
+// See https://github.com/nodejs/undici/issues/1740
+
+export type DOMException = typeof globalThis extends { DOMException: infer T }
+ ? T
+ : any
+
+export interface EventInit {
+  bubbles?: boolean
+  cancelable?: boolean
+  composed?: boolean
+}
+
+export interface EventListenerOptions {
+  capture?: boolean
+}
+
+export interface AddEventListenerOptions extends EventListenerOptions {
+  once?: boolean
+  passive?: boolean
+  signal?: AbortSignal
+}
+
+export type EventListenerOrEventListenerObject = EventListener | EventListenerObject
+
+export interface EventListenerObject {
+  handleEvent (object: Event): void
+}
+
+export interface EventListener {
+  (evt: Event): void
+}

package/native/src/cli/node_modules/undici-types/pool-stats.d.ts

@@ -0,0 +1,19 @@
+import Pool from "./pool"
+
+export default PoolStats
+
+declare class PoolStats {
+  constructor(pool: Pool);
+  /** Number of open socket connections in this pool. */
+  connected: number;
+  /** Number of open socket connections in this pool that do not have an active request. */
+  free: number;
+  /** Number of pending requests across all clients in this pool. */
+  pending: number;
+  /** Number of queued requests across all clients in this pool. */
+  queued: number;
+  /** Number of currently active requests across all clients in this pool. */
+  running: number;
+  /** Number of active, pending, or queued requests across all clients in this pool. */
+  size: number;
+}

package/native/src/cli/node_modules/undici-types/pool.d.ts

@@ -0,0 +1,39 @@
+import Client from './client'
+import TPoolStats from './pool-stats'
+import { URL } from 'url'
+import Dispatcher from "./dispatcher";
+
+export default Pool
+
+type PoolConnectOptions = Omit<Dispatcher.ConnectOptions, "origin">;
+
+declare class Pool extends Dispatcher {
+  constructor(url: string | URL, options?: Pool.Options)
+  /** `true` after `pool.close()` has been called. */
+  closed: boolean;
+  /** `true` after `pool.destroyed()` has been called or `pool.close()` has been called and the pool shutdown has completed. */
+  destroyed: boolean;
+  /** Aggregate stats for a Pool. */
+  readonly stats: TPoolStats;
+
+  // Override dispatcher APIs.
+  override connect(
+    options: PoolConnectOptions
+  ): Promise<Dispatcher.ConnectData>;
+  override connect(
+    options: PoolConnectOptions,
+    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  ): void;
+}
+
+declare namespace Pool {
+  export type PoolStats = TPoolStats;
+  export interface Options extends Client.Options {
+    /** Default: `(origin, opts) => new Client(origin, opts)`. */
+    factory?(origin: URL, opts: object): Dispatcher;
+    /** The max number of clients to create. `null` if no limit. Default `null`. */
+    connections?: number | null;
+
+    interceptors?: { Pool?: readonly Dispatcher.DispatchInterceptor[] } & Client.Options["interceptors"]
+  }
+}

package/native/src/cli/node_modules/undici-types/proxy-agent.d.ts

@@ -0,0 +1,28 @@
+import Agent from './agent'
+import buildConnector from './connector';
+import Dispatcher from './dispatcher'
+import { IncomingHttpHeaders } from './header'
+
+export default ProxyAgent
+
+declare class ProxyAgent extends Dispatcher {
+  constructor(options: ProxyAgent.Options | string)
+
+  dispatch(options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandlers): boolean;
+  close(): Promise<void>;
+}
+
+declare namespace ProxyAgent {
+  export interface Options extends Agent.Options {
+    uri: string;
+    /**
+     * @deprecated use opts.token
+     */
+    auth?: string;
+    token?: string;
+    headers?: IncomingHttpHeaders;
+    requestTls?: buildConnector.BuildOptions;
+    proxyTls?: buildConnector.BuildOptions;
+    clientFactory?(origin: URL, opts: object): Dispatcher;
+  }
+}

package/native/src/cli/node_modules/undici-types/readable.d.ts

@@ -0,0 +1,65 @@
+import { Readable } from "stream";
+import { Blob } from 'buffer'
+
+export default BodyReadable
+
+declare class BodyReadable extends Readable {
+  constructor(
+    resume?: (this: Readable, size: number) => void | null,
+    abort?: () => void | null,
+    contentType?: string
+  )
+
+  /** Consumes and returns the body as a string
+   *  https://fetch.spec.whatwg.org/#dom-body-text
+   */
+  text(): Promise<string>
+
+  /** Consumes and returns the body as a JavaScript Object
+   *  https://fetch.spec.whatwg.org/#dom-body-json
+   */
+  json(): Promise<unknown>
+
+  /** Consumes and returns the body as a Blob
+   *  https://fetch.spec.whatwg.org/#dom-body-blob
+   */
+  blob(): Promise<Blob>
+
+  /** Consumes and returns the body as an Uint8Array
+   *  https://fetch.spec.whatwg.org/#dom-body-bytes
+   */
+  bytes(): Promise<Uint8Array>
+
+  /** Consumes and returns the body as an ArrayBuffer
+   *  https://fetch.spec.whatwg.org/#dom-body-arraybuffer
+   */
+  arrayBuffer(): Promise<ArrayBuffer>
+
+  /** Not implemented
+   *
+   *  https://fetch.spec.whatwg.org/#dom-body-formdata
+   */
+  formData(): Promise<never>
+
+  /** Returns true if the body is not null and the body has been consumed
+   *
+   *  Otherwise, returns false
+   *
+   * https://fetch.spec.whatwg.org/#dom-body-bodyused
+   */
+  readonly bodyUsed: boolean
+
+  /** 
+   * If body is null, it should return null as the body
+   *
+   *  If body is not null, should return the body as a ReadableStream
+   *
+   *  https://fetch.spec.whatwg.org/#dom-body-body
+   */
+  readonly body: never | undefined
+
+  /** Dumps the response body by reading `limit` number of bytes.
+   * @param opts.limit Number of bytes to read (optional) - Default: 262144
+   */
+  dump(opts?: { limit: number }): Promise<void>
+}

package/native/src/cli/node_modules/undici-types/retry-agent.d.ts

@@ -0,0 +1,8 @@
+import Dispatcher from './dispatcher'
+import RetryHandler from './retry-handler'
+
+export default RetryAgent
+
+declare class RetryAgent extends Dispatcher {
+  constructor(dispatcher: Dispatcher, options?: RetryHandler.RetryOptions)
+}

package/native/src/cli/node_modules/undici-types/retry-handler.d.ts

@@ -0,0 +1,116 @@
+import Dispatcher from "./dispatcher";
+
+export default RetryHandler;
+
+declare class RetryHandler implements Dispatcher.DispatchHandlers {
+  constructor(
+    options: Dispatcher.DispatchOptions & {
+      retryOptions?: RetryHandler.RetryOptions;
+    },
+    retryHandlers: RetryHandler.RetryHandlers
+  );
+}
+
+declare namespace RetryHandler {
+  export type RetryState = { counter: number; };
+
+  export type RetryContext = {
+    state: RetryState;
+    opts: Dispatcher.DispatchOptions & {
+      retryOptions?: RetryHandler.RetryOptions;
+    };
+  }
+
+  export type OnRetryCallback = (result?: Error | null) => void;
+
+  export type RetryCallback = (
+    err: Error,
+    context: {
+      state: RetryState;
+      opts: Dispatcher.DispatchOptions & {
+        retryOptions?: RetryHandler.RetryOptions;
+      };
+    },
+    callback: OnRetryCallback
+  ) => number | null;
+
+  export interface RetryOptions {
+    /**
+     * Callback to be invoked on every retry iteration.
+     * It receives the error, current state of the retry object and the options object
+     * passed when instantiating the retry handler.
+     *
+     * @type {RetryCallback}
+     * @memberof RetryOptions
+     */
+    retry?: RetryCallback;
+    /**
+     * Maximum number of retries to allow.
+     *
+     * @type {number}
+     * @memberof RetryOptions
+     * @default 5
+     */
+    maxRetries?: number;
+    /**
+     * Max number of milliseconds allow between retries
+     *
+     * @type {number}
+     * @memberof RetryOptions
+     * @default 30000
+     */
+    maxTimeout?: number;
+    /**
+     * Initial number of milliseconds to wait before retrying for the first time.
+     *
+     * @type {number}
+     * @memberof RetryOptions
+     * @default 500
+     */
+    minTimeout?: number;
+    /**
+     * Factior to multiply the timeout factor between retries.
+     *
+     * @type {number}
+     * @memberof RetryOptions
+     * @default 2
+     */
+    timeoutFactor?: number;
+    /**
+     * It enables to automatically infer timeout between retries based on the `Retry-After` header.
+     *
+     * @type {boolean}
+     * @memberof RetryOptions
+     * @default true
+     */
+    retryAfter?: boolean;
+    /**
+     * HTTP methods to retry.
+     *
+     * @type {Dispatcher.HttpMethod[]}
+     * @memberof RetryOptions
+     * @default ['GET', 'HEAD', 'OPTIONS', 'PUT', 'DELETE', 'TRACE'],
+     */
+    methods?: Dispatcher.HttpMethod[];
+    /**
+     * Error codes to be retried. e.g. `ECONNRESET`, `ENOTFOUND`, `ETIMEDOUT`, `ECONNREFUSED`, etc.
+     *
+     * @type {string[]}
+     * @default ['ECONNRESET','ECONNREFUSED','ENOTFOUND','ENETDOWN','ENETUNREACH','EHOSTDOWN','EHOSTUNREACH','EPIPE']
+     */
+    errorCodes?: string[];
+    /**
+     * HTTP status codes to be retried.
+     *
+     * @type {number[]}
+     * @memberof RetryOptions
+     * @default [500, 502, 503, 504, 429],
+     */
+    statusCodes?: number[];
+  }
+
+  export interface RetryHandlers {
+    dispatch: Dispatcher["dispatch"];
+    handler: Dispatcher.DispatchHandlers;
+  }
+}

package/native/src/cli/node_modules/undici-types/util.d.ts

@@ -0,0 +1,18 @@
+export namespace util {
+  /**
+   * Retrieves a header name and returns its lowercase value.
+   * @param value Header name
+   */
+  export function headerNameToString(value: string | Buffer): string;
+
+  /**
+   * Receives a header object and returns the parsed value.
+   * @param headers Header object
+   * @param obj Object to specify a proxy object. Used to assign parsed values.
+   * @returns If `obj` is specified, it is equivalent to `obj`.
+   */
+  export function parseHeaders(
+    headers: (Buffer | string | (Buffer | string)[])[],
+    obj?: Record<string, string | string[]>
+  ): Record<string, string | string[]>;
+}