@scriptc/compiler 0.4.0 → 0.4.1

package/shims/fs-extra/index.ts

@@ -0,0 +1,9 @@
+// scriptc's built-in implementation of the `fs-extra` package, 8.x-11.x API.
+//
+// Programs whose installed fs-extra is 8.x through 11.x compile this module
+// in its place (see packages/compiler/src/frontend/package-shims.ts), and its
+// declarations stand in for @types/fs-extra. The default import, the
+// namespace import and named imports all read the same exports, as they read
+// fs-extra's single CommonJS export object under Node.
+export * from "./core/api.ts";
+export * as default from "./core/api.ts";

package/shims/undici/core/agent.ts

@@ -0,0 +1,163 @@
+// undici's Agent (lib/dispatcher/agent.js): one dispatcher per origin,
+// created by `factory` (default: a Pool, or a Client when connections is 1).
+import { Client } from "./client.ts";
+import { Dispatcher, DispatcherBase } from "./dispatcher.ts";
+import { InvalidArgumentError } from "./errors.ts";
+import { Pool } from "./pool.ts";
+import type {
+  AgentOptions,
+  DispatchHandlers,
+  DispatchOptions,
+  PoolOptions,
+  Profile,
+} from "./types.ts";
+
+interface AgentEntry {
+  dispatcher: Dispatcher;
+  count: number;
+}
+
+export class Agent extends DispatcherBase {
+  __options: PoolOptions;
+  __factory: ((origin: string | URL, opts: object) => Dispatcher) | null;
+  __clients: Map<string, AgentEntry>;
+  __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(options: AgentOptions | undefined, profile: Profile) {
+    super(profile);
+    const opts: AgentOptions = options ?? {};
+    const interceptors = opts.interceptors;
+    if (profile.major < 7 && interceptors !== undefined && interceptors.Agent !== undefined) {
+      this.__interceptors = interceptors.Agent;
+    }
+    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,
+      connectTimeout: opts.connectTimeout,
+      localAddress: opts.localAddress,
+      connections: opts.connections,
+      connect: opts.connect,
+      interceptors:
+        interceptors !== undefined
+          ? { Pool: interceptors.Pool, Client: interceptors.Client }
+          : undefined,
+    };
+    const factory = opts.factory;
+    this.__factory = factory !== undefined ? factory : null;
+    this.__clients = new Map<string, AgentEntry>();
+    this.__onDrain = (origin: URL, targets: Dispatcher[]): void => {
+      this.emit("drain", origin, [this as Dispatcher, ...targets]);
+    };
+    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);
+    };
+  }
+
+  __runningCount(): number {
+    let ret = 0;
+    for (const entry of this.__clients.values()) ret += entry.dispatcher.__runningCount();
+    return ret;
+  }
+
+  __dispatch(opts: DispatchOptions, handler: DispatchHandlers): boolean {
+    const origin = opts.origin;
+    if (origin === undefined || origin === "") {
+      throw new InvalidArgumentError("opts.origin must be a non-empty string or URL.");
+    }
+    const key = typeof origin === "string" ? origin : origin.href;
+    const existing = this.__clients.get(key);
+    let dispatcher: Dispatcher;
+    if (existing !== undefined) {
+      dispatcher = existing.dispatcher;
+    } else {
+      const factory = this.__factory;
+      dispatcher =
+        factory !== null
+          ? factory(origin, this.__options)
+          : this.__defaultFactory(origin, this.__options);
+      const entry: AgentEntry = { dispatcher, count: 0 };
+      if (this.__profile.major >= 7) {
+        // 7.x closes and forgets an origin's dispatcher once all of its
+        // connections are gone.
+        const closeIfUnused = (connected: boolean): void => {
+          const current = this.__clients.get(key);
+          if (current !== undefined) {
+            if (connected) current.count -= 1;
+            if (current.count <= 0) {
+              this.__clients.delete(key);
+              if (!current.dispatcher.__isDestroyed()) current.dispatcher.close();
+            }
+          }
+        };
+        dispatcher.on("drain", this.__onDrain);
+        dispatcher.on("connect", (o: URL, targets: Dispatcher[]) => {
+          const current = this.__clients.get(key);
+          if (current !== undefined) current.count += 1;
+          this.__onConnect(o, targets);
+        });
+        dispatcher.on("disconnect", (o: URL, targets: Dispatcher[], err: Error) => {
+          closeIfUnused(true);
+          this.__onDisconnect(o, targets, err);
+        });
+        dispatcher.on("connectionError", (o: URL, targets: Dispatcher[], err: Error) => {
+          closeIfUnused(false);
+          this.__onConnectionError(o, targets, err);
+        });
+      } else {
+        dispatcher.on("drain", this.__onDrain);
+        dispatcher.on("connect", this.__onConnect);
+        dispatcher.on("disconnect", this.__onDisconnect);
+        dispatcher.on("connectionError", this.__onConnectionError);
+      }
+      this.__clients.set(key, entry);
+    }
+    return dispatcher.dispatch(opts, handler);
+  }
+
+  /** The default factory: a Client when `connections` is 1, else a Pool, of
+   * the same undici version. */
+  __defaultFactory(origin: string | URL, opts: PoolOptions): Dispatcher {
+    return opts.connections === 1
+      ? this.__createClient(origin, opts)
+      : this.__createPool(origin, opts);
+  }
+
+  __createClient(origin: string | URL, opts: PoolOptions): Dispatcher {
+    return new Client(origin, opts, this.__profile);
+  }
+
+  __createPool(origin: string | URL, opts: PoolOptions): Dispatcher {
+    return new Pool(origin, opts, this.__profile);
+  }
+
+  __close(): Promise<void> {
+    const closing: Promise<void>[] = [];
+    for (const entry of this.__clients.values()) closing.push(entry.dispatcher.close());
+    if (this.__profile.major >= 7) this.__clients.clear();
+    return Promise.all(closing).then(() => {});
+  }
+
+  __destroy(err: Error): Promise<void> {
+    const destroying: Promise<void>[] = [];
+    for (const entry of this.__clients.values()) destroying.push(entry.dispatcher.destroy(err));
+    if (this.__profile.major >= 7) this.__clients.clear();
+    return Promise.all(destroying).then(() => {});
+  }
+}

