skuba 0.0.0-beta-20231002015947

package/lib/api/jest/index.d.ts

@@ -0,0 +1,147 @@
+import type { Config } from '@jest/types';
+/**
+ * Set of Jest options that are recommended and supported for customisation.
+ *
+ * While we technically accept anything compatible with `Config.InitialOptions`,
+ * these are tacitly endorsed for our use cases and receive IntelliSense.
+ */
+type DefaultOptions = 'collectCoverage' | 'collectCoverageFrom' | 'coveragePathIgnorePatterns' | 'coverageThreshold' | 'displayName' | 'globals' | 'globalSetup' | 'globalTeardown' | 'projects' | 'setupFiles' | 'setupFilesAfterEnv' | 'snapshotSerializers' | 'testEnvironment' | 'testPathIgnorePatterns' | 'testTimeout' | 'watchPathIgnorePatterns';
+/**
+ * Merge additional Jest options into the **skuba** preset.
+ *
+ * This concatenates array options like `testPathIgnorePatterns`.
+ */
+export declare const mergePreset: <AdditionalOptions extends "filter" | "json" | "silent" | "cache" | "runtime" | "watch" | "runner" | "projects" | "id" | "automock" | "cacheDirectory" | "clearMocks" | "collectCoverageFrom" | "coverageDirectory" | "coveragePathIgnorePatterns" | "dependencyExtractor" | "detectLeaks" | "detectOpenHandles" | "displayName" | "errorOnDeprecated" | "extensionsToTreatAsEsm" | "fakeTimers" | "forceCoverageMatch" | "globalSetup" | "globalTeardown" | "globals" | "haste" | "injectGlobals" | "moduleDirectories" | "moduleFileExtensions" | "moduleNameMapper" | "modulePathIgnorePatterns" | "modulePaths" | "openHandlesTimeout" | "preset" | "prettierPath" | "resetMocks" | "resetModules" | "resolver" | "restoreMocks" | "rootDir" | "roots" | "sandboxInjectedGlobals" | "setupFiles" | "setupFilesAfterEnv" | "skipFilter" | "skipNodeResolution" | "slowTestThreshold" | "snapshotResolver" | "snapshotSerializers" | "snapshotFormat" | "testEnvironment" | "testEnvironmentOptions" | "testMatch" | "testLocationInResults" | "testPathIgnorePatterns" | "testRegex" | "testRunner" | "transform" | "transformIgnorePatterns" | "watchPathIgnorePatterns" | "unmockedModulePathPatterns" | "workerIdleMemoryLimit" | "bail" | "ci" | "changedFilesWithAncestor" | "changedSince" | "collectCoverage" | "coverageProvider" | "coverageReporters" | "coverageThreshold" | "expand" | "findRelatedTests" | "forceExit" | "reporters" | "logHeapUsage" | "lastCommit" | "listTests" | "maxConcurrency" | "maxWorkers" | "noStackTrace" | "notify" | "notifyMode" | "onlyChanged" | "onlyFailures" | "outputFile" | "passWithNoTests" | "randomize" | "replname" | "runTestsByPath" | "showSeed" | "testFailureExitCode" | "testNamePattern" | "testResultsProcessor" | "testSequencer" | "testTimeout" | "updateSnapshot" | "useStderr" | "verbose" | "watchAll" | "watchman" | "watchPlugins" | "workerThreads">(options: Pick<Partial<{
+    automock: boolean;
+    bail: number | boolean;
+    cache: boolean;
+    cacheDirectory: string;
+    ci: boolean;
+    clearMocks: boolean;
+    changedFilesWithAncestor: boolean;
+    changedSince: string;
+    collectCoverage: boolean;
+    collectCoverageFrom: string[];
+    coverageDirectory: string;
+    coveragePathIgnorePatterns: string[];
+    coverageProvider: "v8" | "babel";
+    coverageReporters: Config.CoverageReporters;
+    coverageThreshold: {
+        [path: string]: Config.CoverageThresholdValue;
+        global: Config.CoverageThresholdValue;
+    };
+    dependencyExtractor: string;
+    detectLeaks: boolean;
+    detectOpenHandles: boolean;
+    displayName: string | Config.DisplayName;
+    expand: boolean;
+    extensionsToTreatAsEsm: string[];
+    fakeTimers: Config.GlobalFakeTimersConfig & ((Config.FakeTimersConfig & {
+        now?: number | undefined;
+    }) | Config.LegacyFakeTimersConfig);
+    filter: string;
+    findRelatedTests: boolean;
+    forceCoverageMatch: string[];
+    forceExit: boolean;
+    json: boolean;
+    globals: Config.ConfigGlobals;
+    globalSetup: string | null | undefined;
+    globalTeardown: string | null | undefined;
+    haste: Config.HasteConfig;
+    id: string;
+    injectGlobals: boolean;
+    reporters: (string | Config.ReporterConfig)[];
+    logHeapUsage: boolean;
+    lastCommit: boolean;
+    listTests: boolean;
+    maxConcurrency: number;
+    maxWorkers: string | number;
+    moduleDirectories: string[];
+    moduleFileExtensions: string[];
+    moduleNameMapper: {
+        [key: string]: string | string[];
+    };
+    modulePathIgnorePatterns: string[];
+    modulePaths: string[];
+    noStackTrace: boolean;
+    notify: boolean;
+    notifyMode: string;
+    onlyChanged: boolean;
+    onlyFailures: boolean;
+    openHandlesTimeout: number;
+    outputFile: string;
+    passWithNoTests: boolean;
+    preset: string | null | undefined;
+    prettierPath: string | null | undefined;
+    projects: (string | Config.InitialProjectOptions)[];
+    randomize: boolean;
+    replname: string | null | undefined;
+    resetMocks: boolean;
+    resetModules: boolean;
+    resolver: string | null | undefined;
+    restoreMocks: boolean;
+    rootDir: string;
+    roots: string[];
+    runner: string;
+    runTestsByPath: boolean;
+    runtime: string;
+    sandboxInjectedGlobals: string[];
+    setupFiles: string[];
+    setupFilesAfterEnv: string[];
+    showSeed: boolean;
+    silent: boolean;
+    skipFilter: boolean;
+    skipNodeResolution: boolean;
+    slowTestThreshold: number;
+    snapshotResolver: string;
+    snapshotSerializers: string[];
+    snapshotFormat: {
+        readonly callToJSON?: boolean | undefined;
+        readonly compareKeys?: null | undefined;
+        readonly escapeRegex?: boolean | undefined;
+        readonly escapeString?: boolean | undefined;
+        readonly highlight?: boolean | undefined;
+        readonly indent?: number | undefined;
+        readonly maxDepth?: number | undefined;
+        readonly maxWidth?: number | undefined;
+        readonly min?: boolean | undefined;
+        readonly printBasicPrototype?: boolean | undefined;
+        readonly printFunctionName?: boolean | undefined;
+        readonly theme?: {
+            readonly value?: string | undefined;
+            readonly tag?: string | undefined;
+            readonly content?: string | undefined;
+            readonly comment?: string | undefined;
+            readonly prop?: string | undefined;
+        } | undefined;
+    };
+    errorOnDeprecated: boolean;
+    testEnvironment: string;
+    testEnvironmentOptions: Record<string, unknown>;
+    testFailureExitCode: string | number;
+    testLocationInResults: boolean;
+    testMatch: string[];
+    testNamePattern: string;
+    testPathIgnorePatterns: string[];
+    testRegex: string | string[];
+    testResultsProcessor: string;
+    testRunner: string;
+    testSequencer: string;
+    testTimeout: number;
+    transform: {
+        [regex: string]: string | Config.TransformerConfig;
+    };
+    transformIgnorePatterns: string[];
+    watchPathIgnorePatterns: string[];
+    unmockedModulePathPatterns: string[];
+    updateSnapshot: boolean;
+    useStderr: boolean;
+    verbose?: boolean | undefined;
+    watch: boolean;
+    watchAll: boolean;
+    watchman: boolean;
+    watchPlugins: (string | [string, Record<string, unknown>])[];
+    workerIdleMemoryLimit: string | number;
+    workerThreads: boolean;
+}>, DefaultOptions | AdditionalOptions>) => Config.InitialOptions;
+export {};

