isaacscript 2.0.6 → 2.0.9

package/src/commands/init/git.ts

@@ -1,249 +0,0 @@
-import chalk from "chalk";
-import commandExists from "command-exists";
-import path from "path";
-import yaml from "yaml";
-import { PROJECT_NAME } from "../../constants";
-import { execShell } from "../../exec";
-import * as file from "../../file";
-import { getInputString, getInputYesNo } from "../../prompt";
-import { GitHubCLIHostsYAML } from "../../types/GitHubCLIHostsYAML";
-import { error, parseSemVer } from "../../utils";
-
-const REQUIRED_GIT_MAJOR_VERSION = 2;
-const REQUIRED_GIT_MINOR_VERSION = 30;
-
-export async function promptGitHubRepoOrGitRemoteURL(
-  projectName: string,
-  yes: boolean,
-  verbose: boolean,
-): Promise<string | undefined> {
-  // We do not need to prompt the user if they do not have Git installed
-  if (!commandExists.sync("git")) {
-    console.log(
-      'Git does not seem to be installed. (The "git" command is not in the path.) Skipping Git-related things.',
-    );
-    return undefined;
-  }
-
-  validateNewGitVersion(verbose);
-
-  const gitHubUsername = getGitHubUsername(verbose);
-  if (gitHubUsername !== undefined) {
-    const [exitStatus] = execShell(
-      "gh",
-      ["repo", "view", projectName],
-      verbose,
-      true,
-    );
-    const gitHubRepoExists = exitStatus === 0;
-    const url = `https://github.com/${gitHubUsername}/${projectName}`;
-
-    if (gitHubRepoExists) {
-      console.log(
-        `Detected an existing GitHub repository at: ${chalk.green(url)}`,
-      );
-      const guessedRemoteURL = getGitRemoteURL(projectName, gitHubUsername);
-
-      if (yes) {
-        console.log(
-          `Using a Git remote URL of: ${chalk.green(guessedRemoteURL)}`,
-        );
-        return guessedRemoteURL;
-      }
-
-      const shouldUseGuessedURL = await getInputYesNo(
-        `Do you want to use a Git remote URL of: ${chalk.green(
-          guessedRemoteURL,
-        )}`,
-      );
-      if (shouldUseGuessedURL) {
-        return guessedRemoteURL;
-      }
-
-      // Assume that since they do not want to connect this project to the existing GitHub
-      // repository, they do not want to initialize a remote Git URL at all.
-      return undefined;
-    }
-
-    if (yes) {
-      execShell("gh", ["repo", "create", projectName, "--public"]);
-      console.log(`Created a new GitHub repository at: ${chalk.green(url)}`);
-      return getGitRemoteURL(projectName, gitHubUsername);
-    }
-
-    const createNewGitHubRepo = await getInputYesNo(
-      `Would you like to create a new GitHub repository at: ${chalk.green(
-        url,
-      )}`,
-    );
-    if (createNewGitHubRepo) {
-      execShell("gh", ["repo", "create", projectName, "--public"]);
-      console.log("Successfully created a new GitHub repository.");
-      return getGitRemoteURL(projectName, gitHubUsername);
-    }
-
-    // Assume that since they do not want to create a new GitHub repository, they do not want to
-    // initialize a remote Git URL at all.
-    return undefined;
-  }
-
-  const gitRemoteURL =
-    await getInputString(`Paste in the remote Git URL for your project.
-For example, if you have an SSH key, it would be something like:
-${chalk.green("git@github.com:Alice/green-candle.git")}
-If you don't have an SSH key, it would be something like:
-${chalk.green("https://github.com/Alice/green-candle.git")}
-If you don't want to initialize a Git repository for this project, press enter to skip.
-`);
-
-  return gitRemoteURL === "" ? undefined : gitRemoteURL;
-}
-
-function validateNewGitVersion(verbose: boolean) {
-  const [, stdout] = execShell("git", ["--version"], verbose);
-
-  const outputPrefix = "git version ";
-  if (!stdout.startsWith(outputPrefix)) {
-    error(
-      `Failed to parse the output from the "git --version" command: ${stdout}`,
-    );
-  }
-
-  const gitVersionString = stdout.slice(outputPrefix.length);
-  const [majorVersion, minorVersion] = parseSemVer(gitVersionString);
-
-  if (
-    majorVersion >= REQUIRED_GIT_MAJOR_VERSION &&
-    minorVersion >= REQUIRED_GIT_MINOR_VERSION
-  ) {
-    return;
-  }
-
-  console.error(`Your Git version is: ${chalk.red(gitVersionString)}`);
-  console.error(
-    `${PROJECT_NAME} requires a Git version of ${chalk.red(
-      `${REQUIRED_GIT_MAJOR_VERSION}.${REQUIRED_GIT_MINOR_VERSION}.0`,
-    )} or greater.`,
-  );
-  console.error(
-    `Please upgrade your version of Git before using ${PROJECT_NAME}.`,
-  );
-  process.exit(1);
-}
-
-function getGitHubUsername(verbose: boolean) {
-  // If the GitHub CLI is installed, we can derive the user's GitHub username
-  if (!commandExists.sync("gh")) {
-    return undefined;
-  }
-
-  const appData = process.env["APPDATA"];
-  if (appData === undefined || appData === "") {
-    return undefined;
-  }
-
-  const githubCLIHostsPath = path.join(appData, "GitHub CLI", "hosts.yml");
-  if (!file.exists(githubCLIHostsPath, verbose)) {
-    return undefined;
-  }
-
-  const configYAMLRaw = file.read(githubCLIHostsPath, verbose);
-  const configYAML = yaml.parse(configYAMLRaw) as GitHubCLIHostsYAML;
-
-  const githubCom = configYAML["github.com"];
-  if (githubCom === undefined) {
-    return undefined;
-  }
-
-  const { user } = githubCom;
-  if (user === undefined || user === "") {
-    return undefined;
-  }
-
-  return user;
-}
-
-function getGitRemoteURL(projectName: string, gitHubUsername: string) {
-  return `git@github.com:${gitHubUsername}/${projectName}.git`;
-}
-
-export function initGitRepository(
-  projectPath: string,
-  gitRemoteURL: string | undefined,
-  verbose: boolean,
-): void {
-  if (!commandExists.sync("git")) {
-    return;
-  }
-
-  if (gitRemoteURL === undefined) {
-    return;
-  }
-
-  execShell("git", ["init"], verbose, false, projectPath);
-  execShell("git", ["branch", "-M", "main"], verbose, false, projectPath);
-
-  if (isGitNameAndEmailConfigured(verbose)) {
-    execShell("git", ["add", "--all"], verbose, false, projectPath);
-    execShell(
-      "git",
-      ["commit", "--message", `${PROJECT_NAME} template`],
-      verbose,
-      false,
-      projectPath,
-    );
-  }
-
-  if (gitRemoteURL !== undefined) {
-    execShell(
-      "git",
-      ["remote", "add", "origin", gitRemoteURL],
-      verbose,
-      false,
-      projectPath,
-    );
-  }
-}
-
-function isGitNameAndEmailConfigured(verbose: boolean) {
-  const [nameExitStatus] = execShell(
-    "git",
-    ["config", "--global", "user.name"],
-    verbose,
-    true,
-  );
-
-  const [emailExitStatus] = execShell(
-    "git",
-    ["config", "--global", "user.email"],
-    verbose,
-    true,
-  );
-
-  return nameExitStatus === 0 && emailExitStatus === 0;
-}
-
-export function isGitDirty(verbose: boolean): boolean {
-  // From: https://remarkablemark.org/blog/2017/10/12/check-git-dirty/
-  const [, stdout] = execShell("git", ["status", "--porcelain"], verbose);
-  return stdout !== "";
-}
-
-export function gitCommitIfChanges(version: string, verbose: boolean): void {
-  // Throw an error if this is not a git repository
-  execShell("git", ["status"], verbose);
-
-  if (!isGitDirty(verbose)) {
-    console.log("There are no changes to commit.");
-    return;
-  }
-
-  const commitMessage = `v${version}`;
-  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}`,
-  );
-}

package/src/commands/init/init.ts

@@ -1,93 +0,0 @@
-import chalk from "chalk";
-import commandExists from "command-exists";
-import path from "path";
-import { CWD, PROJECT_NAME } from "../../constants";
-import { checkIfProjectPathExists } from "./checkIfProjectPathExists";
-import { checkModSubdirectory } from "./checkModSubdirectory";
-import { checkModTargetDirectory } from "./checkModTargetDirectory";
-import { createMod } from "./createMod";
-import { getModsDir } from "./getModsDir";
-import { getProjectPath } from "./getProjectPath";
-import { promptGitHubRepoOrGitRemoteURL } from "./git";
-import { installVSCodeExtensions } from "./installVSCodeExtensions";
-import { promptSaveSlot } from "./promptSaveSlot";
-import { promptVSCode } from "./promptVSCode";
-
-export async function init(argv: Record<string, unknown>): Promise<void> {
-  const skipNPMInstall = argv["skipNpmInstall"] === true;
-  const useCurrentDir = argv["useCurrentDir"] === true;
-  const verbose = argv["verbose"] === true;
-  const vscode = argv["vscode"] === true;
-  const yes = argv["yes"] === true;
-  const forceName = argv["forceName"] === true;
-
-  // Prompt the end-user for some information (and validate it as we go)
-  const [projectPath, createNewDir] = await getProjectPath(
-    argv,
-    useCurrentDir,
-    yes,
-    forceName,
-  );
-  await checkIfProjectPathExists(projectPath, yes, verbose);
-  const modsDirectory = await getModsDir(argv, verbose);
-  checkModSubdirectory(projectPath, modsDirectory);
-  const projectName = path.basename(projectPath);
-  await checkModTargetDirectory(modsDirectory, projectName, yes, verbose);
-  const saveSlot = await promptSaveSlot(argv, yes);
-  const gitRemoteURL = await promptGitHubRepoOrGitRemoteURL(
-    projectName,
-    yes,
-    verbose,
-  );
-
-  // Now that we have asked the user all of the questions we need, we can create the project
-  createMod(
-    projectName,
-    projectPath,
-    createNewDir,
-    modsDirectory,
-    saveSlot,
-    gitRemoteURL,
-    skipNPMInstall,
-    verbose,
-  );
-
-  await openVSCode(projectPath, vscode, verbose);
-  printFinishMessage(projectPath, projectName);
-}
-
-async function openVSCode(
-  projectPath: string,
-  vscode: boolean,
-  verbose: boolean,
-) {
-  const VSCodeCommand = getVSCodeCommand();
-  if (VSCodeCommand === null) {
-    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, verbose);
-}
-
-function getVSCodeCommand() {
-  for (const VSCodeCommand of ["code", "codium", "code-oss", "code-insiders"]) {
-    if (commandExists.sync(VSCodeCommand)) {
-      return VSCodeCommand;
-    }
-  }
-
-  return null;
-}
-
-function printFinishMessage(projectPath: string, projectName: string) {
-  let commandsToType = "";
-  if (projectPath !== CWD) {
-    commandsToType += `"${chalk.green(`cd ${projectName}`)}" and `;
-  }
-  commandsToType += `"${chalk.green("npx isaacscript")}"`;
-  console.log(`Now, start ${PROJECT_NAME} by typing ${commandsToType}.`);
-}

package/src/commands/init/installVSCodeExtensions.ts

@@ -1,47 +0,0 @@
-import chalk from "chalk";
-import * as JSONC from "jsonc-parser";
-import path from "path";
-import { execShell } from "../../exec";
-import * as file from "../../file";
-import { error } from "../../utils";
-
-export function installVSCodeExtensions(
-  projectPath: string,
-  VSCodeCommand: string,
-  verbose: boolean,
-): void {
-  const extensions = getExtensionsFromJSON(projectPath, verbose);
-  for (const extensionName of extensions) {
-    execShell(VSCodeCommand, ["--install-extension", extensionName], verbose);
-  }
-}
-
-interface ExtensionsJSON {
-  recommendations: string[];
-}
-
-function getExtensionsFromJSON(projectPath: string, verbose: boolean) {
-  const extensionsJSONPath = path.join(
-    projectPath,
-    ".vscode",
-    "extensions.json",
-  );
-
-  if (!file.exists(extensionsJSONPath, verbose)) {
-    return [];
-  }
-
-  const extensionsJSONRaw = file.read(extensionsJSONPath, verbose);
-
-  let extensionsJSON: ExtensionsJSON;
-  try {
-    extensionsJSON = JSONC.parse(extensionsJSONRaw) as ExtensionsJSON;
-  } catch (err) {
-    error(
-      `Failed to parse the "${chalk.green(extensionsJSONPath)}" file:`,
-      err,
-    );
-  }
-
-  return extensionsJSON.recommendations;
-}

package/src/commands/init/promptSaveSlot.ts

@@ -1,27 +0,0 @@
-import { getInputInt } from "../../prompt";
-import { error } from "../../utils";
-
-export async function promptSaveSlot(
-  argv: Record<string, unknown>,
-  yes: boolean,
-): Promise<number> {
-  if (argv["saveSlot"] !== undefined) {
-    // They specified the "--save-slot" command-line flag, so there is no need to prompt the user
-    // for it.
-    return argv["saveSlot"] as number; // yargs converts this to a number
-  }
-
-  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) {
-    error("Error: You must choose a number between 1 and 3.");
-  }
-
-  return saveSlot;
-}

package/src/commands/init/promptVSCode.ts

@@ -1,33 +0,0 @@
-import path from "path";
-import { MAIN_TS } from "../../constants";
-import { execShell } from "../../exec";
-import { getInputYesNo } from "../../prompt";
-
-export async function promptVSCode(
-  projectPath: string,
-  VSCodeCommand: string,
-  vscode: boolean,
-  verbose: boolean,
-): Promise<void> {
-  if (vscode) {
-    // They supplied the "--vscode" command-line flag, so there is no need to prompt the user.
-    openVSCode(projectPath, VSCodeCommand, verbose);
-    return;
-  }
-
-  const shouldOpenVSCode = await getInputYesNo(
-    "Do you want to open your new project in VSCode now?",
-  );
-  if (shouldOpenVSCode) {
-    openVSCode(projectPath, VSCodeCommand, verbose);
-  }
-}
-
-function openVSCode(
-  projectPath: string,
-  VSCodeCommand: string,
-  verbose: boolean,
-) {
-  const MAIN_TS_PATH = path.join(projectPath, "src", MAIN_TS);
-  execShell(VSCodeCommand, [projectPath, MAIN_TS_PATH], verbose);
-}

package/src/commands/monitor/copyWatcherMod.ts

@@ -1,54 +0,0 @@
-import path from "path";
-import {
-  DISABLE_IT_FILE,
-  MAIN_LUA,
-  WATCHER_MOD_NAME,
-  WATCHER_MOD_SOURCE_PATH,
-} from "../../constants";
-import * as file from "../../file";
-import { Config } from "../../types/Config";
-
-export function copyWatcherMod(config: Config, verbose: boolean): void {
-  // 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 = file.exists(disableItPath, verbose);
-
-  // Delete and re-copy the watcher mod every time IsaacScript starts. This ensures that it is
-  // always the latest version.
-  if (file.exists(watcherModPath, verbose)) {
-    file.deleteFileOrDirectory(watcherModPath, verbose);
-  }
-
-  file.copy(WATCHER_MOD_SOURCE_PATH, watcherModPath, verbose);
-
-  if (watcherModDisabled) {
-    // Since we deleted the directory, the "disable.it" file was deleted. Restore it.
-    file.write(disableItPath, "", verbose);
-  }
-
-  // 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, verbose);
-  }
-
-  // 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: string,
-  verbose: boolean,
-) {
-  const mainLuaPath = path.join(watcherModPath, MAIN_LUA);
-  const mainLua = file.read(mainLuaPath, verbose);
-
-  const modifiedMainLua = mainLua.replace(
-    "local RESTART_GAME_ON_RECOMPILATION = true",
-    "local RESTART_GAME_ON_RECOMPILATION = false",
-  );
-
-  file.write(mainLuaPath, modifiedMainLua, verbose);
-}

package/src/commands/monitor/modDirectorySyncer/modDirectorySyncer.ts

@@ -1,67 +0,0 @@
-import syncDirectory from "sync-directory";
-import { FILE_SYNCED_MESSAGE } from "../../../constants";
-
-const SUBPROCESS_NAME = "directory syncer";
-const BASE_ARGV_LENGTH = 2;
-
-let modSourcePath: string;
-let modTargetPath: string;
-
-init();
-
-function init() {
-  const firstArg = process.argv[BASE_ARGV_LENGTH];
-  if (firstArg === undefined) {
-    throw new Error(
-      `The ${SUBPROCESS_NAME} process did not get a valid first argument.`,
-    );
-  }
-
-  const secondArg = process.argv[BASE_ARGV_LENGTH + 1];
-  if (secondArg === undefined) {
-    throw new Error(
-      `The ${SUBPROCESS_NAME} process did not get the right amount of arguments.`,
-    );
-  }
-
-  modSourcePath = firstArg;
-  modTargetPath = secondArg;
-
-  syncDirectory(modSourcePath, modTargetPath, {
-    watch: true,
-    type: "copy",
-    afterEachSync,
-    onError,
-    chokidarWatchOptions: {
-      awaitWriteFinish: {
-        stabilityThreshold: 1000,
-      },
-    },
-  });
-}
-
-function afterEachSync(params?: {
-  eventType: string;
-  nodeType: string;
-  relativePath: string;
-  srcPath: string;
-  targetPath: string;
-}) {
-  if (params === undefined) {
-    return;
-  }
-
-  if (params.eventType !== "init:copy") {
-    send(`${FILE_SYNCED_MESSAGE} ${params.relativePath}`);
-  }
-}
-
-function onError(err: Error) {
-  send(`The directory syncer encountered an error: ${err}`);
-}
-
-function send(msg: string) {
-  if (process.send !== undefined) {
-    process.send(msg);
-  }
-}