skuba 0.0.0-beta-20231002015947

package/lib/cli/build/tsc.js

@@ -0,0 +1,102 @@
+"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 tsc_exports = {};
+__export(tsc_exports, {
+  readTsconfig: () => readTsconfig,
+  tsc: () => tsc
+});
+module.exports = __toCommonJS(tsc_exports);
+var import_typescript = __toESM(require("typescript"));
+var import_exec = require("../../utils/exec");
+var import_args = require("./args");
+const DEFAULT_ARGS = ["--project", "tsconfig.build.json"];
+const formatHost = {
+  getCanonicalFileName: (fileName) => fileName,
+  getCurrentDirectory: import_typescript.default.sys.getCurrentDirectory.bind(void 0),
+  getNewLine: () => import_typescript.default.sys.newLine
+};
+const tsconfigCache = /* @__PURE__ */ new Map();
+const computeCacheKey = (args) => Array.from(args).sort().toString();
+const tsc = async (args = process.argv.slice(2)) => {
+  const tscArgs = (0, import_args.parseTscArgs)(args);
+  const defaultArgs = tscArgs.build || tscArgs.project ? [] : DEFAULT_ARGS;
+  return (0, import_exec.exec)("tsc", ...defaultArgs, ...args);
+};
+const readTsconfig = (args = process.argv.slice(2), log) => {
+  const tscArgs = (0, import_args.parseTscArgs)(args);
+  let parsedCommandLine = tsconfigCache.get(computeCacheKey(args));
+  if (!parsedCommandLine) {
+    log.debug(
+      log.bold(
+        "tsconfig",
+        ...tscArgs.project ? ["--project", tscArgs.project] : []
+      )
+    );
+    log.debug(tscArgs.pathname);
+    const tsconfigFile = import_typescript.default.findConfigFile(
+      tscArgs.dirname,
+      import_typescript.default.sys.fileExists.bind(void 0),
+      tscArgs.basename
+    );
+    if (!tsconfigFile) {
+      log.err(`Could not find ${tscArgs.pathname}.`);
+      process.exitCode = 1;
+      return;
+    }
+    const readConfigFile = import_typescript.default.readConfigFile(
+      tsconfigFile,
+      import_typescript.default.sys.readFile.bind(void 0)
+    );
+    if (readConfigFile.error) {
+      log.err(`Could not read ${tscArgs.pathname}.`);
+      log.subtle(import_typescript.default.formatDiagnostic(readConfigFile.error, formatHost));
+      process.exitCode = 1;
+      return;
+    }
+    parsedCommandLine = import_typescript.default.parseJsonConfigFileContent(
+      readConfigFile.config,
+      import_typescript.default.sys,
+      tscArgs.dirname
+    );
+    tsconfigCache.set(computeCacheKey(args), parsedCommandLine);
+  }
+  if (parsedCommandLine.errors.length) {
+    log.err(`Could not parse ${tscArgs.pathname}.`);
+    log.subtle(import_typescript.default.formatDiagnostics(parsedCommandLine.errors, formatHost));
+    process.exitCode = 1;
+    return;
+  }
+  return parsedCommandLine;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  readTsconfig,
+  tsc
+});
+//# sourceMappingURL=tsc.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/cli/build/tsc.ts"],
+  "sourcesContent": ["import ts from 'typescript';\n\nimport { exec } from '../../utils/exec';\nimport type { Logger } from '../../utils/logging';\n\nimport { parseTscArgs } from './args';\n\nconst DEFAULT_ARGS = ['--project', 'tsconfig.build.json'] as const;\n\nconst formatHost: ts.FormatDiagnosticsHost = {\n  getCanonicalFileName: (fileName) => fileName,\n  getCurrentDirectory: ts.sys.getCurrentDirectory.bind(undefined),\n  getNewLine: () => ts.sys.newLine,\n};\n\nconst tsconfigCache = new Map<string, ts.ParsedCommandLine>();\nconst computeCacheKey = (args: string[]) => Array.from(args).sort().toString();\n\nexport const tsc = async (args = process.argv.slice(2)) => {\n  const tscArgs = parseTscArgs(args);\n\n  // Build flag is incompatible with project flag.\n  const defaultArgs = tscArgs.build || tscArgs.project ? [] : DEFAULT_ARGS;\n\n  return exec('tsc', ...defaultArgs, ...args);\n};\n\nexport const readTsconfig = (args = process.argv.slice(2), log: Logger) => {\n  const tscArgs = parseTscArgs(args);\n\n  let parsedCommandLine = tsconfigCache.get(computeCacheKey(args));\n\n  if (!parsedCommandLine) {\n    log.debug(\n      log.bold(\n        'tsconfig',\n        ...(tscArgs.project ? ['--project', tscArgs.project] : []),\n      ),\n    );\n    log.debug(tscArgs.pathname);\n\n    const tsconfigFile = ts.findConfigFile(\n      tscArgs.dirname,\n      ts.sys.fileExists.bind(undefined),\n      tscArgs.basename,\n    );\n    if (!tsconfigFile) {\n      log.err(`Could not find ${tscArgs.pathname}.`);\n      process.exitCode = 1;\n      return;\n    }\n\n    const readConfigFile = ts.readConfigFile(\n      tsconfigFile,\n      ts.sys.readFile.bind(undefined),\n    );\n    if (readConfigFile.error) {\n      log.err(`Could not read ${tscArgs.pathname}.`);\n      log.subtle(ts.formatDiagnostic(readConfigFile.error, formatHost));\n      process.exitCode = 1;\n      return;\n    }\n\n    parsedCommandLine = ts.parseJsonConfigFileContent(\n      readConfigFile.config,\n      ts.sys,\n      tscArgs.dirname,\n    );\n    tsconfigCache.set(computeCacheKey(args), parsedCommandLine);\n  }\n\n  if (parsedCommandLine.errors.length) {\n    log.err(`Could not parse ${tscArgs.pathname}.`);\n    log.subtle(ts.formatDiagnostics(parsedCommandLine.errors, formatHost));\n    process.exitCode = 1;\n    return;\n  }\n\n  return parsedCommandLine;\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAAe;AAEf,kBAAqB;AAGrB,kBAA6B;AAE7B,MAAM,eAAe,CAAC,aAAa,qBAAqB;AAExD,MAAM,aAAuC;AAAA,EAC3C,sBAAsB,CAAC,aAAa;AAAA,EACpC,qBAAqB,kBAAAA,QAAG,IAAI,oBAAoB,KAAK,MAAS;AAAA,EAC9D,YAAY,MAAM,kBAAAA,QAAG,IAAI;AAC3B;AAEA,MAAM,gBAAgB,oBAAI,IAAkC;AAC5D,MAAM,kBAAkB,CAAC,SAAmB,MAAM,KAAK,IAAI,EAAE,KAAK,EAAE,SAAS;AAEtE,MAAM,MAAM,OAAO,OAAO,QAAQ,KAAK,MAAM,CAAC,MAAM;AACzD,QAAM,cAAU,0BAAa,IAAI;AAGjC,QAAM,cAAc,QAAQ,SAAS,QAAQ,UAAU,CAAC,IAAI;AAE5D,aAAO,kBAAK,OAAO,GAAG,aAAa,GAAG,IAAI;AAC5C;AAEO,MAAM,eAAe,CAAC,OAAO,QAAQ,KAAK,MAAM,CAAC,GAAG,QAAgB;AACzE,QAAM,cAAU,0BAAa,IAAI;AAEjC,MAAI,oBAAoB,cAAc,IAAI,gBAAgB,IAAI,CAAC;AAE/D,MAAI,CAAC,mBAAmB;AACtB,QAAI;AAAA,MACF,IAAI;AAAA,QACF;AAAA,QACA,GAAI,QAAQ,UAAU,CAAC,aAAa,QAAQ,OAAO,IAAI,CAAC;AAAA,MAC1D;AAAA,IACF;AACA,QAAI,MAAM,QAAQ,QAAQ;AAE1B,UAAM,eAAe,kBAAAA,QAAG;AAAA,MACtB,QAAQ;AAAA,MACR,kBAAAA,QAAG,IAAI,WAAW,KAAK,MAAS;AAAA,MAChC,QAAQ;AAAA,IACV;AACA,QAAI,CAAC,cAAc;AACjB,UAAI,IAAI,kBAAkB,QAAQ,QAAQ,GAAG;AAC7C,cAAQ,WAAW;AACnB;AAAA,IACF;AAEA,UAAM,iBAAiB,kBAAAA,QAAG;AAAA,MACxB;AAAA,MACA,kBAAAA,QAAG,IAAI,SAAS,KAAK,MAAS;AAAA,IAChC;AACA,QAAI,eAAe,OAAO;AACxB,UAAI,IAAI,kBAAkB,QAAQ,QAAQ,GAAG;AAC7C,UAAI,OAAO,kBAAAA,QAAG,iBAAiB,eAAe,OAAO,UAAU,CAAC;AAChE,cAAQ,WAAW;AACnB;AAAA,IACF;AAEA,wBAAoB,kBAAAA,QAAG;AAAA,MACrB,eAAe;AAAA,MACf,kBAAAA,QAAG;AAAA,MACH,QAAQ;AAAA,IACV;AACA,kBAAc,IAAI,gBAAgB,IAAI,GAAG,iBAAiB;AAAA,EAC5D;AAEA,MAAI,kBAAkB,OAAO,QAAQ;AACnC,QAAI,IAAI,mBAAmB,QAAQ,QAAQ,GAAG;AAC9C,QAAI,OAAO,kBAAAA,QAAG,kBAAkB,kBAAkB,QAAQ,UAAU,CAAC;AACrE,YAAQ,WAAW;AACnB;AAAA,EACF;AAEA,SAAO;AACT;",
+  "names": ["ts"]
+}

