skuba 0.0.0-master-20230318044948

package/lib/cli/configure/processing/json.js

@@ -0,0 +1,57 @@
+"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 json_exports = {};
+__export(json_exports, {
+  formatObject: () => formatObject,
+  parseObject: () => parseObject
+});
+module.exports = __toCommonJS(json_exports);
+var import_validation = require("../../../utils/validation");
+var import_prettier = require("./prettier");
+const formatObject = (data, filepath) => {
+  const sortedData = Object.fromEntries(
+    Object.entries(data).sort(
+      ([keyA], [keyB]) => String(keyA).localeCompare(String(keyB))
+    )
+  );
+  const output = JSON.stringify(sortedData, null, 2);
+  return (0, import_prettier.formatPrettier)(
+    output,
+    filepath === void 0 ? { parser: "json" } : { filepath }
+  );
+};
+const parseObject = (input) => {
+  if (input === void 0) {
+    return;
+  }
+  try {
+    const data = JSON.parse(input);
+    if ((0, import_validation.isObject)(data)) {
+      return data;
+    }
+  } catch {
+  }
+  return;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatObject,
+  parseObject
+});
+//# sourceMappingURL=json.js.map

package/lib/cli/configure/processing/json.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/cli/configure/processing/json.ts"],
+  "sourcesContent": ["import { isObject } from '../../../utils/validation';\n\nimport { formatPrettier } from './prettier';\n\nexport const formatObject = (\n  data: Record<Exclude<PropertyKey, symbol>, unknown>,\n  filepath?: string,\n) => {\n  const sortedData = Object.fromEntries(\n    Object.entries(data).sort(([keyA], [keyB]) =>\n      String(keyA).localeCompare(String(keyB)),\n    ),\n  );\n\n  const output = JSON.stringify(sortedData, null, 2);\n\n  return formatPrettier(\n    output,\n    filepath === undefined ? { parser: 'json' } : { filepath },\n  );\n};\n\nexport const parseObject = (\n  input: string | undefined,\n): Record<Exclude<PropertyKey, symbol>, unknown> | undefined => {\n  if (input === undefined) {\n    return;\n  }\n\n  try {\n    const data = JSON.parse(input) as unknown;\n\n    if (isObject(data)) {\n      return data;\n    }\n  } catch {}\n\n  return;\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAAyB;AAEzB,sBAA+B;AAExB,MAAM,eAAe,CAC1B,MACA,aACG;AACH,QAAM,aAAa,OAAO;AAAA,IACxB,OAAO,QAAQ,IAAI,EAAE;AAAA,MAAK,CAAC,CAAC,IAAI,GAAG,CAAC,IAAI,MACtC,OAAO,IAAI,EAAE,cAAc,OAAO,IAAI,CAAC;AAAA,IACzC;AAAA,EACF;AAEA,QAAM,SAAS,KAAK,UAAU,YAAY,MAAM,CAAC;AAEjD,aAAO;AAAA,IACL;AAAA,IACA,aAAa,SAAY,EAAE,QAAQ,OAAO,IAAI,EAAE,SAAS;AAAA,EAC3D;AACF;AAEO,MAAM,cAAc,CACzB,UAC8D;AAC9D,MAAI,UAAU,QAAW;AACvB;AAAA,EACF;AAEA,MAAI;AACF,UAAM,OAAO,KAAK,MAAM,KAAK;AAE7B,YAAI,4BAAS,IAAI,GAAG;AAClB,aAAO;AAAA,IACT;AAAA,EACF,QAAE;AAAA,EAAO;AAET;AACF;",
+  "names": []
+}

package/lib/cli/configure/processing/loadFiles.d.ts

@@ -0,0 +1,5 @@
+import type { Module } from '../types';
+/**
+ * Load files into cache to perform side effects in another module.
+ */
+export declare const loadFiles: (...filenames: string[]) => Module;

package/lib/cli/configure/processing/loadFiles.js

@@ -0,0 +1,31 @@
+"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 loadFiles_exports = {};
+__export(loadFiles_exports, {
+  loadFiles: () => loadFiles
+});
+module.exports = __toCommonJS(loadFiles_exports);
+const loadFiles = (...filenames) => Object.fromEntries(
+  filenames.map((filename) => [filename, (file) => file])
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadFiles
+});
+//# sourceMappingURL=loadFiles.js.map

