skuba 0.0.0-master-20230318044948

package/lib/cli/lint/external.js

@@ -0,0 +1,120 @@
+"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 external_exports = {};
+__export(external_exports, {
+  StreamInterceptor: () => StreamInterceptor,
+  externalLint: () => externalLint
+});
+module.exports = __toCommonJS(external_exports);
+var import_stream = __toESM(require("stream"));
+var import_util = require("util");
+var import_logging = require("../../utils/logging");
+var import_wait = require("../../utils/wait");
+var import_annotate = require("./annotate");
+var import_autofix = require("./autofix");
+var import_eslint = require("./eslint");
+var import_prettier = require("./prettier");
+var import_tsc = require("./tsc");
+const tscPrefixRegex = /^(.*?tsc\s+│.*?\s)/gm;
+class StreamInterceptor extends import_stream.default.Transform {
+  constructor() {
+    super(...arguments);
+    this.chunks = [];
+  }
+  output() {
+    return Buffer.concat(this.chunks).toString().replace(tscPrefixRegex, "");
+  }
+  _transform(chunk, _encoding, callback) {
+    this.chunks.push(chunk);
+    callback(null, chunk);
+  }
+}
+const lintConcurrently = async ({ tscOutputStream, ...input }) => {
+  const [eslint, prettier, tscOk] = await Promise.all([
+    (0, import_eslint.runESLintInWorkerThread)(input),
+    (0, import_prettier.runPrettierInWorkerThread)(input),
+    (0, import_tsc.runTscInNewProcess)({ ...input, tscOutputStream })
+  ]);
+  return { eslint, prettier, tscOk };
+};
+const lintSerially = async ({ tscOutputStream, ...input }) => {
+  const eslint = await (0, import_eslint.runESLintInWorkerThread)(input);
+  const prettier = await (0, import_prettier.runPrettierInWorkerThread)(input);
+  const tscOk = await (0, import_tsc.runTscInNewProcess)({ ...input, tscOutputStream });
+  return { eslint, prettier, tscOk };
+};
+const lintSeriallyWithoutWorkerThreads = async (input) => {
+  const eslint = await (0, import_eslint.runESLintInCurrentThread)(input);
+  const prettier = await (0, import_prettier.runPrettierInCurrentThread)(input);
+  const tscOk = await (0, import_tsc.runTscInNewProcess)(input);
+  return { eslint, prettier, tscOk };
+};
+const selectLintFunction = (input) => {
+  if (!input.workerThreads) {
+    return lintSeriallyWithoutWorkerThreads;
+  }
+  const isSerial = input.debug || input.serial;
+  return isSerial ? lintSerially : lintConcurrently;
+};
+const externalLint = async (input) => {
+  const lint = selectLintFunction(input);
+  const tscOutputStream = new StreamInterceptor();
+  tscOutputStream.pipe(input.tscOutputStream ?? process.stdout);
+  const { eslint, prettier, tscOk } = await lint({ ...input, tscOutputStream });
+  try {
+    await (0, import_wait.throwOnTimeout)(
+      (0, import_annotate.createAnnotations)(eslint, prettier, tscOk, tscOutputStream),
+      { s: 30 }
+    );
+  } catch (err) {
+    import_logging.log.warn("Failed to annotate lint results.");
+    import_logging.log.subtle((0, import_util.inspect)(err));
+  }
+  if (!eslint.ok || !prettier.ok || !tscOk) {
+    const tools = [
+      ...eslint.ok ? [] : ["ESLint"],
+      ...prettier.ok ? [] : ["Prettier"],
+      ...tscOk ? [] : ["tsc"]
+    ];
+    import_logging.log.newline();
+    import_logging.log.err(`${tools.join(", ")} found issues that require triage.`);
+    process.exitCode = 1;
+  }
+  await (0, import_autofix.autofix)({
+    debug: input.debug,
+    eslint: eslint.fixable,
+    prettier: !prettier.ok
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StreamInterceptor,
+  externalLint
+});
+//# sourceMappingURL=external.js.map

package/lib/cli/lint/external.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/cli/lint/external.ts"],
+  "sourcesContent": ["import stream from 'stream';\nimport { inspect } from 'util';\n\nimport { log } from '../../utils/logging';\nimport { throwOnTimeout } from '../../utils/wait';\n\nimport { createAnnotations } from './annotate';\nimport { autofix } from './autofix';\nimport { runESLintInCurrentThread, runESLintInWorkerThread } from './eslint';\nimport {\n  runPrettierInCurrentThread,\n  runPrettierInWorkerThread,\n} from './prettier';\nimport { runTscInNewProcess } from './tsc';\nimport type { Input } from './types';\n\nconst tscPrefixRegex = /^(.*?tsc\\s+\u2502.*?\\s)/gm;\n\nexport class StreamInterceptor extends stream.Transform {\n  private chunks: Uint8Array[] = [];\n\n  public output() {\n    return Buffer.concat(this.chunks).toString().replace(tscPrefixRegex, '');\n  }\n\n  _transform(\n    chunk: Uint8Array,\n    _encoding: BufferEncoding,\n    callback: stream.TransformCallback,\n  ) {\n    this.chunks.push(chunk);\n\n    callback(null, chunk);\n  }\n}\n\nconst lintConcurrently = async ({ tscOutputStream, ...input }: Input) => {\n  const [eslint, prettier, tscOk] = await Promise.all([\n    runESLintInWorkerThread(input),\n    runPrettierInWorkerThread(input),\n    runTscInNewProcess({ ...input, tscOutputStream }),\n  ]);\n\n  return { eslint, prettier, tscOk };\n};\n\n/**\n * Run linting tools `--serial`ly for resource-constrained environments.\n *\n * Note that we still run ESLint and Prettier in worker threads as a\n * counterintuitive optimisation. Memory can be more readily freed on worker\n * thread exit, which isn't as easy with a monolithic main thread.\n */\nconst lintSerially = async ({ tscOutputStream, ...input }: Input) => {\n  const eslint = await runESLintInWorkerThread(input);\n  const prettier = await runPrettierInWorkerThread(input);\n  const tscOk = await runTscInNewProcess({ ...input, tscOutputStream });\n\n  return { eslint, prettier, tscOk };\n};\n\nconst lintSeriallyWithoutWorkerThreads = async (input: Input) => {\n  const eslint = await runESLintInCurrentThread(input);\n  const prettier = await runPrettierInCurrentThread(input);\n  const tscOk = await runTscInNewProcess(input);\n\n  return { eslint, prettier, tscOk };\n};\n\nconst selectLintFunction = (input: Input) => {\n  if (!input.workerThreads) {\n    return lintSeriallyWithoutWorkerThreads;\n  }\n\n  // `--debug` implies `--serial`.\n  const isSerial = input.debug || input.serial;\n\n  return isSerial ? lintSerially : lintConcurrently;\n};\n\nexport const externalLint = async (input: Input) => {\n  const lint = selectLintFunction(input);\n\n  const tscOutputStream = new StreamInterceptor();\n  tscOutputStream.pipe(input.tscOutputStream ?? process.stdout);\n\n  const { eslint, prettier, tscOk } = await lint({ ...input, tscOutputStream });\n\n  try {\n    await throwOnTimeout(\n      createAnnotations(eslint, prettier, tscOk, tscOutputStream),\n      { s: 30 },\n    );\n  } catch (err) {\n    log.warn('Failed to annotate lint results.');\n    log.subtle(inspect(err));\n  }\n\n  if (!eslint.ok || !prettier.ok || !tscOk) {\n    const tools = [\n      ...(eslint.ok ? [] : ['ESLint']),\n      ...(prettier.ok ? [] : ['Prettier']),\n      ...(tscOk ? [] : ['tsc']),\n    ];\n\n    log.newline();\n    log.err(`${tools.join(', ')} found issues that require triage.`);\n\n    process.exitCode = 1;\n  }\n\n  await autofix({\n    debug: input.debug,\n    eslint: eslint.fixable,\n    prettier: !prettier.ok,\n  });\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAmB;AACnB,kBAAwB;AAExB,qBAAoB;AACpB,kBAA+B;AAE/B,sBAAkC;AAClC,qBAAwB;AACxB,oBAAkE;AAClE,sBAGO;AACP,iBAAmC;AAGnC,MAAM,iBAAiB;AAEhB,MAAM,0BAA0B,cAAAA,QAAO,UAAU;AAAA,EAAjD;AAAA;AACL,SAAQ,SAAuB,CAAC;AAAA;AAAA,EAEzB,SAAS;AACd,WAAO,OAAO,OAAO,KAAK,MAAM,EAAE,SAAS,EAAE,QAAQ,gBAAgB,EAAE;AAAA,EACzE;AAAA,EAEA,WACE,OACA,WACA,UACA;AACA,SAAK,OAAO,KAAK,KAAK;AAEtB,aAAS,MAAM,KAAK;AAAA,EACtB;AACF;AAEA,MAAM,mBAAmB,OAAO,EAAE,iBAAiB,GAAG,MAAM,MAAa;AACvE,QAAM,CAAC,QAAQ,UAAU,KAAK,IAAI,MAAM,QAAQ,IAAI;AAAA,QAClD,uCAAwB,KAAK;AAAA,QAC7B,2CAA0B,KAAK;AAAA,QAC/B,+BAAmB,EAAE,GAAG,OAAO,gBAAgB,CAAC;AAAA,EAClD,CAAC;AAED,SAAO,EAAE,QAAQ,UAAU,MAAM;AACnC;AASA,MAAM,eAAe,OAAO,EAAE,iBAAiB,GAAG,MAAM,MAAa;AACnE,QAAM,SAAS,UAAM,uCAAwB,KAAK;AAClD,QAAM,WAAW,UAAM,2CAA0B,KAAK;AACtD,QAAM,QAAQ,UAAM,+BAAmB,EAAE,GAAG,OAAO,gBAAgB,CAAC;AAEpE,SAAO,EAAE,QAAQ,UAAU,MAAM;AACnC;AAEA,MAAM,mCAAmC,OAAO,UAAiB;AAC/D,QAAM,SAAS,UAAM,wCAAyB,KAAK;AACnD,QAAM,WAAW,UAAM,4CAA2B,KAAK;AACvD,QAAM,QAAQ,UAAM,+BAAmB,KAAK;AAE5C,SAAO,EAAE,QAAQ,UAAU,MAAM;AACnC;AAEA,MAAM,qBAAqB,CAAC,UAAiB;AAC3C,MAAI,CAAC,MAAM,eAAe;AACxB,WAAO;AAAA,EACT;AAGA,QAAM,WAAW,MAAM,SAAS,MAAM;AAEtC,SAAO,WAAW,eAAe;AACnC;AAEO,MAAM,eAAe,OAAO,UAAiB;AAClD,QAAM,OAAO,mBAAmB,KAAK;AAErC,QAAM,kBAAkB,IAAI,kBAAkB;AAC9C,kBAAgB,KAAK,MAAM,mBAAmB,QAAQ,MAAM;AAE5D,QAAM,EAAE,QAAQ,UAAU,MAAM,IAAI,MAAM,KAAK,EAAE,GAAG,OAAO,gBAAgB,CAAC;AAE5E,MAAI;AACF,cAAM;AAAA,UACJ,mCAAkB,QAAQ,UAAU,OAAO,eAAe;AAAA,MAC1D,EAAE,GAAG,GAAG;AAAA,IACV;AAAA,EACF,SAAS,KAAP;AACA,uBAAI,KAAK,kCAAkC;AAC3C,uBAAI,WAAO,qBAAQ,GAAG,CAAC;AAAA,EACzB;AAEA,MAAI,CAAC,OAAO,MAAM,CAAC,SAAS,MAAM,CAAC,OAAO;AACxC,UAAM,QAAQ;AAAA,MACZ,GAAI,OAAO,KAAK,CAAC,IAAI,CAAC,QAAQ;AAAA,MAC9B,GAAI,SAAS,KAAK,CAAC,IAAI,CAAC,UAAU;AAAA,MAClC,GAAI,QAAQ,CAAC,IAAI,CAAC,KAAK;AAAA,IACzB;AAEA,uBAAI,QAAQ;AACZ,uBAAI,IAAI,GAAG,MAAM,KAAK,IAAI,qCAAqC;AAE/D,YAAQ,WAAW;AAAA,EACrB;AAEA,YAAM,wBAAQ;AAAA,IACZ,OAAO,MAAM;AAAA,IACb,QAAQ,OAAO;AAAA,IACf,UAAU,CAAC,SAAS;AAAA,EACtB,CAAC;AACH;",
+  "names": ["stream"]
+}

package/lib/cli/lint/index.d.ts

@@ -0,0 +1,2 @@
+import type { Writable } from 'stream';
+export declare const lint: (args?: string[], tscOutputStream?: Writable | undefined, workerThreads?: boolean) => Promise<void>;

package/lib/cli/lint/index.js

@@ -0,0 +1,49 @@
+"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 lint_exports = {};
+__export(lint_exports, {
+  lint: () => lint
+});
+module.exports = __toCommonJS(lint_exports);
+var import_args = require("../../utils/args");
+var import_addEmptyExports = require("../configure/addEmptyExports");
+var import_patchRenovateConfig = require("../configure/patchRenovateConfig");
+var import_refreshIgnoreFiles = require("../configure/refreshIgnoreFiles");
+var import_external = require("./external");
+var import_internal = require("./internal");
+const lint = async (args = process.argv.slice(2), tscOutputStream = void 0, workerThreads = true) => {
+  await Promise.all([
+    (0, import_addEmptyExports.tryAddEmptyExports)(),
+    (0, import_patchRenovateConfig.tryPatchRenovateConfig)(),
+    (0, import_refreshIgnoreFiles.tryRefreshIgnoreFiles)()
+  ]);
+  const opts = {
+    debug: (0, import_args.hasDebugFlag)(args),
+    serial: (0, import_args.hasSerialFlag)(args),
+    tscOutputStream,
+    workerThreads
+  };
+  await (0, import_external.externalLint)(opts);
+  await (0, import_internal.internalLint)();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  lint
+});
+//# sourceMappingURL=index.js.map

