isaacscript 3.16.0 → 3.16.1-dev.0

package/dist/commands/init/createProject.js

@@ -0,0 +1,199 @@
+import chalk from "chalk";
+import { PACKAGE_JSON, PackageManager, copyFileOrDirectory, getFileNamesInDirectory, getPackageManagerExecCommand, getPackageManagerInstallCICommand, getPackageManagerInstallCommand, getPackageManagerLockFileName, isFile, makeDirectory, readFile, renameFile, updatePackageJSON, writeFile, } from "isaacscript-common-node";
+import { removeLinesBetweenMarkers, removeLinesMatching, repeat, } from "isaacscript-common-ts";
+import path from "node:path";
+import { Config } from "../../classes/Config.js";
+import { createConfigFile } from "../../configFile.js";
+import { ACTION_YML, ACTION_YML_TEMPLATE_PATH, GITIGNORE_TEMPLATE_PATH, MAIN_DEV_TS_TEMPLATE_PATH, MAIN_TS, MAIN_TS_TEMPLATE_PATH, METADATA_XML, METADATA_XML_TEMPLATE_PATH, README_MD, TEMPLATES_DIR, TEMPLATES_DYNAMIC_DIR, TEMPLATES_STATIC_DIR, } from "../../constants.js";
+import { execShell, execShellString } from "../../exec.js";
+import { initGitRepository } from "../../git.js";
+export async function createProject(projectName, authorName, projectPath, createNewDir, modsDirectory, saveSlot, gitRemoteURL, skipInstall, packageManager, typeScript, dev, verbose) {
+    if (createNewDir) {
+        makeDirectory(projectPath);
+    }
+    const config = new Config(modsDirectory, saveSlot, dev);
+    createConfigFile(projectPath, config, typeScript);
+    copyStaticFiles(projectPath, typeScript);
+    copyDynamicFiles(projectName, authorName, projectPath, packageManager, dev, typeScript);
+    upgradeYarn(projectPath, packageManager, verbose);
+    await updatePackageJSON(projectPath);
+    installNodeModules(projectPath, skipInstall, packageManager, verbose);
+    formatFiles(projectPath, packageManager, verbose);
+    // Only make the initial commit once all of the files have been copied and formatted.
+    initGitRepository(projectPath, gitRemoteURL, verbose);
+    const noun = typeScript ? "project" : "mod";
+    console.log(`Successfully created ${noun}: ${chalk.green(projectName)}`);
+}
+/** Copy static files, like ".eslintrc.cjs", "tsconfig.json", etc. */
+function copyStaticFiles(projectPath, typeScript) {
+    // First, copy the static files that are shared between TypeScript projects and IsaacScript mods.
+    copyTemplateDirectoryWithoutOverwriting(TEMPLATES_STATIC_DIR, projectPath);
+    // Second, copy the files that are specific to either a TypeScript project or an IsaacScript mod.
+    const staticDirSuffix = typeScript ? "ts" : "mod";
+    const staticDirPath = path.join(TEMPLATES_DIR, `static-${staticDirSuffix}`);
+    copyTemplateDirectoryWithoutOverwriting(staticDirPath, projectPath);
+    // Rename "_eslintrc.cjs" to ".eslintrc.cjs". (If it is kept as ".eslintrc.cjs", then local
+    // linting will fail.)
+    const ESLintConfigPath = path.join(projectPath, "_eslintrc.cjs");
+    const correctESLintConfigPath = path.join(projectPath, ".eslintrc.cjs");
+    renameFile(ESLintConfigPath, correctESLintConfigPath);
+    // Rename "_gitattributes" to ".gitattributes". (If it is kept as ".gitattributes", then it won't
+    // be committed to git.)
+    const gitAttributesPath = path.join(projectPath, "_gitattributes");
+    const correctGitAttributesPath = path.join(projectPath, ".gitattributes");
+    renameFile(gitAttributesPath, correctGitAttributesPath);
+    // Rename "_cspell.jsonc" to "cspell.jsonc". (If it is kept as "cspell.jsonc", then local spell
+    // checking will fail.)
+    const cSpellConfigPath = path.join(projectPath, "_cspell.jsonc");
+    const correctCSpellConfigPath = path.join(projectPath, "cspell.jsonc");
+    renameFile(cSpellConfigPath, correctCSpellConfigPath);
+}
+function copyTemplateDirectoryWithoutOverwriting(templateDirPath, projectPath) {
+    const fileNames = getFileNamesInDirectory(templateDirPath);
+    for (const fileName of fileNames) {
+        const templateFilePath = path.join(templateDirPath, fileName);
+        const destinationFilePath = path.join(projectPath, fileName);
+        if (!isFile(destinationFilePath)) {
+            copyFileOrDirectory(templateFilePath, destinationFilePath);
+        }
+    }
+}
+/** Copy files that need to have text replaced inside of them. */
+function copyDynamicFiles(projectName, authorName, projectPath, packageManager, dev, typeScript) {
+    const workflowsPath = path.join(projectPath, ".github", "workflows");
+    makeDirectory(workflowsPath);
+    // `.github/workflows/setup/action.yml`
+    {
+        const fileName = ACTION_YML;
+        const templatePath = ACTION_YML_TEMPLATE_PATH;
+        const templateRaw = readFile(templatePath);
+        const template = parseTemplate(templateRaw, typeScript);
+        const lockFileName = getPackageManagerLockFileName(packageManager);
+        const installCommand = getPackageManagerInstallCICommand(packageManager);
+        const actionYML = template
+            .replaceAll("PACKAGE_MANAGER_NAME", packageManager)
+            .replaceAll("PACKAGE_MANAGER_LOCK_FILE_NAME", lockFileName)
+            .replaceAll("PACKAGE_MANAGER_INSTALL_COMMAND", installCommand);
+        const destinationPath = path.join(workflowsPath, fileName);
+        writeFile(destinationPath, actionYML);
+    }
+    // `.gitignore`
+    {
+        const templatePath = GITIGNORE_TEMPLATE_PATH;
+        const templateRaw = readFile(templatePath);
+        const template = parseTemplate(templateRaw, typeScript);
+        // Prepend a header with the project name.
+        let separatorLine = "# ";
+        repeat(projectName.length, () => {
+            separatorLine += "-";
+        });
+        separatorLine += "\n";
+        const gitIgnoreHeader = `${separatorLine}# ${projectName}\n${separatorLine}\n`;
+        const nodeGitIgnorePath = path.join(TEMPLATES_DYNAMIC_DIR, "Node.gitignore");
+        const nodeGitIgnore = readFile(nodeGitIgnorePath);
+        // eslint-disable-next-line prefer-template
+        const gitignore = gitIgnoreHeader + template + "\n" + nodeGitIgnore;
+        // We need to replace the underscore with a period.
+        const destinationPath = path.join(projectPath, ".gitignore");
+        writeFile(destinationPath, gitignore);
+    }
+    // `package.json`
+    {
+        // There are two versions of the template, one for TypeScript, and one for IsaacScript mods.
+        const packageJSONTemplateFileName = typeScript
+            ? "package.ts.json"
+            : "package.mod.json";
+        const templatePath = path.join(TEMPLATES_DYNAMIC_DIR, packageJSONTemplateFileName);
+        const template = readFile(templatePath);
+        const packageJSON = template
+            .replaceAll("PROJECT_NAME", projectName)
+            .replaceAll("AUTHOR_NAME", authorName ?? "unknown")
+            .replaceAll("PACKAGE_MANAGER", packageManager);
+        const destinationPath = path.join(projectPath, PACKAGE_JSON);
+        writeFile(destinationPath, packageJSON);
+    }
+    // `README.md`
+    {
+        // There are two versions of the template, one for TypeScript, and one for IsaacScript mods.
+        const readmeMDTemplateFileName = typeScript
+            ? "README.ts.md"
+            : "README.mod.md";
+        const templatePath = path.join(TEMPLATES_DYNAMIC_DIR, readmeMDTemplateFileName);
+        const template = readFile(templatePath);
+        // "PROJECT-NAME" must be hyphenated, as using an underscore will break Prettier for some
+        // reason.
+        const readmeMD = template.replaceAll("PROJECT-NAME", projectName);
+        const destinationPath = path.join(projectPath, README_MD);
+        writeFile(destinationPath, readmeMD);
+    }
+    // `mod/metadata.xml`
+    if (!typeScript) {
+        const modPath = path.join(projectPath, "mod");
+        makeDirectory(modPath);
+        const fileName = METADATA_XML;
+        const templatePath = METADATA_XML_TEMPLATE_PATH;
+        const template = readFile(templatePath);
+        const metadataXML = template.replaceAll("PROJECT_NAME", projectName);
+        const destinationPath = path.join(modPath, fileName);
+        writeFile(destinationPath, metadataXML);
+    }
+    const srcPath = path.join(projectPath, "src");
+    makeDirectory(srcPath);
+    // `src/main.ts` (TypeScript projects use the simple version from the "static-ts" directory.)
+    if (!typeScript) {
+        // Convert snake_case and kebab-case to camelCase. (Kebab-case in particular will make the
+        // example TypeScript file fail to compile.)
+        const fileName = MAIN_TS;
+        const templatePath = MAIN_TS_TEMPLATE_PATH;
+        const template = readFile(templatePath);
+        const mainTS = template.replaceAll("PROJECT_NAME", projectName);
+        const destinationPath = path.join(srcPath, fileName);
+        writeFile(destinationPath, mainTS);
+    }
+    // If we are initializing an IsaacScript project intended to be used for development, we can
+    // include a better starter file.
+    if (!typeScript && dev) {
+        const fileName = MAIN_TS;
+        const templatePath = MAIN_DEV_TS_TEMPLATE_PATH;
+        const template = readFile(templatePath);
+        const mainTS = template; // No replacements are necessary for this file.
+        const destinationPath = path.join(srcPath, fileName);
+        writeFile(destinationPath, mainTS);
+    }
+}
+function parseTemplate(template, typeScript) {
+    const otherTemplateKind = typeScript ? "mod" : "ts";
+    const otherTemplateMarker = `@template-${otherTemplateKind}`;
+    const templateWithoutMarkers = removeLinesBetweenMarkers(template, otherTemplateMarker);
+    const templateWithoutTemplateComments = removeLinesMatching(templateWithoutMarkers, "@template");
+    const templateWithoutMultipleLineBreaks = templateWithoutTemplateComments.replaceAll(/\n\s*\n\s*\n/g, "\n\n");
+    return templateWithoutMultipleLineBreaks;
+}
+/**
+ * If we are using yarn, assume that we want to use the latest version, which requires some
+ * additional commands to be performed.
+ */
+function upgradeYarn(projectPath, packageManager, verbose) {
+    if (packageManager !== PackageManager.yarn) {
+        return;
+    }
+    execShell("yarn", ["set", "version", "latest"], verbose, false, projectPath);
+    // https://yarnpkg.com/features/linkers
+    // - `pnp` is the default, but it requires a VSCode extension.
+    // - `pnpm` is fast, but it does not work with a D drive:
+    // https://github.com/yarnpkg/berry/issues/5326
+    // - Thus, we use `node-modules`.
+    execShell("yarn", ["config", "set", "nodeLinker", "node-modules"], verbose, false, projectPath);
+}
+function installNodeModules(projectPath, skipInstall, packageManager, verbose) {
+    if (skipInstall) {
+        return;
+    }
+    const command = getPackageManagerInstallCommand(packageManager);
+    console.log(`Installing node modules with "${command}"... (This can take a long time.)`);
+    execShellString(command, verbose, false, projectPath);
+}
+function formatFiles(projectPath, packageManager, verbose) {
+    const command = getPackageManagerExecCommand(packageManager);
+    execShell(command, ["prettier", "--write", projectPath], verbose, false, projectPath);
+}