package/lib/api/jest/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jest_exports = {};
+__export(jest_exports, {
+  mergePreset: () => mergePreset
+});
+module.exports = __toCommonJS(jest_exports);
+var import_jest_preset = __toESM(require("../../../jest-preset"));
+var import_record = require("../../cli/configure/processing/record");
+const mergePreset = (options) => (0, import_record.mergeRaw)(import_jest_preset.default, options);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mergePreset
+});
+//# sourceMappingURL=index.js.map

package/lib/api/jest/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/api/jest/index.ts"],
+  "sourcesContent": ["import type { Config } from '@jest/types';\n\nimport jestPreset from '../../../jest-preset';\nimport { mergeRaw } from '../../cli/configure/processing/record';\n\n/**\n * Set of Jest options that are recommended and supported for customisation.\n *\n * While we technically accept anything compatible with `Config.InitialOptions`,\n * these are tacitly endorsed for our use cases and receive IntelliSense.\n */\ntype DefaultOptions =\n  | 'collectCoverage'\n  | 'collectCoverageFrom'\n  | 'coveragePathIgnorePatterns'\n  | 'coverageThreshold'\n  | 'displayName'\n  | 'globals'\n  | 'globalSetup'\n  | 'globalTeardown'\n  | 'projects'\n  | 'setupFiles'\n  | 'setupFilesAfterEnv'\n  | 'snapshotSerializers'\n  | 'testEnvironment'\n  | 'testPathIgnorePatterns'\n  | 'testTimeout'\n  | 'watchPathIgnorePatterns';\n\n/**\n * Merge additional Jest options into the **skuba** preset.\n *\n * This concatenates array options like `testPathIgnorePatterns`.\n */\nexport const mergePreset = <\n  AdditionalOptions extends keyof Config.InitialOptions,\n>(\n  options: Pick<Config.InitialOptions, AdditionalOptions | DefaultOptions>,\n): Config.InitialOptions => mergeRaw(jestPreset, options);\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,yBAAuB;AACvB,oBAAyB;AA+BlB,MAAM,cAAc,CAGzB,gBAC0B,wBAAS,mBAAAA,SAAY,OAAO;",
+  "names": ["jestPreset"]
+}