package/lib/cli/configure/processing/loadFiles.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/cli/configure/processing/loadFiles.ts"],
+  "sourcesContent": ["import type { Module } from '../types';\n\n/**\n * Load files into cache to perform side effects in another module.\n */\nexport const loadFiles = (...filenames: string[]): Module =>\n  Object.fromEntries(\n    filenames.map((filename) => [filename, (file?: string) => file] as const),\n  );\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKO,MAAM,YAAY,IAAI,cAC3B,OAAO;AAAA,EACL,UAAU,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,SAAkB,IAAI,CAAU;AAC1E;",
+  "names": []
+}

package/lib/cli/configure/processing/module.d.ts

@@ -0,0 +1,10 @@
+export declare const replacePackageReferences: (props: {
+    old: {
+        packageName: string;
+        repoSlug: string;
+    };
+    new: {
+        packageName: string;
+        repoSlug: string;
+    };
+}) => import("../../../utils/copy").TextProcessor;

package/lib/cli/configure/processing/module.js

@@ -0,0 +1,39 @@
+"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 module_exports = {};
+__export(module_exports, {
+  replacePackageReferences: () => replacePackageReferences
+});
+module.exports = __toCommonJS(module_exports);
+var import_copy = require("../../../utils/copy");
+const replacePackageReferences = (props) => (0, import_copy.createStringReplacer)([
+  {
+    input: new RegExp(`(['"])${props.old.packageName}(['"/])`, "g"),
+    output: `$1${props.new.packageName}$2`
+  },
+  {
+    input: new RegExp(props.old.repoSlug, "ig"),
+    output: props.new.repoSlug
+  }
+]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  replacePackageReferences
+});
+//# sourceMappingURL=module.js.map

package/lib/cli/configure/processing/module.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/cli/configure/processing/module.ts"],
+  "sourcesContent": ["import { createStringReplacer } from '../../../utils/copy';\n\nexport const replacePackageReferences = (props: {\n  old: {\n    packageName: string;\n    repoSlug: string;\n  };\n  new: {\n    packageName: string;\n    repoSlug: string;\n  };\n}) =>\n  createStringReplacer([\n    {\n      input: new RegExp(`(['\"])${props.old.packageName}(['\"/])`, 'g'),\n      output: `$1${props.new.packageName}$2`,\n    },\n    {\n      input: new RegExp(props.old.repoSlug, 'ig'),\n      output: props.new.repoSlug,\n    },\n  ]);\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAqC;AAE9B,MAAM,2BAA2B,CAAC,cAUvC,kCAAqB;AAAA,EACnB;AAAA,IACE,OAAO,IAAI,OAAO,SAAS,MAAM,IAAI,sBAAsB,GAAG;AAAA,IAC9D,QAAQ,KAAK,MAAM,IAAI;AAAA,EACzB;AAAA,EACA;AAAA,IACE,OAAO,IAAI,OAAO,MAAM,IAAI,UAAU,IAAI;AAAA,IAC1C,QAAQ,MAAM,IAAI;AAAA,EACpB;AACF,CAAC;",
+  "names": []
+}

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

