isaacscript 1.2.2 → 1.2.3

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

@@ -28,14 +28,15 @@ const MAIN_LUA_REPLACEMENTS = [
   ["Set = __TS__Class()", "Set = Set or __TS__Class()"],
 ];
 
-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);
   const mainLua = file.read(mainLuaPath);
 
   // mainLua = patchInformationalHeader(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
@@ -49,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/util.ts

@@ -1,7 +1,5 @@
-import chalk from "chalk";
-import { execSync, spawnSync, SpawnSyncReturns } from "child_process";
 import moment from "moment";
-import { CURRENT_DIRECTORY_NAME, CWD } from "./constants";
+import { CURRENT_DIRECTORY_NAME } from "./constants";
 import { Config } from "./types/Config";
 
 export const ensureAllCases = (obj: never): never => obj;
@@ -11,82 +9,6 @@ export function error(...args: unknown[]): never {
   process.exit(1);
 }
 
-export function execExe(path: string, cwd = CWD): string {
-  let stdout: string;
-  try {
-    const buffer = execSync(`"${path}"`, {
-      cwd,
-    });
-    stdout = buffer.toString().trim();
-  } catch (err) {
-    console.error(`Failed to run "${chalk.green(path)}":`, err);
-    process.exit(1);
-  }
-
-  return stdout;
-}
-
-/** Returns an array of exit status and stdout. */
-export function execShell(
-  command: string,
-  args: string[] = [],
-  allowFailure = false,
-  cwd = CWD,
-): [number | null, 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('"')) {
-    throw new Error(
-      "execShell cannot execute commands with double quotes in the command.",
-    );
-  }
-  for (let i = 0; i < args.length; i++) {
-    if (args[i].includes('"')) {
-      throw new 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();
-
-  let spawnSyncReturns: SpawnSyncReturns<Buffer>;
-  try {
-    spawnSyncReturns = spawnSync(command, args, {
-      shell: true,
-      cwd,
-    });
-  } catch (err) {
-    error(
-      `Failed to run the "${chalk.green(commandDescription)}" command:`,
-      err,
-    );
-  }
-
-  const exitStatus = spawnSyncReturns.status;
-  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];
-}
-
 export function getModTargetDirectoryName(config: Config): string {
   return config.customTargetModDirectoryName === undefined
     ? CURRENT_DIRECTORY_NAME
@@ -132,3 +54,31 @@ export function parseIntSafe(input: string): number {
 
   return parseInt(trimmedInput, 10);
 }
+
+export function parseSemVer(
+  versionString: string,
+): [major: number, minor: number, patch: number] {
+  const match = /^v*(\d+)\.(\d+)\.(\d+)/g.exec(versionString);
+  if (match === null) {
+    error(`Failed to parse the version string of: ${versionString}`);
+  }
+
+  const [, majorVersionString, minorVersionString, patchVersionString] = match;
+
+  const majorVersion = parseIntSafe(majorVersionString);
+  if (Number.isNaN(majorVersion)) {
+    error(`Failed to parse the major version number from: ${versionString}`);
+  }
+
+  const minorVersion = parseInt(minorVersionString, 10);
+  if (Number.isNaN(minorVersion)) {
+    error(`Failed to parse the minor version number from: ${versionString}`);
+  }
+
+  const patchVersion = parseInt(patchVersionString, 10);
+  if (Number.isNaN(patchVersion)) {
+    error(`Failed to parse the patch version number from: ${versionString}`);
+  }
+
+  return [majorVersion, minorVersion, patchVersion];
+}

package/src/validateNodeVersion.ts

@@ -1,56 +1,24 @@
 import chalk from "chalk";
 import { PROJECT_NAME } from "./constants";
-import { error } from "./util";
+import { parseSemVer } from "./util";
 
-const REQUIRED_MAJOR_VERSION = 16;
+const REQUIRED_NODE_JS_MAJOR_VERSION = 16;
 
 // This program requires Node to be at least v16.0.0,
 // since that is the version that added the "fs.rmSync()" function
 // (I tested on Node v15.0.0 and it failed)
 export function validateNodeVersion(): void {
-  const { version } = process;
+  const nodeJSVersionString = process.version;
+  const [majorVersion] = parseSemVer(nodeJSVersionString);
 
-  const match = /^v(\d+)\.(\d+)\.(\d)+$/g.exec(version);
-  if (match === null) {
-    error(`Failed to parse your NodeJS version of: ${version}`);
-  }
-
-  const majorVersionString = match[1];
-  const majorVersion = parseInt(majorVersionString, 10);
-  if (Number.isNaN(majorVersion)) {
-    error(
-      `Failed to parse the major version number from: ${majorVersionString}`,
-    );
-  }
-
-  const minorVersionString = match[2];
-  const minorVersion = parseInt(minorVersionString, 10);
-  if (Number.isNaN(minorVersion)) {
-    error(
-      `Failed to parse the minor version number from: ${minorVersionString}`,
-    );
-  }
-
-  const patchVersionString = match[3];
-  const patchVersion = parseInt(patchVersionString, 10);
-  if (Number.isNaN(patchVersion)) {
-    error(
-      `Failed to parse the patch version number from: ${patchVersionString}`,
-    );
-  }
-
-  if (majorVersion >= REQUIRED_MAJOR_VERSION) {
+  if (majorVersion >= REQUIRED_NODE_JS_MAJOR_VERSION) {
     return;
   }
 
-  console.error(
-    `Your Node.js version is: ${chalk.red(
-      `${majorVersionString}.${minorVersionString}.${patchVersionString}`,
-    )}`,
-  );
+  console.error(`Your Node.js version is: ${chalk.red(nodeJSVersionString)}`);
   console.error(
     `${PROJECT_NAME} requires a Node.js version of ${chalk.red(
-      "16.0.0",
+      `${REQUIRED_NODE_JS_MAJOR_VERSION}.0.0`,
     )} or greater.`,
   );
   console.error(