isaacscript 1.1.74 → 1.2.4

package/src/commands/publish/publish.ts

@@ -12,15 +12,10 @@ import {
   PUBLISH_PRE_COPY_PY_PATH,
   VERSION_TXT_PATH,
 } from "../../constants";
+import { execExe, execShell } from "../../exec";
 import * as file from "../../file";
 import { Config } from "../../types/Config";
-import {
-  error,
-  execExe,
-  execShell,
-  getModTargetDirectoryName,
-  parseIntSafe,
-} from "../../util";
+import { error, getModTargetDirectoryName, parseIntSafe } from "../../util";
 import { compileAndCopy } from "../copy/copy";
 
 const UPDATE_SCRIPT_NAME = "update.sh";
@@ -30,6 +25,7 @@ export function publish(argv: Record<string, unknown>, config: Config): void {
   const setVersion = argv.setVersion as string | undefined;
   const dryRun = argv.dryRun === true;
   const onlyUpload = argv.onlyUpload === true;
+  const verbose = argv.verbose === true;
 
   const modTargetDirectoryName = getModTargetDirectoryName(config);
   const modTargetPath = path.join(config.modsDirectory, modTargetDirectoryName);
@@ -43,7 +39,7 @@ export function publish(argv: Record<string, unknown>, config: Config): void {
   }
 
   if (onlyUpload) {
-    uploadMod(modTargetPath, config.steamCmdPath);
+    uploadMod(modTargetPath, config.steamCmdPath, verbose);
     return;
   }
 
@@ -54,6 +50,7 @@ export function publish(argv: Record<string, unknown>, config: Config): void {
     setVersion,
     config.steamCmdPath,
     dryRun,
+    verbose,
   );
 }
 
@@ -64,42 +61,43 @@ function startPublish(
   setVersion: string | undefined,
   steamCmdPath: string | undefined,
   dryRun: boolean,
+  verbose: boolean,
 ) {
-  updateDeps();
+  updateDeps(verbose);
 
   let version =
     setVersion === undefined ? getVersionFromPackageJSON() : setVersion;
   if (!skipVersionIncrement && setVersion === undefined) {
-    version = bumpVersionInPackageJSON(version);
+    version = bumpVersionInPackageJSON(version, verbose);
   } else if (setVersion !== undefined) {
-    writeVersionInPackageJSON(version);
+    writeVersionInPackageJSON(version, verbose);
   }
 
-  writeVersionToConstantsTS(version);
-  writeVersionToMetadataXML(version);
-  writeVersionToVersionTXT(version);
-  runReleaseScriptPreCopy();
-  compileAndCopy(modSourcePath, modTargetPath);
-  purgeRoomXMLs(modTargetPath);
-  runReleaseScriptPostCopy();
+  writeVersionToConstantsTS(version, verbose);
+  writeVersionToMetadataXML(version, verbose);
+  writeVersionToVersionTXT(version, verbose);
+  runReleaseScriptPreCopy(verbose);
+  compileAndCopy(modSourcePath, modTargetPath, verbose);
+  purgeRoomXMLs(modTargetPath, verbose);
+  runReleaseScriptPostCopy(verbose);
 
   if (!dryRun) {
-    gitCommitIfChanges(version);
-    uploadMod(modTargetPath, steamCmdPath);
+    gitCommitIfChanges(version, verbose);
+    uploadMod(modTargetPath, steamCmdPath, verbose);
   }
 
   const dryRunSuffix = dryRun ? " (dry run)" : "";
   console.log(`\nPublished version ${version} successfully${dryRunSuffix}.`);
 }
 