@@ -0,0 +1,73 @@
+import type { PackageJson } from '../types';
+export declare const formatPackage: (rawData: PackageJson) => string;
+export declare const parsePackage: (input: string | undefined) => PackageJson | undefined;
+export declare const createDependencyFilter: (names: readonly string[], type: 'dependencies' | 'devDependencies') => (data: PackageJson) => {
+    [x: string]: unknown;
+    name?: string | undefined;
+    version?: string | undefined;
+    description?: string | undefined;
+    keywords?: string[] | undefined;
+    homepage?: import("type-fest").LiteralUnion<".", string> | undefined;
+    bugs?: import("type-fest").PackageJson.BugsLocation | undefined;
+    license?: string | undefined;
+    licenses?: {
+        type?: string | undefined;
+        url?: string | undefined;
+    }[] | undefined;
+    author?: import("type-fest").PackageJson.Person | undefined;
+    contributors?: import("type-fest").PackageJson.Person[] | undefined;
+    maintainers?: import("type-fest").PackageJson.Person[] | undefined;
+    files?: string[] | undefined;
+    type?: "module" | "commonjs" | undefined;
+    main?: string | undefined;
+    exports?: import("type-fest").PackageJson.Exports | undefined;
+    imports?: import("type-fest").PackageJson.Imports | undefined;
+    bin?: string | Partial<Record<string, string>> | undefined;
+    man?: string | string[] | undefined;
+    directories?: import("type-fest").PackageJson.DirectoryLocations | undefined;
+    repository?: string | {
+        type: string;
+        url: string;
+        directory?: string | undefined;
+    } | undefined;
+    scripts?: import("type-fest").PackageJson.Scripts | undefined;
+    config?: Record<string, unknown> | undefined;
+    dependencies?: Partial<Record<string, string>> | undefined;
+    devDependencies?: Partial<Record<string, string>> | undefined;
+    optionalDependencies?: Partial<Record<string, string>> | undefined;
+    peerDependencies?: Partial<Record<string, string>> | undefined;
+    peerDependenciesMeta?: Partial<Record<string, {
+        optional: true;
+    }>> | undefined;
+    bundledDependencies?: string[] | undefined;
+    bundleDependencies?: string[] | undefined;
+    engines?: {
+        [x: string]: string | undefined;
+    } | undefined;
+    engineStrict?: boolean | undefined;
+    os?: import("type-fest").LiteralUnion<"aix" | "darwin" | "freebsd" | "linux" | "openbsd" | "sunos" | "win32" | "!aix" | "!darwin" | "!freebsd" | "!linux" | "!openbsd" | "!sunos" | "!win32", string>[] | undefined;
+    cpu?: import("type-fest").LiteralUnion<"arm" | "arm64" | "ia32" | "mips" | "mipsel" | "ppc" | "ppc64" | "s390" | "s390x" | "x64" | "x32" | "!arm" | "!arm64" | "!ia32" | "!mips" | "!mipsel" | "!ppc" | "!ppc64" | "!s390" | "!s390x" | "!x32" | "!x64", string>[] | undefined;
+    preferGlobal?: boolean | undefined;
+    private?: boolean | undefined;
+    publishConfig?: import("type-fest").PackageJson.PublishConfig | undefined;
+    funding?: string | {
+        type?: import("type-fest").LiteralUnion<"github" | "opencollective" | "patreon" | "individual" | "foundation" | "corporation", string> | undefined;
+        url: string;
+    } | undefined;
+    module?: string | undefined;
+    esnext?: string | {
+        [moduleName: string]: string | undefined;
+        main?: string | undefined;
+        browser?: string | undefined;
+    } | undefined;
+    browser?: string | Partial<Record<string, string | false>> | undefined;
+    sideEffects?: boolean | string[] | undefined;
+    types?: string | undefined;
+    typesVersions?: Partial<Record<string, Partial<Record<string, string[]>>>> | undefined;
+    typings?: string | undefined;
+    workspaces?: string[] | import("type-fest").PackageJson.WorkspaceConfig | undefined;
+    flat?: boolean | undefined;
+    resolutions?: Partial<Record<string, string>> | undefined;
+    jspm?: import("type-fest").PackageJson | undefined;
+};
+export declare const withPackage: (fn: (data: PackageJson) => PackageJson) => (input: string | undefined) => string;

package/lib/cli/configure/processing/package.js

