isaacscript 3.16.0 → 3.16.1-dev.0

package/dist/commands/monitor/monitor.js

@@ -0,0 +1,154 @@
+import chalk from "chalk";
+import { PACKAGE_JSON, PackageManager, deleteFileOrDirectory, dirName, fatalError, getJSONC, getPackageJSONDependencies, getPackageManagerAddCommand, getPackageManagerAddDevCommand, getPackageManagerInstallCommand, isDirectory, isLink, touch, } from "isaacscript-common-node";
+import path from "node:path";
+import { CWD, MOD_SOURCE_PATH, PACKAGE_JSON_PATH } from "../../constants.js";
+import { prepareCustomStages } from "../../customStage.js";
+import { getAndValidateIsaacScriptMonorepoDirectory } from "../../dev.js";
+import { execShell, execShellString } from "../../exec.js";
+import { PACKAGE_MANAGER_USED_FOR_ISAACSCRIPT, getPackageManagerUsedForExistingProject, } from "../../packageManager.js";
+import { getFirstTSConfigIncludePath } from "../../tsconfig.js";
+import { getModTargetDirectoryName } from "../../utils.js";
+import { copyWatcherMod } from "./copyWatcherMod.js";
+import * as notifyGame from "./notifyGame.js";
+import { spawnModDirectorySyncer } from "./spawnModDirectorySyncer.js";
+import { spawnSaveDatWriter } from "./spawnSaveDatWriter.js";
+import { spawnTSTLWatcher } from "./spawnTSTLWatcher.js";
+import { touchWatcherSaveDatFiles } from "./touchWatcherSaveDatFiles.js";
+const __dirname = dirName();
+const REQUIRED_PACKAGE_JSON_DEPENDENCIES = [
+    "isaac-typescript-definitions",
+    // - "isaacscript-common" is not required.
+];
+/**
+ * We want "typescript" and some of the other dependencies to be in "devDependencies" instead of
+ * "dependencies" because it prevents their functions from being placed into the list of
+ * auto-complete functions.
+ */
+const REQUIRED_PACKAGE_JSON_DEV_DEPENDENCIES = [
+    "isaacscript",
+    // - "isaacscript-lint" is not required.
+    // - "isaacscript-spell" is not required.
+    // - "isaacscript-tsconfig" is not required.
+    "typescript",
+    "typescript-to-lua",
+];
+export async function monitor(args, config) {
+    const verbose = args.verbose === true;
+    const skipProjectChecks = args.skipProjectChecks === true;
+    const packageManager = getPackageManagerUsedForExistingProject(args);
+    // If they specified some command-line flags, override the values found in the config file.
+    if (args.modsDirectory !== undefined) {
+        config.modsDirectory = args.modsDirectory; // eslint-disable-line no-param-reassign
+    }
+    if (args.saveSlot !== undefined) {
+        config.saveSlot = args.saveSlot; // eslint-disable-line no-param-reassign
+    }
+    if (args.dev !== undefined) {
+        config.isaacScriptCommonDev = args.dev; // eslint-disable-line no-param-reassign
+    }
+    // Pre-flight checks
+    if (!skipProjectChecks) {
+        validatePackageJSONDependencies(args);
+    }
+    // Read the "tsconfig.json" file.
+    const tsConfigInclude = getFirstTSConfigIncludePath();
+    const resolvedIncludePath = path.resolve(CWD, tsConfigInclude);
+    const modTargetDirectoryName = getModTargetDirectoryName(config);
+    const modTargetPath = path.join(config.modsDirectory, modTargetDirectoryName);
+    // Prepare the IsaacScript watcher mod.
+    copyWatcherMod(config);
+    touchWatcherSaveDatFiles(config);
+    // Perform the steps to link to a development version of "isaacscript-common", if necessary. (This
+    // has to be before preparing custom stages.)
+    if (config.isaacScriptCommonDev === true) {
+        linkDevelopmentIsaacScriptCommon(CWD, packageManager, verbose);
+    }
+    else {
+        warnIfIsaacScriptCommonLinkExists(CWD, packageManager);
+    }
+    // Prepare the custom stages feature, if necessary.
+    await prepareCustomStages(packageManager, verbose);
+    // Delete and re-copy the mod every time IsaacScript starts. This ensures that it is always the
+    // latest version.
+    deleteFileOrDirectory(modTargetPath);
+    // Subprocess #1 - The "save#.dat" file writer.
+    spawnSaveDatWriter(config);
+    // Subprocess #2 - The mod directory syncer.
+    spawnModDirectorySyncer(config);
+    // Subprocess #3 - `tstl --watch` (to automatically convert TypeScript to Lua).
+    spawnTSTLWatcher(config, CWD, packageManager);
+    // Subprocess #4 - `tstl --watch` (for the development version of `isaacscript-common`).
+    if (config.isaacScriptCommonDev === true) {
+        const isaacScriptMonorepoDirectory = getAndValidateIsaacScriptMonorepoDirectory(CWD);
+        const isaacScriptCommonDirectory = path.join(isaacScriptMonorepoDirectory, "packages", "isaacscript-common");
+        if (!isDirectory(isaacScriptCommonDirectory)) {
+            console.error(`The "isaacscript-common" directory does not exist at: ${isaacScriptCommonDirectory}`);
+            fatalError('Please make sure that the IsaacScript repository is placed next to this one. If you do not want to test a local version of "isaacscript-common", then set the "isaacScriptCommonDev" field to false in your "isaacscript.json" file.');
+        }
+        spawnTSTLWatcher(config, isaacScriptCommonDirectory, packageManager, CWD);
+    }
+    // Also, start constantly pinging the watcher mod.
+    setInterval(() => {
+        notifyGame.ping();
+    }, 1000); // Every second
+    console.log("Automatically monitoring the following for changes:");
+    console.log(`1) your TypeScript code:     ${chalk.green(resolvedIncludePath)}`);
+    console.log(`2) the source mod directory: ${chalk.green(MOD_SOURCE_PATH)}`);
+    console.log("");
+    console.log(`Copying files to:            ${chalk.green(modTargetPath)}`);
+    console.log("");
+    // (The process will now continue indefinitely for as long as the subprocesses exist.)
+}
+function validatePackageJSONDependencies(args) {
+    const packageJSON = getJSONC(PACKAGE_JSON_PATH);
+    validatePackageJSONNormalDependencies(packageJSON, args);
+    validatePackageJSONDevDependencies(packageJSON, args);
+}
+function validatePackageJSONNormalDependencies(packageJSON, args) {
+    const dependencies = getPackageJSONDependencies(packageJSON, "dependencies") ?? {};
+    const dependenciesArray = Object.keys(dependencies);
+    for (const dependency of REQUIRED_PACKAGE_JSON_DEPENDENCIES) {
+        if (!dependenciesArray.includes(dependency)) {
+            const packageManager = getPackageManagerUsedForExistingProject(args);
+            const addCommand = getPackageManagerAddCommand(packageManager, dependency);
+            fatalError(`${chalk.red(`IsaacScript projects require a dependency of "${dependency}" in the "${PACKAGE_JSON}" file. You can add it with the following command:`)} ${chalk.green(addCommand)}`);
+        }
+    }
+}
+function validatePackageJSONDevDependencies(packageJSON, args) {
+    const devDependencies = getPackageJSONDependencies(packageJSON, "devDependencies") ?? {};
+    const devDependenciesArray = Object.keys(devDependencies);
+    for (const devDependency of REQUIRED_PACKAGE_JSON_DEV_DEPENDENCIES) {
+        if (!devDependenciesArray.includes(devDependency)) {
+            const packageManager = getPackageManagerUsedForExistingProject(args);
+            const addDevCommand = getPackageManagerAddDevCommand(packageManager, devDependency);
+            fatalError(`${chalk.red(`IsaacScript projects require a development dependency of "${devDependency}" in the "${PACKAGE_JSON}" file. You can add it with the following command:`)} ${chalk.green(addDevCommand)}`);
+        }
+    }
+}
+function linkDevelopmentIsaacScriptCommon(projectPath, packageManager, verbose) {
+    if (packageManager !== PACKAGE_MANAGER_USED_FOR_ISAACSCRIPT) {
+        fatalError(`If you want to use this mod to develop/test "isaacscript-common", then the mod must be set up using the ${PACKAGE_MANAGER_USED_FOR_ISAACSCRIPT} package manager instead of: ${packageManager}`);
+    }
+    const isaacScriptMonorepoDirectory = getAndValidateIsaacScriptMonorepoDirectory(projectPath);
+    console.log('Building "isaacscript-common"...');
+    // Run "yarn install" at the root of the monorepo.
+    const installCommand = getPackageManagerInstallCommand(packageManager);
+    execShellString(installCommand, verbose, false, isaacScriptMonorepoDirectory);
+    // Build "isaacscript-common".
+    const iscPackagePath = path.join(isaacScriptMonorepoDirectory, "packages", "isaacscript-common");
+    const buildCommand = "npm run build";
+    execShellString(buildCommand, verbose, false, iscPackagePath);
+    console.log('Linking this repository to the development version of "isaacscript-common"...');
+    const yarnLockPath = path.join(iscPackagePath, "yarn.lock");
+    touch(yarnLockPath);
+    execShell(PACKAGE_MANAGER_USED_FOR_ISAACSCRIPT, ["link", iscPackagePath], verbose, false, projectPath);
+}
+function warnIfIsaacScriptCommonLinkExists(projectPath, packageManager) {
+    const isaacScriptCommonPath = path.join(projectPath, "node_modules", "isaacscript-common");
+    if (isLink(isaacScriptCommonPath) &&
+        packageManager !== PackageManager.pnpm // pnpm uses links, so it will cause a false positive.
+    ) {
+        fatalError(`Your "node_modules/isaacscript-common" directory is linked, but you do not have "isaacScriptCommonDev" set to true in your "isaacscript.json" file. You must either set it to true or remove the link via: ${PACKAGE_MANAGER_USED_FOR_ISAACSCRIPT} unlink isaacscript-common`);
+    }
+}