package/lib/cli/buildPackage.d.ts

@@ -0,0 +1 @@
+export declare const buildPackage: (args?: string[]) => Promise<void>;

package/lib/cli/buildPackage.js

@@ -0,0 +1,69 @@
+"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 buildPackage_exports = {};
+__export(buildPackage_exports, {
+  buildPackage: () => buildPackage
+});
+module.exports = __toCommonJS(buildPackage_exports);
+var import_args = require("../utils/args");
+var import_exec = require("../utils/exec");
+var import_assets = require("./build/assets");
+var import_addEmptyExports = require("./configure/addEmptyExports");
+const buildPackage = async (args = process.argv.slice(2)) => {
+  await (0, import_addEmptyExports.tryAddEmptyExports)();
+  await (0, import_exec.execConcurrently)(
+    [
+      {
+        command: "tsc --module CommonJS --outDir lib-commonjs --project tsconfig.build.json",
+        name: "commonjs",
+        prefixColor: "green"
+      },
+      {
+        command: "tsc --module ES2015 --outDir lib-es2015 --project tsconfig.build.json",
+        name: "es2015",
+        prefixColor: "yellow"
+      },
+      {
+        command: "tsc --allowJS false --declaration --emitDeclarationOnly --outDir lib-types --project tsconfig.build.json",
+        name: "types",
+        prefixColor: "blue"
+      }
+    ],
+    {
+      maxProcesses: (0, import_args.hasSerialFlag)(args) ? 1 : void 0
+    }
+  );
+  await (0, import_assets.copyAssetsConcurrently)([
+    {
+      outDir: "lib-commonjs",
+      name: "commonjs",
+      prefixColor: "green"
+    },
+    {
+      outDir: "lib-es2015",
+      name: "es2015",
+      prefixColor: "yellow"
+    }
+  ]);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildPackage
+});
+//# sourceMappingURL=buildPackage.js.map