package/lib/cli/lint/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/cli/lint/index.ts"],
+  "sourcesContent": ["import type { Writable } from 'stream';\n\nimport { hasDebugFlag, hasSerialFlag } from '../../utils/args';\nimport { tryAddEmptyExports } from '../configure/addEmptyExports';\nimport { tryPatchRenovateConfig } from '../configure/patchRenovateConfig';\nimport { tryRefreshIgnoreFiles } from '../configure/refreshIgnoreFiles';\n\nimport { externalLint } from './external';\nimport { internalLint } from './internal';\nimport type { Input } from './types';\n\nexport const lint = async (\n  args = process.argv.slice(2),\n  tscOutputStream: Writable | undefined = undefined,\n  workerThreads = true,\n) => {\n  await Promise.all([\n    tryAddEmptyExports(),\n    tryPatchRenovateConfig(),\n    tryRefreshIgnoreFiles(),\n  ]);\n\n  const opts: Input = {\n    debug: hasDebugFlag(args),\n    serial: hasSerialFlag(args),\n    tscOutputStream,\n    workerThreads,\n  };\n\n  await externalLint(opts);\n\n  await internalLint();\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,kBAA4C;AAC5C,6BAAmC;AACnC,iCAAuC;AACvC,gCAAsC;AAEtC,sBAA6B;AAC7B,sBAA6B;AAGtB,MAAM,OAAO,OAClB,OAAO,QAAQ,KAAK,MAAM,CAAC,GAC3B,kBAAwC,QACxC,gBAAgB,SACb;AACH,QAAM,QAAQ,IAAI;AAAA,QAChB,2CAAmB;AAAA,QACnB,mDAAuB;AAAA,QACvB,iDAAsB;AAAA,EACxB,CAAC;AAED,QAAM,OAAc;AAAA,IAClB,WAAO,0BAAa,IAAI;AAAA,IACxB,YAAQ,2BAAc,IAAI;AAAA,IAC1B;AAAA,IACA;AAAA,EACF;AAEA,YAAM,8BAAa,IAAI;AAEvB,YAAM,8BAAa;AACrB;",
+  "names": []
+}