package/lib/api/net/compose.d.ts

@@ -0,0 +1,4 @@
+export declare const resolveComposeAddress: (privateHost: string, privatePort: number) => Promise<{
+    host: string;
+    port: number;
+}>;

package/lib/api/net/compose.js

@@ -0,0 +1,50 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var compose_exports = {};
+__export(compose_exports, {
+  resolveComposeAddress: () => resolveComposeAddress
+});
+module.exports = __toCommonJS(compose_exports);
+var import_exec = require("../../utils/exec");
+const portStringToNumber = (portString) => {
+  const port = Number(portString);
+  if (!Number.isSafeInteger(port)) {
+    throw Error(`received non-integer port: '${portString}'`);
+  }
+  return port;
+};
+const resolveComposeAddress = async (privateHost, privatePort) => {
+  const exec = (0, import_exec.createExec)({ stdio: "pipe" });
+  const { stdout } = await exec(
+    "docker-compose",
+    "port",
+    privateHost,
+    String(privatePort)
+  );
+  const [host, portString] = stdout.trim().split(":");
+  if (!host || !portString) {
+    throw Error(`Docker Compose returned unrecognised address: '${stdout}'`);
+  }
+  return { host, port: portStringToNumber(portString) };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveComposeAddress
+});
+//# sourceMappingURL=compose.js.map