package/shims/undici/core/api.ts

@@ -0,0 +1,93 @@
+// undici's top-level request() (index.js makeDispatcher over
+// lib/api/api-request.js) and the global dispatcher
+// (lib/global.js: one process-wide slot shared by every undici copy).
+import { requestThrough } from "./dispatcher.ts";
+import type { Dispatcher, RequestOptions, ResponseData } from "./dispatcher.ts";
+import { parseOrigin, parseURL } from "./util.ts";
+import type { IncomingHttpHeaders, Profile, RequestBody, UndiciHeaders } from "./types.ts";
+
+/** request(url, options)'s options: Dispatcher.RequestOptions without
+ * origin/path, an optional method, and the dispatcher to use. */
+export interface TopLevelRequestOptions {
+  dispatcher?: Dispatcher;
+  method?: string;
+  path?: string;
+  body?: RequestBody;
+  headers?: UndiciHeaders;
+  idempotent?: boolean;
+  blocking?: boolean;
+  headersTimeout?: number | null;
+  bodyTimeout?: number | null;
+  reset?: boolean;
+  throwOnError?: boolean;
+  opaque?: unknown;
+  signal?: AbortSignal | null;
+  onInfo?: (info: { statusCode: number; headers: IncomingHttpHeaders }) => void;
+  highWaterMark?: number;
+}
+
+let globalDispatcher: Dispatcher | null = null;
+let globalDispatcherSet = false;
+
+export function setGlobalDispatcher(dispatcher: Dispatcher): void {
+  globalDispatcher = dispatcher;
+  globalDispatcherSet = true;
+}
+
+/** The global dispatcher, created on first use by the asking version's
+ * Agent (undici stores whichever copy asked first). */
+export function getGlobalDispatcher(create: () => Dispatcher): Dispatcher {
+  let dispatcher = globalDispatcher;
+  if (dispatcher === null) {
+    dispatcher = create();
+    globalDispatcher = dispatcher;
+  }
+  return dispatcher;
+}
+
+/** True once a program installed its own global dispatcher. */
+export function hasCustomGlobalDispatcher(): boolean {
+  return globalDispatcherSet;
+}
+
+export function request(
+  url: string | URL,
+  options: TopLevelRequestOptions | undefined,
+  createGlobal: () => Dispatcher,
+  profile: Profile,
+): Promise<ResponseData> {
+  // makeDispatcher validates synchronously: an invalid URL throws at the
+  // call rather than rejecting.
+  {
+    const opts: TopLevelRequestOptions = options ?? {};
+    let target: URL;
+    const path = opts.path;
+    if (path !== undefined) {
+      const prefixed = path.startsWith("/") ? path : `/${path}`;
+      target = new URL(parseOrigin(url, profile).origin + prefixed);
+    } else {
+      target = parseURL(url, profile);
+    }
+    const dispatcher = opts.dispatcher ?? getGlobalDispatcher(createGlobal);
+    const method =
+      opts.method !== undefined && opts.method !== "" ? opts.method : opts.body ? "PUT" : "GET";
+    const dispatchOptions: RequestOptions = {
+      origin: target.origin,
+      path: target.search ? `${target.pathname}${target.search}` : target.pathname,
+      method,
+      body: opts.body,
+      headers: opts.headers,
+      idempotent: opts.idempotent,
+      blocking: opts.blocking,
+      headersTimeout: opts.headersTimeout,
+      bodyTimeout: opts.bodyTimeout,
+      reset: opts.reset,
+      throwOnError: opts.throwOnError,
+      opaque: opts.opaque,
+      signal: opts.signal,
+      onInfo: opts.onInfo,
+      highWaterMark: opts.highWaterMark,
+    };
+    return requestThrough(dispatcher, dispatchOptions, profile);
+  }
+}