skuba 0.0.0-master-20230318044948

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 = (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 = 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,WAAO,gCAAe,CAAC,WAAW,WAAW,EAAE,KAAK,MAAM,GAAG;AAAA,MACjE,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,KAAP;AACA,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 = (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 } from '../../utils/copy';\nimport { 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 = 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>;

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

@@ -0,0 +1,58 @@
+"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 files_exports = {};
+__export(files_exports, {
+  tsFileExists: () => tsFileExists
+});
+module.exports = __toCommonJS(files_exports);
+var import_path = __toESM(require("path"));
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_error = require("../../../utils/error");
+const tsFileExists = async (filePath) => {
+  const ext = import_path.default.extname(filePath);
+  if (ext !== "" && ext !== ".ts") {
+    return false;
+  }
+  try {
+    const stats = await import_fs_extra.default.promises.lstat(
+      ext === "" ? `${filePath}.ts` : filePath
+    );
+    return stats.isFile();
+  } catch (err) {
+    if ((0, import_error.isErrorWithCode)(err, "ENOENT")) {
+      return false;
+    }
+    throw err;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  tsFileExists
+});
+//# sourceMappingURL=files.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/cli/configure/analysis/files.ts"],
+  "sourcesContent": ["import path from 'path';\n\nimport fs from 'fs-extra';\n\nimport { isErrorWithCode } from '../../../utils/error';\n\nexport const tsFileExists = async (filePath: string) => {\n  const ext = path.extname(filePath);\n\n  if (ext !== '' && ext !== '.ts') {\n    return false;\n  }\n\n  try {\n    const stats = await fs.promises.lstat(\n      ext === '' ? `${filePath}.ts` : filePath,\n    );\n\n    return stats.isFile();\n  } catch (err) {\n    if (isErrorWithCode(err, 'ENOENT')) {\n      return false;\n    }\n\n    throw err;\n  }\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAiB;AAEjB,sBAAe;AAEf,mBAAgC;AAEzB,MAAM,eAAe,OAAO,aAAqB;AACtD,QAAM,MAAM,YAAAA,QAAK,QAAQ,QAAQ;AAEjC,MAAI,QAAQ,MAAM,QAAQ,OAAO;AAC/B,WAAO;AAAA,EACT;AAEA,MAAI;AACF,UAAM,QAAQ,MAAM,gBAAAC,QAAG,SAAS;AAAA,MAC9B,QAAQ,KAAK,GAAG,gBAAgB;AAAA,IAClC;AAEA,WAAO,MAAM,OAAO;AAAA,EACtB,SAAS,KAAP;AACA,YAAI,8BAAgB,KAAK,QAAQ,GAAG;AAClC,aAAO;AAAA,IACT;AAEA,UAAM;AAAA,EACR;AACF;",
+  "names": ["path", "fs"]
+}

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

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

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

@@ -0,0 +1,54 @@
+"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 git_exports = {};
+__export(git_exports, {
+  auditWorkingTree: () => auditWorkingTree
+});
+module.exports = __toCommonJS(git_exports);
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_isomorphic_git = __toESM(require("isomorphic-git"));
+var import_dir = require("../../../utils/dir");
+var import_logging = require("../../../utils/logging");
+const auditWorkingTree = async (dir) => {
+  const filepaths = await (0, import_dir.crawlDirectory)(dir);
+  const statuses = await Promise.all(
+    filepaths.map((filepath) => import_isomorphic_git.default.status({ dir, fs: import_fs_extra.default, filepath }))
+  );
+  if (statuses.some(
+    (status) => status !== "absent" && status !== "ignored" && status !== "unmodified"
+  )) {
+    import_logging.log.newline();
+    import_logging.log.warn("You have dirty/untracked files that may be overwritten.");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  auditWorkingTree
+});
+//# sourceMappingURL=git.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/cli/configure/analysis/git.ts"],
+  "sourcesContent": ["import fs from 'fs-extra';\nimport git from 'isomorphic-git';\n\nimport { crawlDirectory } from '../../../utils/dir';\nimport { log } from '../../../utils/logging';\n\nexport const auditWorkingTree = async (dir: string) => {\n  const filepaths = await crawlDirectory(dir);\n\n  const statuses = await Promise.all(\n    filepaths.map((filepath) => git.status({ dir, fs, filepath })),\n  );\n\n  if (\n    statuses.some(\n      (status) =>\n        status !== 'absent' && status !== 'ignored' && status !== 'unmodified',\n    )\n  ) {\n    log.newline();\n    log.warn('You have dirty/untracked files that may be overwritten.');\n  }\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,sBAAe;AACf,4BAAgB;AAEhB,iBAA+B;AAC/B,qBAAoB;AAEb,MAAM,mBAAmB,OAAO,QAAgB;AACrD,QAAM,YAAY,UAAM,2BAAe,GAAG;AAE1C,QAAM,WAAW,MAAM,QAAQ;AAAA,IAC7B,UAAU,IAAI,CAAC,aAAa,sBAAAA,QAAI,OAAO,EAAE,KAAK,oBAAAC,SAAI,SAAS,CAAC,CAAC;AAAA,EAC/D;AAEA,MACE,SAAS;AAAA,IACP,CAAC,WACC,WAAW,YAAY,WAAW,aAAa,WAAW;AAAA,EAC9D,GACA;AACA,uBAAI,QAAQ;AACZ,uBAAI,KAAK,yDAAyD;AAAA,EACpE;AACF;",
+  "names": ["git", "fs"]
+}

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

@@ -0,0 +1,13 @@
+import readPkgUp from 'read-pkg-up';
+import type { DependencyDiff, DependencySet } from '../types';
+interface GetDestinationManifestProps {
+    cwd?: string;
+}
+export declare const getDestinationManifest: (props?: GetDestinationManifestProps) => Promise<readPkgUp.NormalizedReadResult>;
+interface DiffDependenciesProps {
+    old: Record<string, string | undefined>;
+    new: Record<string, string | undefined>;
+}
+export declare const diffDependencies: (props: DiffDependenciesProps) => DependencyDiff;
+export declare const generateNotices: ({ dependencies, devDependencies, }: DependencySet) => () => void;
+export {};