-function updateDeps() {
+function updateDeps(verbose: boolean) {
   if (!file.exists(UPDATE_SCRIPT_NAME)) {
     error(
       `The "${UPDATE_SCRIPT_NAME}" script does not exist in the current working directory.`,
     );
   }
 
-  execShell("bash", [UPDATE_SCRIPT_NAME]);
+  execShell("bash", [UPDATE_SCRIPT_NAME], verbose);
 }
 
 function getVersionFromPackageJSON() {
@@ -138,7 +136,7 @@ function getVersionFromPackageJSON() {
   return packageJSON.version;
 }
 
-function bumpVersionInPackageJSON(version: string): string {
+function bumpVersionInPackageJSON(version: string, verbose: boolean): string {
   // Get the patch version (i.e. the third number)
   const matches = /(\d+\.\d+\.)(\d+)/.exec(version);
   if (matches === null) {
@@ -168,7 +166,7 @@ function bumpVersionInPackageJSON(version: string): string {
     /"version": ".+",/,
     `"version": "${incrementedVersion}",`,
   );
-  file.write(PACKAGE_JSON_PATH, newPackageJSON);
+  file.write(PACKAGE_JSON_PATH, newPackageJSON, verbose);
 
   console.log(
     `The version of ${incrementedVersion} was written to: ${PACKAGE_JSON_PATH}`,
@@ -177,18 +175,18 @@ function bumpVersionInPackageJSON(version: string): string {
   return incrementedVersion;
 }
 
-function writeVersionInPackageJSON(version: string) {
+function writeVersionInPackageJSON(version: string, verbose: boolean) {
   const packageJSON = file.read(PACKAGE_JSON_PATH);
   const newPackageJSON = packageJSON.replace(
     /"version": ".+",/,
     `"version": "${version}",`,
   );
-  file.write(PACKAGE_JSON_PATH, newPackageJSON);
+  file.write(PACKAGE_JSON_PATH, newPackageJSON, verbose);
 
   console.log(`The version of ${version} was written to: ${PACKAGE_JSON_PATH}`);
 }
 
-function writeVersionToConstantsTS(version: string) {
+function writeVersionToConstantsTS(version: string, verbose: boolean) {
   if (!file.exists(CONSTANTS_TS_PATH)) {
     console.log(
       'Skipping writing the version to "constants.ts" since it was not found.',
@@ -201,63 +199,64 @@ function writeVersionToConstantsTS(version: string) {
     /const VERSION = ".+"/,
     `const VERSION = "${version}"`,
   );
-  file.write(CONSTANTS_TS_PATH, newConstantsTS);
+  file.write(CONSTANTS_TS_PATH, newConstantsTS, verbose);
 
   console.log(`The version of ${version} was written to: ${CONSTANTS_TS_PATH}`);
 }
 
-function writeVersionToMetadataXML(version: string) {
+function writeVersionToMetadataXML(version: string, verbose: boolean) {
   const metadataXML = file.read(METADATA_XML_PATH);
   const newMetadataXML = metadataXML.replace(
     /<version>.+<\/version>/,
     `<version>${version}</version>`,
   );
-  file.write(METADATA_XML_PATH, newMetadataXML);
+  file.write(METADATA_XML_PATH, newMetadataXML, verbose);
 
   console.log(`The version of ${version} was written to: ${METADATA_XML_PATH}`);
 }
 
-function writeVersionToVersionTXT(version: string) {
-  file.write(VERSION_TXT_PATH, version);
+function writeVersionToVersionTXT(version: string, verbose: boolean) {
+  file.write(VERSION_TXT_PATH, version, verbose);
 
   console.log(`The version of ${version} was written to: ${VERSION_TXT_PATH}`);
 }
 
-function runReleaseScriptPreCopy() {
+function runReleaseScriptPreCopy(verbose: boolean) {
   if (!file.exists(PUBLISH_PRE_COPY_PY_PATH)) {
     return;
   }
 
   console.log(`Running the "${PUBLISH_PRE_COPY_PY_PATH}" script.`);
-  let [, stdout] = execShell("python", [PUBLISH_PRE_COPY_PY_PATH]);
+  let [, stdout] = execShell("python", [PUBLISH_PRE_COPY_PY_PATH], verbose);
   stdout = stdout.trim();
   if (stdout.length > 0) {
     console.log(stdout);
   }
 }
 
-function runReleaseScriptPostCopy() {
+function runReleaseScriptPostCopy(verbose: boolean) {
   if (!file.exists(PUBLISH_POST_COPY_PY_PATH)) {
     return;
   }
 
   console.log(`Running the "${PUBLISH_POST_COPY_PY_PATH}" script.`);
-  let [, stdout] = execShell("python", [PUBLISH_POST_COPY_PY_PATH]);
+  let [, stdout] = execShell("python", [PUBLISH_POST_COPY_PY_PATH], verbose);
   stdout = stdout.trim();
   if (stdout.length > 0) {
     console.log(stdout);
   }
 }
 
-function gitCommitIfChanges(version: string) {
+function gitCommitIfChanges(version: string, verbose: boolean) {
   // Throw an error if this is not a git repository
-  execShell("git", ["status"]);
+  execShell("git", ["status"], verbose);
 
   // Check to see if there are any changes
   // https://stackoverflow.com/questions/3878624/how-do-i-programmatically-determine-if-there-are-uncommitted-changes
   const [exitCode] = execShell(
     "git",
     ["diff-index", "--quiet", "HEAD", "--"],
+    verbose,
     true,
   );
   if (exitCode === 0) {
@@ -267,16 +266,16 @@ function gitCommitIfChanges(version: string) {
   }
 
   const commitMessage = `v${version}`;
-  execShell("git", ["add", "-A"]);
-  execShell("git", ["commit", "-m", commitMessage]);
-  execShell("git", ["push"]);
+  execShell("git", ["add", "-A"], verbose);
+  execShell("git", ["commit", "-m", commitMessage], verbose);
+  execShell("git", ["push"], verbose);
 
   console.log(
     `Committed and pushed to the git repository with a message of: ${commitMessage}`,
   );
 }
 
-function purgeRoomXMLs(modTargetPath: string) {
+function purgeRoomXMLs(modTargetPath: string, verbose: boolean) {
   const roomsPath = path.join(modTargetPath, "resources", "rooms");
   if (!file.exists(roomsPath) || !file.isDir(roomsPath)) {
     return;
@@ -286,25 +285,33 @@ function purgeRoomXMLs(modTargetPath: string) {
   roomFileList.forEach((fileName: string) => {
     if (path.extname(fileName) === ".xml") {
       const roomFilePath = path.join(roomsPath, fileName);
-      file.deleteFileOrDirectory(roomFilePath);
+      file.deleteFileOrDirectory(roomFilePath, verbose);
     }
   });
 }
 
-function uploadMod(modTargetPath: string, steamCmdPath: string | undefined) {
+function uploadMod(
+  modTargetPath: string,
+  steamCmdPath: string | undefined,
+  verbose: boolean,
+) {
   if (steamCmdPath === undefined) {
     console.log(
       `The "steamCmdPath" property was not found in the "${chalk.green(
         CONFIG_FILE_NAME,
       )}" file; assuming that we want to use the ModUploader tool.`,
     );
-    execExe(MOD_UPLOADER_PATH, modTargetPath);
+    execExe(MOD_UPLOADER_PATH, verbose, modTargetPath);
   } else {
-    runSteamCmd(modTargetPath, steamCmdPath);
+    runSteamCmd(modTargetPath, steamCmdPath, verbose);
   }
 }
 
-function runSteamCmd(modTargetPath: string, steamCmdPath: string) {
+function runSteamCmd(
+  modTargetPath: string,
+  steamCmdPath: string,
+  verbose: boolean,
+) {
   if (!file.exists(steamCmdPath)) {
     error(
       chalk.red(
@@ -347,14 +354,18 @@ function runSteamCmd(modTargetPath: string, steamCmdPath: string) {
 
   console.log("Uploading the mod to the Steam Workshop...");
 
-  execShell(steamCmdPath, [
-    "+login",
-    username,
-    password,
-    "+workshop_build_item",
-    metadataVDFPath,
-    "+quit",
-  ]);
+  execShell(
+    steamCmdPath,
+    [
+      "+login",
+      username,
+      password,
+      "+workshop_build_item",
+      metadataVDFPath,
+      "+quit",
+    ],
+    verbose,
+  );
 
   console.log("Mod uploaded successfully.");
 }

package/src/configFile.ts

@@ -9,6 +9,8 @@ import { Config } from "./types/Config";
 import { error } from "./util";
 
 export async function get(argv: Record<string, unknown>): Promise<Config> {
+  const verbose = argv.verbose === true;
+
   const existingConfig = readExistingConfig();
   if (existingConfig !== null) {
     return existingConfig;
@@ -18,7 +20,7 @@ export async function get(argv: Record<string, unknown>): Promise<Config> {
   const modsDirectory = await getModsDir(argv);
   const saveSlot = await promptSaveSlot(argv);
   const config = createObject(modsDirectory, saveSlot);
-  createFile(CWD, config);
+  createFile(CWD, config, verbose);
 
   return config;
 }
@@ -66,8 +68,12 @@ export function createObject(modsDirectory: string, saveSlot: number): Config {
   };
 }
 
-export function createFile(projectPath: string, config: Config): void {
+export function createFile(
+  projectPath: string,
+  config: Config,
+  verbose: boolean,
+): void {
   const configFilePath = path.join(projectPath, CONFIG_FILE_NAME);
   const configContents = JSON.stringify(config, null, 2);
-  file.write(configFilePath, configContents);
+  file.write(configFilePath, configContents, verbose);
 }

package/src/exec.ts

@@ -0,0 +1,102 @@
+import chalk from "chalk";
+import { execSync, spawnSync, SpawnSyncReturns } from "child_process";
+import { CWD } from "./constants";
+import { error } from "./util";
+
+export function execExe(path: string, verbose = false, cwd = CWD): string {
+  if (verbose) {
+    console.log(`Executing binary: ${path}`);
+  }
+
+  let stdout: string;
+  try {
+    const buffer = execSync(`"${path}"`, {
+      cwd,
+    });
+    stdout = buffer.toString().trim();
+  } catch (err) {
+    error(`Failed to run "${chalk.green(path)}":`, err);
+  }
+
+  if (verbose) {
+    console.log(`Executed binary: ${path}`);
+  }
+
+  return stdout;
+}
+
+/** Returns an array of exit status and stdout. */
+export function execShell(
+  command: string,
+  args: string[] = [],
+  verbose = false,
+  allowFailure = false,
+  cwd = CWD,
+): [number, string] {
+  // On Windows, "spawnSync()" will not account for spaces in arguments
+  // Thus, wrap everything in a double quote
+  // This will cause arguments that naturally have double quotes to fail
+  if (command.includes('"')) {
+    error(
+      "execShell cannot execute commands with double quotes in the command.",
+    );
+  }
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].includes('"')) {
+      error(
+        "execShell cannot execute commands with double quotes in the arguments.",
+      );
+    }
+
+    args[i] = `"${args[i]}"`; // eslint-disable-line no-param-reassign
+  }
+
+  const commandDescription = `${command} ${args.join(" ")}`.trim();
+
+  if (verbose) {
+    console.log(`Executing command: ${commandDescription}`);
+  }
+
+  let spawnSyncReturns: SpawnSyncReturns<Buffer>;
+  try {
+    spawnSyncReturns = spawnSync(command, args, {
+      shell: true,
+      cwd,
+    });
+  } catch (err) {
+    error(
+      `Failed to run the "${chalk.green(commandDescription)}" command:`,
+      err,
+    );
+  }
+
+  if (verbose) {
+    console.log(`Executed command: ${commandDescription}`);
+  }
+
+  const exitStatus = spawnSyncReturns.status;
+  if (exitStatus === null) {
+    error(
+      `Failed to get the return status of th command: ${commandDescription}`,
+    );
+  }
+
+  const stdout = spawnSyncReturns.output.join("\n").trim();
+
+  if (exitStatus !== 0) {
+    if (allowFailure) {
+      return [exitStatus, stdout];
+    }
+
+    console.error(
+      `Failed to run the "${chalk.green(
+        commandDescription,
+      )}" command with an exit code of ${exitStatus}.`,
+    );
+    console.error("The output was as follows:");
+    console.error(stdout);
+    process.exit(1);
+  }
+
+  return [exitStatus, stdout];
+}

package/src/file.ts

@@ -3,7 +3,11 @@ import fs from "fs-extra";
 import path from "path";
 import { error } from "./util";
 
-export function copy(srcPath: string, dstPath: string): void {
+export function copy(srcPath: string, dstPath: string, verbose: boolean): void {
+  if (verbose) {
+    console.log(`Copying: ${srcPath} --> ${dstPath}`);
+  }
+
   try {
     // "copySync()" is a "fs-extra" method for copying directories recursively
     fs.copySync(srcPath, dstPath, {
@@ -17,9 +21,20 @@ export function copy(srcPath: string, dstPath: string): void {
       err,
     );
   }
+
+  if (verbose) {
+    console.log(`Copied: ${srcPath} --> ${dstPath}`);
+  }
 }
 
-export function deleteFileOrDirectory(filePath: string): void {
+export function deleteFileOrDirectory(
+  filePath: string,
+  verbose: boolean,
+): void {
+  if (verbose) {
+    console.log(`Deleting: ${filePath}`);
+  }
+
   try {
     fs.rmSync(filePath, {
       recursive: true,
@@ -30,6 +45,10 @@ export function deleteFileOrDirectory(filePath: string): void {
       err,
     );
   }
+
+  if (verbose) {
+    console.log(`Deleted: ${filePath}`);
+  }
 }
 
 export function exists(filePath: string): boolean {
@@ -80,7 +99,11 @@ export function isSubDirOf(dir: string, parent: string): boolean {
   );
 }
 
-export function makeDir(dirPath: string): void {
+export function makeDir(dirPath: string, verbose: boolean): void {
+  if (verbose) {
+    console.log(`Making a directory: ${dirPath}`);
+  }
+
   try {
     fs.mkdirSync(dirPath, {
       recursive: true,
@@ -88,6 +111,10 @@ export function makeDir(dirPath: string): void {
   } catch (err) {
     error(`Failed to create the "${chalk.green(dirPath)}" directory:`, err);
   }
+
+  if (verbose) {
+    console.log(`Made a directory: ${dirPath}`);
+  }
 }
 
 export function read(filePath: string): string {
@@ -101,21 +128,37 @@ export function read(filePath: string): string {
   return fileContents;
 }
 
-export function touch(filePath: string): void {
+export function touch(filePath: string, verbose: boolean): void {
+  if (verbose) {
+    console.log(`Touching: ${filePath}`);
+  }
+
   try {
     const fileHandle = fs.openSync(filePath, "w");
     fs.closeSync(fileHandle);
   } catch (err) {
     error(`Failed to touch the "${chalk.green(filePath)}" file:`, err);
   }
+
+  if (verbose) {
+    console.log(`Touched: ${filePath}`);
+  }
 }
 
-export function write(filePath: string, data: string): void {
+export function write(filePath: string, data: string, verbose: boolean): void {
+  if (verbose) {
+    console.log(`Writing data to: ${filePath}`);
+  }
+
   try {
     fs.writeFileSync(filePath, data);
   } catch (err) {
     error(`Failed to write to the "${chalk.green(filePath)}" file:`, err);
   }
+
+  if (verbose) {
+    console.log(`Wrote data to: ${filePath}`);
+  }
 }
 
 export function writeTry(filePath: string, data: string): void {

package/src/main.ts

@@ -89,7 +89,7 @@ async function handleCommands(argv: Record<string, unknown>) {
     }
 
     case "copy": {
-      copy(config);
+      copy(argv, config);
       break;
     }
 

package/src/monkeyPatch.ts

@@ -20,29 +20,23 @@ see the official website: https://isaacscript.github.io/
 `;
 
 const MAIN_LUA_REPLACEMENTS = [
-  // For TSTL v1.2.X
+  // For TSTL v1.2.X-v1.3.3
+  // (fixed with GlassBrick's PR)
   ["WeakMap = __TS__Class()", "WeakMap = WeakMap or __TS__Class()"],
   ["WeakSet = __TS__Class()", "WeakSet = WeakSet or __TS__Class()"],
   ["Map = __TS__Class()", "Map = Map or __TS__Class()"],
   ["Set = __TS__Class()", "Set = Set or __TS__Class()"],
-
-  // For TSTL v1.1.1
-  /*
-  ["WeakMap = (function", "WeakMap = WeakMap or (function"],
-  ["WeakSet = (function", "WeakSet = WeakSet or (function"],
-  ["Map = (function", "Map = Map or (function"],
-  ["Set = (function", "Set = Set or (function"],
-  */
 ];
 
-export function monkeyPatchMainLua(targetModDirectory: string): void {
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function monkeyPatchMainLua(targetModDirectory: string, verbose: boolean) {
   const mainLuaPath = path.join(targetModDirectory, MAIN_LUA);
-  let mainLua = file.read(mainLuaPath);
+  const mainLua = file.read(mainLuaPath);
 
   // mainLua = patchInformationalHeader(mainLua);
-  mainLua = patchGlobalObjects(mainLua);
+  // mainLua = patchGlobalObjects(mainLua);
 
-  file.write(mainLuaPath, mainLua);
+  file.write(mainLuaPath, mainLua, verbose);
 }
 
 // Add an informational header for people who happen to be browsing the Lua output
@@ -56,6 +50,7 @@ function patchInformationalHeader(mainLua: string) {
 // Until TSTL has an official fix, monkey patch this
 // We also make sure of this function to compose a stock comment header for curious people looking
 // at the transpiled Lua code
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function patchGlobalObjects(originalMainLua: string) {
   let mainLua = originalMainLua;
 

package/src/parseArgs.ts

@@ -24,6 +24,11 @@ export function parseArgs() {
           alias: "c",
           type: "boolean",
           description: "Enable crash debugging",
+        })
+        .option("verbose", {
+          alias: "v",
+          type: "boolean",
+          description: "Enable verbose output",
         }),
     )
 
@@ -59,10 +64,21 @@ export function parseArgs() {
             type: "boolean",
             description:
               'Don\'t automatically run "npm install" after initializing the project',
+          })
+          .option("verbose", {
+            alias: "v",
+            type: "boolean",
+            description: "Enable verbose output",
           }),
     )
 
-    .command("copy", "Only compile & copy the mod.")
+    .command("copy", "Only compile & copy the mod.", (builder) =>
+      builder.option("verbose", {
+        alias: "v",
+        type: "boolean",
+        description: "Enable verbose output",
+      }),
+    )
 
     .command(
       "publish",
@@ -90,6 +106,11 @@ export function parseArgs() {
             type: "boolean",
             description:
               "only upload the mod to the Steam Workshop (without doing anything else)",
+          })
+          .option("verbose", {
+            alias: "v",
+            type: "boolean",
+            description: "Enable verbose output",
           }),
     )
 

package/src/plugins/addCrashDebugStatements.ts

@@ -1,7 +1,7 @@
+import * as tstl from "@zamiell/typescript-to-lua";
 import * as crypto from "crypto";
 import { SourceNode } from "source-map";
 import * as ts from "typescript";
-import * as tstl from "typescript-to-lua";
 
 class CustomPrinter extends tstl.LuaPrinter {
   printStatement(statement: tstl.Statement): SourceNode {