package/dist/commands/init/getAuthorName.js

@@ -0,0 +1,22 @@
+import { fatalError } from "isaacscript-common-node";
+import { getGitHubUsername } from "../../git.js";
+import { getInputString } from "../../prompt.js";
+export async function getAuthorName(typeScript) {
+    const gitHubUsername = getGitHubUsername();
+    if (gitHubUsername !== undefined) {
+        return gitHubUsername;
+    }
+    if (!typeScript) {
+        // In IsaacScript mods, putting the author in the "package.json" file is not necessary.
+        return undefined;
+    }
+    return getNewAuthorName();
+}
+async function getNewAuthorName() {
+    console.log("The author name was not found from the GitHub CLI configuration file.");
+    const authorName = await getInputString("Enter the author of the project:");
+    if (authorName === "") {
+        fatalError("You must enter an author name.");
+    }
+    return authorName;
+}

package/dist/commands/init/getModsDir.js

@@ -0,0 +1,48 @@
+import chalk from "chalk";
+import { fatalError, isDirectory } from "isaacscript-common-node";
+import path from "node:path";
+import { HOME_DIR } from "../../constants.js";
+import { getInputString } from "../../prompt.js";
+const MODS = "mods";
+const DEFAULT_MODS_PATH_WINDOWS = path.join("C:", "Program Files (x86)", "Steam", "steamapps", "common", "The Binding of Isaac Rebirth", MODS);
+/** This is a subdirectory of `$HOME`. */
+const DEFAULT_MODS_PATH_LINUX = path.join(HOME_DIR, ".local", "share", "Steam", "steamapps", "common", "The Binding of Isaac Rebirth", MODS);
+export async function getModsDir(args, typeScript) {
+    if (typeScript) {
+        return undefined;
+    }
+    if (args.modsDirectory !== undefined) {
+        // They specified the "--mods-directory" command-line flag, so there is no need to prompt the
+        // user for it.
+        return args.modsDirectory;
+    }
+    const defaultModsPath = getDefaultModsPath(process.platform);
+    if (isDirectory(defaultModsPath)) {
+        return defaultModsPath;
+    }
+    console.error(`Failed to find your mods directory at: ${chalk.green(defaultModsPath)}`);
+    const modsDir = await getInputString(`Enter the full path to the "${MODS}" directory on your system, which should be next to your "isaac-ng.exe" program:`);
+    if (modsDir === "") {
+        fatalError("Error: You did not provide a response; exiting.");
+    }
+    if (!isDirectory(modsDir)) {
+        fatalError(`Error: The directory of "${chalk.green(modsDir)}" does not exist. Exiting.`);
+    }
+    if (path.basename(modsDir) !== MODS) {
+        fatalError(`Error: You entered a path of "${chalk.green(modsDir)}", but you need to input a directory with a name of "${MODS}" at the end. Exiting.`);
+    }
+    return modsDir;
+}
+function getDefaultModsPath(platform) {
+    switch (platform) {
+        case "win32": {
+            return DEFAULT_MODS_PATH_WINDOWS;
+        }
+        case "linux": {
+            return DEFAULT_MODS_PATH_LINUX;
+        }
+        default: {
+            return fatalError(`There does not exist a default mod path for the platform of: ${chalk.green(platform)}`);
+        }
+    }
+}