package/lib/cli/lint/internal.d.ts

@@ -0,0 +1 @@
+export declare const internalLint: () => Promise<void>;

package/lib/cli/lint/internal.js

@@ -0,0 +1,64 @@
+"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 internal_exports = {};
+__export(internal_exports, {
+  internalLint: () => internalLint
+});
+module.exports = __toCommonJS(internal_exports);
+var import_path = __toESM(require("path"));
+var import_chalk = __toESM(require("chalk"));
+var import_fs_extra = require("fs-extra");
+var import_logging = require("../../utils/logging");
+var import_manifest = require("../../utils/manifest");
+const noSkubaTemplateJs = async () => {
+  const manifest = await (0, import_manifest.getConsumerManifest)();
+  if (!manifest) {
+    return;
+  }
+  const templateConfigPath = import_path.default.join(
+    import_path.default.dirname(manifest.path),
+    "skuba.template.js"
+  );
+  if (await (0, import_fs_extra.pathExists)(templateConfigPath)) {
+    import_logging.log.err(
+      `Template is incomplete; run ${import_chalk.default.bold(
+        "yarn skuba configure"
+      )}. ${import_chalk.default.dim("no-skuba-template-js")}`
+    );
+    process.exitCode = 1;
+  }
+};
+const internalLint = async () => {
+  await noSkubaTemplateJs();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  internalLint
+});
+//# sourceMappingURL=internal.js.map