@@ -0,0 +1,87 @@
+"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 package_exports = {};
+__export(package_exports, {
+  createDependencyFilter: () => createDependencyFilter,
+  formatPackage: () => formatPackage,
+  parsePackage: () => parsePackage,
+  withPackage: () => withPackage
+});
+module.exports = __toCommonJS(package_exports);
+var import_normalize_package_data = __toESM(require("normalize-package-data"));
+var import_sort_package_json = __toESM(require("sort-package-json"));
+var import_json = require("./json");
+var import_prettier = require("./prettier");
+const formatPackage = (rawData) => {
+  (0, import_normalize_package_data.default)(rawData);
+  const data = (0, import_sort_package_json.default)(rawData);
+  delete data._id;
+  if (data.name === "") {
+    delete data.name;
+  }
+  if (data.readme === "ERROR: No README data found!") {
+    delete data.readme;
+  }
+  if (data.version === "") {
+    delete data.version;
+  }
+  return (0, import_prettier.formatPrettier)(JSON.stringify(data), {
+    filepath: "package.json"
+  });
+};
+const parsePackage = (input) => {
+  const data = (0, import_json.parseObject)(input);
+  if (data === void 0) {
+    return;
+  }
+  (0, import_normalize_package_data.default)(data);
+  return data;
+};
+const createDependencyFilter = (names, type) => {
+  const set = new Set(names);
+  return (data) => ({
+    ...data,
+    [type]: Object.fromEntries(
+      Object.entries(data[type] ?? {}).filter(([name]) => !set.has(name))
+    )
+  });
+};
+const withPackage = (fn) => (input) => {
+  const inputObject = parsePackage(input);
+  const outputObject = fn(inputObject ?? {});
+  return formatPackage(outputObject);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDependencyFilter,
+  formatPackage,
+  parsePackage,
+  withPackage
+});
+//# sourceMappingURL=package.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/cli/configure/processing/package.ts"],
+  "sourcesContent": ["import normalizeData from 'normalize-package-data';\nimport sortPackageJson from 'sort-package-json';\n\nimport type { PackageJson } from '../types';\n\nimport { parseObject } from './json';\nimport { formatPrettier } from './prettier';\n\nexport const formatPackage = (rawData: PackageJson) => {\n  normalizeData(rawData);\n\n  const data = sortPackageJson(rawData);\n\n  // normalize-package-data fields that aren't useful for applications\n\n  delete data._id;\n\n  if (data.name === '') {\n    delete data.name;\n  }\n\n  if (data.readme === 'ERROR: No README data found!') {\n    delete data.readme;\n  }\n\n  if (data.version === '') {\n    delete data.version;\n  }\n\n  return formatPrettier(JSON.stringify(data), {\n    filepath: 'package.json',\n  });\n};\n\nexport const parsePackage = (\n  input: string | undefined,\n): PackageJson | undefined => {\n  const data = parseObject(input);\n\n  if (data === undefined) {\n    return;\n  }\n\n  normalizeData(data);\n\n  return data;\n};\n\nexport const createDependencyFilter = (\n  names: readonly string[],\n  type: 'dependencies' | 'devDependencies',\n) => {\n  const set = new Set(names);\n\n  return (data: PackageJson) => ({\n    ...data,\n    [type]: Object.fromEntries(\n      Object.entries(data[type] ?? {}).filter(([name]) => !set.has(name)),\n    ),\n  });\n};\n\nexport const withPackage =\n  (fn: (data: PackageJson) => PackageJson) => (input: string | undefined) => {\n    const inputObject = parsePackage(input);\n\n    const outputObject = fn(inputObject ?? {});\n\n    return formatPackage(outputObject);\n  };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oCAA0B;AAC1B,+BAA4B;AAI5B,kBAA4B;AAC5B,sBAA+B;AAExB,MAAM,gBAAgB,CAAC,YAAyB;AACrD,oCAAAA,SAAc,OAAO;AAErB,QAAM,WAAO,yBAAAC,SAAgB,OAAO;AAIpC,SAAO,KAAK;AAEZ,MAAI,KAAK,SAAS,IAAI;AACpB,WAAO,KAAK;AAAA,EACd;AAEA,MAAI,KAAK,WAAW,gCAAgC;AAClD,WAAO,KAAK;AAAA,EACd;AAEA,MAAI,KAAK,YAAY,IAAI;AACvB,WAAO,KAAK;AAAA,EACd;AAEA,aAAO,gCAAe,KAAK,UAAU,IAAI,GAAG;AAAA,IAC1C,UAAU;AAAA,EACZ,CAAC;AACH;AAEO,MAAM,eAAe,CAC1B,UAC4B;AAC5B,QAAM,WAAO,yBAAY,KAAK;AAE9B,MAAI,SAAS,QAAW;AACtB;AAAA,EACF;AAEA,oCAAAD,SAAc,IAAI;AAElB,SAAO;AACT;AAEO,MAAM,yBAAyB,CACpC,OACA,SACG;AACH,QAAM,MAAM,IAAI,IAAI,KAAK;AAEzB,SAAO,CAAC,UAAuB;AAAA,IAC7B,GAAG;AAAA,IACH,CAAC,IAAI,GAAG,OAAO;AAAA,MACb,OAAO,QAAQ,KAAK,IAAI,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,IAAI,MAAM,CAAC,IAAI,IAAI,IAAI,CAAC;AAAA,IACpE;AAAA,EACF;AACF;AAEO,MAAM,cACX,CAAC,OAA2C,CAAC,UAA8B;AACzE,QAAM,cAAc,aAAa,KAAK;AAEtC,QAAM,eAAe,GAAG,eAAe,CAAC,CAAC;AAEzC,SAAO,cAAc,YAAY;AACnC;",
+  "names": ["normalizeData", "sortPackageJson"]
+}