package/lib/api/net/compose.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/api/net/compose.ts"],
+  "sourcesContent": ["import { createExec } from '../../utils/exec';\n\nconst portStringToNumber = (portString: string) => {\n  const port = Number(portString);\n\n  if (!Number.isSafeInteger(port)) {\n    throw Error(`received non-integer port: '${portString}'`);\n  }\n\n  return port;\n};\n\nexport const resolveComposeAddress = async (\n  privateHost: string,\n  privatePort: number,\n) => {\n  const exec = createExec({ stdio: 'pipe' });\n\n  const { stdout } = await exec(\n    'docker-compose',\n    'port',\n    privateHost,\n    String(privatePort),\n  );\n\n  const [host, portString] = stdout.trim().split(':');\n\n  if (!host || !portString) {\n    throw Error(`Docker Compose returned unrecognised address: '${stdout}'`);\n  }\n\n  return { host, port: portStringToNumber(portString) };\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAA2B;AAE3B,MAAM,qBAAqB,CAAC,eAAuB;AACjD,QAAM,OAAO,OAAO,UAAU;AAE9B,MAAI,CAAC,OAAO,cAAc,IAAI,GAAG;AAC/B,UAAM,MAAM,+BAA+B,UAAU,GAAG;AAAA,EAC1D;AAEA,SAAO;AACT;AAEO,MAAM,wBAAwB,OACnC,aACA,gBACG;AACH,QAAM,WAAO,wBAAW,EAAE,OAAO,OAAO,CAAC;AAEzC,QAAM,EAAE,OAAO,IAAI,MAAM;AAAA,IACvB;AAAA,IACA;AAAA,IACA;AAAA,IACA,OAAO,WAAW;AAAA,EACpB;AAEA,QAAM,CAAC,MAAM,UAAU,IAAI,OAAO,KAAK,EAAE,MAAM,GAAG;AAElD,MAAI,CAAC,QAAQ,CAAC,YAAY;AACxB,UAAM,MAAM,kDAAkD,MAAM,GAAG;AAAA,EACzE;AAEA,SAAO,EAAE,MAAM,MAAM,mBAAmB,UAAU,EAAE;AACtD;",
+  "names": []
+}

package/lib/api/net/index.d.ts

@@ -0,0 +1 @@
+export { waitFor } from './waitFor';

package/lib/api/net/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var net_exports = {};
+__export(net_exports, {
+  waitFor: () => import_waitFor.waitFor
+});
+module.exports = __toCommonJS(net_exports);
+var import_waitFor = require("./waitFor");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  waitFor
+});
+//# sourceMappingURL=index.js.map

package/lib/api/net/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/api/net/index.ts"],
+  "sourcesContent": ["export { waitFor } from './waitFor';\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAAwB;",
+  "names": []
+}

package/lib/api/net/socket.d.ts

@@ -0,0 +1,5 @@
+export interface SocketAddress {
+    host: string;
+    port: number;
+}
+export declare const pollSocket: (host: string, port: number, timeout: number) => Promise<void>;

package/lib/api/net/socket.js

@@ -0,0 +1,68 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var socket_exports = {};
+__export(socket_exports, {
+  pollSocket: () => pollSocket
+});
+module.exports = __toCommonJS(socket_exports);
+var import_net = __toESM(require("net"));
+const trySocket = async (host, port) => new Promise((resolve) => {
+  const socket = new import_net.default.Socket();
+  const onFailure = () => {
+    socket.destroy();
+    resolve(false);
+  };
+  const onSuccess = () => socket.end(() => resolve(true));
+  socket.connect(port, host, onSuccess).once("error", onFailure).once("timeout", onFailure).setTimeout(1e3);
+});
+const pollSocket = async (host, port, timeout) => new Promise((resolve, reject) => {
+  const callPort = async () => {
+    const success = await trySocket(host, port);
+    if (!success) {
+      return;
+    }
+    clearTimeout(intervalId);
+    clearTimeout(timeoutId);
+    resolve();
+  };
+  const intervalId = setInterval(() => {
+    callPort().catch(() => void 0);
+  }, 250);
+  const timeoutId = setTimeout(() => {
+    clearTimeout(intervalId);
+    clearTimeout(timeoutId);
+    reject(Error(`could not reach ${host}:${port} within ${timeout}ms`));
+  }, timeout);
+  callPort().catch(() => void 0);
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pollSocket
+});
+//# sourceMappingURL=socket.js.map

