@yanglaofish/fishtools 0.5.2 → 0.5.3

package/node_modules/undici/docs/docs/getting-started.md

@@ -1,281 +0,0 @@
-# Getting Started
-
-<!--type=misc-->
-
-## Installation
-
-```bash
-npm install undici
-```
-
-## Fetch
-
-The quickest way to get started is with `fetch`, which follows the
-[Fetch Standard](https://fetch.spec.whatwg.org/) and works the same way as
-the browser API:
-
-```mjs
-import { fetch } from 'undici'
-
-const res = await fetch('https://example.com')
-const data = await res.json()
-console.log(data)
-```
-
-### Using the Request object
-
-undici also exports a `Request` class that follows the Fetch Standard:
-
-```mjs
-import { fetch, Request } from 'undici'
-
-const req = new Request('https://example.com', {
-  method: 'POST',
-  headers: { 'content-type': 'application/json' },
-  body: JSON.stringify({ hello: 'world' })
-})
-const res = await fetch(req)
-console.log(res.status)
-```
-
-### Streaming the response
-
-`res.body` is a web `ReadableStream`. Use `pipeline` from
-`node:stream/promises` to stream it to a file:
-
-```mjs
-import { fetch } from 'undici'
-import { pipeline } from 'node:stream/promises'
-import { createWriteStream } from 'node:fs'
-
-const res = await fetch('https://example.com/large-file.zip')
-await pipeline(res.body, createWriteStream('./file.zip'))
-```
-
-> Always consume or cancel the response body. In Node.js, garbage collection
-> is not aggressive enough to release connections promptly, so leaving a body
-> unread can cause connection leaks and stalled requests. See
-> [Specification Compliance - Garbage Collection](/#garbage-collection)
-> for details.
-
-For more on `fetch`, see [API Reference: Fetch](api/Fetch.md).
-
-## Dispatchers: Connection reuse and pooling
-
-By default, `fetch`, `request`, `stream`, and `pipeline` create a new connection
-for each call. For applications that make many requests to the same origin,
-this is wasteful. undici provides **dispatchers** that manage connections
-internally.
-
-### `Agent` — for requests to multiple origins
-
-`Agent` is the most general-purpose dispatcher. It pools connections per-origin
-and is the recommended default for most applications. Use it with
-`setGlobalDispatcher` to affect all undici calls globally:
-
-```js
-import { Agent, setGlobalDispatcher, fetch } from 'undici'
-
-const agent = new Agent({
-  keepAliveTimeout: 30_000,
-  keepAliveMaxTimeout: 600_000
-})
-setGlobalDispatcher(agent)
-
-// All subsequent fetch/request/stream/pipeline calls reuse connections
-const res = await fetch('https://api.example.com/data')
-```
-
-You can also pass a dispatcher per-request:
-
-```js
-await fetch('https://api.example.com/data', { dispatcher: agent })
-```
-
-### `Pool` — for requests to a single origin
-
-`Pool` manages a fixed set of connections to one origin. It gives you explicit
-control over concurrency:
-
-```js
-import { Pool, request } from 'undici'
-
-const pool = new Pool('https://api.example.com', { connections: 10 })
-
-const { body } = await request('https://api.example.com/data', {
-  dispatcher: pool
-})
-const data = await body.json()
-
-pool.close()
-```
-
-### `Client` — for a single connection
-
-`Client` maps to a single TCP connection. It supports pipelining (sending
-multiple requests before responses arrive), which should only be enabled for
-trusted remote servers:
-
-```js
-import { Client } from 'undici'
-
-const client = new Client('https://api.example.com', {
-  pipelining: 5
-})
-
-const { body } = await client.request({ path: '/', method: 'GET' })
-await body.dump()
-
-client.close()
-```
-
-For more on dispatcher options and lifecycle, see:
-- [API Reference: Agent](api/Agent.md)
-- [API Reference: Pool](api/Pool.md)
-- [API Reference: Client](api/Client.md)
-
-## Timeouts
-
-undici applies timeouts at two levels:
-
-- **`headersTimeout`** — time to wait for response headers (default: 300s).
-- **`bodyTimeout`** — time between consecutive body chunks (default: 300s).
-
-Set these on the dispatcher or per-request:
-
-```js
-import { Agent, setGlobalDispatcher } from 'undici'
-
-const agent = new Agent({
-  headersTimeout: 5_000,
-  bodyTimeout: 30_000
-})
-
-setGlobalDispatcher(agent)
-```
-
-Timeout errors are thrown as `HeadersTimeoutError` and `BodyTimeoutError`.
-See [API Reference: Errors](api/Errors.md) for the full list.
-
-## Error handling
-
-undici exposes structured errors via `error.code`:
-
-```js
-import { request, errors } from 'undici'
-
-try {
-  const { body } = await request('https://example.com')
-  await body.json()
-} catch (err) {
-  switch (err.code) {
-    case 'UND_ERR_CONNECT_TIMEOUT':
-      console.error('Connection timed out')
-      break
-    case 'UND_ERR_HEADERS_TIMEOUT':
-      console.error('Headers timed out')
-      break
-    case 'UND_ERR_BODY_TIMEOUT':
-      console.error('Body timed out')
-      break
-    case 'UND_ERR_ABORTED':
-      console.error('Request was aborted')
-      break
-    default:
-      console.error(err)
-  }
-}
-```
-
-### Aborting requests
-
-```js
-import { request } from 'undici'
-
-const ac = new AbortController()
-
-setTimeout(() => ac.abort(), 1000)
-
-try {
-  const { body } = await request('https://example.com', {
-    signal: ac.signal
-  })
-  await body.dump()
-} catch (err) {
-  console.error(err.code) // UND_ERR_ABORTED
-}
-```
-
-## Common patterns
-
-### Proxies
-
-Use `ProxyAgent` for HTTP(S) proxies, or `EnvHttpProxyAgent` to pick up
-proxy settings from environment variables:
-
-```js
-import { ProxyAgent, setGlobalDispatcher } from 'undici'
-
-const proxy = new ProxyAgent('http://proxy.internal:8080')
-setGlobalDispatcher(proxy)
-```
-
-See [Best Practices: Proxy](best-practices/proxy.md) and
-[API Reference: ProxyAgent](api/ProxyAgent.md).
-
-### Mocking in tests
-
-```js
-import { MockAgent, setGlobalDispatcher, request } from 'undici'
-
-const mockAgent = new MockAgent()
-setGlobalDispatcher(mockAgent)
-
-const mockPool = mockAgent.get('https://api.example.com')
-mockPool.intercept({ path: '/users' }).reply(200, [{ id: 1 }])
-
-const { body } = await request('https://api.example.com/users')
-console.log(await body.json())
-```
-
-See [Best Practices: Mocking Request](best-practices/mocking-request.md)
-and [API Reference: MockAgent](api/MockAgent.md).
-
-### Testing with undici
-
-For test suites, set short keep-alive timeouts to avoid slow teardowns:
-
-```js
-import { Agent, setGlobalDispatcher } from 'undici'
-
-const agent = new Agent({
-  keepAliveTimeout: 10,
-  keepAliveMaxTimeout: 10
-})
-setGlobalDispatcher(agent)
-```
-
-See [Best Practices: Writing Tests](best-practices/writing-tests.md).
-
-### Customizing the global fetch
-
-You can override Node.js's built-in globals with `install()`:
-
-```js
-import { install } from 'undici'
-
-install()
-
-// Global fetch, Headers, Response, Request, and FormData
-// now come from undici, not the Node.js bundle
-const res = await fetch('https://example.com')
-```
-
-See [API Reference: Global Installation](api/GlobalInstallation.md).
-
-## Further reading
-
-- [Undici vs. Built-in Fetch](best-practices/undici-vs-builtin-fetch.md) —
-  when to install undici vs using Node.js built-in fetch
-- [API Reference](api/Dispatcher.md) — full dispatcher API documentation
-- [Examples](/examples/) — runnable code examples

package/node_modules/undici/docs/docs/site.json

@@ -1,125 +0,0 @@
-{
-  "sidebar": [
-    {
-      "groupName": "Documentation",
-      "items": [
-        { "link": "/", "label": "Home" },
-        { "link": "/getting-started", "label": "Getting Started" }
-      ]
-    },
-    {
-      "groupName": "API",
-      "items": [
-        {
-          "label": "Core",
-          "items": [
-            { "link": "/api/Dispatcher", "label": "Dispatcher" },
-            { "link": "/api/Client", "label": "Client" },
-            { "link": "/api/H2CClient", "label": "H2CClient" },
-            { "link": "/api/Pool", "label": "Pool" },
-            { "link": "/api/BalancedPool", "label": "BalancedPool" },
-            { "link": "/api/RoundRobinPool", "label": "RoundRobinPool" },
-            { "link": "/api/Agent", "label": "Agent" },
-            { "link": "/api/PoolStats", "label": "PoolStats" },
-            { "link": "/api/Connector", "label": "Connector" }
-          ]
-        },
-        {
-          "label": "Proxy & Agents",
-          "items": [
-            { "link": "/api/ProxyAgent", "label": "ProxyAgent" },
-            {
-              "link": "/api/EnvHttpProxyAgent",
-              "label": "EnvHttpProxyAgent"
-            },
-            { "link": "/api/Socks5ProxyAgent", "label": "Socks5ProxyAgent" },
-            { "link": "/api/RetryAgent", "label": "RetryAgent" }
-          ]
-        },
-        {
-          "label": "Web Standards",
-          "items": [
-            { "link": "/api/Fetch", "label": "Fetch" },
-            { "link": "/api/EventSource", "label": "EventSource" },
-            { "link": "/api/WebSocket", "label": "WebSocket" },
-            { "link": "/api/Cookies", "label": "Cookies" },
-            { "link": "/api/CacheStorage", "label": "CacheStorage" },
-            { "link": "/api/ContentType", "label": "MIME Type Parsing" }
-          ]
-        },
-        {
-          "label": "Mocking",
-          "items": [
-            { "link": "/api/MockClient", "label": "MockClient" },
-            { "link": "/api/MockPool", "label": "MockPool" },
-            { "link": "/api/MockAgent", "label": "MockAgent" },
-            { "link": "/api/SnapshotAgent", "label": "SnapshotAgent" },
-            { "link": "/api/MockCallHistory", "label": "MockCallHistory" },
-            {
-              "link": "/api/MockCallHistoryLog",
-              "label": "MockCallHistoryLog"
-            },
-            { "link": "/api/MockErrors", "label": "MockErrors" }
-          ]
-        },
-        {
-          "label": "Interceptors",
-          "items": [
-            { "link": "/api/Interceptors", "label": "Interceptors" }
-          ]
-        },
-        {
-          "label": "Handlers",
-          "items": [
-            { "link": "/api/RedirectHandler", "label": "RedirectHandler" },
-            { "link": "/api/RetryHandler", "label": "RetryHandler" }
-          ]
-        },
-        {
-          "label": "Diagnostics & Utilities",
-          "items": [
-            { "link": "/api/Errors", "label": "Errors" },
-            {
-              "link": "/api/DiagnosticsChannel",
-              "label": "Diagnostics Channel Support"
-            },
-            { "link": "/api/Debug", "label": "Debug" },
-            { "link": "/api/Util", "label": "Util" },
-            {
-              "link": "/api/GlobalInstallation",
-              "label": "Global Installation"
-            },
-            { "link": "/api/api-lifecycle", "label": "API Lifecycle" }
-          ]
-        }
-      ]
-    },
-    {
-      "groupName": "Best Practices",
-      "items": [
-        {
-          "link": "/best-practices/undici-vs-builtin-fetch",
-          "label": "Undici vs. Built-in Fetch"
-        },
-        {
-          "link": "/best-practices/migrating-from-v7-to-v8",
-          "label": "Migrating from Undici 7 to 8"
-        },
-        { "link": "/best-practices/proxy", "label": "Proxy" },
-        {
-          "link": "/best-practices/client-certificate",
-          "label": "Client Certificate"
-        },
-        {
-          "link": "/best-practices/writing-tests",
-          "label": "Writing Tests"
-        },
-        {
-          "link": "/best-practices/mocking-request",
-          "label": "Mocking Request"
-        },
-        { "link": "/best-practices/crawling", "label": "Crawling" }
-      ]
-    }
-  ]
-}

package/node_modules/undici/docs/docs/type-map.json

@@ -1,79 +0,0 @@
-{
-  "AbortError": "/api/Errors.md#class-aborterror",
-  "Agent": "/api/Agent.md#class-agent",
-  "AgentDispatchOptions": "/api/Agent.md#agentdispatchoptions-handler",
-  "AgentOptions": "/api/Agent.md#new-agentoptions",
-  "BalancedPool": "/api/BalancedPool.md#class-balancedpool",
-  "BalancedPoolOptions": "/api/BalancedPool.md#parameter-balancedpooloptions",
-  "BodyMixin": "/api/Fetch.md#new-formdata",
-  "Buffer": "https://nodejs.org/api/buffer.html#class-buffer",
-  "BuildOptions": "/api/Connector.md#buildconnectoroptions",
-  "CacheKey": "/api/CacheStore.md#cachekey",
-  "CacheStore": "/api/CacheStore.md#new-memorycachestoreoptions",
-  "CacheValue": "/api/CacheStore.md#cachevalue",
-  "ClientDestroyedError": "/api/Errors.md#class-clientdestroyederror",
-  "ClientOptions": "/api/Client.md#new-clienturl-options",
-  "ClientStats": "/api/ClientStats.md#class-clientstats",
-  "ConnectOptions": "/api/Dispatcher.md#class-dispatcher",
-  "Cookie": "/api/Cookies.md#cookie",
-  "DispatchController": "/api/Dispatcher.md#class-dispatcher",
-  "DispatchHandler": "/api/Dispatcher.md#class-dispatcher",
-  "DispatchOptions": "/api/Dispatcher.md#class-dispatcher",
-  "Dispatcher": "/api/Dispatcher.md#class-dispatcher",
-  "Duplex": "https://nodejs.org/api/stream.html#class-streamduplex",
-  "EnvHttpProxyAgent": "/api/EnvHttpProxyAgent.md#class-envhttpproxyagent",
-  "EnvHttpProxyAgentOptions": "/api/EnvHttpProxyAgent.md#new-envhttpproxyagentoptions",
-  "EventEmitter": "https://nodejs.org/api/events.html#class-eventemitter",
-  "GetResult": "/api/CacheStore.md#getresult",
-  "H2CClientOptions": "/api/H2CClient.md#new-h2cclienturl-options",
-  "HeadersInit": "https://developer.mozilla.org/docs/Web/API/Headers/Headers",
-  "InvalidArgumentError": "/api/Errors.md#class-invalidargumenterror",
-  "Iterable": "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Iteration_protocols",
-  "MaxOriginsReachedError": "/api/Errors.md#class-maxoriginsreachederror",
-  "MockAgent": "/api/MockAgent.md#class-mockagent",
-  "MockAgentOptions": "/api/MockAgent.md#parameter-mockagentoptions",
-  "MockCallHistory": "/api/MockCallHistory.md#class-mockcallhistory",
-  "MockCallHistoryLog": "/api/MockCallHistoryLog.md#class-mockcallhistorylog",
-  "MockClient": "/api/MockClient.md#class-mockclient",
-  "MockClientOptions": "/api/MockClient.md#parameter-mockclientoptions",
-  "MockInterceptor": "/api/MockPool.md#return-mockinterceptor",
-  "MockInterceptor.Options": "/api/MockPool.md#parameter-mockpoolinterceptoptions",
-  "MockPool": "/api/MockPool.md#class-mockpool",
-  "MockPoolInterceptOptions": "/api/MockPool.md#parameter-mockpoolinterceptoptions",
-  "MockPoolOptions": "/api/MockPool.md#parameter-mockpooloptions",
-  "MockResponseOptions": "/api/MockPool.md#parameter-mockresponseoptions",
-  "MockScope": "/api/MockPool.md#return-mockscope",
-  "PendingInterceptor": "/api/MockAgent.md#new-mockagentoptions",
-  "PipelineOptions": "/api/Dispatcher.md#class-dispatcher",
-  "Pool": "/api/Pool.md#class-pool",
-  "PoolOptions": "/api/Pool.md#new-poolurl-options",
-  "PoolStats": "/api/PoolStats.md#class-poolstats",
-  "ProxyAgent": "/api/ProxyAgent.md#class-proxyagent",
-  "ProxyAgentOptions": "/api/ProxyAgent.md#new-proxyagentoptions",
-  "Readable": "https://nodejs.org/api/stream.html#class-streamreadable",
-  "Record": "https://www.typescriptlang.org/docs/handbook/utility-types.html#recordkeys-type",
-  "RequestInit": "/api/Fetch.md#new-formdata",
-  "RequestOptions": "/api/Dispatcher.md#class-dispatcher",
-  "ResponseInit": "/api/Fetch.md#new-formdata",
-  "RetryContext": "/api/RetryHandler.md#retrycontext",
-  "RetryHandler": "/api/RetryHandler.md#class-retryhandler",
-  "RetryHandlers": "/api/RetryHandler.md#parameter-retryhandlers",
-  "RetryOptions": "/api/RetryHandler.md#retryoptions",
-  "RetryState": "/api/RetryHandler.md#retrystate",
-  "RoundRobinPoolOptions": "/api/RoundRobinPool.md#parameter-roundrobinpooloptions",
-  "SnapshotRecorder": "/api/SnapshotAgent.md#new-snapshotagentoptions",
-  "Socket": "https://nodejs.org/api/net.html#class-netsocket",
-  "SocketInfo": "/api/Errors.md#new-requestretryerrormessage-code-options",
-  "StreamOptions": "/api/Dispatcher.md#class-dispatcher",
-  "TLSSocket": "https://nodejs.org/api/tls.html#class-tlstlssocket",
-  "UndiciError": "/api/Errors.md#class-undicierror",
-  "UndiciHeaders": "/api/Dispatcher.md#class-dispatcher",
-  "UpgradeOptions": "/api/Dispatcher.md#class-dispatcher",
-  "UrlObject": "/index.md#urlobject",
-  "WebSocketInit": "/api/WebSocket.md#new-websocketurl-protocols",
-  "WebSocketStreamOptions": "/api/WebSocket.md#new-websocketurl-protocols",
-  "Writable": "https://nodejs.org/api/stream.html#class-streamwritable",
-  "buildConnector.BuildOptions": "/api/Connector.md#buildconnectoroptions",
-  "net.Socket": "https://nodejs.org/api/net.html#class-netsocket",
-  "stream.Readable": "https://nodejs.org/api/stream.html#class-streamreadable"
-}

package/node_modules/undici/lib/dispatcher/dispatcher1-wrapper.js

@@ -1,110 +0,0 @@
-'use strict'
-
-const Dispatcher = require('./dispatcher')
-const { InvalidArgumentError } = require('../core/errors')
-const { toRawHeaders } = require('../core/util')
-const { kOriginless, kUrl } = require('../core/symbols')
-
-class LegacyHandlerWrapper {
-  #handler
-
-  constructor (handler) {
-    this.#handler = handler
-  }
-
-  onRequestStart (controller, context) {
-    this.#handler.onConnect?.((reason) => controller.abort(reason), context)
-  }
-
-  onRequestUpgrade (controller, statusCode, headers, socket) {
-    const rawHeaders = controller?.rawHeaders ?? toRawHeaders(headers ?? {})
-    this.#handler.onUpgrade?.(statusCode, rawHeaders, socket)
-  }
-
-  onResponseStart (controller, statusCode, headers, statusMessage) {
-    const rawHeaders = controller?.rawHeaders ?? toRawHeaders(headers ?? {})
-
-    if (this.#handler.onHeaders?.(statusCode, rawHeaders, () => controller.resume(), statusMessage) === false) {
-      controller.pause()
-    }
-  }
-
-  onResponseData (controller, chunk) {
-    if (this.#handler.onData?.(chunk) === false) {
-      controller.pause()
-    }
-  }
-
-  onResponseEnd (controller, trailers) {
-    const rawTrailers = controller?.rawTrailers ?? toRawHeaders(trailers ?? {})
-    this.#handler.onComplete?.(rawTrailers)
-  }
-
-  onResponseError (_controller, err) {
-    if (!this.#handler.onError) {
-      throw err
-    }
-
-    this.#handler.onError(err)
-  }
-
-  onBodySent (chunk) {
-    this.#handler.onBodySent?.(chunk)
-  }
-
-  onRequestSent () {
-    this.#handler.onRequestSent?.()
-  }
-
-  onResponseStarted () {
-    this.#handler.onResponseStarted?.()
-  }
-}
-
-class Dispatcher1Wrapper extends Dispatcher {
-  #dispatcher
-
-  constructor (dispatcher) {
-    super()
-
-    if (!dispatcher || typeof dispatcher.dispatch !== 'function') {
-      throw new InvalidArgumentError('Argument dispatcher must implement dispatch')
-    }
-
-    this.#dispatcher = dispatcher
-    this[kUrl] = dispatcher[kUrl]
-    this[kOriginless] = dispatcher[kOriginless]
-  }
-
-  static wrapHandler (handler) {
-    if (!handler || typeof handler !== 'object') {
-      throw new InvalidArgumentError('handler must be an object')
-    }
-
-    if (typeof handler.onRequestStart === 'function') {
-      return handler
-    }
-
-    return new LegacyHandlerWrapper(handler)
-  }
-
-  dispatch (opts, handler) {
-    // Legacy (v1) consumers do not support HTTP/2, so force HTTP/1.1.
-    // See https://github.com/nodejs/undici/issues/4989
-    if (opts.allowH2 !== false) {
-      opts = { ...opts, allowH2: false }
-    }
-
-    return this.#dispatcher.dispatch(opts, Dispatcher1Wrapper.wrapHandler(handler))
-  }
-
-  close (...args) {
-    return this.#dispatcher.close(...args)
-  }
-
-  destroy (...args) {
-    return this.#dispatcher.destroy(...args)
-  }
-}
-
-module.exports = Dispatcher1Wrapper

package/node_modules/undici/types/dispatcher1-wrapper.d.ts

@@ -1,7 +0,0 @@
-import Dispatcher from './dispatcher'
-
-export default Dispatcher1Wrapper
-
-declare class Dispatcher1Wrapper extends Dispatcher {
-  constructor (dispatcher: Dispatcher)
-}