package/lib/cli/configure/processing/prettier.d.ts

@@ -0,0 +1,4 @@
+import prettier from 'prettier';
+type Options = Pick<prettier.Options, 'filepath' | 'parser'>;
+export declare const formatPrettier: (source: string, options: Options) => string;
+export {};

package/lib/cli/configure/processing/prettier.js

@@ -0,0 +1,44 @@
+"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, {
+  formatPrettier: () => formatPrettier
+});
+module.exports = __toCommonJS(prettier_exports);
+var import_prettier = __toESM(require("prettier"));
+var import_prettier2 = __toESM(require("../../../../config/prettier"));
+const formatPrettier = (source, options) => import_prettier.default.format(source, {
+  ...options,
+  ...import_prettier2.default
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatPrettier
+});
+//# sourceMappingURL=prettier.js.map

package/lib/cli/configure/processing/prettier.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/cli/configure/processing/prettier.ts"],
+  "sourcesContent": ["import prettier from 'prettier';\n\nimport prettierConfig from '../../../../config/prettier';\n\ntype Options = Pick<prettier.Options, 'filepath' | 'parser'>;\n\nexport const formatPrettier = (source: string, options: Options) =>\n  prettier.format(source, {\n    ...options,\n    ...prettierConfig,\n  });\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,sBAAqB;AAErB,IAAAA,mBAA2B;AAIpB,MAAM,iBAAiB,CAAC,QAAgB,YAC7C,gBAAAC,QAAS,OAAO,QAAQ;AAAA,EACtB,GAAG;AAAA,EACH,GAAG,iBAAAC;AACL,CAAC;",
+  "names": ["import_prettier", "prettier", "prettierConfig"]
+}

package/lib/cli/configure/processing/record.d.ts

@@ -0,0 +1,11 @@
+export declare const getFirstDefined: <T>(record: Record<string, T | undefined>, keys: string[]) => T | undefined;
+/**
+ * Merge two objects together.
+ *
+ * Array properties are sorted and deduped.
+ */
+export declare const merge: <A, B>(obj: A, src: B) => {} & A & B;
+/**
+ * Like `merge`, but arrays are not deduped or sorted to preserve order.
+ */
+export declare const mergeRaw: <A, B>(obj: A, src: B) => {} & A & B;

package/lib/cli/configure/processing/record.js

@@ -0,0 +1,65 @@
+"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 record_exports = {};
+__export(record_exports, {
+  getFirstDefined: () => getFirstDefined,
+  merge: () => merge,
+  mergeRaw: () => mergeRaw
+});
+module.exports = __toCommonJS(record_exports);
+var import_lodash = __toESM(require("lodash.mergewith"));
+const isArray = (value) => Array.isArray(value);
+const getFirstDefined = (record, keys) => {
+  for (const key of keys) {
+    const value = record[key];
+    if (value !== void 0) {
+      return value;
+    }
+  }
+  return;
+};
+const merge = (obj, src) => (0, import_lodash.default)({}, obj, src, (objValue, srcValue) => {
+  if (isArray(objValue) && isArray(srcValue)) {
+    return [...new Set(objValue.concat(srcValue))].sort();
+  }
+  return;
+});
+const mergeRaw = (obj, src) => (0, import_lodash.default)(
+  {},
+  obj,
+  src,
+  (objValue, srcValue) => isArray(objValue) && isArray(srcValue) ? objValue.concat(srcValue) : void 0
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getFirstDefined,
+  merge,
+  mergeRaw
+});
+//# sourceMappingURL=record.js.map