package/lib/api/net/socket.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/api/net/socket.ts"],
+  "sourcesContent": ["import net from 'net';\n\nexport interface SocketAddress {\n  host: string;\n  port: number;\n}\n\nconst trySocket = async (host: string, port: number) =>\n  new Promise((resolve) => {\n    const socket = new net.Socket();\n\n    const onFailure = () => {\n      socket.destroy();\n      resolve(false);\n    };\n\n    const onSuccess = () => socket.end(() => resolve(true));\n\n    socket\n      .connect(port, host, onSuccess)\n      .once('error', onFailure)\n      .once('timeout', onFailure)\n      .setTimeout(1_000);\n  });\n\nexport const pollSocket = async (host: string, port: number, timeout: number) =>\n  new Promise<void>((resolve, reject) => {\n    const callPort = async () => {\n      const success = await trySocket(host, port);\n\n      if (!success) {\n        return;\n      }\n\n      clearTimeout(intervalId);\n      clearTimeout(timeoutId);\n\n      resolve();\n    };\n\n    const intervalId = setInterval(() => {\n      callPort().catch(() => undefined);\n    }, 250);\n\n    const timeoutId = setTimeout(() => {\n      clearTimeout(intervalId);\n      clearTimeout(timeoutId);\n\n      reject(Error(`could not reach ${host}:${port} within ${timeout}ms`));\n    }, timeout);\n\n    callPort().catch(() => undefined);\n  });\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAAgB;AAOhB,MAAM,YAAY,OAAO,MAAc,SACrC,IAAI,QAAQ,CAAC,YAAY;AACvB,QAAM,SAAS,IAAI,WAAAA,QAAI,OAAO;AAE9B,QAAM,YAAY,MAAM;AACtB,WAAO,QAAQ;AACf,YAAQ,KAAK;AAAA,EACf;AAEA,QAAM,YAAY,MAAM,OAAO,IAAI,MAAM,QAAQ,IAAI,CAAC;AAEtD,SACG,QAAQ,MAAM,MAAM,SAAS,EAC7B,KAAK,SAAS,SAAS,EACvB,KAAK,WAAW,SAAS,EACzB,WAAW,GAAK;AACrB,CAAC;AAEI,MAAM,aAAa,OAAO,MAAc,MAAc,YAC3D,IAAI,QAAc,CAAC,SAAS,WAAW;AACrC,QAAM,WAAW,YAAY;AAC3B,UAAM,UAAU,MAAM,UAAU,MAAM,IAAI;AAE1C,QAAI,CAAC,SAAS;AACZ;AAAA,IACF;AAEA,iBAAa,UAAU;AACvB,iBAAa,SAAS;AAEtB,YAAQ;AAAA,EACV;AAEA,QAAM,aAAa,YAAY,MAAM;AACnC,aAAS,EAAE,MAAM,MAAM,MAAS;AAAA,EAClC,GAAG,GAAG;AAEN,QAAM,YAAY,WAAW,MAAM;AACjC,iBAAa,UAAU;AACvB,iBAAa,SAAS;AAEtB,WAAO,MAAM,mBAAmB,IAAI,IAAI,IAAI,WAAW,OAAO,IAAI,CAAC;AAAA,EACrE,GAAG,OAAO;AAEV,WAAS,EAAE,MAAM,MAAM,MAAS;AAClC,CAAC;",
+  "names": ["net"]
+}

package/lib/api/net/waitFor.d.ts

@@ -0,0 +1,22 @@
+import { type SocketAddress } from './socket';
+/**
+ * Wait for a resource to start listening on a socket address.
+ *
+ * The socket is polled on an interval until it accepts a connection or the
+ * `timeout` is reached.
+ */
+export declare const waitFor: ({ host, port, resolveCompose, timeout, }: {
+    host?: string | undefined;
+    port: number;
+    /**
+     * Whether to treat the `host` and `port` arguments as a private Docker
+     * Compose network address and to resolve them to a public local address.
+     *
+     * This is typically:
+     *
+     * - Enabled locally, when the application is running directly on the machine
+     * - Disabled in CI, when running in a container on the Docker Compose network
+     */
+    resolveCompose?: boolean | undefined;
+    timeout?: number | undefined;
+}) => Promise<SocketAddress>;

package/lib/api/net/waitFor.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var waitFor_exports = {};
+__export(waitFor_exports, {
+  waitFor: () => waitFor
+});
+module.exports = __toCommonJS(waitFor_exports);
+var import_compose = require("./compose");
+var import_socket = require("./socket");
+const waitFor = async ({
+  host = "localhost",
+  port,
+  resolveCompose = false,
+  timeout = 15e3
+}) => {
+  const resolvedAddress = resolveCompose ? await (0, import_compose.resolveComposeAddress)(host, port) : { host, port };
+  await (0, import_socket.pollSocket)(resolvedAddress.host, resolvedAddress.port, timeout);
+  return resolvedAddress;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  waitFor
+});
+//# sourceMappingURL=waitFor.js.map