package/lib/cli/buildPackage.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/cli/buildPackage.ts"],
+  "sourcesContent": ["import { hasSerialFlag } from '../utils/args';\nimport { execConcurrently } from '../utils/exec';\n\nimport { copyAssetsConcurrently } from './build/assets';\nimport { tryAddEmptyExports } from './configure/addEmptyExports';\n\nexport const buildPackage = async (args = process.argv.slice(2)) => {\n  await tryAddEmptyExports();\n\n  await execConcurrently(\n    [\n      {\n        command:\n          'tsc --module CommonJS --outDir lib-commonjs --project tsconfig.build.json',\n        name: 'commonjs',\n        prefixColor: 'green',\n      },\n      {\n        command:\n          'tsc --module ES2015 --outDir lib-es2015 --project tsconfig.build.json',\n        name: 'es2015',\n        prefixColor: 'yellow',\n      },\n      {\n        command:\n          'tsc --allowJS false --declaration --emitDeclarationOnly --outDir lib-types --project tsconfig.build.json',\n        name: 'types',\n        prefixColor: 'blue',\n      },\n    ],\n    {\n      maxProcesses: hasSerialFlag(args) ? 1 : undefined,\n    },\n  );\n\n  await copyAssetsConcurrently([\n    {\n      outDir: 'lib-commonjs',\n      name: 'commonjs',\n      prefixColor: 'green',\n    },\n    {\n      outDir: 'lib-es2015',\n      name: 'es2015',\n      prefixColor: 'yellow',\n    },\n  ]);\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAA8B;AAC9B,kBAAiC;AAEjC,oBAAuC;AACvC,6BAAmC;AAE5B,MAAM,eAAe,OAAO,OAAO,QAAQ,KAAK,MAAM,CAAC,MAAM;AAClE,YAAM,2CAAmB;AAEzB,YAAM;AAAA,IACJ;AAAA,MACE;AAAA,QACE,SACE;AAAA,QACF,MAAM;AAAA,QACN,aAAa;AAAA,MACf;AAAA,MACA;AAAA,QACE,SACE;AAAA,QACF,MAAM;AAAA,QACN,aAAa;AAAA,MACf;AAAA,MACA;AAAA,QACE,SACE;AAAA,QACF,MAAM;AAAA,QACN,aAAa;AAAA,MACf;AAAA,IACF;AAAA,IACA;AAAA,MACE,kBAAc,2BAAc,IAAI,IAAI,IAAI;AAAA,IAC1C;AAAA,EACF;AAEA,YAAM,sCAAuB;AAAA,IAC3B;AAAA,MACE,QAAQ;AAAA,MACR,MAAM;AAAA,MACN,aAAa;AAAA,IACf;AAAA,IACA;AAAA,MACE,QAAQ;AAAA,MACR,MAAM;AAAA,MACN,aAAa;AAAA,IACf;AAAA,EACF,CAAC;AACH;",
+  "names": []
+}

