@scriptc/compiler 0.4.0 → 0.4.1

package/shims/undici/core/pool.ts

@@ -0,0 +1,280 @@
+// undici's Pool (lib/dispatcher/pool.js, pool-base.js, pool-stats.js): a
+// set of Clients for one origin, created on demand up to `connections`, with
+// a queue for requests no client can take.
+import { buildConnector } from "./connector.ts";
+import { Client } from "./client.ts";
+import { Dispatcher, DispatcherBase } from "./dispatcher.ts";
+import { InvalidArgumentError } from "./errors.ts";
+import { parseOrigin } from "./util.ts";
+import type {
+  ClientOptions,
+  DispatchHandlers,
+  DispatchOptions,
+  PoolOptions,
+  Profile,
+} from "./types.ts";
+
+interface QueuedDispatch {
+  opts: DispatchOptions;
+  handler: DispatchHandlers;
+}
+
+/** pool-stats.js: live counters over a pool's clients. */
+export class PoolStats {
+  __pool: PoolBase;
+
+  constructor(pool: PoolBase) {
+    this.__pool = pool;
+  }
+
+  get connected(): number {
+    return this.__pool.__connectedCount();
+  }
+
+  get free(): number {
+    return this.__pool.__freeCount();
+  }
+
+  get pending(): number {
+    return this.__pool.__pendingCount();
+  }
+
+  get queued(): number {
+    return this.__pool.__queuedCount();
+  }
+
+  get running(): number {
+    return this.__pool.__runningCount();
+  }
+
+  get size(): number {
+    return this.__pool.__sizeCount();
+  }
+}
+
+export class PoolBase extends DispatcherBase {
+  __clients: Dispatcher[];
+  __clientNeedDrain: Map<Dispatcher, boolean>;
+  __queue: QueuedDispatch[];
+  __queued: number;
+  __needDrain: boolean;
+  __closedResolve: (() => void) | null;
+  __stats: PoolStats;
+  __onDrain: (origin: URL, targets: Dispatcher[]) => void;
+  __onConnect: (origin: URL, targets: Dispatcher[]) => void;
+  __onDisconnect: (origin: URL, targets: Dispatcher[], err: Error) => void;
+  __onConnectionError: (origin: URL, targets: Dispatcher[], err: Error) => void;
+
+  constructor(profile: Profile) {
+    super(profile);
+    this.__clients = [];
+    this.__clientNeedDrain = new Map<Dispatcher, boolean>();
+    this.__queue = [];
+    this.__queued = 0;
+    this.__needDrain = false;
+    this.__closedResolve = null;
+    this.__stats = new PoolStats(this);
+    this.__onDrain = (origin: URL, targets: Dispatcher[]): void => {
+      const client = targets[0]!;
+      let needDrain = false;
+      while (!needDrain) {
+        const item = this.__queue.shift();
+        if (item === undefined) break;
+        this.__queued--;
+        needDrain = !client.dispatch(item.opts, item.handler);
+      }
+      this.__clientNeedDrain.set(client, needDrain);
+      if (!needDrain && this.__needDrain) {
+        this.__needDrain = false;
+        this.emit("drain", origin, [this as Dispatcher, ...targets]);
+      }
+      const closed = this.__closedResolve;
+      if (closed !== null && this.__queue.length === 0) {
+        Promise.all(this.__clients.map((c) => c.close())).then(() => closed());
+      }
+    };
+    this.__onConnect = (origin: URL, targets: Dispatcher[]): void => {
+      this.emit("connect", origin, [this as Dispatcher, ...targets]);
+    };
+    this.__onDisconnect = (origin: URL, targets: Dispatcher[], err: Error): void => {
+      this.emit("disconnect", origin, [this as Dispatcher, ...targets], err);
+    };
+    this.__onConnectionError = (origin: URL, targets: Dispatcher[], err: Error): void => {
+      this.emit("connectionError", origin, [this as Dispatcher, ...targets], err);
+    };
+  }
+
+  get stats(): PoolStats {
+    return this.__stats;
+  }
+
+  __busyFlag(): boolean {
+    return this.__needDrain;
+  }
+
+  __connectedCount(): number {
+    return this.__clients.filter((c) => c.__connectedFlag()).length;
+  }
+
+  __freeCount(): number {
+    return this.__clients.filter((c) => c.__connectedFlag() && !this.__clientNeedDrain.get(c))
+      .length;
+  }
+
+  __pendingCount(): number {
+    let ret = this.__queued;
+    for (const c of this.__clients) ret += c.__pendingCount();
+    return ret;
+  }
+
+  __queuedCount(): number {
+    return this.__queued;
+  }
+
+  __runningCount(): number {
+    let ret = 0;
+    for (const c of this.__clients) ret += c.__runningCount();
+    return ret;
+  }
+
+  __sizeCount(): number {
+    let ret = this.__queued;
+    for (const c of this.__clients) ret += c.__sizeCount();
+    return ret;
+  }
+
+  __close(): Promise<void> {
+    if (this.__queue.length === 0) {
+      return Promise.all(this.__clients.map((c) => c.close())).then(() => {});
+    }
+    return new Promise<void>((resolve) => {
+      this.__closedResolve = resolve;
+    });
+  }
+
+  __destroy(err: Error): Promise<void> {
+    for (;;) {
+      const item = this.__queue.shift();
+      if (item === undefined) break;
+      if (item.handler.onError !== undefined) item.handler.onError!(err);
+    }
+    return Promise.all(this.__clients.map((c) => c.destroy(err))).then(() => {});
+  }
+
+  __dispatch(opts: DispatchOptions, handler: DispatchHandlers): boolean {
+    const dispatcher = this.__getDispatcher();
+    if (dispatcher === null) {
+      this.__needDrain = true;
+      this.__queue.push({ opts, handler });
+      this.__queued++;
+    } else if (!dispatcher.dispatch(opts, handler)) {
+      this.__clientNeedDrain.set(dispatcher, true);
+      this.__needDrain = this.__getDispatcher() === null;
+    }
+    return !this.__needDrain;
+  }
+
+  __getDispatcher(): Dispatcher | null {
+    return null;
+  }
+
+  __addClient(client: Dispatcher): void {
+    client.on("drain", this.__onDrain);
+    client.on("connect", this.__onConnect);
+    client.on("disconnect", this.__onDisconnect);
+    client.on("connectionError", this.__onConnectionError);
+    this.__clients.push(client);
+    this.__clientNeedDrain.set(client, false);
+    if (this.__needDrain) {
+      process.nextTick(() => {
+        if (this.__needDrain) this.__onDrain(clientUrl(client), [client, this as Dispatcher]);
+      });
+    }
+  }
+}
+
+function clientUrl(client: Dispatcher): URL {
+  return client instanceof Client ? client.__url : new URL("http://localhost");
+}
+
+export class Pool extends PoolBase {
+  __connections: number | null;
+  __url: URL;
+  __options: ClientOptions;
+  __factory: ((origin: URL, opts: object) => Dispatcher) | null;
+
+  constructor(origin: string | URL, options: PoolOptions | undefined, profile: Profile) {
+    super(profile);
+    const opts: PoolOptions = options ?? {};
+    const connections = opts.connections ?? null;
+    if (connections !== null && (!Number.isFinite(connections) || connections < 0)) {
+      throw new InvalidArgumentError("invalid connections");
+    }
+    const connect = opts.connect ?? null;
+    const connector =
+      typeof connect === "function"
+        ? connect
+        : buildConnector(
+            connect !== null
+              ? {
+                  ...connect,
+                  timeout:
+                    connect.timeout !== undefined ? connect.timeout : (opts.connectTimeout ?? 10e3),
+                }
+              : { timeout: opts.connectTimeout ?? 10e3 },
+          );
+    const interceptors = opts.interceptors;
+    if (profile.major < 7 && interceptors !== undefined && interceptors.Pool !== undefined) {
+      this.__interceptors = interceptors.Pool;
+    }
+    this.__connections = connections !== null && connections !== 0 ? connections : null;
+    this.__url = parseOrigin(origin, profile);
+    this.__options = {
+      keepAliveTimeout: opts.keepAliveTimeout,
+      keepAliveMaxTimeout: opts.keepAliveMaxTimeout,
+      keepAliveTimeoutThreshold: opts.keepAliveTimeoutThreshold,
+      pipelining: opts.pipelining,
+      maxHeaderSize: opts.maxHeaderSize,
+      bodyTimeout: opts.bodyTimeout,
+      headersTimeout: opts.headersTimeout,
+      strictContentLength: opts.strictContentLength,
+      maxRequestsPerClient: opts.maxRequestsPerClient,
+      maxResponseSize: opts.maxResponseSize,
+      localAddress: opts.localAddress,
+      interceptors: interceptors !== undefined ? { Client: interceptors.Client } : undefined,
+      connect: connector,
+    };
+    const factory = opts.factory;
+    this.__factory = factory !== undefined ? factory : null;
+    if (profile.major >= 7) {
+      // 7.x drops a client whose connection attempt failed.
+      this.on("connectionError", (_origin: URL, targets: Dispatcher[], _err: Error) => {
+        for (const target of targets) {
+          const idx = this.__clients.indexOf(target);
+          if (idx !== -1) this.__clients.splice(idx, 1);
+        }
+      });
+    }
+  }
+
+  __getDispatcher(): Dispatcher | null {
+    for (const client of this.__clients) {
+      if (!this.__clientNeedDrain.get(client)) return client;
+    }
+    if (this.__connections === null || this.__clients.length < this.__connections) {
+      const factory = this.__factory;
+      const client =
+        factory !== null
+          ? factory(this.__url, this.__options)
+          : this.__createClient(this.__url, this.__options);
+      this.__addClient(client);
+      return client;
+    }
+    return null;
+  }
+
+  /** The default factory: a Client of the same undici version. */
+  __createClient(origin: URL, options: ClientOptions): Dispatcher {
+    return new Client(origin, options, this.__profile);
+  }
+}