package/lib/api/net/waitFor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/api/net/waitFor.ts"],
+  "sourcesContent": ["import { resolveComposeAddress } from './compose';\nimport { type SocketAddress, pollSocket } from './socket';\n\n/**\n * Wait for a resource to start listening on a socket address.\n *\n * The socket is polled on an interval until it accepts a connection or the\n * `timeout` is reached.\n */\nexport const waitFor = async ({\n  host = 'localhost',\n  port,\n  resolveCompose = false,\n  timeout = 15_000,\n}: {\n  host?: string;\n\n  port: number;\n\n  /**\n   * Whether to treat the `host` and `port` arguments as a private Docker\n   * Compose network address and to resolve them to a public local address.\n   *\n   * This is typically:\n   *\n   * - Enabled locally, when the application is running directly on the machine\n   * - Disabled in CI, when running in a container on the Docker Compose network\n   */\n  resolveCompose?: boolean;\n\n  timeout?: number;\n}): Promise<SocketAddress> => {\n  const resolvedAddress = resolveCompose\n    ? await resolveComposeAddress(host, port)\n    : { host, port };\n\n  await pollSocket(resolvedAddress.host, resolvedAddress.port, timeout);\n\n  return resolvedAddress;\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAAsC;AACtC,oBAA+C;AAQxC,MAAM,UAAU,OAAO;AAAA,EAC5B,OAAO;AAAA,EACP;AAAA,EACA,iBAAiB;AAAA,EACjB,UAAU;AACZ,MAiB8B;AAC5B,QAAM,kBAAkB,iBACpB,UAAM,sCAAsB,MAAM,IAAI,IACtC,EAAE,MAAM,KAAK;AAEjB,YAAM,0BAAW,gBAAgB,MAAM,gBAAgB,MAAM,OAAO;AAEpE,SAAO;AACT;",
+  "names": []
+}

package/lib/cli/adapter/eslint.d.ts

@@ -0,0 +1,14 @@
+import { type Linter } from 'eslint';
+import { type Logger } from '../../utils/logging';
+export interface ESLintResult {
+    messages: Linter.LintMessage[];
+    filePath: string;
+}
+export interface ESLintOutput {
+    errors: ESLintResult[];
+    fixable: boolean;
+    ok: boolean;
+    output: string;
+    warnings: ESLintResult[];
+}
+export declare const runESLint: (mode: 'format' | 'lint', logger: Logger) => Promise<ESLintOutput>;

package/lib/cli/adapter/eslint.js

@@ -0,0 +1,99 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var eslint_exports = {};
+__export(eslint_exports, {
+  runESLint: () => runESLint
+});
+module.exports = __toCommonJS(eslint_exports);
+var import_path = __toESM(require("path"));
+var import_chalk = __toESM(require("chalk"));
+var import_eslint = require("eslint");
+var import_logging = require("../../utils/logging");
+const symbolForResult = (result) => {
+  if (result.errorCount) {
+    return import_chalk.default.red("\u25CB");
+  }
+  return result.warningCount ? import_chalk.default.yellow("\u25CD") : import_chalk.default.green("\u25CB");
+};
+const runESLint = async (mode, logger) => {
+  logger.debug("Initialising ESLint...");
+  const engine = new import_eslint.ESLint({
+    cache: true,
+    fix: mode === "format",
+    reportUnusedDisableDirectives: "error"
+  });
+  const cwd = process.cwd();
+  logger.debug("Processing files...");
+  const start = process.hrtime.bigint();
+  const [formatter, results] = await Promise.all([
+    engine.loadFormatter(),
+    engine.lintFiles(".")
+  ]);
+  const end = process.hrtime.bigint();
+  logger.plain(
+    `Processed ${(0, import_logging.pluralise)(results.length, "file")} in ${logger.timing(
+      start,
+      end
+    )}.`
+  );
+  const errors = [];
+  const warnings = [];
+  let fixable = false;
+  for (const result of results) {
+    const relativePath = import_path.default.relative(cwd, result.filePath);
+    if (result.fixableErrorCount + result.fixableWarningCount) {
+      fixable = true;
+    }
+    if (result.errorCount) {
+      errors.push({
+        filePath: relativePath,
+        messages: result.messages
+      });
+    }
+    if (result.warningCount) {
+      warnings.push({
+        filePath: relativePath,
+        messages: result.messages
+      });
+    }
+    logger.debug(symbolForResult(result), relativePath);
+  }
+  const ok = errors.length === 0;
+  await import_eslint.ESLint.outputFixes(results);
+  const output = await formatter.format(results);
+  if (output) {
+    logger.plain(output);
+  }
+  return { errors, fixable, ok, output, warnings };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runESLint
+});
+//# sourceMappingURL=eslint.js.map