package/lib/cli/configure/addEmptyExports.d.ts

@@ -0,0 +1,6 @@
+export declare const JEST_SETUP_FILES: string[];
+/**
+ * Tries to add an empty `export {}` statement to the bottom of Jest setup files
+ * for compliance with TypeScript isolated modules.
+ */
+export declare const tryAddEmptyExports: () => Promise<void>;

package/lib/cli/configure/addEmptyExports.js

@@ -0,0 +1,76 @@
+"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 addEmptyExports_exports = {};
+__export(addEmptyExports_exports, {
+  JEST_SETUP_FILES: () => JEST_SETUP_FILES,
+  tryAddEmptyExports: () => tryAddEmptyExports
+});
+module.exports = __toCommonJS(addEmptyExports_exports);
+var import_path = __toESM(require("path"));
+var import_util = require("util");
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_logging = require("../../utils/logging");
+var import_package = require("./analysis/package");
+var import_project = require("./analysis/project");
+var import_prettier = require("./processing/prettier");
+const JEST_SETUP_FILES = ["jest.setup.ts", "jest.setup.int.ts"];
+const addEmptyExports = async () => {
+  const manifest = await (0, import_package.getDestinationManifest)();
+  const destinationRoot = import_path.default.dirname(manifest.path);
+  const readDestinationFile = (0, import_project.createDestinationFileReader)(destinationRoot);
+  const addEmptyExport = async (filename) => {
+    const inputFile = await readDestinationFile(filename);
+    if (!inputFile || // The file appears to have an import or export so it should be compatible
+    // with isolated modules. This is a very naive check that we don't want to
+    // overcomplicate because it is invoked before many skuba commands.
+    inputFile.includes("import ") || inputFile.includes("export ")) {
+      return;
+    }
+    const data = await (0, import_prettier.formatPrettier)([inputFile, "export {}"].join("\n\n"), {
+      parser: "typescript"
+    });
+    const filepath = import_path.default.join(destinationRoot, filename);
+    await import_fs_extra.default.promises.writeFile(filepath, data);
+  };
+  await Promise.all(JEST_SETUP_FILES.map(addEmptyExport));
+};
+const tryAddEmptyExports = async () => {
+  try {
+    await addEmptyExports();
+  } catch (err) {
+    import_logging.log.warn("Failed to convert Jest setup files to isolated modules.");
+    import_logging.log.subtle((0, import_util.inspect)(err));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JEST_SETUP_FILES,
+  tryAddEmptyExports
+});
+//# sourceMappingURL=addEmptyExports.js.map