package/lib/cli/lint/internal.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/cli/lint/internal.ts"],
+  "sourcesContent": ["import path from 'path';\n\nimport chalk from 'chalk';\nimport { pathExists } from 'fs-extra';\n\nimport { log } from '../../utils/logging';\nimport { getConsumerManifest } from '../../utils/manifest';\n\nconst noSkubaTemplateJs = async () => {\n  const manifest = await getConsumerManifest();\n\n  if (!manifest) {\n    return;\n  }\n\n  const templateConfigPath = path.join(\n    path.dirname(manifest.path),\n    'skuba.template.js',\n  );\n\n  if (await pathExists(templateConfigPath)) {\n    log.err(\n      `Template is incomplete; run ${chalk.bold(\n        'yarn skuba configure',\n      )}. ${chalk.dim('no-skuba-template-js')}`,\n    );\n\n    process.exitCode = 1;\n  }\n};\n\nexport const internalLint = async () => {\n  await noSkubaTemplateJs();\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAiB;AAEjB,mBAAkB;AAClB,sBAA2B;AAE3B,qBAAoB;AACpB,sBAAoC;AAEpC,MAAM,oBAAoB,YAAY;AACpC,QAAM,WAAW,UAAM,qCAAoB;AAE3C,MAAI,CAAC,UAAU;AACb;AAAA,EACF;AAEA,QAAM,qBAAqB,YAAAA,QAAK;AAAA,IAC9B,YAAAA,QAAK,QAAQ,SAAS,IAAI;AAAA,IAC1B;AAAA,EACF;AAEA,MAAI,UAAM,4BAAW,kBAAkB,GAAG;AACxC,uBAAI;AAAA,MACF,+BAA+B,aAAAC,QAAM;AAAA,QACnC;AAAA,MACF,MAAM,aAAAA,QAAM,IAAI,sBAAsB;AAAA,IACxC;AAEA,YAAQ,WAAW;AAAA,EACrB;AACF;AAEO,MAAM,eAAe,YAAY;AACtC,QAAM,kBAAkB;AAC1B;",
+  "names": ["path", "chalk"]
+}

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