package/dist/commands/init/getProjectPath.js

@@ -0,0 +1,84 @@
+import chalk from "chalk";
+import { fatalError } from "isaacscript-common-node";
+import { hasWhiteSpace, isKebabCase } from "isaacscript-common-ts";
+import path from "node:path";
+import { CURRENT_DIRECTORY_NAME, CWD } from "../../constants.js";
+import { getInputString, getInputYesNo } from "../../prompt.js";
+// From: https://gist.github.com/doctaphred/d01d05291546186941e1b7ddc02034d3
+const ILLEGAL_CHARACTERS_FOR_WINDOWS_FILENAMES = [
+    "<",
+    ">",
+    ":",
+    '"',
+    "/",
+    "\\",
+    "|",
+    "?",
+    "*",
+];
+export async function getProjectPath(args, useCurrentDir, yes, forceName) {
+    let projectName = getProjectNameFromCommandLineArgument(args);
+    let projectPath;
+    let createNewDir;
+    if (useCurrentDir) {
+        // The "--use-current-dir" command-line flag was specified, so there is no need to prompt the
+        // user.
+        projectName = CURRENT_DIRECTORY_NAME;
+        projectPath = CWD;
+        createNewDir = false;
+    }
+    else if (projectName !== undefined) {
+        // The project name was specified on the command-line.
+        projectPath = path.join(CWD, projectName);
+        createNewDir = true;
+    }
+    else if (yes) {
+        // The "--yes" command-line flag was specified and the project name was not specified on the
+        // command-line, so default to using the current directory.
+        projectName = CURRENT_DIRECTORY_NAME;
+        projectPath = CWD;
+        createNewDir = false;
+    }
+    else {
+        // The project name was not specified on the command-line, so prompt the user for it.
+        [projectName, projectPath, createNewDir] = await getNewProjectName();
+    }
+    validateProjectName(projectName, forceName);
+    console.log(`Using a project name of: ${chalk.green(projectName)}`);
+    return [projectPath, createNewDir];
+}
+function getProjectNameFromCommandLineArgument(args) {
+    const { name } = args;
+    return typeof name === "string" && name !== "" ? name : undefined;
+}
+async function getNewProjectName() {
+    console.log("You did not specify a project name as a command-line argument.");
+    const shouldUseCurrentDir = await getInputYesNo(`Would you like to create a new project using the current directory "${chalk.green(CURRENT_DIRECTORY_NAME)}" as the root?`);
+    if (shouldUseCurrentDir) {
+        return [CURRENT_DIRECTORY_NAME, CWD, false];
+    }
+    const projectName = await getInputString("Enter the name of the project:");
+    const projectPath = path.join(CWD, projectName);
+    return [projectName, projectPath, true];
+}
+function validateProjectName(projectName, forceName) {
+    if (projectName === "") {
+        fatalError("Error: You cannot have a blank project name.");
+    }
+    if (process.platform === "win32") {
+        for (const character of ILLEGAL_CHARACTERS_FOR_WINDOWS_FILENAMES) {
+            if (projectName.includes(character)) {
+                fatalError(`Error: The "${character}" character is not allowed in a Windows file name.`);
+            }
+        }
+    }
+    if (forceName) {
+        return;
+    }
+    if (hasWhiteSpace(projectName)) {
+        fatalError('Error: The project name has whitespace in it, which is not allowed. Use kebab-case for your project name. (e.g. "green-candle")');
+    }
+    if (!isKebabCase(projectName)) {
+        fatalError('Error: The project name is not in kebab-case. (Kebab-case is the style of using all lowercase letters, with words separated by hyphens.) Project names must use kebab-case to match GitHub repository standards. If necessary, you can override this check with the "--force-name" flag.');
+    }
+}