package/lib/cli/configure/addEmptyExports.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/cli/configure/addEmptyExports.ts"],
+  "sourcesContent": ["import path from 'path';\nimport { inspect } from 'util';\n\nimport fs from 'fs-extra';\n\nimport { log } from '../../utils/logging';\n\nimport { getDestinationManifest } from './analysis/package';\nimport { createDestinationFileReader } from './analysis/project';\nimport { formatPrettier } from './processing/prettier';\n\n// TODO: glob `**/jest.*setup*.ts`?\nexport const JEST_SETUP_FILES = ['jest.setup.ts', 'jest.setup.int.ts'];\n\nconst addEmptyExports = async () => {\n  const manifest = await getDestinationManifest();\n\n  const destinationRoot = path.dirname(manifest.path);\n\n  const readDestinationFile = createDestinationFileReader(destinationRoot);\n\n  const addEmptyExport = async (filename: string) => {\n    const inputFile = await readDestinationFile(filename);\n\n    if (\n      !inputFile ||\n      // The file appears to have an import or export so it should be compatible\n      // with isolated modules. This is a very naive check that we don't want to\n      // overcomplicate because it is invoked before many skuba commands.\n      inputFile.includes('import ') ||\n      inputFile.includes('export ')\n    ) {\n      return;\n    }\n\n    const data = await formatPrettier([inputFile, 'export {}'].join('\\n\\n'), {\n      parser: 'typescript',\n    });\n\n    const filepath = path.join(destinationRoot, filename);\n\n    await fs.promises.writeFile(filepath, data);\n  };\n\n  await Promise.all(JEST_SETUP_FILES.map(addEmptyExport));\n};\n\n/**\n * Tries to add an empty `export {}` statement to the bottom of Jest setup files\n * for compliance with TypeScript isolated modules.\n */\nexport const tryAddEmptyExports = async () => {\n  try {\n    await addEmptyExports();\n  } catch (err) {\n    log.warn('Failed to convert Jest setup files to isolated modules.');\n    log.subtle(inspect(err));\n  }\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAiB;AACjB,kBAAwB;AAExB,sBAAe;AAEf,qBAAoB;AAEpB,qBAAuC;AACvC,qBAA4C;AAC5C,sBAA+B;AAGxB,MAAM,mBAAmB,CAAC,iBAAiB,mBAAmB;AAErE,MAAM,kBAAkB,YAAY;AAClC,QAAM,WAAW,UAAM,uCAAuB;AAE9C,QAAM,kBAAkB,YAAAA,QAAK,QAAQ,SAAS,IAAI;AAElD,QAAM,0BAAsB,4CAA4B,eAAe;AAEvE,QAAM,iBAAiB,OAAO,aAAqB;AACjD,UAAM,YAAY,MAAM,oBAAoB,QAAQ;AAEpD,QACE,CAAC;AAAA;AAAA;AAAA,IAID,UAAU,SAAS,SAAS,KAC5B,UAAU,SAAS,SAAS,GAC5B;AACA;AAAA,IACF;AAEA,UAAM,OAAO,UAAM,gCAAe,CAAC,WAAW,WAAW,EAAE,KAAK,MAAM,GAAG;AAAA,MACvE,QAAQ;AAAA,IACV,CAAC;AAED,UAAM,WAAW,YAAAA,QAAK,KAAK,iBAAiB,QAAQ;AAEpD,UAAM,gBAAAC,QAAG,SAAS,UAAU,UAAU,IAAI;AAAA,EAC5C;AAEA,QAAM,QAAQ,IAAI,iBAAiB,IAAI,cAAc,CAAC;AACxD;AAMO,MAAM,qBAAqB,YAAY;AAC5C,MAAI;AACF,UAAM,gBAAgB;AAAA,EACxB,SAAS,KAAK;AACZ,uBAAI,KAAK,yDAAyD;AAClE,uBAAI,WAAO,qBAAQ,GAAG,CAAC;AAAA,EACzB;AACF;",
+  "names": ["path", "fs"]
+}

package/lib/cli/configure/analyseConfiguration.d.ts

@@ -0,0 +1,9 @@
+import type { ProjectType } from '../../utils/manifest';
+interface Props {
+    destinationRoot: string;
+    entryPoint: string;
+    firstRun: boolean;
+    type: ProjectType;
+}
+export declare const analyseConfiguration: (props: Props) => Promise<undefined | (() => Promise<void>)>;
+export {};

package/lib/cli/configure/analyseConfiguration.js

@@ -0,0 +1,69 @@
+"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 analyseConfiguration_exports = {};
+__export(analyseConfiguration_exports, {
+  analyseConfiguration: () => analyseConfiguration
+});
+module.exports = __toCommonJS(analyseConfiguration_exports);
+var import_path = __toESM(require("path"));
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_logging = require("../../utils/logging");
+var import_project = require("./analysis/project");
+const analyseConfiguration = async (props) => {
+  import_logging.log.newline();
+  import_logging.log.plain(import_logging.log.bold("Config:"));
+  const files = await (0, import_project.diffFiles)(props);
+  if (Object.keys(files).length === 0) {
+    import_logging.log.newline();
+    import_logging.log.ok("\u2714 No changes");
+    return;
+  }
+  import_logging.log.newline();
+  Object.entries(files).sort(([filenameA], [filenameB]) => filenameA.localeCompare(filenameB)).forEach(([filename, { operation }]) => import_logging.log.plain(operation, filename));
+  return async () => {
+    const dirnames = [
+      ...new Set(Object.keys(files).map((filename) => import_path.default.dirname(filename)))
+    ];
+    await Promise.all(
+      dirnames.map(
+        (dirname) => import_fs_extra.default.promises.mkdir(dirname, { recursive: true })
+      )
+    );
+    await Promise.all(
+      Object.entries(files).map(
+        ([filename, { data }]) => data === void 0 ? import_fs_extra.default.promises.rm(filename) : import_fs_extra.default.promises.writeFile(filename, data)
+      )
+    );
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  analyseConfiguration
+});
+//# sourceMappingURL=analyseConfiguration.js.map