@@ -0,0 +1,4 @@
+import type { PrettierOutput } from '../adapter/prettier';
+import type { Input } from './types';
+export declare const runPrettierInCurrentThread: ({ debug }: Input) => Promise<PrettierOutput>;
+export declare const runPrettierInWorkerThread: (input: Input) => Promise<PrettierOutput>;

package/lib/cli/lint/prettier.js

@@ -0,0 +1,55 @@
+"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 prettier_exports = {};
+__export(prettier_exports, {
+  runPrettierInCurrentThread: () => runPrettierInCurrentThread,
+  runPrettierInWorkerThread: () => runPrettierInWorkerThread
+});
+module.exports = __toCommonJS(prettier_exports);
+var import_path = __toESM(require("path"));
+var import_worker_threads = require("worker_threads");
+var import_chalk = __toESM(require("chalk"));
+var import_logging = require("../../utils/logging");
+var import_worker = require("../../utils/worker");
+var import_prettier = require("../adapter/prettier");
+const LOG_PREFIX = import_chalk.default.cyan("Prettier \u2502");
+const runPrettierInCurrentThread = ({ debug }) => (0, import_prettier.runPrettier)("lint", (0, import_logging.createLogger)(debug, LOG_PREFIX));
+const runPrettierInWorkerThread = (input) => (0, import_worker.execWorkerThread)(
+  import_path.default.posix.join(__dirname, "prettier.js"),
+  input
+);
+if (!import_worker_threads.isMainThread) {
+  (0, import_worker.postWorkerOutput)(runPrettierInCurrentThread, (0, import_logging.createLogger)(false, LOG_PREFIX));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runPrettierInCurrentThread,
+  runPrettierInWorkerThread
+});
+//# sourceMappingURL=prettier.js.map