package/shims/undici/core/readable.ts

@@ -0,0 +1,268 @@
+// undici's response body (lib/api/readable.js): a readable byte stream fed
+// by the dispatch handler, with the fetch body mixin (text/json/
+// arrayBuffer/blob/bytes) and dump().
+//
+// It follows node:stream's Readable contract for the members it declares
+// (flowing on a 'data' listener or resume(), pause(), 'data'/'end'/'close'/
+// 'error' events and their ordering, destroy(err), back-pressure through
+// push()'s return value), built on EventEmitter: scriptc compiles program
+// classes extending EventEmitter under both its own Node declarations and
+// @types/node, which a node:stream subclass does not get.
+import { EventEmitter } from "node:events";
+import { NotSupportedError, RequestAbortedError } from "./errors.ts";
+import type { Profile } from "./types.ts";
+
+const HIGH_WATER_MARK = 64 * 1024;
+
+export class BodyReadable extends EventEmitter {
+  __resumeFn: () => void;
+  __abortFn: (err: Error) => void;
+  __contentType: string;
+  __consuming: boolean;
+  __profile: Profile;
+  __buffer: Buffer[];
+  __length: number;
+  __flowing: boolean;
+  __ended: boolean;
+  __endEmitted: boolean;
+  __destroyed: boolean;
+  __flowScheduled: boolean;
+  __needsResume: boolean;
+
+  constructor(
+    resume: () => void,
+    abort: (err: Error) => void,
+    contentType: string,
+    profile: Profile,
+  ) {
+    super();
+    this.__resumeFn = resume;
+    this.__abortFn = abort;
+    this.__contentType = contentType;
+    this.__consuming = false;
+    this.__profile = profile;
+    this.__buffer = [];
+    this.__length = 0;
+    this.__flowing = false;
+    this.__ended = false;
+    this.__endEmitted = false;
+    this.__destroyed = false;
+    this.__flowScheduled = false;
+    this.__needsResume = false;
+    // Readable.on('data') switches the stream to flowing mode.
+    this.on("newListener", (event: string) => {
+      if (event === "data" && !this.__flowing) this.resume();
+    });
+  }
+
+  get destroyed(): boolean {
+    return this.__destroyed;
+  }
+
+  get readableEnded(): boolean {
+    return this.__endEmitted;
+  }
+
+  get readableLength(): number {
+    return this.__length;
+  }
+
+  get readableFlowing(): boolean {
+    return this.__flowing;
+  }
+
+  /** Readable.push: queue a chunk (null ends the body). Returns false once
+   * the buffer reaches the high-water mark; the dispatcher then pauses the
+   * connection until the consumer drains it. */
+  push(chunk: Buffer | null): boolean {
+    if (this.__destroyed || this.__ended) return false;
+    if (chunk === null) {
+      this.__ended = true;
+      if (this.__length === 0) this.__scheduleEnd();
+      else this.__scheduleFlow();
+      return false;
+    }
+    if (this.__flowing && this.__length === 0 && this.listenerCount("data") > 0) {
+      this.emit("data", chunk);
+      return true;
+    }
+    this.__buffer.push(chunk);
+    this.__length += chunk.length;
+    if (this.__flowing) this.__scheduleFlow();
+    const below = this.__length < HIGH_WATER_MARK;
+    if (!below) this.__needsResume = true;
+    return below;
+  }
+
+  resume(): this {
+    if (!this.__flowing) {
+      this.__flowing = true;
+      this.__scheduleFlow();
+    }
+    return this;
+  }
+
+  pause(): this {
+    this.__flowing = false;
+    return this;
+  }
+
+  destroy(err?: Error): this {
+    if (this.__destroyed) return this;
+    this.__destroyed = true;
+    let error: Error | null = err ?? null;
+    if (error === null && !this.__endEmitted) error = new RequestAbortedError();
+    if (error !== null) this.__abortFn(error);
+    this.__buffer = [];
+    this.__length = 0;
+    const reported = error;
+    process.nextTick(() => {
+      if (reported !== null) this.emit("error", reported);
+      this.emit("close");
+    });
+    return this;
+  }
+
+  __scheduleFlow(): void {
+    if (this.__flowScheduled) return;
+    this.__flowScheduled = true;
+    process.nextTick(() => {
+      this.__flowScheduled = false;
+      this.__flow();
+    });
+  }
+
+  __flow(): void {
+    while (this.__flowing && !this.__destroyed && this.__buffer.length > 0) {
+      const chunk = this.__buffer.shift()!;
+      this.__length -= chunk.length;
+      this.emit("data", chunk);
+    }
+    if (this.__destroyed) return;
+    if (this.__needsResume && this.__length < HIGH_WATER_MARK) {
+      this.__needsResume = false;
+      this.__resumeFn();
+    }
+    if (this.__ended && this.__length === 0 && this.__flowing) this.__scheduleEnd();
+  }
+
+  __scheduleEnd(): void {
+    process.nextTick(() => {
+      if (this.__endEmitted || this.__destroyed || !this.__flowing || this.__length > 0) return;
+      this.__endEmitted = true;
+      this.emit("end");
+      // autoDestroy: a fully read body closes.
+      process.nextTick(() => {
+        if (this.__destroyed) return;
+        this.__destroyed = true;
+        this.emit("close");
+      });
+    });
+  }
+
+  /** True once text()/json()/arrayBuffer()/bytes()/blob()/dump() started
+   * consuming the body. */
+  get bodyUsed(): boolean {
+    return this.__consuming;
+  }
+
+  text(): Promise<string> {
+    return this.__consume().then((bytes) => decodeText(bytes, this.__profile));
+  }
+
+  // undici declares json() as Promise<any>: callers assign the parsed value
+  // to their own annotated types without a cast, exactly as with undici.
+  // oxlint-disable-next-line typescript/no-explicit-any
+  json(): Promise<any> {
+    return this.__consume().then((bytes) => JSON.parse(decodeText(bytes, this.__profile)));
+  }
+
+  arrayBuffer(): Promise<ArrayBuffer> {
+    return this.__consume().then((bytes) => {
+      const out = new ArrayBuffer(bytes.length);
+      new Uint8Array(out).set(bytes);
+      return out;
+    });
+  }
+
+  bytes(): Promise<Uint8Array> {
+    return this.__consume().then((bytes) => new Uint8Array(bytes));
+  }
+
+  blob(): Promise<Blob> {
+    return this.__consume().then((bytes) => new Blob([bytes], { type: this.__contentType }));
+  }
+
+  formData(): Promise<never> {
+    return Promise.reject(new NotSupportedError());
+  }
+
+  /** Reads and discards up to `limit` bytes (default 256 KiB on 5.x, 128 KiB
+   * on 7.x), then resolves; read errors are swallowed like undici's. */
+  dump(opts?: { limit: number }): Promise<void> {
+    let limit =
+      opts !== undefined && Number.isFinite(opts.limit)
+        ? opts.limit
+        : this.__profile.major >= 7
+          ? 131072
+          : 262144;
+    this.__consuming = true;
+    return new Promise<void>((resolve) => {
+      if (this.__endEmitted || this.__destroyed) {
+        resolve();
+        return;
+      }
+      this.on("data", (chunk: Buffer) => {
+        limit -= chunk.length;
+        if (limit < 0) {
+          this.destroy();
+          resolve();
+        }
+      });
+      this.on("end", () => resolve());
+      this.on("error", () => resolve());
+      this.on("close", () => resolve());
+    });
+  }
+
+  __consume(): Promise<Buffer> {
+    if (this.bodyUsed) return Promise.reject(new TypeError("unusable"));
+    this.__consuming = true;
+    return new Promise<Buffer>((resolve, reject) => {
+      const chunks: Buffer[] = [];
+      let done = false;
+      this.on("data", (chunk: Buffer) => {
+        chunks.push(chunk);
+      });
+      this.on("end", () => {
+        if (done) return;
+        done = true;
+        resolve(Buffer.concat(chunks));
+      });
+      this.on("error", (err: Error) => {
+        if (done) return;
+        done = true;
+        reject(err);
+      });
+      this.on("close", () => {
+        if (done) return;
+        done = true;
+        reject(new RequestAbortedError());
+      });
+    });
+  }
+}
+
+/** 5.x decodes UTF-8 as-is; 7.x strips a leading byte-order mark first. */
+function decodeText(bytes: Buffer, profile: Profile): string {
+  if (
+    profile.major >= 7 &&
+    bytes.length >= 3 &&
+    bytes[0] === 0xef &&
+    bytes[1] === 0xbb &&
+    bytes[2] === 0xbf
+  ) {
+    return bytes.subarray(3).toString("utf8");
+  }
+  return bytes.toString("utf8");
+}