package/dist/commands/init/init.js

@@ -0,0 +1,73 @@
+import chalk from "chalk";
+import commandExists from "command-exists";
+import { getPackageManagerExecCommand } from "isaacscript-common-node";
+import path from "node:path";
+import { CWD, PROJECT_NAME } from "../../constants.js";
+import { promptGitHubRepoOrGitRemoteURL } from "../../git.js";
+import { getPackageManagerUsedForNewProject } from "../../packageManager.js";
+import { checkIfProjectPathExists } from "./checkIfProjectPathExists.js";
+import { checkModSubdirectory } from "./checkModSubdirectory.js";
+import { checkModTargetDirectory } from "./checkModTargetDirectory.js";
+import { createProject } from "./createProject.js";
+import { getAuthorName } from "./getAuthorName.js";
+import { getModsDir } from "./getModsDir.js";
+import { getProjectPath } from "./getProjectPath.js";
+import { installVSCodeExtensions } from "./installVSCodeExtensions.js";
+import { promptSaveSlot } from "./promptSaveSlot.js";
+import { promptVSCode } from "./promptVSCode.js";
+export async function init(args, typeScript) {
+    const packageManager = getPackageManagerUsedForNewProject(args);
+    const noGit = args.noGit === true;
+    const skipInstall = args.skipInstall === true;
+    const useCurrentDir = args.useCurrentDir === true;
+    const verbose = args.verbose === true;
+    const vscode = args.vscode === true;
+    const yes = args.yes === true;
+    const forceName = args.forceName === true;
+    const dev = args.dev === true;
+    // Prompt the end-user for some information (and validate it as we go).
+    const [projectPath, createNewDir] = await getProjectPath(args, useCurrentDir, yes, forceName);
+    await checkIfProjectPathExists(projectPath, yes);
+    const projectName = path.basename(projectPath);
+    const authorName = await getAuthorName(typeScript);
+    const gitRemoteURL = await promptGitHubRepoOrGitRemoteURL(projectName, noGit, yes, dev, verbose);
+    const modsDirectory = await getModsDir(args, typeScript);
+    if (modsDirectory !== undefined) {
+        checkModSubdirectory(projectPath, modsDirectory);
+        await checkModTargetDirectory(modsDirectory, projectName, yes);
+    }
+    const saveSlot = typeScript ? undefined : await promptSaveSlot(args, yes);
+    // Now that we have asked the user all of the questions we need, we can create the project.
+    await createProject(projectName, authorName, projectPath, createNewDir, modsDirectory, saveSlot, gitRemoteURL, skipInstall, packageManager, typeScript, dev, verbose);
+    await openVSCode(projectPath, vscode, yes, verbose);
+    printFinishMessage(projectPath, projectName, packageManager, typeScript);
+}
+async function openVSCode(projectPath, vscode, yes, verbose) {
+    const VSCodeCommand = getVSCodeCommand();
+    if (VSCodeCommand === undefined) {
+        console.log('VSCode does not seem to be installed. (The "code" command is not in the path.) Skipping VSCode-related things.');
+        return;
+    }
+    installVSCodeExtensions(projectPath, VSCodeCommand, verbose);
+    await promptVSCode(projectPath, VSCodeCommand, vscode, yes, verbose);
+}
+function getVSCodeCommand() {
+    for (const VSCodeCommand of ["code", "codium", "code-oss", "code-insiders"]) {
+        if (commandExists.sync(VSCodeCommand)) {
+            return VSCodeCommand;
+        }
+    }
+    return undefined;
+}
+function printFinishMessage(projectPath, projectName, packageManager, typeScript) {
+    if (typeScript) {
+        return;
+    }
+    let commandsToType = "";
+    if (projectPath !== CWD) {
+        commandsToType += `"${chalk.green(`cd ${projectName}`)}" and `;
+    }
+    const command = getPackageManagerExecCommand(packageManager);
+    commandsToType += `"${chalk.green(`${command} isaacscript`)}"`;
+    console.log(`Now, start ${PROJECT_NAME} by typing ${commandsToType}.`);
+}