package/lib/cli/lint/prettier.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/cli/lint/prettier.ts"],
+  "sourcesContent": ["import path from 'path';\nimport { isMainThread } from 'worker_threads';\n\nimport chalk from 'chalk';\n\nimport { createLogger } from '../../utils/logging';\nimport { execWorkerThread, postWorkerOutput } from '../../utils/worker';\nimport type { PrettierOutput } from '../adapter/prettier';\nimport { runPrettier } from '../adapter/prettier';\n\nimport type { Input } from './types';\n\nconst LOG_PREFIX = chalk.cyan('Prettier \u2502');\n\nexport const runPrettierInCurrentThread = ({ debug }: Input) =>\n  runPrettier('lint', createLogger(debug, LOG_PREFIX));\n\nexport const runPrettierInWorkerThread = (input: Input) =>\n  execWorkerThread<Input, PrettierOutput>(\n    path.posix.join(__dirname, 'prettier.js'),\n    input,\n  );\n\nif (!isMainThread) {\n  postWorkerOutput(runPrettierInCurrentThread, createLogger(false, LOG_PREFIX));\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAiB;AACjB,4BAA6B;AAE7B,mBAAkB;AAElB,qBAA6B;AAC7B,oBAAmD;AAEnD,sBAA4B;AAI5B,MAAM,aAAa,aAAAA,QAAM,KAAK,iBAAY;AAEnC,MAAM,6BAA6B,CAAC,EAAE,MAAM,UACjD,6BAAY,YAAQ,6BAAa,OAAO,UAAU,CAAC;AAE9C,MAAM,4BAA4B,CAAC,cACxC;AAAA,EACE,YAAAC,QAAK,MAAM,KAAK,WAAW,aAAa;AAAA,EACxC;AACF;AAEF,IAAI,CAAC,oCAAc;AACjB,sCAAiB,gCAA4B,6BAAa,OAAO,UAAU,CAAC;AAC9E;",
+  "names": ["chalk", "path"]
+}

package/lib/cli/lint/tsc.d.ts

@@ -0,0 +1,2 @@
+import type { Input } from './types';
+export declare const runTscInNewProcess: ({ debug, tscOutputStream, }: Input) => Promise<boolean>;

package/lib/cli/lint/tsc.js

@@ -0,0 +1,58 @@
+"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 tsc_exports = {};
+__export(tsc_exports, {
+  runTscInNewProcess: () => runTscInNewProcess
+});
+module.exports = __toCommonJS(tsc_exports);
+var import_exec = require("../../utils/exec");
+const runTscInNewProcess = async ({
+  debug,
+  tscOutputStream
+}) => {
+  const command = [
+    "tsc",
+    ...debug ? ["--extendedDiagnostics"] : [],
+    "--noEmit"
+  ].join(" ");
+  try {
+    await (0, import_exec.execConcurrently)(
+      [
+        {
+          command,
+          name: "tsc",
+          prefixColor: "blue"
+        }
+      ],
+      {
+        maxProcesses: 1,
+        nameLength: "Prettier".length,
+        outputStream: tscOutputStream
+      }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runTscInNewProcess
+});
+//# sourceMappingURL=tsc.js.map

package/lib/cli/lint/tsc.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/cli/lint/tsc.ts"],
+  "sourcesContent": ["import { execConcurrently } from '../../utils/exec';\n\nimport type { Input } from './types';\n\nexport const runTscInNewProcess = async ({\n  debug,\n  tscOutputStream,\n}: Input): Promise<boolean> => {\n  const command = [\n    'tsc',\n    ...(debug ? ['--extendedDiagnostics'] : []),\n    '--noEmit',\n  ].join(' ');\n\n  try {\n    // Misappropriate `concurrently` as a stdio prefixer.\n    // We can use our regular console logger once we decide on an approach for\n    // compiling in-process, whether by interacting with the TypeScript Compiler\n    // API directly or using a higher-level tool like esbuild.\n    await execConcurrently(\n      [\n        {\n          command,\n          name: 'tsc',\n          prefixColor: 'blue',\n        },\n      ],\n      {\n        maxProcesses: 1,\n        nameLength: 'Prettier'.length,\n        outputStream: tscOutputStream,\n      },\n    );\n\n    return true;\n  } catch {\n    return false;\n  }\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAiC;AAI1B,MAAM,qBAAqB,OAAO;AAAA,EACvC;AAAA,EACA;AACF,MAA+B;AAC7B,QAAM,UAAU;AAAA,IACd;AAAA,IACA,GAAI,QAAQ,CAAC,uBAAuB,IAAI,CAAC;AAAA,IACzC;AAAA,EACF,EAAE,KAAK,GAAG;AAEV,MAAI;AAKF,cAAM;AAAA,MACJ;AAAA,QACE;AAAA,UACE;AAAA,UACA,MAAM;AAAA,UACN,aAAa;AAAA,QACf;AAAA,MACF;AAAA,MACA;AAAA,QACE,cAAc;AAAA,QACd,YAAY,WAAW;AAAA,QACvB,cAAc;AAAA,MAChB;AAAA,IACF;AAEA,WAAO;AAAA,EACT,QAAE;AACA,WAAO;AAAA,EACT;AACF;",
+  "names": []
+}

package/lib/cli/lint/types.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+import type { Writable } from 'stream';
+export interface Input {
+    /**
+     * Whether to enable verbose debug logging.
+     *
+     * Defaults to `false`.
+     */
+    debug: boolean;
+    /**
+     * Whether to disable parallelism to run linting operations serially.
+     *
+     * This can be useful for executing in resource-constrained environments and
+     * snapshotting deterministic output in tests.
+     *
+     * Defaults to `false`.
+     */
+    serial: boolean;
+    /**
+     * An override output stream that can be supplied to test `tsc` logging.
+     *
+     * Defaults to `process.stdout`.
+     */
+    tscOutputStream?: Writable;
+    /**
+     * Whether to allow usage of Node.js worker threads.
+     *
+     * This may be set to `false` when there is a worker thread incompatibility,
+     * such as calling in from a TypeScript context in our Jest tests.
+     *
+     * Defaults to `true`.
+     */
+    workerThreads?: boolean;
+}

package/lib/cli/lint/types.js

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);
+//# sourceMappingURL=types.js.map