package/lib/cli/configure/analyseConfiguration.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/cli/configure/analyseConfiguration.ts"],
+  "sourcesContent": ["import path from 'path';\n\nimport fs from 'fs-extra';\n\nimport { log } from '../../utils/logging';\nimport type { ProjectType } from '../../utils/manifest';\n\nimport { diffFiles } from './analysis/project';\n\ninterface Props {\n  destinationRoot: string;\n  entryPoint: string;\n  firstRun: boolean;\n  type: ProjectType;\n}\n\nexport const analyseConfiguration = async (\n  props: Props,\n): Promise<undefined | (() => Promise<void>)> => {\n  log.newline();\n  log.plain(log.bold('Config:'));\n\n  const files = await diffFiles(props);\n\n  if (Object.keys(files).length === 0) {\n    log.newline();\n    log.ok('\u2714 No changes');\n    return;\n  }\n\n  log.newline();\n  Object.entries(files)\n    .sort(([filenameA], [filenameB]) => filenameA.localeCompare(filenameB))\n    .forEach(([filename, { operation }]) => log.plain(operation, filename));\n\n  return async () => {\n    const dirnames = [\n      ...new Set(Object.keys(files).map((filename) => path.dirname(filename))),\n    ];\n\n    await Promise.all(\n      dirnames.map((dirname) =>\n        fs.promises.mkdir(dirname, { recursive: true }),\n      ),\n    );\n\n    await Promise.all(\n      Object.entries(files).map(([filename, { data }]) =>\n        data === undefined\n          ? fs.promises.rm(filename)\n          : fs.promises.writeFile(filename, data),\n      ),\n    );\n  };\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAiB;AAEjB,sBAAe;AAEf,qBAAoB;AAGpB,qBAA0B;AASnB,MAAM,uBAAuB,OAClC,UAC+C;AAC/C,qBAAI,QAAQ;AACZ,qBAAI,MAAM,mBAAI,KAAK,SAAS,CAAC;AAE7B,QAAM,QAAQ,UAAM,0BAAU,KAAK;AAEnC,MAAI,OAAO,KAAK,KAAK,EAAE,WAAW,GAAG;AACnC,uBAAI,QAAQ;AACZ,uBAAI,GAAG,mBAAc;AACrB;AAAA,EACF;AAEA,qBAAI,QAAQ;AACZ,SAAO,QAAQ,KAAK,EACjB,KAAK,CAAC,CAAC,SAAS,GAAG,CAAC,SAAS,MAAM,UAAU,cAAc,SAAS,CAAC,EACrE,QAAQ,CAAC,CAAC,UAAU,EAAE,UAAU,CAAC,MAAM,mBAAI,MAAM,WAAW,QAAQ,CAAC;AAExE,SAAO,YAAY;AACjB,UAAM,WAAW;AAAA,MACf,GAAG,IAAI,IAAI,OAAO,KAAK,KAAK,EAAE,IAAI,CAAC,aAAa,YAAAA,QAAK,QAAQ,QAAQ,CAAC,CAAC;AAAA,IACzE;AAEA,UAAM,QAAQ;AAAA,MACZ,SAAS;AAAA,QAAI,CAAC,YACZ,gBAAAC,QAAG,SAAS,MAAM,SAAS,EAAE,WAAW,KAAK,CAAC;AAAA,MAChD;AAAA,IACF;AAEA,UAAM,QAAQ;AAAA,MACZ,OAAO,QAAQ,KAAK,EAAE;AAAA,QAAI,CAAC,CAAC,UAAU,EAAE,KAAK,CAAC,MAC5C,SAAS,SACL,gBAAAA,QAAG,SAAS,GAAG,QAAQ,IACvB,gBAAAA,QAAG,SAAS,UAAU,UAAU,IAAI;AAAA,MAC1C;AAAA,IACF;AAAA,EACF;AACF;",
+  "names": ["path", "fs"]
+}

package/lib/cli/configure/analyseDependencies.d.ts

@@ -0,0 +1,10 @@
+import type { NormalizedReadResult } from 'read-pkg-up';
+import type { ProjectType } from '../../utils/manifest';
+interface Props {
+    destinationRoot: string;
+    include: (pathname: string) => boolean;
+    manifest: NormalizedReadResult;
+    type: ProjectType;
+}
+export declare const analyseDependencies: ({ destinationRoot, include, manifest: { packageJson }, type, }: Props) => Promise<undefined | (() => Promise<void>)>;
+export {};

package/lib/cli/configure/analyseDependencies.js