package/{src → dist}/commands/monitor/notifyGame.js

@@ -1,12 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ping = exports.command = exports.msg = void 0;
-const tslib_1 = require("tslib");
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const constants_js_1 = require("../../constants.js");
-const utils_js_1 = require("../../utils.js");
-const spawnSaveDatWriter_js_1 = require("./spawnSaveDatWriter.js");
-function msg(data) {
+import chalk from "chalk";
+import { COMPILATION_SUCCESSFUL_MESSAGE } from "../../constants.js";
+import { getTime } from "../../utils.js";
+import { sendMsgToSaveDatWriter } from "./spawnSaveDatWriter.js";
+export function msg(data) {
     const formattedData = data
         .replaceAll("/\r\n", "\n") // Replace Windows newlines with Unix newlines
         .trim(); // Trim whitespace
@@ -20,8 +16,8 @@ function msg(data) {
             return;
         }
         // Add a time prefix.
-        const formattedLine = `[${(0, utils_js_1.getTime)()}] ${trimmedLine}`;
-        (0, spawnSaveDatWriter_js_1.sendMsgToSaveDatWriter)({
+        const formattedLine = `[${getTime()}] ${trimmedLine}`;
+        sendMsgToSaveDatWriter({
             type: "msg",
             data: formattedLine,
         });
@@ -30,29 +26,25 @@ function msg(data) {
         printMsgToStandardOut(formattedLine);
     }
 }
-exports.msg = msg;
 function printMsgToStandardOut(data) {
     let coloredData = data;
-    if (data.includes(constants_js_1.COMPILATION_SUCCESSFUL_MESSAGE)) {
-        coloredData = chalk_1.default.green(data);
+    if (data.includes(COMPILATION_SUCCESSFUL_MESSAGE)) {
+        coloredData = chalk.green(data);
     }
     else if (data.match(/error/g) !== null) {
-        coloredData = chalk_1.default.red(data);
+        coloredData = chalk.red(data);
     }
     console.log(coloredData);
 }
-function command(data) {
-    (0, spawnSaveDatWriter_js_1.sendMsgToSaveDatWriter)({
+export function command(data) {
+    sendMsgToSaveDatWriter({
         type: "command",
         data,
     });
 }
-exports.command = command;
-function ping() {
-    (0, spawnSaveDatWriter_js_1.sendMsgToSaveDatWriter)({
+export function ping() {
+    sendMsgToSaveDatWriter({
         type: "ping",
         data: "",
     });
 }
-exports.ping = ping;
-//# sourceMappingURL=notifyGame.js.map

package/{src → dist}/commands/monitor/saveDatWriter/saveDatWriter.js

@@ -1,27 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const JSONC = tslib_1.__importStar(require("jsonc-parser"));
-const node_path_1 = tslib_1.__importDefault(require("node:path"));
-const constants_js_1 = require("../../../constants.js");
-const file_js_1 = require("../../../file.js");
-const isaacScriptCommonTS_js_1 = require("../../../isaacScriptCommonTS.js");
+import { getArgs, isFile, makeDirectory, readFile, } from "isaacscript-common-node";
+import { assertDefined } from "isaacscript-common-ts";
+import * as JSONC from "jsonc-parser";
+import fs from "node:fs";
+import path from "node:path";
+import { PROJECT_NAME } from "../../../constants.js";
 const SUBPROCESS_NAME = "save#.dat writer";
 const MAX_MESSAGES = 100;
-const VERBOSE = false;
 let saveDatPath;
 let saveDatFileName;
-init(VERBOSE);
-function init(verbose) {
-    const args = process.argv.slice(2);
+init();
+function init() {
+    const args = getArgs();
     const firstArg = args[0];
-    (0, isaacScriptCommonTS_js_1.assertDefined)(firstArg, `The ${SUBPROCESS_NAME} process did not get a valid first argument.`);
+    assertDefined(firstArg, `The ${SUBPROCESS_NAME} process did not get a valid first argument.`);
     saveDatPath = firstArg;
-    saveDatFileName = node_path_1.default.basename(saveDatPath);
+    saveDatFileName = path.basename(saveDatPath);
     // Check to see if the data directory exists.
-    const watcherModDataPath = node_path_1.default.dirname(saveDatPath);
-    if (!(0, file_js_1.fileExists)(watcherModDataPath, verbose)) {
-        (0, file_js_1.makeDir)(watcherModDataPath, verbose);
+    const watcherModDataPath = path.dirname(saveDatPath);
+    if (!isFile(watcherModDataPath)) {
+        makeDirectory(watcherModDataPath);
     }
     // Listen for messages from the parent process.
     process.on("message", (msg) => {
@@ -29,7 +26,7 @@ function init(verbose) {
     });
 }
 function onMessage(type, data, numRetries = 0) {
-    const saveDat = readSaveDatFromDisk(VERBOSE);
+    const saveDat = readSaveDatFromDisk();
     if (saveDat.length > MAX_MESSAGES) {
         // If IsaacScript is running and:
         // - the game is not open
@@ -41,12 +38,12 @@ function onMessage(type, data, numRetries = 0) {
         return;
     }
     addMessageToSaveDat(type, saveDat, data); // Mutates saveDat
-    writeSaveDatToDisk(type, data, saveDat, numRetries, VERBOSE);
+    writeSaveDatToDisk(type, data, saveDat, numRetries);
 }
-function readSaveDatFromDisk(verbose) {
+function readSaveDatFromDisk() {
     let saveDat;
-    if ((0, file_js_1.fileExists)(saveDatPath, verbose)) {
-        const saveDatRaw = (0, file_js_1.readFile)(saveDatPath, verbose);
+    if (isFile(saveDatPath)) {
+        const saveDatRaw = readFile(saveDatPath);
         try {
             saveDat = JSONC.parse(saveDatRaw);
         }
@@ -85,14 +82,15 @@ function addMessageToSaveDat(type, saveDat, data) {
         }
     }
 }
-function writeSaveDatToDisk(type, data, saveDat, numRetries, verbose) {
-    const saveDatRaw = JSON.stringify(saveDat, undefined, 2);
+function writeSaveDatToDisk(type, data, saveDat, numRetries) {
+    const saveDatRaw = `${JSON.stringify(saveDat, undefined, 2)}\n`; // Prettify it for easier debugging.
     try {
-        (0, file_js_1.writeFileTry)(saveDatPath, saveDatRaw, verbose);
+        // We don't use the "writeFile" helper function here, since we want to allow for failure.
+        fs.writeFileSync(saveDatPath, saveDatRaw);
     }
     catch (error) {
         if (numRetries > 4) {
-            send(`Failed to write to the ${saveDatFileName} for 5 times in a row. Maybe the file got locked somehow. ${constants_js_1.PROJECT_NAME} will now exit.\nThe writing error is as follows: ${error}`);
+            send(`Failed to write to the ${saveDatFileName} for 5 times in a row. Maybe the file got locked somehow. ${PROJECT_NAME} will now exit.\nThe writing error is as follows: ${error}`);
             process.exit(1);
         }
         send(`Writing to "${saveDatFileName}" failed. (The number of retries so far is ${numRetries}.) Trying again in 0.1 seconds...`);
@@ -106,4 +104,3 @@ function send(msg) {
         process.send(msg);
     }
 }
-//# sourceMappingURL=saveDatWriter.js.map

package/dist/commands/monitor/saveDatWriter/types.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/monitor/spawnModDirectorySyncer.js

@@ -0,0 +1,31 @@
+import { dirName, fatalError } from "isaacscript-common-node";
+import { fork } from "node:child_process";
+import path from "node:path";
+import { FILE_SYNCED_MESSAGE, MAIN_LUA, MOD_SOURCE_PATH, } from "../../constants.js";
+import { getModTargetDirectoryName } from "../../utils.js";
+import * as notifyGame from "./notifyGame.js";
+const __dirname = dirName();
+const SUBPROCESS_NAME = "modDirectorySyncer";
+const SUBPROCESS_DESCRIPTION = "Directory syncer";
+export function spawnModDirectorySyncer(config) {
+    const processPath = path.join(__dirname, SUBPROCESS_NAME, SUBPROCESS_NAME);
+    const modTargetName = getModTargetDirectoryName(config);
+    const modTargetPath = path.join(config.modsDirectory, modTargetName);
+    const directorySyncer = fork(processPath, [MOD_SOURCE_PATH, modTargetPath]);
+    directorySyncer.on("message", (msg) => {
+        notifyGame.msg(msg);
+        // If the "main.lua" file was successfully copied over, we also have to tell isaacscript-watcher
+        // to reload the mod. Look for something like: "File synced: \main.lua"
+        if (msg === `${FILE_SYNCED_MESSAGE} ${path.sep}${MAIN_LUA}`) {
+            notifyGame.command(`luamod ${modTargetName}`);
+            notifyGame.command("restart");
+            notifyGame.msg("Reloaded the mod.");
+        }
+    });
+    directorySyncer.on("close", (code) => {
+        fatalError(`Error: ${SUBPROCESS_DESCRIPTION} subprocess closed with code: ${code}`);
+    });
+    directorySyncer.on("exit", (code) => {
+        fatalError(`Error: ${SUBPROCESS_DESCRIPTION} subprocess exited with code: ${code}`);
+    });
+}

package/dist/commands/monitor/spawnSaveDatWriter.js

@@ -0,0 +1,29 @@
+import { dirName, fatalError } from "isaacscript-common-node";
+import { fork } from "node:child_process";
+import path from "node:path";
+import { WATCHER_MOD_NAME } from "../../constants.js";
+const __dirname = dirName();
+const SUBPROCESS_NAME = "saveDatWriter";
+const SUBPROCESS_DESCRIPTION = "save#.dat writer";
+let saveDatWriter;
+export function spawnSaveDatWriter(config) {
+    const processPath = path.join(__dirname, SUBPROCESS_NAME, SUBPROCESS_NAME);
+    const modsDataPath = path.join(config.modsDirectory, "..", "data");
+    const watcherModDataPath = path.join(modsDataPath, WATCHER_MOD_NAME);
+    const saveDatFileName = `save${config.saveSlot}.dat`;
+    const saveDatPath = path.join(watcherModDataPath, saveDatFileName);
+    saveDatWriter = fork(processPath, [saveDatPath], {
+        stdio: ["pipe", "pipe", "pipe", "ipc"],
+    });
+    saveDatWriter.on("close", (code) => {
+        fatalError(`Error: ${SUBPROCESS_DESCRIPTION} subprocess closed with code: ${code}`);
+    });
+    saveDatWriter.on("exit", (code) => {
+        fatalError(`Error: ${SUBPROCESS_DESCRIPTION} subprocess exited with code: ${code}`);
+    });
+}
+export function sendMsgToSaveDatWriter(msg) {
+    if (saveDatWriter !== undefined) {
+        saveDatWriter.send(msg);
+    }
+}

package/dist/commands/monitor/spawnTSTLWatcher.js

@@ -0,0 +1,74 @@
+import { appendFile, fatalError, getPackageManagerExecCommand, isFile, } from "isaacscript-common-node";
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { COMPILATION_SUCCESSFUL_MESSAGE, PROJECT_NAME, } from "../../constants.js";
+import * as notifyGame from "./notifyGame.js";
+let compilationStartTime = new Date();
+export function spawnTSTLWatcher(config, cwd, packageManager, modCWD) {
+    const processDescription = "tstl";
+    const command = getPackageManagerExecCommand(packageManager);
+    const tstl = spawn(command, ["tstl", "--watch", "--preserveWatchOutput"], {
+        shell: true,
+        cwd,
+    });
+    tstl.stdout.on("data", (data) => {
+        const msg = data.toString().trim();
+        const suffix = getMonitorMessageSuffix(config, cwd);
+        if (msg.includes("Starting compilation in watch mode...")) {
+            const newMsg1 = `${PROJECT_NAME} is now watching for future changes${suffix}.`;
+            notifyGame.msg(newMsg1);
+            const target = suffix.includes("isaacscript-common")
+                ? '"isaacscript-common"'
+                : "the mod";
+            const newMsg2 = `Compiling ${target} for the first time...`;
+            notifyGame.msg(newMsg2);
+        }
+        else if (msg.includes("File change detected. Starting incremental compilation...")) {
+            compilationStartTime = new Date();
+            const newMsg = `TypeScript change detected${suffix}. Compiling...`;
+            notifyGame.msg(newMsg);
+        }
+        else if (msg.includes("Found 0 errors. Watching for file changes.")) {
+            const compilationFinishTime = new Date();
+            const elapsedTimeMilliseconds = compilationFinishTime.getTime() - compilationStartTime.getTime();
+            const elapsedTimeSeconds = elapsedTimeMilliseconds / 1000;
+            const newMsg = `${COMPILATION_SUCCESSFUL_MESSAGE} (in ${elapsedTimeSeconds} seconds)${suffix}`;
+            notifyGame.msg(newMsg);
+            // Successful compilation of "isaacscript-common" will not trigger a recompilation in the mod.
+            // Thus, we must arbitrarily change a file to trigger a mod recompilation.
+            if (modCWD !== undefined) {
+                const bundleEntryTSPath = path.join(modCWD, "src", "bundleEntry.ts");
+                if (isFile(bundleEntryTSPath)) {
+                    appendFile(bundleEntryTSPath, "// isaacscript-common dev forced recompilation\n");
+                }
+            }
+        }
+        else {
+            notifyGame.msg(msg);
+        }
+    });
+    tstl.stderr.on("data", (data) => {
+        const msg = data.toString().trim();
+        if (msg === "^C") {
+            // Hide the line that appears when you cancel the program with `Ctrl + c`.
+            return;
+        }
+        notifyGame.msg(`Error: ${msg}`);
+    });
+    tstl.on("close", (code) => {
+        fatalError(`Error: ${processDescription} subprocess exited with code: ${code}`);
+    });
+    tstl.on("exit", (code) => {
+        fatalError(`Error: ${processDescription} subprocess exited with code: ${code}`);
+    });
+}
+function getMonitorMessageSuffix(config, cwd) {
+    if (config.isaacScriptCommonDev === false ||
+        config.isaacScriptCommonDev === undefined) {
+        return "";
+    }
+    const baseName = path.basename(cwd);
+    return baseName === "isaacscript-common"
+        ? ' (in "isaacscript-common")'
+        : " (in this mod)";
+}

package/dist/commands/monitor/touchWatcherSaveDatFiles.js

@@ -0,0 +1,15 @@
+import { isDirectory, isFile, makeDirectory, touch, } from "isaacscript-common-node";
+import path from "node:path";
+import { WATCHER_MOD_NAME } from "../../constants.js";
+export function touchWatcherSaveDatFiles(config) {
+    const modsDataPath = path.join(config.modsDirectory, "..", "data");
+    const watcherModDataPath = path.join(modsDataPath, WATCHER_MOD_NAME);
+    if (!isDirectory(watcherModDataPath)) {
+        makeDirectory(watcherModDataPath);
+    }
+    const saveDatFileName = `save${config.saveSlot}.dat`;
+    const saveDatPath = path.join(watcherModDataPath, saveDatFileName);
+    if (!isFile(saveDatPath)) {
+        touch(saveDatPath);
+    }
+}

package/dist/commands/publish/isaacscriptMod.js

@@ -0,0 +1,90 @@
+import chalk from "chalk";
+import { deleteFileOrDirectory, getFileNamesInDirectory, getPackageJSONVersion, isDirectory, isFile, readFile, writeFile, } from "isaacscript-common-node";
+import path from "node:path";
+import { CONSTANTS_TS_PATH, CWD, MOD_SOURCE_PATH, MOD_UPLOADER_PATH, PUBLISH_POST_COPY_PY_PATH, PUBLISH_PRE_COPY_PY_PATH, } from "../../constants.js";
+import { execExe, execShell, execShellString } from "../../exec.js";
+import { getReleaseGitCommitMessage, gitCommitAllAndPush } from "../../git.js";
+import { getPackageManagerUsedForExistingProject } from "../../packageManager.js";
+import { getModTargetDirectoryName } from "../../utils.js";
+import { compileAndCopy } from "../copy/copy.js";
+export async function publishIsaacScriptMod(args, config) {
+    const dryRun = args.dryRun === true;
+    const verbose = args.verbose === true;
+    const packageManager = getPackageManagerUsedForExistingProject(args);
+    const modTargetDirectoryName = getModTargetDirectoryName(config);
+    const modTargetPath = path.join(config.modsDirectory, modTargetDirectoryName);
+    const version = getPackageJSONVersion(undefined);
+    unsetDevelopmentConstant();
+    runReleaseScriptPreCopy(verbose);
+    await compileAndCopy(MOD_SOURCE_PATH, modTargetPath, packageManager, verbose);
+    purgeRoomXMLs(modTargetPath);
+    runReleaseScriptPostCopy(verbose);
+    if (dryRun) {
+        execShellString("git reset --hard", verbose); // Revert the version changes.
+    }
+    else {
+        const releaseGitCommitMessage = getReleaseGitCommitMessage(version);
+        gitCommitAllAndPush(releaseGitCommitMessage, verbose);
+        uploadMod(modTargetPath, verbose);
+    }
+    const dryRunSuffix = dryRun ? " (dry run)" : "";
+    console.log(`\nPublished version ${version} successfully${dryRunSuffix}.`);
+}
+function unsetDevelopmentConstant() {
+    if (!isFile(CONSTANTS_TS_PATH)) {
+        return;
+    }
+    const constantsTS = readFile(CONSTANTS_TS_PATH);
+    const newConstantsTS = constantsTS.replace("const IS_DEV = true", "const IS_DEV = false");
+    writeFile(CONSTANTS_TS_PATH, newConstantsTS);
+}
+function runReleaseScriptPreCopy(verbose) {
+    if (!isFile(PUBLISH_PRE_COPY_PY_PATH)) {
+        return;
+    }
+    console.log(`Running the "${PUBLISH_PRE_COPY_PY_PATH}" script.`);
+    const { stdout } = execShell("python", [PUBLISH_PRE_COPY_PY_PATH], verbose);
+    if (stdout !== "") {
+        console.log(stdout);
+    }
+}
+function runReleaseScriptPostCopy(verbose) {
+    if (!isFile(PUBLISH_POST_COPY_PY_PATH)) {
+        return;
+    }
+    console.log(`Running the "${PUBLISH_POST_COPY_PY_PATH}" script.`);
+    const { stdout } = execShell("python", [PUBLISH_POST_COPY_PY_PATH], verbose);
+    if (stdout !== "") {
+        console.log(stdout);
+    }
+}
+function purgeRoomXMLs(modTargetPath) {
+    const roomsPath = path.join(modTargetPath, "resources", "rooms");
+    if (!isDirectory(roomsPath)) {
+        return;
+    }
+    const fileNames = getFileNamesInDirectory(roomsPath);
+    const xmlFileNames = fileNames.filter((fileName) => path.extname(fileName) === ".xml");
+    for (const xmlFileName of xmlFileNames) {
+        const roomFilePath = path.join(roomsPath, xmlFileName);
+        deleteFileOrDirectory(roomFilePath);
+    }
+}
+function uploadMod(modTargetPath, verbose) {
+    if (hasIsaacSteamWorkshopUploadGitHubAction()) {
+        // CI will automatically upload the new version to the Steam Workshop, so there is no need to
+        // open the mod uploader program.
+        return;
+    }
+    console.log(`The "isaac-steam-workshop-upload" action was not found in the "${chalk.green("ci.yml")}" file; assuming that we want to use the "ModUploader.exe" tool.`);
+    execExe(MOD_UPLOADER_PATH, [], verbose, modTargetPath);
+}
+function hasIsaacSteamWorkshopUploadGitHubAction() {
+    const ciYMLPath = path.join(CWD, ".github", "workflows", "ci.yml");
+    if (!isFile(ciYMLPath)) {
+        return false;
+    }
+    const ciYML = readFile(ciYMLPath);
+    const lines = ciYML.split("\n");
+    return lines.some((line) => line.match(/^\s*uses: IsaacScript\/isaac-steam-workshop-upload/) !== null);
+}