package/lib/cli/lint/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/cli/lint/types.ts"],
+  "sourcesContent": ["import type { Writable } from 'stream';\n\nexport interface Input {\n  /**\n   * Whether to enable verbose debug logging.\n   *\n   * Defaults to `false`.\n   */\n  debug: boolean;\n\n  /**\n   * Whether to disable parallelism to run linting operations serially.\n   *\n   * This can be useful for executing in resource-constrained environments and\n   * snapshotting deterministic output in tests.\n   *\n   * Defaults to `false`.\n   */\n  serial: boolean;\n\n  /**\n   * An override output stream that can be supplied to test `tsc` logging.\n   *\n   * Defaults to `process.stdout`.\n   */\n  tscOutputStream?: Writable;\n\n  /**\n   * Whether to allow usage of Node.js worker threads.\n   *\n   * This may be set to `false` when there is a worker thread incompatibility,\n   * such as calling in from a TypeScript context in our Jest tests.\n   *\n   * Defaults to `true`.\n   */\n  workerThreads?: boolean;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
+  "names": []
+}

package/lib/cli/node.d.ts

@@ -0,0 +1 @@
+export declare const node: () => Promise<void | import("execa").ExecaReturnValue<string>>;

package/lib/cli/node.js

@@ -0,0 +1,77 @@
+"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 node_exports = {};
+__export(node_exports, {
+  node: () => node
+});
+module.exports = __toCommonJS(node_exports);
+var import_path = __toESM(require("path"));
+var import_get_port = __toESM(require("get-port"));
+var tsNode = __toESM(require("ts-node"));
+var import_args = require("../utils/args");
+var import_exec = require("../utils/exec");
+var import_validation = require("../utils/validation");
+const node = async () => {
+  const args = (0, import_args.parseRunArgs)(process.argv.slice(2));
+  const availablePort = await (0, import_get_port.default)();
+  if (args.entryPoint) {
+    const exec = (0, import_exec.createExec)({
+      env: {
+        __SKUBA_ENTRY_POINT: args.entryPoint,
+        __SKUBA_PORT: String((0, import_validation.isIpPort)(args.port) ? args.port : availablePort)
+      }
+    });
+    return exec(
+      "node",
+      ...args.node,
+      "--require",
+      "dotenv/config",
+      "--require",
+      "tsconfig-paths/register",
+      "--require",
+      "ts-node/register/transpile-only",
+      // Override dangerously warn-only default on Node.js <15 so that we
+      // predictably return a non-zero exit code on an unhandled rejection.
+      "--unhandled-rejections=throw",
+      import_path.default.join(__dirname, "..", "wrapper"),
+      ...args.script
+    );
+  }
+  return tsNode.createRepl({
+    service: tsNode.register({
+      require: ["dotenv/config", "tsconfig-paths/register"],
+      transpileOnly: true
+    })
+  }).start();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  node
+});
+//# sourceMappingURL=node.js.map