@@ -0,0 +1,136 @@
+"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 analyseDependencies_exports = {};
+__export(analyseDependencies_exports, {
+  analyseDependencies: () => analyseDependencies
+});
+module.exports = __toCommonJS(analyseDependencies_exports);
+var import_path = __toESM(require("path"));
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_copy = require("../../utils/copy");
+var import_logging = require("../../utils/logging");
+var import_version = require("../../utils/version");
+var import_package = require("./analysis/package");
+var dependencyMutators = __toESM(require("./dependencies"));
+var import_package2 = require("./processing/package");
+const logDiff = (diff) => {
+  const entries = Object.entries(diff);
+  if (entries.length === 0) {
+    import_logging.log.ok("\u2714 No changes");
+    return false;
+  }
+  Object.entries(diff).sort(([nameA], [nameB]) => nameA.localeCompare(nameB)).forEach(
+    ([name, { operation, version }]) => import_logging.log.plain(operation, name, import_logging.log.formatSubtle(version))
+  );
+  return true;
+};
+const pinUnspecifiedVersions = async (dependencies) => {
+  const updates = await Promise.all(
+    Object.entries(dependencies).filter(([, version]) => version === "*").map(async ([name]) => {
+      const version = await (name === "skuba" ? (0, import_version.getSkubaVersion)() : (0, import_version.latestNpmVersion)(name));
+      return [name, version];
+    })
+  );
+  updates.forEach(([name, version]) => {
+    dependencies[name] = version;
+  });
+};
+const analyseDependencies = async ({
+  destinationRoot,
+  include,
+  manifest: { packageJson },
+  type
+}) => {
+  const input = {
+    dependencies: packageJson.dependencies ?? {},
+    devDependencies: packageJson.devDependencies ?? {},
+    type
+  };
+  const output = {
+    dependencies: { ...input.dependencies },
+    devDependencies: { ...input.devDependencies },
+    type
+  };
+  const printNotices = (0, import_package.generateNotices)(input);
+  const processors = Object.values(dependencyMutators).reduce(
+    (acc, mutate) => {
+      const newProcessors = mutate(output);
+      acc.push(...newProcessors);
+      return acc;
+    },
+    []
+  );
+  await Promise.all([
+    pinUnspecifiedVersions(output.dependencies),
+    pinUnspecifiedVersions(output.devDependencies)
+  ]);
+  const dependencyDiff = (0, import_package.diffDependencies)({
+    old: input.dependencies,
+    new: output.dependencies
+  });
+  import_logging.log.newline();
+  import_logging.log.plain(import_logging.log.bold("Dependencies:"));
+  import_logging.log.newline();
+  const hasDependencyDiff = logDiff(dependencyDiff);
+  const devDependencyDiff = (0, import_package.diffDependencies)({
+    old: input.devDependencies,
+    new: output.devDependencies
+  });
+  import_logging.log.newline();
+  import_logging.log.plain(import_logging.log.bold("Dev dependencies:"));
+  import_logging.log.newline();
+  const hasDevDependencyDiff = logDiff(devDependencyDiff);
+  printNotices();
+  const packageJsonFilepath = import_path.default.join(destinationRoot, "package.json");
+  if (!hasDependencyDiff && !hasDevDependencyDiff) {
+    return;
+  }
+  return async () => {
+    const updatedPackageJson = await (0, import_package2.formatPackage)({
+      ...packageJson,
+      dependencies: output.dependencies,
+      devDependencies: output.devDependencies
+    });
+    await import_fs_extra.default.promises.writeFile(packageJsonFilepath, updatedPackageJson);
+    if (processors.length === 0) {
+      return;
+    }
+    await (0, import_copy.copyFiles)({
+      sourceRoot: destinationRoot,
+      destinationRoot,
+      include,
+      processors
+    });
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  analyseDependencies
+});
+//# sourceMappingURL=analyseDependencies.js.map