package/dist/commands/init/installVSCodeExtensions.js

@@ -0,0 +1,27 @@
+import { fatalError, getJSONC, isFile } from "isaacscript-common-node";
+import path from "node:path";
+import { execShell } from "../../exec.js";
+export function installVSCodeExtensions(projectPath, VSCodeCommand, verbose) {
+    // Installing extensions from inside WSL on Windows will result in the VSCode process never
+    // exiting for some reason. Thus, skip this step on Linux. (Linux users will probably be smart
+    // enough to install the extensions on their own.)
+    if (process.platform === "linux") {
+        return;
+    }
+    const extensions = getExtensionsFromJSON(projectPath);
+    for (const extensionName of extensions) {
+        execShell(VSCodeCommand, ["--install-extension", extensionName], verbose);
+    }
+}
+function getExtensionsFromJSON(projectPath) {
+    const extensionsJSONPath = path.join(projectPath, ".vscode", "extensions.json");
+    if (!isFile(extensionsJSONPath)) {
+        return [];
+    }
+    const extensionsJSON = getJSONC(extensionsJSONPath);
+    const { recommendations } = extensionsJSON;
+    if (!Array.isArray(recommendations)) {
+        fatalError('The "recommendations" field in the "extensions.json" file is not an array.');
+    }
+    return recommendations;
+}