package/lib/cli/configure/processing/record.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/cli/configure/processing/record.ts"],
+  "sourcesContent": ["import mergeWith from 'lodash.mergewith';\n\nconst isArray = (value: unknown): value is unknown[] => Array.isArray(value);\n\nexport const getFirstDefined = <T>(\n  record: Record<string, T | undefined>,\n  keys: string[],\n): T | undefined => {\n  for (const key of keys) {\n    const value = record[key];\n    if (value !== undefined) {\n      return value;\n    }\n  }\n\n  return;\n};\n\n/**\n * Merge two objects together.\n *\n * Array properties are sorted and deduped.\n */\nexport const merge = <A, B>(obj: A, src: B) =>\n  mergeWith({}, obj, src, (objValue: unknown, srcValue: unknown) => {\n    if (isArray(objValue) && isArray(srcValue)) {\n      return [...new Set(objValue.concat(srcValue))].sort();\n    }\n\n    return;\n  });\n\n/**\n * Like `merge`, but arrays are not deduped or sorted to preserve order.\n */\nexport const mergeRaw = <A, B>(obj: A, src: B) =>\n  mergeWith({}, obj, src, (objValue: unknown, srcValue: unknown) =>\n    isArray(objValue) && isArray(srcValue)\n      ? objValue.concat(srcValue)\n      : undefined,\n  );\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAsB;AAEtB,MAAM,UAAU,CAAC,UAAuC,MAAM,QAAQ,KAAK;AAEpE,MAAM,kBAAkB,CAC7B,QACA,SACkB;AAClB,aAAW,OAAO,MAAM;AACtB,UAAM,QAAQ,OAAO,GAAG;AACxB,QAAI,UAAU,QAAW;AACvB,aAAO;AAAA,IACT;AAAA,EACF;AAEA;AACF;AAOO,MAAM,QAAQ,CAAO,KAAQ,YAClC,cAAAA,SAAU,CAAC,GAAG,KAAK,KAAK,CAAC,UAAmB,aAAsB;AAChE,MAAI,QAAQ,QAAQ,KAAK,QAAQ,QAAQ,GAAG;AAC1C,WAAO,CAAC,GAAG,IAAI,IAAI,SAAS,OAAO,QAAQ,CAAC,CAAC,EAAE,KAAK;AAAA,EACtD;AAEA;AACF,CAAC;AAKI,MAAM,WAAW,CAAO,KAAQ,YACrC,cAAAA;AAAA,EAAU,CAAC;AAAA,EAAG;AAAA,EAAK;AAAA,EAAK,CAAC,UAAmB,aAC1C,QAAQ,QAAQ,KAAK,QAAQ,QAAQ,IACjC,SAAS,OAAO,QAAQ,IACxB;AACN;",
+  "names": ["mergeWith"]
+}

package/lib/cli/configure/processing/typescript.d.ts

@@ -0,0 +1,23 @@
+import ts from 'typescript';
+type Props = ts.NodeArray<ts.ObjectLiteralElementLike>;
+type Transformer<T> = (context: ts.TransformationContext | null, props: T) => T;
+/**
+ * Create a transformer to filter out unspecified props from an object literal.
+ */
+export declare const createPropFilter: (names: string[]) => Transformer<Props>;
+export declare const createPropAppender: (appendingProps: Props) => Transformer<Props>;
+/**
+ * Read out `export default` or `module.exports` props from a source file.
+ *
+ * The props can then be used when transforming another source file.
+ */
+export declare const readModuleExports: (inputFile: string) => Props | undefined;
+/**
+ * Mutate imports and exports in a source file:
+ *
+ * - Convert `const x = require('')` into `import x from ''`
+ * - Convert `module.exports =` into `export default`
+ * - Run a transformer over the exported props
+ */
+export declare const transformModuleImportsAndExports: (inputFile: string, transformProps: Transformer<Props>) => string;
+export {};