package/lib/cli/configure/analyseDependencies.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/cli/configure/analyseDependencies.ts"],
+  "sourcesContent": ["import path from 'path';\n\nimport fs from 'fs-extra';\nimport type { NormalizedReadResult } from 'read-pkg-up';\n\nimport { type TextProcessor, copyFiles } from '../../utils/copy';\nimport { log } from '../../utils/logging';\nimport type { ProjectType } from '../../utils/manifest';\nimport { getSkubaVersion, latestNpmVersion } from '../../utils/version';\n\nimport { diffDependencies, generateNotices } from './analysis/package';\nimport * as dependencyMutators from './dependencies';\nimport { formatPackage } from './processing/package';\nimport type { DependencyDiff } from './types';\n\nconst logDiff = (diff: DependencyDiff): boolean => {\n  const entries = Object.entries(diff);\n\n  if (entries.length === 0) {\n    log.ok('\u2714 No changes');\n\n    return false;\n  }\n\n  Object.entries(diff)\n    .sort(([nameA], [nameB]) => nameA.localeCompare(nameB))\n    .forEach(([name, { operation, version }]) =>\n      log.plain(operation, name, log.formatSubtle(version)),\n    );\n\n  return true;\n};\n\nconst pinUnspecifiedVersions = async (\n  dependencies: Record<string, string>,\n): Promise<void> => {\n  const updates = await Promise.all(\n    Object.entries(dependencies)\n      .filter(([, version]) => version === '*')\n      .map(async ([name]) => {\n        const version = await (name === 'skuba'\n          ? getSkubaVersion()\n          : latestNpmVersion(name));\n\n        return [name, version] as const;\n      }),\n  );\n\n  updates.forEach(([name, version]) => {\n    dependencies[name] = version;\n  });\n};\n\ninterface Props {\n  destinationRoot: string;\n  include: (pathname: string) => boolean;\n  manifest: NormalizedReadResult;\n  type: ProjectType;\n}\n\nexport const analyseDependencies = async ({\n  destinationRoot,\n  include,\n  manifest: { packageJson },\n  type,\n}: Props): Promise<undefined | (() => Promise<void>)> => {\n  const input = {\n    dependencies: packageJson.dependencies ?? {},\n    devDependencies: packageJson.devDependencies ?? {},\n    type,\n  };\n\n  const output = {\n    dependencies: { ...input.dependencies },\n    devDependencies: { ...input.devDependencies },\n    type,\n  };\n\n  const printNotices = generateNotices(input);\n\n  const processors = Object.values(dependencyMutators).reduce<TextProcessor[]>(\n    (acc, mutate) => {\n      const newProcessors = mutate(output);\n      acc.push(...newProcessors);\n      return acc;\n    },\n    [],\n  );\n\n  await Promise.all([\n    pinUnspecifiedVersions(output.dependencies),\n    pinUnspecifiedVersions(output.devDependencies),\n  ]);\n\n  const dependencyDiff = diffDependencies({\n    old: input.dependencies,\n    new: output.dependencies,\n  });\n\n  log.newline();\n  log.plain(log.bold('Dependencies:'));\n\n  log.newline();\n  const hasDependencyDiff = logDiff(dependencyDiff);\n\n  const devDependencyDiff = diffDependencies({\n    old: input.devDependencies,\n    new: output.devDependencies,\n  });\n\n  log.newline();\n  log.plain(log.bold('Dev dependencies:'));\n\n  log.newline();\n  const hasDevDependencyDiff = logDiff(devDependencyDiff);\n\n  printNotices();\n\n  const packageJsonFilepath = path.join(destinationRoot, 'package.json');\n\n  if (!hasDependencyDiff && !hasDevDependencyDiff) {\n    return;\n  }\n\n  return async () => {\n    const updatedPackageJson = await formatPackage({\n      ...packageJson,\n      dependencies: output.dependencies,\n      devDependencies: output.devDependencies,\n    });\n\n    await fs.promises.writeFile(packageJsonFilepath, updatedPackageJson);\n\n    if (processors.length === 0) {\n      return;\n    }\n\n    await copyFiles({\n      sourceRoot: destinationRoot,\n      destinationRoot,\n      include,\n      processors,\n    });\n  };\n};\n"],
+  "mappings": "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",
+  "names": ["import_package", "path", "fs"]
+}

package/lib/cli/configure/analysis/diff.d.ts

@@ -0,0 +1 @@
+export declare const determineOperation: (oldData?: string, newData?: string) => string;

package/lib/cli/configure/analysis/diff.js

@@ -0,0 +1,45 @@
+"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 diff_exports = {};
+__export(diff_exports, {
+  determineOperation: () => determineOperation
+});
+module.exports = __toCommonJS(diff_exports);
+var import_chalk = __toESM(require("chalk"));
+const determineOperation = (oldData, newData) => {
+  if (oldData === void 0) {
+    return import_chalk.default.green("A");
+  }
+  return newData === void 0 ? import_chalk.default.red("D") : import_chalk.default.yellow("M");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  determineOperation
+});
+//# sourceMappingURL=diff.js.map

package/lib/cli/configure/analysis/diff.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/cli/configure/analysis/diff.ts"],
+  "sourcesContent": ["import chalk from 'chalk';\n\nexport const determineOperation = (\n  oldData?: string,\n  newData?: string,\n): string => {\n  if (oldData === undefined) {\n    return chalk.green('A');\n  }\n\n  return newData === undefined ? chalk.red('D') : chalk.yellow('M');\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAkB;AAEX,MAAM,qBAAqB,CAChC,SACA,YACW;AACX,MAAI,YAAY,QAAW;AACzB,WAAO,aAAAA,QAAM,MAAM,GAAG;AAAA,EACxB;AAEA,SAAO,YAAY,SAAY,aAAAA,QAAM,IAAI,GAAG,IAAI,aAAAA,QAAM,OAAO,GAAG;AAClE;",
+  "names": ["chalk"]
+}

package/lib/cli/configure/analysis/files.d.ts

@@ -0,0 +1 @@
+export declare const tsFileExists: (filePath: string) => Promise<boolean>;