projen 0.100.4 → 0.100.6

package/lib/util/exec.js

@@ -0,0 +1,238 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rawShell = exports.npx = exports.npm = exports.node = exports.poetry = exports.uv = exports.git = void 0;
+exports.tool = tool;
+const child_process = __importStar(require("child_process"));
+const dax_1 = require("dax");
+const logging = __importStar(require("../logging"));
+const MAX_BUFFER = 10 * 1024 * 1024;
+function spawnOpts(options) {
+    return {
+        maxBuffer: MAX_BUFFER,
+        cwd: options.cwd,
+        env: options.env ? { ...process.env, ...options.env } : undefined,
+        // run the program directly, without going through a shell
+        shell: false,
+    };
+}
+/**
+ * Runs a program with the given arguments, inheriting stdout. Throws if the
+ * command exits with a non-zero status.
+ */
+function run(file, args, options) {
+    logging.debug(`${file} ${args.join(" ")} (cwd: ${options.cwd})`);
+    child_process.execFileSync(file, args, {
+        ...spawnOpts(options),
+        // By default the child's stdout is redirected to STDERR (to keep the
+        // parent's STDOUT clean) and its STDERR is piped so it surfaces in
+        // exceptions. `inheritStdio` instead streams both straight to the parent.
+        stdio: options.inheritStdio ? "inherit" : ["inherit", 2, "pipe"],
+    });
+}
+/**
+ * Runs a program and returns its trimmed STDOUT. Throws if the command exits
+ * with a non-zero status.
+ */
+function capture(file, args, options) {
+    logging.debug(`${file} ${args.join(" ")} (cwd: ${options.cwd})`);
+    return child_process
+        .execFileSync(file, args, {
+        ...spawnOpts(options),
+        stdio: ["inherit", "pipe", "pipe"], // "pipe" for STDERR means it appears in exceptions
+    })
+        .toString("utf-8")
+        .trim();
+}
+/**
+ * Runs a program and returns its trimmed STDOUT, or `undefined` if the command
+ * failed or produced no output.
+ */
+function tryCapture(file, args, options) {
+    logging.debug(`${file} ${args.join(" ")} (cwd: ${options.cwd})`);
+    try {
+        const value = child_process
+            .execFileSync(file, args, {
+            ...spawnOpts(options),
+            stdio: ["inherit", "pipe", "pipe"], // "pipe" for STDERR means it appears in exceptions
+        })
+            .toString("utf-8")
+            .trim();
+        // an empty string is the same as undefined
+        return value || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Creates a shell-free {@link Tool} for the given program.
+ *
+ * @example const git = tool("git"); git.run(["tag", "--delete", tag], { cwd });
+ */
+function tool(file) {
+    return {
+        run: (args, options) => run(file, args, options),
+        capture: (args, options) => capture(file, args, options),
+        tryCapture: (args, options) => tryCapture(file, args, options),
+    };
+}
+/**
+ * Shell-free helper for invoking `git`.
+ *
+ * @example git.run(["tag", "--delete", tag], { cwd });
+ */
+exports.git = tool("git");
+/**
+ * Shell-free helper for invoking `uv` (ships as a native binary on all
+ * platforms).
+ */
+exports.uv = tool("uv");
+/**
+ * Shell-free helper for invoking `poetry`.
+ */
+exports.poetry = tool("poetry");
+/**
+ * Shell-free helper for invoking the current Node.js executable
+ * (`process.execPath`).
+ */
+exports.node = tool(process.execPath);
+/**
+ * Creates an {@link AsyncTool} that invokes `file` via dax, resolving Windows
+ * `.cmd`/`.bat` shims and escaping every argument (so each value is passed as
+ * a single literal argument).
+ *
+ * @example await npx.run(["commit-and-tag-version@^12"], { cwd });
+ */
+function shimTool(file) {
+    const build = (args, options) => {
+        const cmd = (0, dax_1.$) `${file} ${args}`.cwd(options.cwd).stderr("piped").noThrow();
+        return options.env ? cmd.env(options.env) : cmd;
+    };
+    const ensureOk = (args, result) => {
+        if (result.code !== 0) {
+            // Mimic the `child_process` error shape (`status`, `stderr`) so callers
+            // can inspect stderr (e.g. to detect ENOENT/E404 from npm).
+            const error = new Error(`Command failed (exit code ${result.code}): ${file} ${args.join(" ")}`);
+            error.status = result.code;
+            error.stderr = Buffer.from(result.stderr);
+            throw error;
+        }
+    };
+    return {
+        run: async (args, options) => {
+            logging.debug(`${file} ${args.join(" ")} (cwd: ${options.cwd})`);
+            ensureOk(args, await build(args, options));
+        },
+        capture: async (args, options) => {
+            logging.debug(`${file} ${args.join(" ")} (cwd: ${options.cwd})`);
+            const result = await build(args, options).stdout("piped");
+            ensureOk(args, result);
+            return result.stdout.trim();
+        },
+    };
+}
+/**
+ * Cross-platform helper for `npm` (a Windows `.cmd` shim).
+ */
+exports.npm = shimTool("npm");
+/**
+ * Cross-platform helper for `npx` (a Windows `.cmd` shim).
+ */
+exports.npx = shimTool("npx");
+exports.rawShell = {
+    /**
+     * Runs a command line through the system shell and returns a normalized
+     * result. Never throws for a non-zero exit (that is reported via `status`);
+     * a spawn failure is reported via `error`.
+     *
+     * The caller is responsible for supplying the full `env`.
+     */
+    exec(command, options) {
+        logging.debug(`${command} (cwd: ${options.cwd})`);
+        const result = child_process.spawnSync(command, {
+            cwd: options.cwd,
+            shell: true,
+            maxBuffer: MAX_BUFFER,
+            env: options.env,
+            // "pipe" for STDERR (when capturing) means it appears in exceptions.
+            stdio: options.capture ? ["inherit", "pipe", "pipe"] : "inherit",
+        });
+        return {
+            status: result.status,
+            stdout: result.stdout ?? null,
+            stderr: result.stderr ?? null,
+            error: result.error,
+        };
+    },
+    /**
+     * Runs a user-supplied shell command line and resolves its trimmed STDOUT.
+     * Rejects if the command exits non-zero.
+     */
+    capture: async (command, options) => {
+        const result = exports.rawShell.exec(command, {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.env },
+            capture: true,
+        });
+        if (result.error) {
+            throw result.error;
+        }
+        if (result.status !== 0) {
+            const error = new Error(`Command failed (exit code ${result.status}): ${command}`);
+            error.status = result.status;
+            error.stderr = result.stderr;
+            throw error;
+        }
+        return (result.stdout?.toString("utf-8") ?? "").trim();
+    },
+    /**
+     * Runs a user-supplied shell command line and resolves its trimmed STDOUT,
+     * or `undefined` if the command failed or produced no output.
+     */
+    tryCapture: async (command, options) => {
+        const result = exports.rawShell.exec(command, {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.env },
+            capture: true,
+        });
+        if (result.error || result.status !== 0) {
+            return undefined;
+        }
+        const out = (result.stdout?.toString("utf-8") ?? "").trim();
+        return out || undefined;
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"exec.js","sourceRoot":"","sources":["../../src/util/exec.ts"],"names":[],"mappings":"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","sourcesContent":["import * as child_process from \"child_process\";\nimport { $ } from \"dax\";\nimport * as logging from \"../logging\";\n\nconst MAX_BUFFER = 10 * 1024 * 1024;\n\n//\n// ---------------------------------------------------------------------------\n// Shell-free execution (execFileSync, shell: false).\n//\n// The program and each argument are passed to the OS directly without going\n// through a shell, so there is no quoting to get right and no differences\n// between platform shells to account for when commands include values derived\n// from files, git output, configuration, etc.\n//\n// Only per-tool helpers are exported (e.g. `git`); the generic primitives are\n// kept private so call sites are explicit about which tool they invoke.\n// ---------------------------------------------------------------------------\n//\n\n/**\n * Options for shell-free command execution.\n */\nexport interface ExecFileOptions {\n  /**\n   * Working directory for the command.\n   */\n  readonly cwd: string;\n\n  /**\n   * Additional environment variables, merged on top of `process.env`.\n   */\n  readonly env?: Record<string, string>;\n}\n\n/**\n * Options for {@link Tool.run}.\n */\nexport interface RunOptions extends ExecFileOptions {\n  /**\n   * Stream the child's stdout and stderr straight to the parent's stdout and\n   * stderr (full inheritance), instead of redirecting stdout to stderr and\n   * capturing stderr (the default).\n   *\n   * Use this when launching a child process whose stdout is meaningful and\n   * whose output should stream live to the user (e.g. the projen CLI).\n   *\n   * @default false\n   */\n  readonly inheritStdio?: boolean;\n}\n\nfunction spawnOpts(options: ExecFileOptions) {\n  return {\n    maxBuffer: MAX_BUFFER,\n    cwd: options.cwd,\n    env: options.env ? { ...process.env, ...options.env } : undefined,\n    // run the program directly, without going through a shell\n    shell: false as const,\n  };\n}\n\n/**\n * Runs a program with the given arguments, inheriting stdout. Throws if the\n * command exits with a non-zero status.\n */\nfunction run(file: string, args: string[], options: RunOptions): void {\n  logging.debug(`${file} ${args.join(\" \")} (cwd: ${options.cwd})`);\n\n  child_process.execFileSync(file, args, {\n    ...spawnOpts(options),\n    // By default the child's stdout is redirected to STDERR (to keep the\n    // parent's STDOUT clean) and its STDERR is piped so it surfaces in\n    // exceptions. `inheritStdio` instead streams both straight to the parent.\n    stdio: options.inheritStdio ? \"inherit\" : [\"inherit\", 2, \"pipe\"],\n  });\n}\n\n/**\n * Runs a program and returns its trimmed STDOUT. Throws if the command exits\n * with a non-zero status.\n */\nfunction capture(\n  file: string,\n  args: string[],\n  options: ExecFileOptions,\n): string {\n  logging.debug(`${file} ${args.join(\" \")} (cwd: ${options.cwd})`);\n\n  return child_process\n    .execFileSync(file, args, {\n      ...spawnOpts(options),\n      stdio: [\"inherit\", \"pipe\", \"pipe\"], // \"pipe\" for STDERR means it appears in exceptions\n    })\n    .toString(\"utf-8\")\n    .trim();\n}\n\n/**\n * Runs a program and returns its trimmed STDOUT, or `undefined` if the command\n * failed or produced no output.\n */\nfunction tryCapture(\n  file: string,\n  args: string[],\n  options: ExecFileOptions,\n): string | undefined {\n  logging.debug(`${file} ${args.join(\" \")} (cwd: ${options.cwd})`);\n\n  try {\n    const value = child_process\n      .execFileSync(file, args, {\n        ...spawnOpts(options),\n        stdio: [\"inherit\", \"pipe\", \"pipe\"], // \"pipe\" for STDERR means it appears in exceptions\n      })\n      .toString(\"utf-8\")\n      .trim();\n\n    // an empty string is the same as undefined\n    return value || undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * A shell-free handle for invoking a single program by name or path.\n *\n * Each argument is passed to the program verbatim (no shell parsing), so there\n * is no quoting to get right for values such as tags, versions, branch names\n * or file paths.\n *\n * Note: the program is executed directly, without a shell. On Windows this\n * means it must be a real executable - `.cmd`/`.bat` shims (such as\n * npm-installed CLIs like npm/npx/yarn/pnpm) cannot be invoked this way.\n */\nexport interface Tool {\n  /**\n   * Runs `<tool> <args>`, inheriting stdout. Throws on non-zero exit.\n   */\n  run(args: string[], options: RunOptions): void;\n\n  /**\n   * Runs `<tool> <args>` and returns its trimmed STDOUT. Throws on non-zero exit.\n   */\n  capture(args: string[], options: ExecFileOptions): string;\n\n  /**\n   * Runs `<tool> <args>` and returns its trimmed STDOUT, or `undefined` if the\n   * command failed or produced no output.\n   */\n  tryCapture(args: string[], options: ExecFileOptions): string | undefined;\n}\n\n/**\n * Creates a shell-free {@link Tool} for the given program.\n *\n * @example const git = tool(\"git\"); git.run([\"tag\", \"--delete\", tag], { cwd });\n */\nexport function tool(file: string): Tool {\n  return {\n    run: (args, options) => run(file, args, options),\n    capture: (args, options) => capture(file, args, options),\n    tryCapture: (args, options) => tryCapture(file, args, options),\n  };\n}\n\n/**\n * Shell-free helper for invoking `git`.\n *\n * @example git.run([\"tag\", \"--delete\", tag], { cwd });\n */\nexport const git = tool(\"git\");\n\n/**\n * Shell-free helper for invoking `uv` (ships as a native binary on all\n * platforms).\n */\nexport const uv = tool(\"uv\");\n\n/**\n * Shell-free helper for invoking `poetry`.\n */\nexport const poetry = tool(\"poetry\");\n\n/**\n * Shell-free helper for invoking the current Node.js executable\n * (`process.execPath`).\n */\nexport const node = tool(process.execPath);\n\n//\n// ---------------------------------------------------------------------------\n// Cross-platform execution via dax (for binaries that may be `.cmd` shims).\n//\n// `tool` above uses `execFileSync` with `shell: false`, which cannot launch\n// Windows `.cmd`/`.bat` shims such as `npx` or `npm`. `shimTool` runs through\n// dax, which resolves those shims cross-platform. Arguments are interpolated\n// through dax's escaping (NOT `$.raw`), so each value is passed as a single\n// literal argument with no quoting to get right. dax is asynchronous, so\n// these helpers are only usable from async call sites.\n// ---------------------------------------------------------------------------\n//\n\n/**\n * Async, dax-backed equivalent of {@link Tool} for programs that may be a\n * Windows `.cmd`/`.bat` shim (e.g. `npx`, `npm`).\n */\nexport interface AsyncTool {\n  /**\n   * Runs `<tool> <args>`, inheriting stdout. Rejects on non-zero exit.\n   */\n  run(args: string[], options: ExecFileOptions): Promise<void>;\n\n  /**\n   * Runs `<tool> <args>` and resolves its trimmed STDOUT. Rejects on non-zero\n   * exit.\n   */\n  capture(args: string[], options: ExecFileOptions): Promise<string>;\n}\n\n/**\n * Creates an {@link AsyncTool} that invokes `file` via dax, resolving Windows\n * `.cmd`/`.bat` shims and escaping every argument (so each value is passed as\n * a single literal argument).\n *\n * @example await npx.run([\"commit-and-tag-version@^12\"], { cwd });\n */\nfunction shimTool(file: string): AsyncTool {\n  const build = (args: string[], options: ExecFileOptions) => {\n    const cmd = $`${file} ${args}`.cwd(options.cwd).stderr(\"piped\").noThrow();\n    return options.env ? cmd.env(options.env) : cmd;\n  };\n  const ensureOk = (\n    args: string[],\n    result: { code: number; stderr: string },\n  ) => {\n    if (result.code !== 0) {\n      // Mimic the `child_process` error shape (`status`, `stderr`) so callers\n      // can inspect stderr (e.g. to detect ENOENT/E404 from npm).\n      const error: any = new Error(\n        `Command failed (exit code ${result.code}): ${file} ${args.join(\" \")}`,\n      );\n      error.status = result.code;\n      error.stderr = Buffer.from(result.stderr);\n      throw error;\n    }\n  };\n  return {\n    run: async (args, options) => {\n      logging.debug(`${file} ${args.join(\" \")} (cwd: ${options.cwd})`);\n      ensureOk(args, await build(args, options));\n    },\n    capture: async (args, options) => {\n      logging.debug(`${file} ${args.join(\" \")} (cwd: ${options.cwd})`);\n      const result = await build(args, options).stdout(\"piped\");\n      ensureOk(args, result);\n      return result.stdout.trim();\n    },\n  };\n}\n\n/**\n * Cross-platform helper for `npm` (a Windows `.cmd` shim).\n */\nexport const npm = shimTool(\"npm\");\n\n/**\n * Cross-platform helper for `npx` (a Windows `.cmd` shim).\n */\nexport const npx = shimTool(\"npx\");\n\n//\n// ---------------------------------------------------------------------------\n// rawShell: arbitrary shell command strings (via the system shell).\n//\n// This runs an opaque command *string* through the operating system's default\n// shell (`/bin/sh` on POSIX, `cmd.exe` on Windows) - the same mechanism the\n// codebase used previously. It is meant for command lines that cannot be\n// expressed as a fixed binary plus a list of arguments, e.g. a release's\n// `nextVersionCommand` or `ReleasableCommits.exec()` (and projen's own\n// generated `ReleasableCommits` queries), as well as task steps on non-Windows\n// platforms. For everything else prefer the structured `tool`/`git` helpers\n// (or `shimTool` for `.cmd` shims), which take an explicit list of arguments.\n// ---------------------------------------------------------------------------\n//\n\n/**\n * Normalized result of running a command through the system shell. This is a\n * subset of node's `SpawnSyncReturns` shape.\n */\nexport interface RawShellResult {\n  /**\n   * The exit code, or `null` if the process was terminated by a signal or\n   * never spawned.\n   */\n  readonly status: number | null;\n\n  /**\n   * Captured stdout, or `null` when stdout was inherited (not captured).\n   */\n  readonly stdout: Buffer | null;\n\n  /**\n   * Captured stderr, or `null` when stderr was inherited (not captured).\n   */\n  readonly stderr: Buffer | null;\n\n  /**\n   * An error raised while attempting to spawn the command (not a non-zero\n   * exit, which is reported via `status`).\n   */\n  readonly error?: Error;\n}\n\n/**\n * Options for {@link rawShell.exec}.\n */\nexport interface RawShellExecOptions {\n  /**\n   * Working directory for the command.\n   */\n  readonly cwd: string;\n\n  /**\n   * The full environment for the command. Passed through to the shell as-is\n   * (it is *not* merged with `process.env`), so callers that want to inherit\n   * the parent environment must include it themselves.\n   */\n  readonly env?: NodeJS.ProcessEnv;\n\n  /**\n   * Capture stdout/stderr (so the caller can read them from the result)\n   * instead of inheriting the parent's streams.\n   *\n   * @default false\n   */\n  readonly capture?: boolean;\n}\n\n/**\n * Options for {@link rawShell.capture} / {@link rawShell.tryCapture}.\n */\nexport interface RawShellCaptureOptions {\n  /**\n   * Working directory for the command.\n   */\n  readonly cwd: string;\n\n  /**\n   * Additional environment variables, merged on top of `process.env`.\n   */\n  readonly env?: Record<string, string>;\n}\n\nexport const rawShell = {\n  /**\n   * Runs a command line through the system shell and returns a normalized\n   * result. Never throws for a non-zero exit (that is reported via `status`);\n   * a spawn failure is reported via `error`.\n   *\n   * The caller is responsible for supplying the full `env`.\n   */\n  exec(command: string, options: RawShellExecOptions): RawShellResult {\n    logging.debug(`${command} (cwd: ${options.cwd})`);\n\n    const result = child_process.spawnSync(command, {\n      cwd: options.cwd,\n      shell: true,\n      maxBuffer: MAX_BUFFER,\n      env: options.env,\n      // \"pipe\" for STDERR (when capturing) means it appears in exceptions.\n      stdio: options.capture ? [\"inherit\", \"pipe\", \"pipe\"] : \"inherit\",\n    });\n\n    return {\n      status: result.status,\n      stdout: result.stdout ?? null,\n      stderr: result.stderr ?? null,\n      error: result.error,\n    };\n  },\n\n  /**\n   * Runs a user-supplied shell command line and resolves its trimmed STDOUT.\n   * Rejects if the command exits non-zero.\n   */\n  capture: async (\n    command: string,\n    options: RawShellCaptureOptions,\n  ): Promise<string> => {\n    const result = rawShell.exec(command, {\n      cwd: options.cwd,\n      env: { ...process.env, ...options.env },\n      capture: true,\n    });\n    if (result.error) {\n      throw result.error;\n    }\n    if (result.status !== 0) {\n      const error: any = new Error(\n        `Command failed (exit code ${result.status}): ${command}`,\n      );\n      error.status = result.status;\n      error.stderr = result.stderr;\n      throw error;\n    }\n    return (result.stdout?.toString(\"utf-8\") ?? \"\").trim();\n  },\n\n  /**\n   * Runs a user-supplied shell command line and resolves its trimmed STDOUT,\n   * or `undefined` if the command failed or produced no output.\n   */\n  tryCapture: async (\n    command: string,\n    options: RawShellCaptureOptions,\n  ): Promise<string | undefined> => {\n    const result = rawShell.exec(command, {\n      cwd: options.cwd,\n      env: { ...process.env, ...options.env },\n      capture: true,\n    });\n    if (result.error || result.status !== 0) {\n      return undefined;\n    }\n    const out = (result.stdout?.toString(\"utf-8\") ?? \"\").trim();\n    return out || undefined;\n  },\n};\n"]}

package/lib/util/fs.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Recursively determines whether a directory contains at least one file,
+ * optionally filtered by file extension.
+ *
+ * @param dir The directory to search. If it does not exist, `false` is
+ * returned.
+ * @param ext Optional file extension (e.g. `".ts"`) used to filter files. When
+ * provided, only files whose name ends with this extension are considered.
+ * @returns `true` if a matching file is found anywhere in the tree, otherwise
+ * `false` (including when the directory only contains empty subdirectories).
+ */
+export declare function dirContainsFile(dir: string, ext?: string): boolean;

package/lib/util/fs.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dirContainsFile = dirContainsFile;
+const fs_1 = require("fs");
+const path_1 = require("path");
+/**
+ * Recursively determines whether a directory contains at least one file,
+ * optionally filtered by file extension.
+ *
+ * @param dir The directory to search. If it does not exist, `false` is
+ * returned.
+ * @param ext Optional file extension (e.g. `".ts"`) used to filter files. When
+ * provided, only files whose name ends with this extension are considered.
+ * @returns `true` if a matching file is found anywhere in the tree, otherwise
+ * `false` (including when the directory only contains empty subdirectories).
+ */
+function dirContainsFile(dir, ext) {
+    if (!(0, fs_1.existsSync)(dir)) {
+        return false;
+    }
+    for (const entry of (0, fs_1.readdirSync)(dir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+            if (dirContainsFile((0, path_1.join)(dir, entry.name), ext)) {
+                return true;
+            }
+        }
+        else if (!ext || entry.name.endsWith(ext)) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/util.d.ts

@@ -1,26 +1,4 @@
-import * as child_process from "child_process";
 import * as path from "path";
-/**
- * Executes a command with STDOUT > STDERR.
- */
-export declare function exec(command: string, options: {
-    cwd: string;
-    env?: Record<string, string>;
-    stdio?: child_process.StdioOptions;
-}): void;
-/**
- * Executes command and returns STDOUT. If the command fails (non-zero), throws an error.
- */
-export declare function execCapture(command: string, options: {
-    cwd: string;
-    modEnv?: Record<string, string>;
-}): Buffer<ArrayBufferLike>;
-/**
- * Executes `command` and returns its value or undefined if the command failed.
- */
-export declare function execOrUndefined(command: string, options: {
-    cwd: string;
-}): string | undefined;
 export interface WriteFileOptions {
     /**
      * Whether the generated file should be marked as executable.

package/lib/util.js

@@ -33,9 +33,6 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.exec = exec;
-exports.execCapture = execCapture;
-exports.execOrUndefined = execOrUndefined;
 exports.getFilePermissions = getFilePermissions;
 exports.writeFile = writeFile;
 exports.decamelizeKeysRecursively = decamelizeKeysRecursively;
@@ -59,62 +56,9 @@ exports.multipleSelected = multipleSelected;
 exports.isRoot = isRoot;
 exports.findUp = findUp;
 exports.normalizePersistedPath = normalizePersistedPath;
-const child_process = __importStar(require("child_process"));
 const fs_1 = require("fs");
 const path = __importStar(require("path"));
 const Case = __importStar(require("case"));
-const logging = __importStar(require("./logging"));
-const MAX_BUFFER = 10 * 1024 * 1024;
-/**
- * Executes a command with STDOUT > STDERR.
- */
-function exec(command, options) {
-    logging.debug(`${command} (cwd: ${options.cwd})`);
-    child_process.execSync(command, {
-        stdio: options.stdio || ["inherit", 2, "pipe"], // "pipe" for STDERR means it appears in exceptions
-        maxBuffer: MAX_BUFFER,
-        cwd: options.cwd,
-        env: options.env,
-    });
-}
-/**
- * Executes command and returns STDOUT. If the command fails (non-zero), throws an error.
- */
-function execCapture(command, options) {
-    logging.debug(`${command} (cwd: ${options.cwd})`);
-    return child_process.execSync(command, {
-        stdio: ["inherit", "pipe", "pipe"], // "pipe" for STDERR means it appears in exceptions
-        maxBuffer: MAX_BUFFER,
-        cwd: options.cwd,
-        env: {
-            ...process.env,
-            ...options.modEnv,
-        },
-    });
-}
-/**
- * Executes `command` and returns its value or undefined if the command failed.
- */
-function execOrUndefined(command, options) {
-    logging.debug(`${command} (cwd: ${options.cwd})`);
-    try {
-        const value = child_process
-            .execSync(command, {
-            stdio: ["inherit", "pipe", "pipe"], // "pipe" for STDERR means it appears in exceptions
-            maxBuffer: MAX_BUFFER,
-            cwd: options.cwd,
-        })
-            .toString("utf-8")
-            .trim();
-        if (!value) {
-            return undefined;
-        } // an empty string is the same as undefined
-        return value;
-    }
-    catch {
-        return undefined;
-    }
-}
 function getFilePermissions(options) {
     const readonly = options.readonly ?? false;
     const executable = options.executable ?? false;
@@ -463,4 +407,4 @@ function findUp(lookFor, cwd = process.cwd()) {
 function normalizePersistedPath(p) {
     return p.replace(/\\/g, path.posix.sep);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"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","sourcesContent":["import * as child_process from \"child_process\";\nimport {\n  accessSync,\n  chmodSync,\n  constants as fs_constants,\n  existsSync,\n  mkdirSync,\n  promises as fs,\n  readFileSync,\n  writeFileSync,\n} from \"fs\";\nimport * as path from \"path\";\nimport * as Case from \"case\";\nimport * as logging from \"./logging\";\n\nconst MAX_BUFFER = 10 * 1024 * 1024;\n\n/**\n * Executes a command with STDOUT > STDERR.\n */\nexport function exec(\n  command: string,\n  options: {\n    cwd: string;\n    env?: Record<string, string>;\n    stdio?: child_process.StdioOptions;\n  },\n): void {\n  logging.debug(`${command} (cwd: ${options.cwd})`);\n\n  child_process.execSync(command, {\n    stdio: options.stdio || [\"inherit\", 2, \"pipe\"], // \"pipe\" for STDERR means it appears in exceptions\n    maxBuffer: MAX_BUFFER,\n    cwd: options.cwd,\n    env: options.env,\n  });\n}\n\n/**\n * Executes command and returns STDOUT. If the command fails (non-zero), throws an error.\n */\nexport function execCapture(\n  command: string,\n  options: { cwd: string; modEnv?: Record<string, string> },\n) {\n  logging.debug(`${command} (cwd: ${options.cwd})`);\n\n  return child_process.execSync(command, {\n    stdio: [\"inherit\", \"pipe\", \"pipe\"], // \"pipe\" for STDERR means it appears in exceptions\n    maxBuffer: MAX_BUFFER,\n    cwd: options.cwd,\n    env: {\n      ...process.env,\n      ...options.modEnv,\n    },\n  });\n}\n\n/**\n * Executes `command` and returns its value or undefined if the command failed.\n */\nexport function execOrUndefined(\n  command: string,\n  options: { cwd: string },\n): string | undefined {\n  logging.debug(`${command} (cwd: ${options.cwd})`);\n\n  try {\n    const value = child_process\n      .execSync(command, {\n        stdio: [\"inherit\", \"pipe\", \"pipe\"], // \"pipe\" for STDERR means it appears in exceptions\n        maxBuffer: MAX_BUFFER,\n        cwd: options.cwd,\n      })\n      .toString(\"utf-8\")\n      .trim();\n\n    if (!value) {\n      return undefined;\n    } // an empty string is the same as undefined\n    return value;\n  } catch {\n    return undefined;\n  }\n}\n\nexport interface WriteFileOptions {\n  /**\n   * Whether the generated file should be marked as executable.\n   *\n   * @default false\n   */\n  executable?: boolean;\n\n  /**\n   * Whether the generated file should be readonly.\n   *\n   * @default false\n   */\n  readonly?: boolean;\n}\n\nexport function getFilePermissions(options: WriteFileOptions): string {\n  const readonly = options.readonly ?? false;\n  const executable = options.executable ?? false;\n  if (readonly && executable) {\n    return \"544\";\n  } else if (readonly) {\n    return \"444\";\n  } else if (executable) {\n    return \"755\";\n  } else {\n    return \"644\";\n  }\n}\n\nexport function writeFile(\n  filePath: string,\n  data: any,\n  options: WriteFileOptions = {},\n) {\n  if (existsSync(filePath)) {\n    chmodSync(filePath, \"600\");\n  }\n\n  mkdirSync(path.dirname(filePath), { recursive: true });\n  writeFileSync(filePath, data);\n\n  chmodSync(filePath, getFilePermissions(options));\n}\n\n/**\n * Decamelizes the keys of an object structure, recursing through child objects and arrays.\n * @experimental\n */\nexport interface DecamelizeRecursivelyOptions {\n  /**\n   * Max depth to recurse before erroring.\n   * @default 10\n   */\n  maxDepth?: number;\n\n  /**\n   * Returns true when a key should be decamelized\n   * @default - all keys are decamelized\n   */\n  shouldDecamelize?: (path: string[], value: any) => boolean;\n\n  /**\n   * Separator for decamelizing.\n   * @default \"_\"\n   */\n  separator?: string;\n\n  /**\n   * Current path.\n   * @internal\n   */\n  path?: string[];\n}\n\nexport function decamelizeKeysRecursively(\n  input: any,\n  opt?: DecamelizeRecursivelyOptions,\n): any {\n  const shouldAlwaysDecamelize = () => true;\n  const shouldDecamelize = opt?.shouldDecamelize ?? shouldAlwaysDecamelize;\n  const separator = opt?.separator ?? \"_\";\n  const path_ = opt?.path ?? [];\n  const maxDepth = opt?.maxDepth ?? 10;\n\n  if (path_.length > maxDepth) {\n    throw new Error(\n      \"Decamelled too deeply - check that the input has no circular references\",\n    );\n  }\n\n  if (Array.isArray(input)) {\n    return input.map((k, i) =>\n      decamelizeKeysRecursively(k, {\n        ...opt,\n        path: [...path_, i.toString()],\n      }),\n    );\n  }\n\n  if (typeof input === \"object\" && input !== null) {\n    const mappedObject: Record<string, any> = {};\n    for (const [key, value] of Object.entries(input)) {\n      const transformedKey = shouldDecamelize([...path_, key], value)\n        ? decamelize(key, separator)\n        : key;\n\n      mappedObject[transformedKey] = decamelizeKeysRecursively(value, {\n        ...opt,\n        path: [...path_, key],\n      });\n    }\n\n    return mappedObject;\n  }\n\n  return input;\n}\n\n/**\n * Returns false if value is unset or a falsey value, and true otherwise.\n * @param value an environment variable\n */\nexport function isTruthy(value: string | undefined): boolean {\n  return !(\n    value === undefined ||\n    [\"null\", \"undefined\", \"0\", \"false\", \"\"].includes(value.toLocaleLowerCase())\n  );\n}\n\n/**\n * Type of a map mapping strings to some arbitrary type\n */\nexport type Obj<T> = { [key: string]: T };\n\n/**\n * Return whether the given value is a plain struct object\n *\n * Even though arrays and instances of classes technically are objects, we\n * usually want to treat them differently, so we return false in those cases.\n */\nexport function isObject(x: any): x is Obj<any> {\n  return (\n    x !== null &&\n    typeof x === \"object\" &&\n    !Array.isArray(x) &&\n    x.constructor.name === \"Object\"\n  );\n}\n\n/**\n * Configure the behavior of `deepMerge`.\n */\ninterface MergeOptions {\n  /**\n   * Whether to delete keys with `undefined` values.\n   *\n   * @default false\n   */\n  readonly destructive?: boolean;\n  /**\n   * Whether to merge arrays.\n   *\n   * @default false\n   */\n  readonly mergeArrays?: boolean;\n}\n\n/**\n * Recursively merge objects together\n *\n * The leftmost object is mutated and returned.\n *\n * If an object is merged into something other than an object, the non-object is lost.\n * Arrays are overwritten not merged; set `mergeArrays: true` to merge arrays and deduplicate the result.\n * An `undefined` key in a source object will persist; set `destructive: true` to fully remove the key instead.\n * Empty objects as values are preserved in the output; set `destructive: true` to remove them instead.\n */\nexport function deepMerge(\n  objects: Array<Obj<any> | undefined>,\n  { destructive = false, mergeArrays = false }: MergeOptions = {},\n) {\n  function mergeOne(target: Obj<any>, source: Obj<any>) {\n    for (const key of Object.keys(source)) {\n      // Prevent prototype pollution by blocking dangerous keys\n      if (key === \"__proto__\" || key === \"constructor\" || key === \"prototype\") {\n        continue;\n      }\n      const value = source[key];\n\n      // if the current value is a plain object, we recursively merge it\n      if (isObject(value)) {\n        // if the value at the target is not an object, override it with an\n        // object so we can continue the recursion\n        if (typeof target[key] !== \"object\") {\n          target[key] = value;\n        }\n\n        // Special handling for __$APPEND, which is used to append values to arrays\n        if (\"__$APPEND\" in value && Array.isArray(value.__$APPEND)) {\n          if (Array.isArray(target[key])) {\n            target[key].push(...value.__$APPEND);\n          } else {\n            target[key] = value.__$APPEND;\n          }\n        }\n\n        // recursively merge the object\n        mergeOne(target[key], value);\n\n        // if the result of the merge is an empty object, it's because the\n        // eventual value we assigned is `undefined`, and there are no\n        // sibling concrete values alongside, so we can delete this tree.\n        if (\n          destructive &&\n          typeof target[key] === \"object\" &&\n          Object.keys(target[key]).length === 0\n        ) {\n          delete target[key];\n        }\n        continue;\n      }\n\n      // in destructive mode, we delete the existing key if the value is undefined\n      if (destructive && value === undefined) {\n        delete target[key];\n        continue;\n      }\n\n      // in array merging mode, we merge and deduplicate arrays\n      if (mergeArrays && Array.isArray(target[key]) && Array.isArray(value)) {\n        target[key] = [...new Set([...target[key], ...value])];\n        continue;\n      }\n\n      // all other values are simply overwritten by overriding object\n      if (typeof value !== \"undefined\") {\n        target[key] = value;\n        continue;\n      }\n    }\n  }\n\n  const others = objects.filter((x) => x != null) as Array<Obj<any>>;\n\n  if (others.length === 0) {\n    return {};\n  }\n  const into = others.splice(0, 1)[0];\n\n  others.forEach((other) => mergeOne(into, other));\n  return into;\n}\n\n/*\n * Deduplicate values in a list, returning a new array.\n * @param array list of values\n */\nexport function dedupArray<T>(array: T[]): T[] {\n  return array.filter((val, idx) => array.indexOf(val) === idx);\n}\n\n/**\n * Returns a sorted version of `x` or `undefined` if it is an empty array or object.\n */\nexport function sorted<T>(x: T) {\n  if (x == null) {\n    return undefined;\n  }\n  if (Array.isArray(x)) {\n    if (x.length === 0) {\n      return undefined;\n    }\n    return (x as unknown[]).sort();\n  } else if (typeof x === \"object\") {\n    if (Object.keys(x).length === 0) {\n      return undefined;\n    }\n    const result: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(x).sort(([l], [r]) =>\n      l.localeCompare(r),\n    )) {\n      result[key] = value;\n    }\n    return result as T;\n  } else {\n    return x;\n  }\n}\n\nexport function formatAsPythonModule(name: string) {\n  return name.replace(/-/g, \"_\").replace(/\\./g, \"_\");\n}\n\n/**\n * Extract git version number from command line\n *\n * @param gitVersionOutput the output from `git version` CLI\n * @returns the version of git\n */\nexport function getGitVersion(gitVersionOutput: string) {\n  const match = gitVersionOutput.match(/\\d+.\\d+.\\d+/);\n  if (!match) {\n    throw new Error(\"Unable to retrieve git version\");\n  }\n\n  return match[0];\n}\n\nexport function kebabCaseKeys<T = unknown>(obj: T, recursive = true): T {\n  if (typeof obj !== \"object\" || obj == null) {\n    return obj;\n  }\n\n  if (Array.isArray(obj)) {\n    if (recursive) {\n      obj = obj.map((v) => kebabCaseKeys(v, recursive)) as any;\n    }\n    return obj;\n  }\n\n  const result: Record<string, unknown> = {};\n  for (let [k, v] of Object.entries(obj)) {\n    if (recursive) {\n      v = kebabCaseKeys(v, recursive);\n    }\n    result[decamelize(k).replace(/_/gm, \"-\")] = v;\n  }\n  return result as any;\n}\n\nexport function snakeCaseKeys<T = unknown>(\n  obj: T,\n  recursive = true,\n  exclusiveForRecordKeys: string[] = [],\n): T {\n  if (typeof obj !== \"object\" || obj == null) {\n    return obj;\n  }\n\n  if (Array.isArray(obj)) {\n    if (recursive) {\n      obj = obj.map((v) =>\n        snakeCaseKeys(v, recursive, exclusiveForRecordKeys),\n      ) as any;\n    }\n    return obj;\n  }\n\n  const result: Record<string, unknown> = {};\n  for (let [k, v] of Object.entries(obj)) {\n    if (recursive) {\n      v = snakeCaseKeys(v, recursive, exclusiveForRecordKeys);\n    }\n    const modifiedKey =\n      exclusiveForRecordKeys.length == 0 || exclusiveForRecordKeys.includes(k)\n        ? Case.snake(k)\n        : k;\n    result[modifiedKey] = v;\n  }\n  return result as any;\n}\n\nexport async function tryReadFile(file: string) {\n  if (!existsSync(file)) {\n    return \"\";\n  }\n\n  return fs.readFile(file, \"utf-8\");\n}\n\nexport function tryReadFileSync(file: string) {\n  if (!existsSync(file)) {\n    return undefined;\n  }\n\n  return readFileSync(file, \"utf-8\");\n}\n\nexport function isWritable(file: string) {\n  try {\n    accessSync(file, fs_constants.W_OK);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Asserts that the file should be executable. Always returns true on Windows.\n *\n * In Windows, the executable attribute is stored in the system setting PATHEXT, not in each file. Then, checking for executability is equivalent to checking for existence. To bypass checking for executability, we always return true on Windows.\n *\n * @param filePath The path to the file\n * @param shouldBeExecutable Whether the file should be executable\n * @returns true if `filePath` executable attribute matches `shouldBeExecutable` or if the platform is Windows, false otherwise\n */\nexport function assertExecutablePermissions(\n  filePath: string,\n  shouldBeExecutable: boolean,\n): boolean {\n  const isWindows = process.platform === \"win32\";\n  if (isWindows) {\n    return true;\n  }\n\n  const prevExecutable = isExecutable(filePath);\n\n  return prevExecutable === shouldBeExecutable;\n}\n\nexport function isExecutable(file: string) {\n  try {\n    accessSync(file, fs_constants.X_OK);\n\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\nfunction decamelize(s: string, sep: string = \"_\") {\n  if (Case.of(s) === \"camel\") {\n    return Case.lower(s, sep);\n  } else {\n    return s;\n  }\n}\n\nexport function getNodeMajorVersion(): number | undefined {\n  const match = process.version.match(/(\\d+)\\.(\\d+)\\.(\\d+)/);\n  if (match) {\n    const [major] = match.slice(1).map((x) => parseInt(x));\n    return major;\n  }\n  return undefined;\n}\n\nexport function anySelected(options: (boolean | undefined)[]): boolean {\n  return options.some((opt) => opt);\n}\n\nexport function multipleSelected(options: (boolean | undefined)[]): boolean {\n  return options.filter((opt) => opt).length > 1;\n}\n\n/**\n * Checks if a path is a FS root\n *\n * Optional uses a provided OS specific path implementation,\n * defaults to use the implementation for the current OS.\n *\n * @internal\n */\nexport function isRoot(dir: string, osPathLib: typeof path = path): boolean {\n  const parent = osPathLib.dirname(dir);\n  return parent === dir;\n}\n\n/**\n * Run up project tree to find a file or directory\n *\n * @param lookFor the file or directory to look for\n * @param cwd current working directory, must be an absolute path\n * @returns path to the file or directory we are looking for, undefined if not found\n */\nexport function findUp(\n  lookFor: string,\n  cwd: string = process.cwd(),\n): string | undefined {\n  if (existsSync(path.join(cwd, lookFor))) {\n    return cwd;\n  }\n\n  if (isRoot(cwd)) {\n    // This is a root\n    return undefined;\n  }\n  return findUp(lookFor, path.dirname(cwd));\n}\n\n/**\n * Normalizes a path that is going to be persisted to have a cross platform representation.\n *\n * Normalized paths can be persisted and doesn't need to be modified when the platform changes.\n * `normalizePersistedPath` takes care of platform-specific properties like directory separator.\n * It uses `path.posix.sep` that is supported both in Windows and Unix platforms.\n *\n *\n * @param p the path to be normalized\n * @returns the normalized path\n */\nexport function normalizePersistedPath(p: string) {\n  return p.replace(/\\\\/g, path.posix.sep);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,gDAYC;AAED,8BAaC;AAgCD,8DA0CC;AAMD,4BAKC;AAaD,4BAOC;AA8BD,8BA0EC;AAMD,gCAEC;AAKD,wBAuBC;AAED,oDAEC;AAQD,sCAOC;AAED,sCAoBC;AAED,sCA8BC;AAED,kCAMC;AAED,0CAMC;AAED,gCAOC;AAWD,kEAYC;AAED,oCAQC;AAUD,kDAOC;AAED,kCAEC;AAED,4CAEC;AAUD,wBAGC;AASD,wBAaC;AAaD,wDAEC;AA3fD,2BASY;AACZ,2CAA6B;AAC7B,2CAA6B;AAkB7B,SAAgB,kBAAkB,CAAC,OAAyB;IAC1D,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,KAAK,CAAC;IAC3C,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,KAAK,CAAC;IAC/C,IAAI,QAAQ,IAAI,UAAU,EAAE,CAAC;QAC3B,OAAO,KAAK,CAAC;IACf,CAAC;SAAM,IAAI,QAAQ,EAAE,CAAC;QACpB,OAAO,KAAK,CAAC;IACf,CAAC;SAAM,IAAI,UAAU,EAAE,CAAC;QACtB,OAAO,KAAK,CAAC;IACf,CAAC;SAAM,CAAC;QACN,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,SAAgB,SAAS,CACvB,QAAgB,EAChB,IAAS,EACT,UAA4B,EAAE;IAE9B,IAAI,IAAA,eAAU,EAAC,QAAQ,CAAC,EAAE,CAAC;QACzB,IAAA,cAAS,EAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IAC7B,CAAC;IAED,IAAA,cAAS,EAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACvD,IAAA,kBAAa,EAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IAE9B,IAAA,cAAS,EAAC,QAAQ,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC;AACnD,CAAC;AAgCD,SAAgB,yBAAyB,CACvC,KAAU,EACV,GAAkC;IAElC,MAAM,sBAAsB,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC;IAC1C,MAAM,gBAAgB,GAAG,GAAG,EAAE,gBAAgB,IAAI,sBAAsB,CAAC;IACzE,MAAM,SAAS,GAAG,GAAG,EAAE,SAAS,IAAI,GAAG,CAAC;IACxC,MAAM,KAAK,GAAG,GAAG,EAAE,IAAI,IAAI,EAAE,CAAC;IAC9B,MAAM,QAAQ,GAAG,GAAG,EAAE,QAAQ,IAAI,EAAE,CAAC;IAErC,IAAI,KAAK,CAAC,MAAM,GAAG,QAAQ,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CACb,yEAAyE,CAC1E,CAAC;IACJ,CAAC;IAED,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CACxB,yBAAyB,CAAC,CAAC,EAAE;YAC3B,GAAG,GAAG;YACN,IAAI,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC;SAC/B,CAAC,CACH,CAAC;IACJ,CAAC;IAED,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAChD,MAAM,YAAY,GAAwB,EAAE,CAAC;QAC7C,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACjD,MAAM,cAAc,GAAG,gBAAgB,CAAC,CAAC,GAAG,KAAK,EAAE,GAAG,CAAC,EAAE,KAAK,CAAC;gBAC7D,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,SAAS,CAAC;gBAC5B,CAAC,CAAC,GAAG,CAAC;YAER,YAAY,CAAC,cAAc,CAAC,GAAG,yBAAyB,CAAC,KAAK,EAAE;gBAC9D,GAAG,GAAG;gBACN,IAAI,EAAE,CAAC,GAAG,KAAK,EAAE,GAAG,CAAC;aACtB,CAAC,CAAC;QACL,CAAC;QAED,OAAO,YAAY,CAAC;IACtB,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;GAGG;AACH,SAAgB,QAAQ,CAAC,KAAyB;IAChD,OAAO,CAAC,CACN,KAAK,KAAK,SAAS;QACnB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,iBAAiB,EAAE,CAAC,CAC5E,CAAC;AACJ,CAAC;AAOD;;;;;GAKG;AACH,SAAgB,QAAQ,CAAC,CAAM;IAC7B,OAAO,CACL,CAAC,KAAK,IAAI;QACV,OAAO,CAAC,KAAK,QAAQ;QACrB,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;QACjB,CAAC,CAAC,WAAW,CAAC,IAAI,KAAK,QAAQ,CAChC,CAAC;AACJ,CAAC;AAoBD;;;;;;;;;GASG;AACH,SAAgB,SAAS,CACvB,OAAoC,EACpC,EAAE,WAAW,GAAG,KAAK,EAAE,WAAW,GAAG,KAAK,KAAmB,EAAE;IAE/D,SAAS,QAAQ,CAAC,MAAgB,EAAE,MAAgB;QAClD,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YACtC,yDAAyD;YACzD,IAAI,GAAG,KAAK,WAAW,IAAI,GAAG,KAAK,aAAa,IAAI,GAAG,KAAK,WAAW,EAAE,CAAC;gBACxE,SAAS;YACX,CAAC;YACD,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;YAE1B,kEAAkE;YAClE,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;gBACpB,mEAAmE;gBACnE,0CAA0C;gBAC1C,IAAI,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,QAAQ,EAAE,CAAC;oBACpC,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;gBACtB,CAAC;gBAED,2EAA2E;gBAC3E,IAAI,WAAW,IAAI,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC;oBAC3D,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;wBAC/B,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC;oBACvC,CAAC;yBAAM,CAAC;wBACN,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC;oBAChC,CAAC;gBACH,CAAC;gBAED,+BAA+B;gBAC/B,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;gBAE7B,kEAAkE;gBAClE,8DAA8D;gBAC9D,iEAAiE;gBACjE,IACE,WAAW;oBACX,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,QAAQ;oBAC/B,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,EACrC,CAAC;oBACD,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC;gBACrB,CAAC;gBACD,SAAS;YACX,CAAC;YAED,4EAA4E;YAC5E,IAAI,WAAW,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gBACvC,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC;gBACnB,SAAS;YACX,CAAC;YAED,yDAAyD;YACzD,IAAI,WAAW,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;gBACtE,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;gBACvD,SAAS;YACX,CAAC;YAED,+DAA+D;YAC/D,IAAI,OAAO,KAAK,KAAK,WAAW,EAAE,CAAC;gBACjC,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;gBACpB,SAAS;YACX,CAAC;QACH,CAAC;IACH,CAAC;IAED,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,IAAI,CAAoB,CAAC;IAEnE,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxB,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAEpC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC;IACjD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;GAGG;AACH,SAAgB,UAAU,CAAI,KAAU;IACtC,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC;AAChE,CAAC;AAED;;GAEG;AACH,SAAgB,MAAM,CAAI,CAAI;IAC5B,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC;QACd,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;QACrB,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACnB,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,OAAQ,CAAe,CAAC,IAAI,EAAE,CAAC;IACjC,CAAC;SAAM,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;QACjC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAChC,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,MAAM,MAAM,GAA4B,EAAE,CAAC;QAC3C,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAC7D,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CACnB,EAAE,CAAC;YACF,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;QACtB,CAAC;QACD,OAAO,MAAW,CAAC;IACrB,CAAC;SAAM,CAAC;QACN,OAAO,CAAC,CAAC;IACX,CAAC;AACH,CAAC;AAED,SAAgB,oBAAoB,CAAC,IAAY;IAC/C,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;AACrD,CAAC;AAED;;;;;GAKG;AACH,SAAgB,aAAa,CAAC,gBAAwB;IACpD,MAAM,KAAK,GAAG,gBAAgB,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;IACpD,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;IACpD,CAAC;IAED,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC;AAED,SAAgB,aAAa,CAAc,GAAM,EAAE,SAAS,GAAG,IAAI;IACjE,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QAC3C,OAAO,GAAG,CAAC;IACb,CAAC;IAED,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACvB,IAAI,SAAS,EAAE,CAAC;YACd,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,aAAa,CAAC,CAAC,EAAE,SAAS,CAAC,CAAQ,CAAC;QAC3D,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED,MAAM,MAAM,GAA4B,EAAE,CAAC;IAC3C,KAAK,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACvC,IAAI,SAAS,EAAE,CAAC;YACd,CAAC,GAAG,aAAa,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;QAClC,CAAC;QACD,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IAChD,CAAC;IACD,OAAO,MAAa,CAAC;AACvB,CAAC;AAED,SAAgB,aAAa,CAC3B,GAAM,EACN,SAAS,GAAG,IAAI,EAChB,yBAAmC,EAAE;IAErC,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QAC3C,OAAO,GAAG,CAAC;IACb,CAAC;IAED,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACvB,IAAI,SAAS,EAAE,CAAC;YACd,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAClB,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,sBAAsB,CAAC,CAC7C,CAAC;QACX,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED,MAAM,MAAM,GAA4B,EAAE,CAAC;IAC3C,KAAK,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACvC,IAAI,SAAS,EAAE,CAAC;YACd,CAAC,GAAG,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,sBAAsB,CAAC,CAAC;QAC1D,CAAC;QACD,MAAM,WAAW,GACf,sBAAsB,CAAC,MAAM,IAAI,CAAC,IAAI,sBAAsB,CAAC,QAAQ,CAAC,CAAC,CAAC;YACtE,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;YACf,CAAC,CAAC,CAAC,CAAC;QACR,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IAC1B,CAAC;IACD,OAAO,MAAa,CAAC;AACvB,CAAC;AAEM,KAAK,UAAU,WAAW,CAAC,IAAY;IAC5C,IAAI,CAAC,IAAA,eAAU,EAAC,IAAI,CAAC,EAAE,CAAC;QACtB,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,OAAO,aAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACpC,CAAC;AAED,SAAgB,eAAe,CAAC,IAAY;IAC1C,IAAI,CAAC,IAAA,eAAU,EAAC,IAAI,CAAC,EAAE,CAAC;QACtB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO,IAAA,iBAAY,EAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACrC,CAAC;AAED,SAAgB,UAAU,CAAC,IAAY;IACrC,IAAI,CAAC;QACH,IAAA,eAAU,EAAC,IAAI,EAAE,cAAY,CAAC,IAAI,CAAC,CAAC;QACpC,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,2BAA2B,CACzC,QAAgB,EAChB,kBAA2B;IAE3B,MAAM,SAAS,GAAG,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC;IAC/C,IAAI,SAAS,EAAE,CAAC;QACd,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,cAAc,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC;IAE9C,OAAO,cAAc,KAAK,kBAAkB,CAAC;AAC/C,CAAC;AAED,SAAgB,YAAY,CAAC,IAAY;IACvC,IAAI,CAAC;QACH,IAAA,eAAU,EAAC,IAAI,EAAE,cAAY,CAAC,IAAI,CAAC,CAAC;QAEpC,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,SAAS,UAAU,CAAC,CAAS,EAAE,MAAc,GAAG;IAC9C,IAAI,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,OAAO,EAAE,CAAC;QAC3B,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;IAC5B,CAAC;SAAM,CAAC;QACN,OAAO,CAAC,CAAC;IACX,CAAC;AACH,CAAC;AAED,SAAgB,mBAAmB;IACjC,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC;IAC3D,IAAI,KAAK,EAAE,CAAC;QACV,MAAM,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACvD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,SAAgB,WAAW,CAAC,OAAgC;IAC1D,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC;AACpC,CAAC;AAED,SAAgB,gBAAgB,CAAC,OAAgC;IAC/D,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;AACjD,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,MAAM,CAAC,GAAW,EAAE,YAAyB,IAAI;IAC/D,MAAM,MAAM,GAAG,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACtC,OAAO,MAAM,KAAK,GAAG,CAAC;AACxB,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,MAAM,CACpB,OAAe,EACf,MAAc,OAAO,CAAC,GAAG,EAAE;IAE3B,IAAI,IAAA,eAAU,EAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;QACxC,OAAO,GAAG,CAAC;IACb,CAAC;IAED,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;QAChB,iBAAiB;QACjB,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,sBAAsB,CAAC,CAAS;IAC9C,OAAO,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AAC1C,CAAC","sourcesContent":["import {\n  accessSync,\n  chmodSync,\n  constants as fs_constants,\n  existsSync,\n  mkdirSync,\n  promises as fs,\n  readFileSync,\n  writeFileSync,\n} from \"fs\";\nimport * as path from \"path\";\nimport * as Case from \"case\";\n\nexport interface WriteFileOptions {\n  /**\n   * Whether the generated file should be marked as executable.\n   *\n   * @default false\n   */\n  executable?: boolean;\n\n  /**\n   * Whether the generated file should be readonly.\n   *\n   * @default false\n   */\n  readonly?: boolean;\n}\n\nexport function getFilePermissions(options: WriteFileOptions): string {\n  const readonly = options.readonly ?? false;\n  const executable = options.executable ?? false;\n  if (readonly && executable) {\n    return \"544\";\n  } else if (readonly) {\n    return \"444\";\n  } else if (executable) {\n    return \"755\";\n  } else {\n    return \"644\";\n  }\n}\n\nexport function writeFile(\n  filePath: string,\n  data: any,\n  options: WriteFileOptions = {},\n) {\n  if (existsSync(filePath)) {\n    chmodSync(filePath, \"600\");\n  }\n\n  mkdirSync(path.dirname(filePath), { recursive: true });\n  writeFileSync(filePath, data);\n\n  chmodSync(filePath, getFilePermissions(options));\n}\n\n/**\n * Decamelizes the keys of an object structure, recursing through child objects and arrays.\n * @experimental\n */\nexport interface DecamelizeRecursivelyOptions {\n  /**\n   * Max depth to recurse before erroring.\n   * @default 10\n   */\n  maxDepth?: number;\n\n  /**\n   * Returns true when a key should be decamelized\n   * @default - all keys are decamelized\n   */\n  shouldDecamelize?: (path: string[], value: any) => boolean;\n\n  /**\n   * Separator for decamelizing.\n   * @default \"_\"\n   */\n  separator?: string;\n\n  /**\n   * Current path.\n   * @internal\n   */\n  path?: string[];\n}\n\nexport function decamelizeKeysRecursively(\n  input: any,\n  opt?: DecamelizeRecursivelyOptions,\n): any {\n  const shouldAlwaysDecamelize = () => true;\n  const shouldDecamelize = opt?.shouldDecamelize ?? shouldAlwaysDecamelize;\n  const separator = opt?.separator ?? \"_\";\n  const path_ = opt?.path ?? [];\n  const maxDepth = opt?.maxDepth ?? 10;\n\n  if (path_.length > maxDepth) {\n    throw new Error(\n      \"Decamelled too deeply - check that the input has no circular references\",\n    );\n  }\n\n  if (Array.isArray(input)) {\n    return input.map((k, i) =>\n      decamelizeKeysRecursively(k, {\n        ...opt,\n        path: [...path_, i.toString()],\n      }),\n    );\n  }\n\n  if (typeof input === \"object\" && input !== null) {\n    const mappedObject: Record<string, any> = {};\n    for (const [key, value] of Object.entries(input)) {\n      const transformedKey = shouldDecamelize([...path_, key], value)\n        ? decamelize(key, separator)\n        : key;\n\n      mappedObject[transformedKey] = decamelizeKeysRecursively(value, {\n        ...opt,\n        path: [...path_, key],\n      });\n    }\n\n    return mappedObject;\n  }\n\n  return input;\n}\n\n/**\n * Returns false if value is unset or a falsey value, and true otherwise.\n * @param value an environment variable\n */\nexport function isTruthy(value: string | undefined): boolean {\n  return !(\n    value === undefined ||\n    [\"null\", \"undefined\", \"0\", \"false\", \"\"].includes(value.toLocaleLowerCase())\n  );\n}\n\n/**\n * Type of a map mapping strings to some arbitrary type\n */\nexport type Obj<T> = { [key: string]: T };\n\n/**\n * Return whether the given value is a plain struct object\n *\n * Even though arrays and instances of classes technically are objects, we\n * usually want to treat them differently, so we return false in those cases.\n */\nexport function isObject(x: any): x is Obj<any> {\n  return (\n    x !== null &&\n    typeof x === \"object\" &&\n    !Array.isArray(x) &&\n    x.constructor.name === \"Object\"\n  );\n}\n\n/**\n * Configure the behavior of `deepMerge`.\n */\ninterface MergeOptions {\n  /**\n   * Whether to delete keys with `undefined` values.\n   *\n   * @default false\n   */\n  readonly destructive?: boolean;\n  /**\n   * Whether to merge arrays.\n   *\n   * @default false\n   */\n  readonly mergeArrays?: boolean;\n}\n\n/**\n * Recursively merge objects together\n *\n * The leftmost object is mutated and returned.\n *\n * If an object is merged into something other than an object, the non-object is lost.\n * Arrays are overwritten not merged; set `mergeArrays: true` to merge arrays and deduplicate the result.\n * An `undefined` key in a source object will persist; set `destructive: true` to fully remove the key instead.\n * Empty objects as values are preserved in the output; set `destructive: true` to remove them instead.\n */\nexport function deepMerge(\n  objects: Array<Obj<any> | undefined>,\n  { destructive = false, mergeArrays = false }: MergeOptions = {},\n) {\n  function mergeOne(target: Obj<any>, source: Obj<any>) {\n    for (const key of Object.keys(source)) {\n      // Prevent prototype pollution by blocking dangerous keys\n      if (key === \"__proto__\" || key === \"constructor\" || key === \"prototype\") {\n        continue;\n      }\n      const value = source[key];\n\n      // if the current value is a plain object, we recursively merge it\n      if (isObject(value)) {\n        // if the value at the target is not an object, override it with an\n        // object so we can continue the recursion\n        if (typeof target[key] !== \"object\") {\n          target[key] = value;\n        }\n\n        // Special handling for __$APPEND, which is used to append values to arrays\n        if (\"__$APPEND\" in value && Array.isArray(value.__$APPEND)) {\n          if (Array.isArray(target[key])) {\n            target[key].push(...value.__$APPEND);\n          } else {\n            target[key] = value.__$APPEND;\n          }\n        }\n\n        // recursively merge the object\n        mergeOne(target[key], value);\n\n        // if the result of the merge is an empty object, it's because the\n        // eventual value we assigned is `undefined`, and there are no\n        // sibling concrete values alongside, so we can delete this tree.\n        if (\n          destructive &&\n          typeof target[key] === \"object\" &&\n          Object.keys(target[key]).length === 0\n        ) {\n          delete target[key];\n        }\n        continue;\n      }\n\n      // in destructive mode, we delete the existing key if the value is undefined\n      if (destructive && value === undefined) {\n        delete target[key];\n        continue;\n      }\n\n      // in array merging mode, we merge and deduplicate arrays\n      if (mergeArrays && Array.isArray(target[key]) && Array.isArray(value)) {\n        target[key] = [...new Set([...target[key], ...value])];\n        continue;\n      }\n\n      // all other values are simply overwritten by overriding object\n      if (typeof value !== \"undefined\") {\n        target[key] = value;\n        continue;\n      }\n    }\n  }\n\n  const others = objects.filter((x) => x != null) as Array<Obj<any>>;\n\n  if (others.length === 0) {\n    return {};\n  }\n  const into = others.splice(0, 1)[0];\n\n  others.forEach((other) => mergeOne(into, other));\n  return into;\n}\n\n/*\n * Deduplicate values in a list, returning a new array.\n * @param array list of values\n */\nexport function dedupArray<T>(array: T[]): T[] {\n  return array.filter((val, idx) => array.indexOf(val) === idx);\n}\n\n/**\n * Returns a sorted version of `x` or `undefined` if it is an empty array or object.\n */\nexport function sorted<T>(x: T) {\n  if (x == null) {\n    return undefined;\n  }\n  if (Array.isArray(x)) {\n    if (x.length === 0) {\n      return undefined;\n    }\n    return (x as unknown[]).sort();\n  } else if (typeof x === \"object\") {\n    if (Object.keys(x).length === 0) {\n      return undefined;\n    }\n    const result: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(x).sort(([l], [r]) =>\n      l.localeCompare(r),\n    )) {\n      result[key] = value;\n    }\n    return result as T;\n  } else {\n    return x;\n  }\n}\n\nexport function formatAsPythonModule(name: string) {\n  return name.replace(/-/g, \"_\").replace(/\\./g, \"_\");\n}\n\n/**\n * Extract git version number from command line\n *\n * @param gitVersionOutput the output from `git version` CLI\n * @returns the version of git\n */\nexport function getGitVersion(gitVersionOutput: string) {\n  const match = gitVersionOutput.match(/\\d+.\\d+.\\d+/);\n  if (!match) {\n    throw new Error(\"Unable to retrieve git version\");\n  }\n\n  return match[0];\n}\n\nexport function kebabCaseKeys<T = unknown>(obj: T, recursive = true): T {\n  if (typeof obj !== \"object\" || obj == null) {\n    return obj;\n  }\n\n  if (Array.isArray(obj)) {\n    if (recursive) {\n      obj = obj.map((v) => kebabCaseKeys(v, recursive)) as any;\n    }\n    return obj;\n  }\n\n  const result: Record<string, unknown> = {};\n  for (let [k, v] of Object.entries(obj)) {\n    if (recursive) {\n      v = kebabCaseKeys(v, recursive);\n    }\n    result[decamelize(k).replace(/_/gm, \"-\")] = v;\n  }\n  return result as any;\n}\n\nexport function snakeCaseKeys<T = unknown>(\n  obj: T,\n  recursive = true,\n  exclusiveForRecordKeys: string[] = [],\n): T {\n  if (typeof obj !== \"object\" || obj == null) {\n    return obj;\n  }\n\n  if (Array.isArray(obj)) {\n    if (recursive) {\n      obj = obj.map((v) =>\n        snakeCaseKeys(v, recursive, exclusiveForRecordKeys),\n      ) as any;\n    }\n    return obj;\n  }\n\n  const result: Record<string, unknown> = {};\n  for (let [k, v] of Object.entries(obj)) {\n    if (recursive) {\n      v = snakeCaseKeys(v, recursive, exclusiveForRecordKeys);\n    }\n    const modifiedKey =\n      exclusiveForRecordKeys.length == 0 || exclusiveForRecordKeys.includes(k)\n        ? Case.snake(k)\n        : k;\n    result[modifiedKey] = v;\n  }\n  return result as any;\n}\n\nexport async function tryReadFile(file: string) {\n  if (!existsSync(file)) {\n    return \"\";\n  }\n\n  return fs.readFile(file, \"utf-8\");\n}\n\nexport function tryReadFileSync(file: string) {\n  if (!existsSync(file)) {\n    return undefined;\n  }\n\n  return readFileSync(file, \"utf-8\");\n}\n\nexport function isWritable(file: string) {\n  try {\n    accessSync(file, fs_constants.W_OK);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Asserts that the file should be executable. Always returns true on Windows.\n *\n * In Windows, the executable attribute is stored in the system setting PATHEXT, not in each file. Then, checking for executability is equivalent to checking for existence. To bypass checking for executability, we always return true on Windows.\n *\n * @param filePath The path to the file\n * @param shouldBeExecutable Whether the file should be executable\n * @returns true if `filePath` executable attribute matches `shouldBeExecutable` or if the platform is Windows, false otherwise\n */\nexport function assertExecutablePermissions(\n  filePath: string,\n  shouldBeExecutable: boolean,\n): boolean {\n  const isWindows = process.platform === \"win32\";\n  if (isWindows) {\n    return true;\n  }\n\n  const prevExecutable = isExecutable(filePath);\n\n  return prevExecutable === shouldBeExecutable;\n}\n\nexport function isExecutable(file: string) {\n  try {\n    accessSync(file, fs_constants.X_OK);\n\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\nfunction decamelize(s: string, sep: string = \"_\") {\n  if (Case.of(s) === \"camel\") {\n    return Case.lower(s, sep);\n  } else {\n    return s;\n  }\n}\n\nexport function getNodeMajorVersion(): number | undefined {\n  const match = process.version.match(/(\\d+)\\.(\\d+)\\.(\\d+)/);\n  if (match) {\n    const [major] = match.slice(1).map((x) => parseInt(x));\n    return major;\n  }\n  return undefined;\n}\n\nexport function anySelected(options: (boolean | undefined)[]): boolean {\n  return options.some((opt) => opt);\n}\n\nexport function multipleSelected(options: (boolean | undefined)[]): boolean {\n  return options.filter((opt) => opt).length > 1;\n}\n\n/**\n * Checks if a path is a FS root\n *\n * Optional uses a provided OS specific path implementation,\n * defaults to use the implementation for the current OS.\n *\n * @internal\n */\nexport function isRoot(dir: string, osPathLib: typeof path = path): boolean {\n  const parent = osPathLib.dirname(dir);\n  return parent === dir;\n}\n\n/**\n * Run up project tree to find a file or directory\n *\n * @param lookFor the file or directory to look for\n * @param cwd current working directory, must be an absolute path\n * @returns path to the file or directory we are looking for, undefined if not found\n */\nexport function findUp(\n  lookFor: string,\n  cwd: string = process.cwd(),\n): string | undefined {\n  if (existsSync(path.join(cwd, lookFor))) {\n    return cwd;\n  }\n\n  if (isRoot(cwd)) {\n    // This is a root\n    return undefined;\n  }\n  return findUp(lookFor, path.dirname(cwd));\n}\n\n/**\n * Normalizes a path that is going to be persisted to have a cross platform representation.\n *\n * Normalized paths can be persisted and doesn't need to be modified when the platform changes.\n * `normalizePersistedPath` takes care of platform-specific properties like directory separator.\n * It uses `path.posix.sep` that is supported both in Windows and Unix platforms.\n *\n *\n * @param p the path to be normalized\n * @returns the normalized path\n */\nexport function normalizePersistedPath(p: string) {\n  return p.replace(/\\\\/g, path.posix.sep);\n}\n"]}

package/lib/version.js

@@ -24,7 +24,7 @@ exports.CHANGES_SINCE_LAST_RELEASE = 'git log --oneline -1 | grep -qv "chore(rel
  */
 const COMMIT_AND_TAG_VERSION_DEFAULT = "commit-and-tag-version@^12";
 class Version extends component_1.Component {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.Version", version: "0.100.4" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.Version", version: "0.100.6" };
     bumpTask;
     unbumpTask;
     /**
@@ -141,7 +141,7 @@ exports.Version = Version;
  */
 class ReleasableCommits {
     cmd;
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.ReleasableCommits", version: "0.100.4" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.ReleasableCommits", version: "0.100.6" };
     /**
      * Release every commit
      *

package/lib/vscode/devcontainer.js

@@ -13,7 +13,7 @@ const DEVCONTAINER_FILE = ".devcontainer.json";
  * codespaces.
  */
 class DevContainer extends component_1.Component {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.vscode.DevContainer", version: "0.100.4" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.vscode.DevContainer", version: "0.100.6" };
     dockerImage;
     postCreateTasks;
     ports;

package/lib/vscode/extensions.js

@@ -9,7 +9,7 @@ const json_1 = require("../json");
  * Source: https://code.visualstudio.com/docs/editor/extension-marketplace#_workspace-recommended-extensions
  */
 class VsCodeRecommendedExtensions extends component_1.Component {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.vscode.VsCodeRecommendedExtensions", version: "0.100.4" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.vscode.VsCodeRecommendedExtensions", version: "0.100.6" };
     /**
      * List of extensions which should be recommended for users of this workspace.
      * The identifier of an extension is always '${publisher}.${name}'. For example: 'ms-python.python'.