package/lib/cli/adapter/eslint.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/cli/adapter/eslint.ts"],
+  "sourcesContent": ["import path from 'path';\n\nimport chalk from 'chalk';\nimport { ESLint, type Linter } from 'eslint';\n\nimport { type Logger, pluralise } from '../../utils/logging';\n\nconst symbolForResult = (result: ESLint.LintResult) => {\n  if (result.errorCount) {\n    return chalk.red('\u25CB');\n  }\n\n  return result.warningCount ? chalk.yellow('\u25CD') : chalk.green('\u25CB');\n};\n\nexport interface ESLintResult {\n  messages: Linter.LintMessage[];\n  filePath: string;\n}\n\nexport interface ESLintOutput {\n  errors: ESLintResult[];\n  fixable: boolean;\n  ok: boolean;\n  output: string;\n  warnings: ESLintResult[];\n}\n\nexport const runESLint = async (\n  mode: 'format' | 'lint',\n  logger: Logger,\n): Promise<ESLintOutput> => {\n  logger.debug('Initialising ESLint...');\n\n  const engine = new ESLint({\n    cache: true,\n    fix: mode === 'format',\n    reportUnusedDisableDirectives: 'error',\n  });\n\n  const cwd = process.cwd();\n\n  logger.debug('Processing files...');\n\n  const start = process.hrtime.bigint();\n\n  const [formatter, results] = await Promise.all([\n    engine.loadFormatter(),\n    engine.lintFiles('.'),\n  ]);\n\n  const end = process.hrtime.bigint();\n\n  logger.plain(\n    `Processed ${pluralise(results.length, 'file')} in ${logger.timing(\n      start,\n      end,\n    )}.`,\n  );\n\n  const errors: ESLintResult[] = [];\n  const warnings: ESLintResult[] = [];\n  let fixable = false;\n\n  for (const result of results) {\n    const relativePath = path.relative(cwd, result.filePath);\n    if (result.fixableErrorCount + result.fixableWarningCount) {\n      fixable = true;\n    }\n\n    if (result.errorCount) {\n      errors.push({\n        filePath: relativePath,\n        messages: result.messages,\n      });\n    }\n\n    if (result.warningCount) {\n      warnings.push({\n        filePath: relativePath,\n        messages: result.messages,\n      });\n    }\n\n    logger.debug(symbolForResult(result), relativePath);\n  }\n\n  const ok = errors.length === 0;\n\n  await ESLint.outputFixes(results);\n\n  const output = await formatter.format(results);\n\n  if (output) {\n    logger.plain(output);\n  }\n\n  return { errors, fixable, ok, output, warnings };\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAiB;AAEjB,mBAAkB;AAClB,oBAAoC;AAEpC,qBAAuC;AAEvC,MAAM,kBAAkB,CAAC,WAA8B;AACrD,MAAI,OAAO,YAAY;AACrB,WAAO,aAAAA,QAAM,IAAI,QAAG;AAAA,EACtB;AAEA,SAAO,OAAO,eAAe,aAAAA,QAAM,OAAO,QAAG,IAAI,aAAAA,QAAM,MAAM,QAAG;AAClE;AAeO,MAAM,YAAY,OACvB,MACA,WAC0B;AAC1B,SAAO,MAAM,wBAAwB;AAErC,QAAM,SAAS,IAAI,qBAAO;AAAA,IACxB,OAAO;AAAA,IACP,KAAK,SAAS;AAAA,IACd,+BAA+B;AAAA,EACjC,CAAC;AAED,QAAM,MAAM,QAAQ,IAAI;AAExB,SAAO,MAAM,qBAAqB;AAElC,QAAM,QAAQ,QAAQ,OAAO,OAAO;AAEpC,QAAM,CAAC,WAAW,OAAO,IAAI,MAAM,QAAQ,IAAI;AAAA,IAC7C,OAAO,cAAc;AAAA,IACrB,OAAO,UAAU,GAAG;AAAA,EACtB,CAAC;AAED,QAAM,MAAM,QAAQ,OAAO,OAAO;AAElC,SAAO;AAAA,IACL,iBAAa,0BAAU,QAAQ,QAAQ,MAAM,CAAC,OAAO,OAAO;AAAA,MAC1D;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AAEA,QAAM,SAAyB,CAAC;AAChC,QAAM,WAA2B,CAAC;AAClC,MAAI,UAAU;AAEd,aAAW,UAAU,SAAS;AAC5B,UAAM,eAAe,YAAAC,QAAK,SAAS,KAAK,OAAO,QAAQ;AACvD,QAAI,OAAO,oBAAoB,OAAO,qBAAqB;AACzD,gBAAU;AAAA,IACZ;AAEA,QAAI,OAAO,YAAY;AACrB,aAAO,KAAK;AAAA,QACV,UAAU;AAAA,QACV,UAAU,OAAO;AAAA,MACnB,CAAC;AAAA,IACH;AAEA,QAAI,OAAO,cAAc;AACvB,eAAS,KAAK;AAAA,QACZ,UAAU;AAAA,QACV,UAAU,OAAO;AAAA,MACnB,CAAC;AAAA,IACH;AAEA,WAAO,MAAM,gBAAgB,MAAM,GAAG,YAAY;AAAA,EACpD;AAEA,QAAM,KAAK,OAAO,WAAW;AAE7B,QAAM,qBAAO,YAAY,OAAO;AAEhC,QAAM,SAAS,MAAM,UAAU,OAAO,OAAO;AAE7C,MAAI,QAAQ;AACV,WAAO,MAAM,MAAM;AAAA,EACrB;AAEA,SAAO,EAAE,QAAQ,SAAS,IAAI,QAAQ,SAAS;AACjD;",
+  "names": ["chalk", "path"]
+}