package/dist/commands/init/promptSaveSlot.js

@@ -0,0 +1,17 @@
+import { fatalError } from "isaacscript-common-node";
+import { getInputInt } from "../../prompt.js";
+export async function promptSaveSlot(args, yes) {
+    if (args.saveSlot !== undefined) {
+        // They specified the "--save-slot" command-line flag, so there is no need to prompt the user
+        // for it.
+        return args.saveSlot;
+    }
+    if (yes) {
+        return 1;
+    }
+    const saveSlot = await getInputInt("In-game, will you test your mod on save slot 1, 2, or 3?");
+    if (saveSlot !== 1 && saveSlot !== 2 && saveSlot !== 3) {
+        fatalError("Error: You must choose a number between 1 and 3.");
+    }
+    return saveSlot;
+}

package/{src → dist}/commands/init/promptVSCode.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.promptVSCode = void 0;
-const exec_js_1 = require("../../exec.js");
-const prompt_js_1 = require("../../prompt.js");
-async function promptVSCode(projectPath, VSCodeCommand, vscode, yes, verbose) {
+import { execShell } from "../../exec.js";
+import { getInputYesNo } from "../../prompt.js";
+export async function promptVSCode(projectPath, VSCodeCommand, vscode, yes, verbose) {
     if (vscode) {
         // They supplied the "--vscode" command-line flag, so there is no need to prompt the user.
         openVSCode(projectPath, VSCodeCommand, verbose);
@@ -18,13 +15,11 @@ async function promptVSCode(projectPath, VSCodeCommand, vscode, yes, verbose) {
     if (process.platform === "linux") {
         return;
     }
-    const shouldOpenVSCode = await (0, prompt_js_1.getInputYesNo)("Do you want to open your new project in VSCode now?");
+    const shouldOpenVSCode = await getInputYesNo("Do you want to open your new project in VSCode now?");
     if (shouldOpenVSCode) {
         openVSCode(projectPath, VSCodeCommand, verbose);
     }
 }
-exports.promptVSCode = promptVSCode;
 function openVSCode(projectPath, VSCodeCommand, verbose) {
-    (0, exec_js_1.execShell)(VSCodeCommand, [projectPath], verbose);
+    execShell(VSCodeCommand, [projectPath], verbose);
 }
-//# sourceMappingURL=promptVSCode.js.map

package/dist/commands/monitor/copyWatcherMod.js

@@ -0,0 +1,31 @@
+import { copyFileOrDirectory, deleteFileOrDirectory, isFile, readFile, writeFile, } from "isaacscript-common-node";
+import path from "node:path";
+import { DISABLE_IT_FILE, MAIN_LUA, WATCHER_MOD_NAME, WATCHER_MOD_SOURCE_PATH, } from "../../constants.js";
+export function copyWatcherMod(config) {
+    // Check to see if this mod was disabled.
+    const watcherModPath = path.join(config.modsDirectory, WATCHER_MOD_NAME);
+    const disableItPath = path.join(watcherModPath, DISABLE_IT_FILE);
+    const watcherModDisabled = isFile(disableItPath);
+    // Delete and re-copy the watcher mod every time IsaacScript starts. This ensures that it is
+    // always the latest version.
+    deleteFileOrDirectory(watcherModPath);
+    copyFileOrDirectory(WATCHER_MOD_SOURCE_PATH, watcherModPath);
+    if (watcherModDisabled) {
+        // Since we deleted the directory, the "disable.it" file was deleted. Restore it.
+        writeFile(disableItPath, "");
+    }
+    // By default, the IsaacScript watcher mod automatically restarts the game, so we only need to
+    // disable it if the config option is explicitly set to false.
+    if (config.enableIsaacScriptWatcherAutoRestart === false) {
+        disableIsaacScriptWatcherAutomaticRestart(watcherModPath);
+    }
+    // If we copied a new version of the watcher mod into place, but the user currently has the game
+    // open, then the old version will stay loaded. However, if the watcher mod reloads itself, the
+    // game will crash, so there is no automated solution for this.
+}
+function disableIsaacScriptWatcherAutomaticRestart(watcherModPath) {
+    const mainLuaPath = path.join(watcherModPath, MAIN_LUA);
+    const mainLua = readFile(mainLuaPath);
+    const modifiedMainLua = mainLua.replace("local RESTART_GAME_ON_RECOMPILATION = true", "local RESTART_GAME_ON_RECOMPILATION = false");
+    writeFile(mainLuaPath, modifiedMainLua);
+}

package/dist/commands/monitor/modDirectorySyncer/modDirectorySyncer.js

@@ -0,0 +1,44 @@
+import syncDirectory from "@zamiell/sync-directory";
+import { getArgs } from "isaacscript-common-node";
+import { assertDefined } from "isaacscript-common-ts";
+import { FILE_SYNCED_MESSAGE } from "../../../constants.js";
+const SUBPROCESS_NAME = "directory syncer";
+let modSourcePath;
+let modTargetPath;
+init();
+function init() {
+    const args = getArgs();
+    const firstArg = args[0];
+    assertDefined(firstArg, `The ${SUBPROCESS_NAME} process did not get a valid first argument.`);
+    const secondArg = args[1];
+    assertDefined(secondArg, `The ${SUBPROCESS_NAME} process did not get a valid second argument.`);
+    modSourcePath = firstArg;
+    modTargetPath = secondArg;
+    syncDirectory(modSourcePath, modTargetPath, {
+        watch: true,
+        type: "copy",
+        afterEachSync,
+        onError,
+        chokidarWatchOptions: {
+            awaitWriteFinish: {
+                stabilityThreshold: 1000,
+            },
+        },
+    });
+}
+function afterEachSync(params) {
+    if (params === undefined) {
+        return;
+    }
+    if (params.eventType !== "init:copy") {
+        send(`${FILE_SYNCED_MESSAGE} ${params.relativePath}`);
+    }
+}
+function onError(err) {
+    send(`The directory syncer encountered an error: ${err.message}`);
+}
+function send(msg) {
+    if (process.send !== undefined) {
+        process.send(msg);
+    }
+}