package/lib/cli/node.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/cli/node.ts"],
+  "sourcesContent": ["import path from 'path';\n\nimport getPort from 'get-port';\nimport * as tsNode from 'ts-node';\n\nimport { parseRunArgs } from '../utils/args';\nimport { createExec } from '../utils/exec';\nimport { isIpPort } from '../utils/validation';\n\nexport const node = async () => {\n  const args = parseRunArgs(process.argv.slice(2));\n\n  const availablePort = await getPort();\n\n  if (args.entryPoint) {\n    const exec = createExec({\n      env: {\n        __SKUBA_ENTRY_POINT: args.entryPoint,\n        __SKUBA_PORT: String(isIpPort(args.port) ? args.port : availablePort),\n      },\n    });\n\n    // Run a script with plain `node` to support inspector options.\n    // https://github.com/TypeStrong/ts-node#programmatic\n    return exec(\n      'node',\n      ...args.node,\n      '--require',\n      'dotenv/config',\n      '--require',\n      'tsconfig-paths/register',\n      '--require',\n      'ts-node/register/transpile-only',\n      // Override dangerously warn-only default on Node.js <15 so that we\n      // predictably return a non-zero exit code on an unhandled rejection.\n      '--unhandled-rejections=throw',\n      path.join(__dirname, '..', 'wrapper'),\n      ...args.script,\n    );\n  }\n\n  // REPL with `ts-node` to support import statements.\n  return tsNode\n    .createRepl({\n      service: tsNode.register({\n        require: ['dotenv/config', 'tsconfig-paths/register'],\n        transpileOnly: true,\n      }),\n    })\n    .start();\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAiB;AAEjB,sBAAoB;AACpB,aAAwB;AAExB,kBAA6B;AAC7B,kBAA2B;AAC3B,wBAAyB;AAElB,MAAM,OAAO,YAAY;AAC9B,QAAM,WAAO,0BAAa,QAAQ,KAAK,MAAM,CAAC,CAAC;AAE/C,QAAM,gBAAgB,UAAM,gBAAAA,SAAQ;AAEpC,MAAI,KAAK,YAAY;AACnB,UAAM,WAAO,wBAAW;AAAA,MACtB,KAAK;AAAA,QACH,qBAAqB,KAAK;AAAA,QAC1B,cAAc,WAAO,4BAAS,KAAK,IAAI,IAAI,KAAK,OAAO,aAAa;AAAA,MACtE;AAAA,IACF,CAAC;AAID,WAAO;AAAA,MACL;AAAA,MACA,GAAG,KAAK;AAAA,MACR;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA;AAAA;AAAA,MAGA;AAAA,MACA,YAAAC,QAAK,KAAK,WAAW,MAAM,SAAS;AAAA,MACpC,GAAG,KAAK;AAAA,IACV;AAAA,EACF;AAGA,SAAO,OACJ,WAAW;AAAA,IACV,SAAS,OAAO,SAAS;AAAA,MACvB,SAAS,CAAC,iBAAiB,yBAAyB;AAAA,MACpD,eAAe;AAAA,IACjB,CAAC;AAAA,EACH,CAAC,EACA,MAAM;AACX;",
+  "names": ["getPort", "path"]
+}

package/lib/cli/release.d.ts

@@ -0,0 +1 @@
+export declare const release: () => Promise<void>;

package/lib/cli/release.js

@@ -0,0 +1,32 @@
+"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 release_exports = {};
+__export(release_exports, {
+  release: () => release
+});
+module.exports = __toCommonJS(release_exports);
+var import_exec = require("../utils/exec");
+const release = async () => {
+  await (0, import_exec.exec)("semantic-release", "--success", "false");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  release
+});
+//# sourceMappingURL=release.js.map

package/lib/cli/release.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/cli/release.ts"],
+  "sourcesContent": ["import { exec } from '../utils/exec';\n\nexport const release = async () => {\n  await exec('semantic-release', '--success', 'false');\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAqB;AAEd,MAAM,UAAU,YAAY;AACjC,YAAM,kBAAK,oBAAoB,aAAa,OAAO;AACrD;",
+  "names": []
+}

package/lib/cli/start.d.ts

@@ -0,0 +1 @@
+export declare const start: () => Promise<import("execa").ExecaReturnValue<string>>;