123 unmodified lines
124
125## submission
126
127- source of truth: https://sublimated.com/sublimated/code/obsidian
128- GitHub mirror for submission: https://github.com/sublimates/obsidian — required for Obsidian community plugins. keep sublimated.com as primary, push to GitHub for releases
129- PR to obsidianmd/obsidian-releases adding entry to community-plugins.json
130- automated validation + manual review
131- README with screenshots, description, setup instructions
128- GitHub live mirror: https://github.com/sublimates/obsidian — live-synced from sublimated.com
129- todo: PR to obsidianmd/obsidian-releases adding entry to community-plugins.json
130- todo: GitHub release workflow for plugin submission (main.js, manifest.json, styles.css as release assets)
131- todo: README with screenshots, description, setup instructions
132- automated validation + manual review by Obsidian team
133
133### setup GitHub mirror
134
135- create repo at https://github.com/sublimates/obsidian
136- push current code (excluding node_modules)
137- set up a workflow to mirror from sublimated.com to GitHub (manual push or automated)
138- add GitHub release workflow for Obsidian plugin submission (main.js, manifest.json, styles.css as release assets)
139
134## promotion
135
136- r/ObsidianMD
137- Obsidian Forum "Share & showcase"
3 unmodified lines

1{
2	"name": "builtin-modules",
3	"version": "4.0.0",
4	"description": "A static list of the Node.js builtin modules from the latest Node.js version",
5	"license": "MIT",
6	"repository": "sindresorhus/builtin-modules",
7	"funding": "https://github.com/sponsors/sindresorhus",
8	"author": {
9		"name": "Sindre Sorhus",
10		"email": "sindresorhus@gmail.com",
11		"url": "https://sindresorhus.com"
12	},
13	"type": "module",
14	"exports": {
15		"types": "./index.d.ts",
16		"default": "./index.js"
17	},
18	"sideEffects": false,
19	"engines": {
20		"node": ">=18.20"
21	},
22	"scripts": {
23		"//test": "xo && ava && tsd",
24		"test": "ava && tsd",
25		"make": "node make.js"
26	},
27	"files": [
28		"index.js",
29		"index.d.ts",
30		"builtin-modules.json"
31	],
32	"keywords": [
33		"builtin",
34		"built-in",
35		"builtins",
36		"node",
37		"modules",
38		"core",
39		"bundled",
40		"list",
41		"array",
42		"names"
43	],
44	"devDependencies": {
45		"ava": "^6.1.2",
46		"tsd": "^0.31.0",
47		"xo": "^0.58.0"
48	}
49}

1[
2	"assert",
3	"assert/strict",
4	"async_hooks",
5	"buffer",
6	"child_process",
7	"cluster",
8	"console",
9	"constants",
10	"crypto",
11	"dgram",
12	"diagnostics_channel",
13	"dns",
14	"dns/promises",
15	"domain",
16	"events",
17	"fs",
18	"fs/promises",
19	"http",
20	"http2",
21	"https",
22	"inspector",
23	"inspector/promises",
24	"module",
25	"net",
26	"os",
27	"path",
28	"path/posix",
29	"path/win32",
30	"perf_hooks",
31	"process",
32	"punycode",
33	"querystring",
34	"readline",
35	"readline/promises",
36	"repl",
37	"stream",
38	"stream/consumers",
39	"stream/promises",
40	"stream/web",
41	"string_decoder",
42	"timers",
43	"timers/promises",
44	"tls",
45	"trace_events",
46	"tty",
47	"url",
48	"util",
49	"util/types",
50	"v8",
51	"vm",
52	"wasi",
53	"worker_threads",
54	"zlib"
55]

1MIT License
2
3Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
4
5Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
6
7The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
8
9THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