package/lib/cli/adapter/prettier.d.ts

@@ -0,0 +1,52 @@
+import { type Options } from 'prettier';
+import { type Logger } from '../../utils/logging';
+/**
+ * Infers a parser for the specified filepath.
+ *
+ * This is a cut-down version of Prettier's built-in function of the same name;
+ * ours operates purely on the `filepath` string and does not perform file I/O.
+ * Prettier's internal `getInterpreter` function can open a file to read the
+ * shebang, and its file descriptor usage can throw warnings on worker threads:
+ *
+ * ```console
+ * Warning: File descriptor 123 closed but not opened in unmanaged mode
+ *     at Object.closeSync (node:fs:530:11)
+ *     at Object.closeSync (node_modules/graceful-fs/graceful-fs.js:74:20)
+ *     ...
+ * ```
+ *
+ * References:
+ *
+ * - https://github.com/prettier/prettier/blob/2.4.1/src/main/options.js#L167
+ * - seek-oss/skuba#659
+ */
+export declare const inferParser: (filepath: string) => Promise<string | undefined>;
+interface File {
+    data: string;
+    options: Options;
+    filepath: string;
+}
+interface Result {
+    count: number;
+    errored: Array<{
+        err?: unknown;
+        filepath: string;
+    }>;
+    touched: string[];
+    unparsed: string[];
+}
+export declare const formatOrLintFile: ({ data, filepath, options }: File, mode: 'format' | 'lint', result: Result | null) => Promise<string | undefined>;
+export interface PrettierOutput {
+    ok: boolean;
+    result: Result;
+}
+/**
+ * Formats/lints files with Prettier.
+ *
+ * Prettier doesn't provide a higher-level Node.js API that replicates the
+ * behaviour of its CLI, so we have to plumb together its lower-level functions.
+ * On the other hand, this affords more flexibility in how we track and report
+ * on progress and results.
+ */
+export declare const runPrettier: (mode: 'format' | 'lint', logger: Logger) => Promise<PrettierOutput>;
+export {};