1# builtin-modules
2
3> A static list of the Node.js builtin modules from the latest Node.js version
4
5The list is just a [JSON file](builtin-modules.json) and can be used anywhere.
6
7## Install
8
9```sh
10npm install builtin-modules
11```
12
13## Usage
14
15```js
16import builtinModules from 'builtin-modules';
17
18console.log(builtinModules);
19//=> ['assert', 'buffer', …]
20```
21
22## Tip
23
24To get a list from the current Node.js version, use the built-in API:
25
26```js
27import {builtinModules} from 'node:module';
28```
29
30## Related
31
32- [is-builtin-module](https://github.com/sindresorhus/is-builtin-module) - Check if a string matches the name of a Node.js builtin module

1import builtinModules from './builtin-modules.json' with {type: 'json'};
2
3export default builtinModules;

1// based on https://github.com/Ethan-Arrowood/undici-fetch/blob/249269714db874351589d2d364a0645d5160ae71/index.d.ts (MIT license)
2// and https://github.com/node-fetch/node-fetch/blob/914ce6be5ec67a8bab63d68510aabf07cb818b6d/index.d.ts (MIT license)
3/// <reference types="node" />
4
5import { Blob } from 'buffer'
6import { URL, URLSearchParams } from 'url'
7import { ReadableStream } from 'stream/web'
8import { FormData } from './formdata'
9
10import Dispatcher from './dispatcher'
11
12export type RequestInfo = string | URL | Request
13
14export declare function fetch (
15  input: RequestInfo,
16  init?: RequestInit
17): Promise<Response>
18
19export type BodyInit =
20  | ArrayBuffer
21  | AsyncIterable<Uint8Array>
22  | Blob
23  | FormData
24  | Iterable<Uint8Array>
25  | NodeJS.ArrayBufferView
26  | URLSearchParams
27  | null
28  | string
29
30export class BodyMixin {
31  readonly body: ReadableStream | null
32  readonly bodyUsed: boolean
33
34  readonly arrayBuffer: () => Promise<ArrayBuffer>
35  readonly blob: () => Promise<Blob>
36  /**
37   * @deprecated This method is not recommended for parsing multipart/form-data bodies in server environments.
38   * It is recommended to use a library such as [@fastify/busboy](https://www.npmjs.com/package/@fastify/busboy) as follows:
39   * 
40   * @example
41   * ```js
42   * import { Busboy } from '@fastify/busboy'
43   * import { Readable } from 'node:stream'
44   * 
45   * const response = await fetch('...')
46   * const busboy = new Busboy({ headers: { 'content-type': response.headers.get('content-type') } })
47   * 
48   * // handle events emitted from `busboy`
49   * 
50   * Readable.fromWeb(response.body).pipe(busboy)
51   * ```
52   */
53  readonly formData: () => Promise<FormData>
54  readonly json: () => Promise<unknown>
55  readonly text: () => Promise<string>
56}
57
58export interface SpecIterator<T, TReturn = any, TNext = undefined> {
59  next(...args: [] | [TNext]): IteratorResult<T, TReturn>;
60}
61
62export interface SpecIterableIterator<T> extends SpecIterator<T> {
63  [Symbol.iterator](): SpecIterableIterator<T>;
64}
65
66export interface SpecIterable<T> {
67  [Symbol.iterator](): SpecIterator<T>;
68}
69
70export type HeadersInit = string[][] | Record<string, string | ReadonlyArray<string>> | Headers
71
72export declare class Headers implements SpecIterable<[string, string]> {
73  constructor (init?: HeadersInit)
74  readonly append: (name: string, value: string) => void
75  readonly delete: (name: string) => void
76  readonly get: (name: string) => string | null
77  readonly has: (name: string) => boolean
78  readonly set: (name: string, value: string) => void
79  readonly getSetCookie: () => string[]
80  readonly forEach: (
81    callbackfn: (value: string, key: string, iterable: Headers) => void,
82    thisArg?: unknown
83  ) => void
84
85  readonly keys: () => SpecIterableIterator<string>
86  readonly values: () => SpecIterableIterator<string>
87  readonly entries: () => SpecIterableIterator<[string, string]>
88  readonly [Symbol.iterator]: () => SpecIterableIterator<[string, string]>
89}
90
91export type RequestCache =
92  | 'default'
93  | 'force-cache'
94  | 'no-cache'
95  | 'no-store'
96  | 'only-if-cached'
97  | 'reload'
98
99export type RequestCredentials = 'omit' | 'include' | 'same-origin'
100
101type RequestDestination =
102  | ''
103  | 'audio'
104  | 'audioworklet'
105  | 'document'
106  | 'embed'
107  | 'font'
108  | 'image'
109  | 'manifest'
110  | 'object'
111  | 'paintworklet'
112  | 'report'
113  | 'script'
114  | 'sharedworker'
115  | 'style'
116  | 'track'
117  | 'video'
118  | 'worker'
119  | 'xslt'
120
121export interface RequestInit {
122  method?: string
123  keepalive?: boolean
124  headers?: HeadersInit
125  body?: BodyInit | null
126  redirect?: RequestRedirect
127  integrity?: string
128  signal?: AbortSignal | null
129  credentials?: RequestCredentials
130  mode?: RequestMode
131  referrer?: string
132  referrerPolicy?: ReferrerPolicy
133  window?: null
134  dispatcher?: Dispatcher
135  duplex?: RequestDuplex
136}
137
138export type ReferrerPolicy =
139  | ''
140  | 'no-referrer'
141  | 'no-referrer-when-downgrade'
142  | 'origin'
143  | 'origin-when-cross-origin'
144  | 'same-origin'
145  | 'strict-origin'
146  | 'strict-origin-when-cross-origin'
147  | 'unsafe-url';
148
149export type RequestMode = 'cors' | 'navigate' | 'no-cors' | 'same-origin'
150
151export type RequestRedirect = 'error' | 'follow' | 'manual'
152
153export type RequestDuplex = 'half'
154
155export declare class Request extends BodyMixin {
156  constructor (input: RequestInfo, init?: RequestInit)
157
158  readonly cache: RequestCache
159  readonly credentials: RequestCredentials
160  readonly destination: RequestDestination
161  readonly headers: Headers
162  readonly integrity: string
163  readonly method: string
164  readonly mode: RequestMode
165  readonly redirect: RequestRedirect
166  readonly referrer: string
167  readonly referrerPolicy: ReferrerPolicy
168  readonly url: string
169
170  readonly keepalive: boolean
171  readonly signal: AbortSignal
172  readonly duplex: RequestDuplex
173
174  readonly clone: () => Request
175}
176
177export interface ResponseInit {
178  readonly status?: number
179  readonly statusText?: string
180  readonly headers?: HeadersInit
181}
182
183export type ResponseType =
184  | 'basic'
185  | 'cors'
186  | 'default'
187  | 'error'
188  | 'opaque'
189  | 'opaqueredirect'
190
191export type ResponseRedirectStatus = 301 | 302 | 303 | 307 | 308
192
193export declare class Response extends BodyMixin {
194  constructor (body?: BodyInit, init?: ResponseInit)
195
196  readonly headers: Headers
197  readonly ok: boolean
198  readonly status: number
199  readonly statusText: string
200  readonly type: ResponseType
201  readonly url: string
202  readonly redirected: boolean
203
204  readonly clone: () => Response
205
206  static error (): Response
207  static json(data: any, init?: ResponseInit): Response
208  static redirect (url: string | URL, status: ResponseRedirectStatus): Response
209}

1import Dispatcher from'./dispatcher'
2import { setGlobalDispatcher, getGlobalDispatcher } from './global-dispatcher'
3import { setGlobalOrigin, getGlobalOrigin } from './global-origin'
4import Pool from'./pool'
5import { RedirectHandler, DecoratorHandler } from './handlers'
6
7import BalancedPool from './balanced-pool'
8import Client from'./client'
9import buildConnector from'./connector'
10import errors from'./errors'
11import Agent from'./agent'
12import MockClient from'./mock-client'
13import MockPool from'./mock-pool'
14import MockAgent from'./mock-agent'
15import mockErrors from'./mock-errors'
16import ProxyAgent from'./proxy-agent'
17import EnvHttpProxyAgent from './env-http-proxy-agent'
18import RetryHandler from'./retry-handler'
19import RetryAgent from'./retry-agent'
20import { request, pipeline, stream, connect, upgrade } from './api'
21import interceptors from './interceptors'
22
23export * from './util'
24export * from './cookies'
25export * from './eventsource'
26export * from './fetch'
27export * from './file'
28export * from './filereader'
29export * from './formdata'
30export * from './diagnostics-channel'
31export * from './websocket'
32export * from './content-type'
33export * from './cache'
34export { Interceptable } from './mock-interceptor'
35
36export { Dispatcher, BalancedPool, Pool, Client, buildConnector, errors, Agent, request, stream, pipeline, connect, upgrade, setGlobalDispatcher, getGlobalDispatcher, setGlobalOrigin, getGlobalOrigin, interceptors, MockClient, MockPool, MockAgent, mockErrors, ProxyAgent, EnvHttpProxyAgent, RedirectHandler, DecoratorHandler, RetryHandler, RetryAgent }
37export default Undici
38
39declare namespace Undici {
40  var Dispatcher: typeof import('./dispatcher').default
41  var Pool: typeof import('./pool').default;
42  var RedirectHandler: typeof import ('./handlers').RedirectHandler
43  var DecoratorHandler: typeof import ('./handlers').DecoratorHandler
44  var RetryHandler: typeof import ('./retry-handler').default
45  var createRedirectInterceptor: typeof import ('./interceptors').default.createRedirectInterceptor
46  var BalancedPool: typeof import('./balanced-pool').default;
47  var Client: typeof import('./client').default;
48  var buildConnector: typeof import('./connector').default;
49  var errors: typeof import('./errors').default;
50  var Agent: typeof import('./agent').default;
51  var setGlobalDispatcher: typeof import('./global-dispatcher').setGlobalDispatcher;
52  var getGlobalDispatcher: typeof import('./global-dispatcher').getGlobalDispatcher;
53  var request: typeof import('./api').request;
54  var stream: typeof import('./api').stream;
55  var pipeline: typeof import('./api').pipeline;
56  var connect: typeof import('./api').connect;
57  var upgrade: typeof import('./api').upgrade;
58  var MockClient: typeof import('./mock-client').default;
59  var MockPool: typeof import('./mock-pool').default;
60  var MockAgent: typeof import('./mock-agent').default;
61  var mockErrors: typeof import('./mock-errors').default;
62  var fetch: typeof import('./fetch').fetch;
63  var Headers: typeof import('./fetch').Headers;
64  var Response: typeof import('./fetch').Response;
65  var Request: typeof import('./fetch').Request;
66  var FormData: typeof import('./formdata').FormData;
67  var File: typeof import('./file').File;
68  var FileReader: typeof import('./filereader').FileReader;
69  var caches: typeof import('./cache').caches;
70  var interceptors: typeof import('./interceptors').default;
71}

1/// <reference types="node" />
2
3import { Blob } from 'buffer'
4import { DOMException, EventInit } from './patch'
5
6export declare class FileReader {
7  __proto__: EventTarget & FileReader
8
9  constructor ()
10
11  readAsArrayBuffer (blob: Blob): void
12  readAsBinaryString (blob: Blob): void
13  readAsText (blob: Blob, encoding?: string): void
14  readAsDataURL (blob: Blob): void
15
16  abort (): void
17
18  static readonly EMPTY = 0
19  static readonly LOADING = 1
20  static readonly DONE = 2
21
22  readonly EMPTY = 0
23  readonly LOADING = 1
24  readonly DONE = 2
25
26  readonly readyState: number
27
28  readonly result: string | ArrayBuffer | null
29
30  readonly error: DOMException | null
31
32  onloadstart: null | ((this: FileReader, event: ProgressEvent) => void)
33  onprogress: null | ((this: FileReader, event: ProgressEvent) => void)
34  onload: null | ((this: FileReader, event: ProgressEvent) => void)
35  onabort: null |  ((this: FileReader, event: ProgressEvent) => void)
36  onerror: null | ((this: FileReader, event: ProgressEvent) => void)
37  onloadend: null | ((this: FileReader, event: ProgressEvent) => void)
38}
39
40export interface ProgressEventInit extends EventInit {
41  lengthComputable?: boolean
42  loaded?: number
43  total?: number
44}
45
46export declare class ProgressEvent {
47  __proto__: Event & ProgressEvent
48
49  constructor (type: string, eventInitDict?: ProgressEventInit)
50
51  readonly lengthComputable: boolean
52  readonly loaded: number
53  readonly total: number
54}

1import Agent from './agent'
2import Dispatcher from './dispatcher'
3import { Interceptable, MockInterceptor } from './mock-interceptor'
4import MockDispatch = MockInterceptor.MockDispatch;
5
6export default MockAgent
7
8interface PendingInterceptor extends MockDispatch {
9  origin: string;
10}
11
12/** A mocked Agent class that implements the Agent API. It allows one to intercept HTTP requests made through undici and return mocked responses instead. */
13declare class MockAgent<TMockAgentOptions extends MockAgent.Options = MockAgent.Options> extends Dispatcher {
14  constructor(options?: MockAgent.Options)
15  /** Creates and retrieves mock Dispatcher instances which can then be used to intercept HTTP requests. If the number of connections on the mock agent is set to 1, a MockClient instance is returned. Otherwise a MockPool instance is returned. */
16  get<TInterceptable extends Interceptable>(origin: string): TInterceptable;
17  get<TInterceptable extends Interceptable>(origin: RegExp): TInterceptable;
18  get<TInterceptable extends Interceptable>(origin: ((origin: string) => boolean)): TInterceptable;
19  /** Dispatches a mocked request. */
20  dispatch(options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandlers): boolean;
21  /** Closes the mock agent and waits for registered mock pools and clients to also close before resolving. */
22  close(): Promise<void>;
23  /** Disables mocking in MockAgent. */
24  deactivate(): void;
25  /** Enables mocking in a MockAgent instance. When instantiated, a MockAgent is automatically activated. Therefore, this method is only effective after `MockAgent.deactivate` has been called. */
26  activate(): void;
27  /** Define host matchers so only matching requests that aren't intercepted by the mock dispatchers will be attempted. */
28  enableNetConnect(): void;
29  enableNetConnect(host: string): void;
30  enableNetConnect(host: RegExp): void;
31  enableNetConnect(host: ((host: string) => boolean)): void;
32  /** Causes all requests to throw when requests are not matched in a MockAgent intercept. */
33  disableNetConnect(): void;
34  pendingInterceptors(): PendingInterceptor[];
35  assertNoPendingInterceptors(options?: {
36    pendingInterceptorsFormatter?: PendingInterceptorsFormatter;
37  }): void;
38}
39
40interface PendingInterceptorsFormatter {
41  format(pendingInterceptors: readonly PendingInterceptor[]): string;
42}
43
44declare namespace MockAgent {
45  /** MockAgent options. */
46  export interface Options extends Agent.Options {
47    /** A custom agent to be encapsulated by the MockAgent. */
48    agent?: Agent;
49  }
50}

1// These types are not exported, and are only used internally
2
3/**
4 * Take in an unknown value and return one that is of type T
5 */
6type Converter<T> = (object: unknown) => T
7
8type SequenceConverter<T> = (object: unknown, iterable?: IterableIterator<T>) => T[]
9
10type RecordConverter<K extends string, V> = (object: unknown) => Record<K, V>
11
12interface ConvertToIntOpts {
13  clamp?: boolean
14  enforceRange?: boolean
15}
16
17interface WebidlErrors {
18  exception (opts: { header: string, message: string }): TypeError
19  /**
20   * @description Throw an error when conversion from one type to another has failed
21   */
22  conversionFailed (opts: {
23    prefix: string
24    argument: string
25    types: string[]
26  }): TypeError
27  /**
28   * @description Throw an error when an invalid argument is provided
29   */
30  invalidArgument (opts: {
31    prefix: string
32    value: string
33    type: string
34  }): TypeError
35}
36
37interface WebidlUtil {
38  /**
39   * @see https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values
40   */
41  Type (object: unknown):
42    | 'Undefined'
43    | 'Boolean'
44    | 'String'
45    | 'Symbol'
46    | 'Number'
47    | 'BigInt'
48    | 'Null'
49    | 'Object'
50
51  /**
52   * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
53   */
54  ConvertToInt (
55    V: unknown,
56    bitLength: number,
57    signedness: 'signed' | 'unsigned',
58    opts?: ConvertToIntOpts
59  ): number
60
61  /**
62   * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
63   */
64  IntegerPart (N: number): number
65
66  /**
67   * Stringifies {@param V}
68   */
69  Stringify (V: any): string
70
71  /**
72   * Mark a value as uncloneable for Node.js.
73   * This is only effective in some newer Node.js versions.
74   */
75  markAsUncloneable (V: any): void
76}
77
78interface WebidlConverters {
79  /**
80   * @see https://webidl.spec.whatwg.org/#es-DOMString
81   */
82  DOMString (V: unknown, prefix: string, argument: string, opts?: {
83    legacyNullToEmptyString: boolean
84  }): string
85
86  /**
87   * @see https://webidl.spec.whatwg.org/#es-ByteString
88   */
89  ByteString (V: unknown, prefix: string, argument: string): string
90
91  /**
92   * @see https://webidl.spec.whatwg.org/#es-USVString
93   */
94  USVString (V: unknown): string
95
96  /**
97   * @see https://webidl.spec.whatwg.org/#es-boolean
98   */
99  boolean (V: unknown): boolean
100
101  /**
102   * @see https://webidl.spec.whatwg.org/#es-any
103   */
104  any <Value>(V: Value): Value
105
106  /**
107   * @see https://webidl.spec.whatwg.org/#es-long-long
108   */
109  ['long long'] (V: unknown): number
110
111  /**
112   * @see https://webidl.spec.whatwg.org/#es-unsigned-long-long
113   */
114  ['unsigned long long'] (V: unknown): number
115
116  /**
117   * @see https://webidl.spec.whatwg.org/#es-unsigned-long
118   */
119  ['unsigned long'] (V: unknown): number
120
121  /**
122   * @see https://webidl.spec.whatwg.org/#es-unsigned-short
123   */
124  ['unsigned short'] (V: unknown, opts?: ConvertToIntOpts): number
125
126  /**
127   * @see https://webidl.spec.whatwg.org/#idl-ArrayBuffer
128   */
129  ArrayBuffer (V: unknown): ArrayBufferLike
130  ArrayBuffer (V: unknown, opts: { allowShared: false }): ArrayBuffer
131
132  /**
133   * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
134   */
135  TypedArray (
136    V: unknown,
137    TypedArray: NodeJS.TypedArray | ArrayBufferLike
138  ): NodeJS.TypedArray | ArrayBufferLike
139  TypedArray (
140    V: unknown,
141    TypedArray: NodeJS.TypedArray | ArrayBufferLike,
142    opts?: { allowShared: false }
143  ): NodeJS.TypedArray | ArrayBuffer
144
145  /**
146   * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
147   */
148  DataView (V: unknown, opts?: { allowShared: boolean }): DataView
149
150  /**
151   * @see https://webidl.spec.whatwg.org/#BufferSource
152   */
153  BufferSource (
154    V: unknown,
155    opts?: { allowShared: boolean }
156  ): NodeJS.TypedArray | ArrayBufferLike | DataView
157
158  ['sequence<ByteString>']: SequenceConverter<string>
159  
160  ['sequence<sequence<ByteString>>']: SequenceConverter<string[]>
161
162  ['record<ByteString, ByteString>']: RecordConverter<string, string>
163
164  [Key: string]: (...args: any[]) => unknown
165}
166
167export interface Webidl {
168  errors: WebidlErrors
169  util: WebidlUtil
170  converters: WebidlConverters
171
172  /**
173   * @description Performs a brand-check on {@param V} to ensure it is a
174   * {@param cls} object.
175   */
176  brandCheck <Interface>(V: unknown, cls: Interface, opts?: { strict?: boolean }): asserts V is Interface
177
178  /**
179   * @see https://webidl.spec.whatwg.org/#es-sequence
180   * @description Convert a value, V, to a WebIDL sequence type.
181   */
182  sequenceConverter <Type>(C: Converter<Type>): SequenceConverter<Type>
183
184  illegalConstructor (): never
185
186  /**
187   * @see https://webidl.spec.whatwg.org/#es-to-record
188   * @description Convert a value, V, to a WebIDL record type.
189   */
190  recordConverter <K extends string, V>(
191    keyConverter: Converter<K>,
192    valueConverter: Converter<V>
193  ): RecordConverter<K, V>
194
195  /**
196   * Similar to {@link Webidl.brandCheck} but allows skipping the check if third party
197   * interfaces are allowed.
198   */
199  interfaceConverter <Interface>(cls: Interface): (
200    V: unknown,
201    opts?: { strict: boolean }
202  ) => asserts V is typeof cls
203
204  // TODO(@KhafraDev): a type could likely be implemented that can infer the return type
205  // from the converters given?
206  /**
207   * Converts a value, V, to a WebIDL dictionary types. Allows limiting which keys are
208   * allowed, values allowed, optional and required keys. Auto converts the value to
209   * a type given a converter.
210   */
211  dictionaryConverter (converters: {
212    key: string,
213    defaultValue?: () => unknown,
214    required?: boolean,
215    converter: (...args: unknown[]) => unknown,
216    allowedValues?: unknown[]
217  }[]): (V: unknown) => Record<string, unknown>
218
219  /**
220   * @see https://webidl.spec.whatwg.org/#idl-nullable-type
221   * @description allows a type, V, to be null
222   */
223  nullableConverter <T>(
224    converter: Converter<T>
225  ): (V: unknown) => ReturnType<typeof converter> | null
226
227  argumentLengthCheck (args: { length: number }, min: number, context: string): void
228}

1import Pool from './pool'
2import Dispatcher from './dispatcher'
3import { URL } from 'url'
4
5export default BalancedPool
6
7type BalancedPoolConnectOptions = Omit<Dispatcher.ConnectOptions, "origin">;
8
9declare class BalancedPool extends Dispatcher {
10  constructor(url: string | string[] | URL | URL[], options?: Pool.Options);
11
12  addUpstream(upstream: string | URL): BalancedPool;
13  removeUpstream(upstream: string | URL): BalancedPool;
14  upstreams: Array<string>;
15
16  /** `true` after `pool.close()` has been called. */
17  closed: boolean;
18  /** `true` after `pool.destroyed()` has been called or `pool.close()` has been called and the pool shutdown has completed. */
19  destroyed: boolean;
20
21  // Override dispatcher APIs.
22  override connect(
23    options: BalancedPoolConnectOptions
24  ): Promise<Dispatcher.ConnectData>;
25  override connect(
26    options: BalancedPoolConnectOptions,
27    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
28  ): void;
29}

1import Pool from "./pool"
2
3export default PoolStats
4
5declare class PoolStats {
6  constructor(pool: Pool);
7  /** Number of open socket connections in this pool. */
8  connected: number;
9  /** Number of open socket connections in this pool that do not have an active request. */
10  free: number;
11  /** Number of pending requests across all clients in this pool. */
12  pending: number;
13  /** Number of queued requests across all clients in this pool. */
14  queued: number;
15  /** Number of currently active requests across all clients in this pool. */
16  running: number;
17  /** Number of active, pending, or queued requests across all clients in this pool. */
18  size: number;
19}

1export {
2	setGlobalOrigin,
3	getGlobalOrigin
4}
5  
6declare function setGlobalOrigin(origin: string | URL | undefined): void;
7declare function getGlobalOrigin(): URL | undefined;

1import { IncomingHttpHeaders } from "./header";
2import Client from './client'
3
4export default Errors
5
6declare namespace Errors {
7  export class UndiciError extends Error {
8    name: string;
9    code: string;
10  }
11
12  /** Connect timeout error. */
13  export class ConnectTimeoutError extends UndiciError {
14    name: 'ConnectTimeoutError';
15    code: 'UND_ERR_CONNECT_TIMEOUT';
16  }
17
18  /** A header exceeds the `headersTimeout` option. */
19  export class HeadersTimeoutError extends UndiciError {
20    name: 'HeadersTimeoutError';
21    code: 'UND_ERR_HEADERS_TIMEOUT';
22  }
23
24  /** Headers overflow error. */
25  export class HeadersOverflowError extends UndiciError {
26    name: 'HeadersOverflowError'
27    code: 'UND_ERR_HEADERS_OVERFLOW'
28  }
29
30  /** A body exceeds the `bodyTimeout` option. */
31  export class BodyTimeoutError extends UndiciError {
32    name: 'BodyTimeoutError';
33    code: 'UND_ERR_BODY_TIMEOUT';
34  }
35
36  export class ResponseStatusCodeError extends UndiciError {
37    constructor (
38      message?: string,
39      statusCode?: number,
40      headers?: IncomingHttpHeaders | string[] | null,
41      body?: null | Record<string, any> | string
42    );
43    name: 'ResponseStatusCodeError';
44    code: 'UND_ERR_RESPONSE_STATUS_CODE';
45    body: null | Record<string, any> | string
46    status: number
47    statusCode: number
48    headers: IncomingHttpHeaders | string[] | null;
49  }
50
51  /** Passed an invalid argument. */
52  export class InvalidArgumentError extends UndiciError {
53    name: 'InvalidArgumentError';
54    code: 'UND_ERR_INVALID_ARG';
55  }
56
57  /** Returned an invalid value. */
58  export class InvalidReturnValueError extends UndiciError {
59    name: 'InvalidReturnValueError';
60    code: 'UND_ERR_INVALID_RETURN_VALUE';
61  }
62
63  /** The request has been aborted by the user. */
64  export class RequestAbortedError extends UndiciError {
65    name: 'AbortError';
66    code: 'UND_ERR_ABORTED';
67  }
68
69  /** Expected error with reason. */
70  export class InformationalError extends UndiciError {
71    name: 'InformationalError';
72    code: 'UND_ERR_INFO';
73  }
74
75  /** Request body length does not match content-length header. */
76  export class RequestContentLengthMismatchError extends UndiciError {
77    name: 'RequestContentLengthMismatchError';
78    code: 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH';
79  }
80
81  /** Response body length does not match content-length header. */
82  export class ResponseContentLengthMismatchError extends UndiciError {
83    name: 'ResponseContentLengthMismatchError';
84    code: 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH';
85  }
86
87  /** Trying to use a destroyed client. */
88  export class ClientDestroyedError extends UndiciError {
89    name: 'ClientDestroyedError';
90    code: 'UND_ERR_DESTROYED';
91  }
92
93  /** Trying to use a closed client. */
94  export class ClientClosedError extends UndiciError {
95    name: 'ClientClosedError';
96    code: 'UND_ERR_CLOSED';
97  }
98
99  /** There is an error with the socket. */
100  export class SocketError extends UndiciError {
101    name: 'SocketError';
102    code: 'UND_ERR_SOCKET';
103    socket: Client.SocketInfo | null
104  }
105
106  /** Encountered unsupported functionality. */
107  export class NotSupportedError extends UndiciError {
108    name: 'NotSupportedError';
109    code: 'UND_ERR_NOT_SUPPORTED';
110  }
111
112  /** No upstream has been added to the BalancedPool. */
113  export class BalancedPoolMissingUpstreamError extends UndiciError {
114    name: 'MissingUpstreamError';
115    code: 'UND_ERR_BPL_MISSING_UPSTREAM';
116  }
117
118  export class HTTPParserError extends UndiciError {
119    name: 'HTTPParserError';
120    code: string;
121  }
122
123  /** The response exceed the length allowed. */
124  export class ResponseExceededMaxSizeError extends UndiciError {
125    name: 'ResponseExceededMaxSizeError';
126    code: 'UND_ERR_RES_EXCEEDED_MAX_SIZE';
127  }
128
129  export class RequestRetryError extends UndiciError {
130    constructor (
131      message: string,
132      statusCode: number,
133      headers?: IncomingHttpHeaders | string[] | null,
134      body?: null | Record<string, any> | string
135    );
136    name: 'RequestRetryError';
137    code: 'UND_ERR_REQ_RETRY';
138    statusCode: number;
139    data: {
140      count: number;
141    };
142    headers: Record<string, string | string[]>;
143  }
144
145  export class SecureProxyConnectionError extends UndiciError {
146    name: 'SecureProxyConnectionError';
147    code: 'UND_ERR_PRX_TLS';
148  }
149}