@react-gnome/core/dist/legacy/programs/init-program.js

## Getting Started

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);

// src/programs/init-program.ts
var init_program_exports = {};
__export(init_program_exports, {
  InitProgram: () => InitProgram
});
module.exports = __toCommonJS(init_program_exports);
var import_child_process = require("child_process");
var import_clify = require("clify.js");
var import_fs = __toESM(require("fs"));
var import_promises = __toESM(require("fs/promises"));
var import_path = __toESM(require("path"));
var import_termx_markup = require("termx-markup");
var import_config_file_js = require("../init-project/config-file-js.js");
var import_config_file_ts = require("../init-project/config-file-ts.js");
var import_entry_file_js = require("../init-project/entry-file-js.js");
var import_entry_file_ts = require("../init-project/entry-file-ts.js");
var import_tsconfig_file = require("../init-project/tsconfig-file.js");
var ForceTypescriptArg = (0, import_clify.defineOption)({
  char: "t",
  name: "typescript",
  description: "Initiate project with typescript. By default this will be enabled automatically if a tsconfig.json file is detected.",
  type: "boolean"
});
var InitProgram = class {
  constructor(init) {
    __publicField(this, "type", "init");
    __publicField(this, "forceTypescript");
    __publicField(this, "packageManager");
    __publicField(this, "projectDir", process.cwd());
    this.forceTypescript = init.option(ForceTypescriptArg);
  }
  detectPackageManager(projectFiles) {
    if (this.packageManager) {
      return this.packageManager;
    }
    if (projectFiles == null) {
      projectFiles = import_fs.default.readdirSync(this.projectDir);
    }
    if (projectFiles.includes("yarn.lock")) {
      this.packageManager = "yarn";
    } else if (projectFiles.includes("package-lock.json")) {
      this.packageManager = "npm";
    } else if (projectFiles.includes("pnpm-lock.yaml")) {
      this.packageManager = "pnpm";
    } else if (projectFiles.includes("bun.lockb")) {
      this.packageManager = "bun";
    } else {
      this.packageManager = "npm";
    }
    return this.packageManager;
  }
  async createFiles(projectDir, useTypescript) {
    const srcDir = import_path.default.resolve(projectDir, "src");
    if (!import_fs.default.existsSync(srcDir)) {
      await import_promises.default.mkdir(srcDir);
    }
    const entryFilePath = import_path.default.resolve(
      projectDir,
      "src",
      useTypescript ? "start.tsx" : "start.jsx"
    );
    if (!import_fs.default.existsSync(entryFilePath)) {
      const entryFileContent = useTypescript ? (0, import_entry_file_ts.getTsEntryFile)() : (0, import_entry_file_js.getJsEntryFile)();
      import_termx_markup.Output.print(
        import_termx_markup.html`<span>
          Creating entrypoint file:
          <span color="white">
            ./${import_path.default.relative(projectDir, entryFilePath)}
          </span>
        </span>`
      );
      await import_promises.default.writeFile(entryFilePath, entryFileContent);
    }
    const configFilePath = import_path.default.resolve(
      projectDir,
      useTypescript ? "react-gtk.config.ts" : "react-gtk.config.mjs"
    );
    if (!import_fs.default.existsSync(configFilePath)) {
      const configFileContent = useTypescript ? (0, import_config_file_ts.getTsProjectConfigFile)() : (0, import_config_file_js.getJsProjectConfigFile)();
      import_termx_markup.Output.print(
        import_termx_markup.html`<span>
          Creating config file:
          <span color="white">
            ./${import_path.default.relative(projectDir, configFilePath)}
          </span>
        </span>`
      );
      await import_promises.default.writeFile(configFilePath, configFileContent);
    }
    if (useTypescript) {
      const tsconfigPath = import_path.default.resolve(projectDir, "tsconfig.json");
      if (!import_fs.default.existsSync(tsconfigPath)) {
        const fileContent = (0, import_tsconfig_file.getTsConfig)();
        import_termx_markup.Output.print(
          import_termx_markup.html`<span>
            Creating tsconfig file:
            <span color="white">
              ./${import_path.default.relative(projectDir, tsconfigPath)}
            </span>
          </span>`
        );
        await import_promises.default.writeFile(tsconfigPath, fileContent);
      }
    }
  }
  async updatePackageJson(packageJson, filepath) {
    import_termx_markup.Output.print(
      import_termx_markup.html`<span>
        Updating scripts in:
        <span color="white">./package.json</span>
      </span>`
    );
    const scripts = packageJson.scripts ?? {};
    scripts.build = `react-gtk build`;
    scripts.bundle = `react-gtk bundle`;
    scripts.start = `react-gtk start -m development -w`;
    scripts["install-pkg"] = "meson install -C ./dist/.build/_build";
    packageJson.type = "module";
    packageJson.scripts = scripts;
    await import_promises.default.writeFile(filepath, JSON.stringify(packageJson, null, 2));
  }
  async installDependencies(packageJson, useTypescript) {
    const hasDep = (dep) => {
      return packageJson.dependencies && !!packageJson.dependencies[dep] || packageJson.devDependencies && !!packageJson.devDependencies[dep];
    };
    import_termx_markup.Output.print(import_termx_markup.html`<span>Installing dependencies...</span>`);
    const neededDeps = {
      dev: [],
      prod: []
    };
    if (!hasDep("react")) {
      neededDeps.prod.push("react");
    }
    if (!hasDep("@reactgjs/renderer")) {
      neededDeps.prod.push("@reactgjs/renderer");
    }
    if (useTypescript) {
      if (!hasDep("typescript")) {
        neededDeps.dev.push("typescript");
      }
      if (!hasDep("@types/react")) {
        neededDeps.dev.push("@types/react");
      }
      if (!hasDep("ts-node")) {
        neededDeps.dev.push("ts-node");
      }
      if (!hasDep("gjs-esm-types")) {
        neededDeps.dev.push("gjs-esm-types");
      }
    }
    switch (this.detectPackageManager()) {
      case "yarn":
        await execute(`yarn add -D ${neededDeps.dev.join(" ")}`);
        await execute(`yarn add ${neededDeps.prod.join(" ")}`);
        break;
      case "pnpm":
        await execute(`pnpm add -D ${neededDeps.dev.join(" ")}`);
        await execute(`pnpm add ${neededDeps.prod.join(" ")}`);
        break;
      case "bun":
        await execute(`bun add -D ${neededDeps.dev.join(" ")}`);
        await execute(`bun add ${neededDeps.prod.join(" ")}`);
        break;
      case "npm":
        await execute(`npm install --save-dev ${neededDeps.dev.join(" ")}`);
        await execute(`npm install --save ${neededDeps.prod.join(" ")}`);
        break;
    }
  }
  async run() {
    import_termx_markup.Output.print(import_termx_markup.html` <span color="green">Initializing new project.</span> `);
    const projectDir = process.cwd();
    const projectFiles = await import_promises.default.readdir(projectDir);
    const useTypescript = this.forceTypescript.value ?? projectFiles.includes("tsconfig.json");
    this.detectPackageManager(projectFiles);
    await this.createFiles(projectDir, useTypescript);
    const packageJsonPath = import_path.default.resolve(projectDir, "package.json");
    let packageJson = {};
    if (import_fs.default.existsSync(packageJsonPath)) {
      packageJson = JSON.parse(await import_promises.default.readFile(packageJsonPath, "utf-8"));
    }
    await this.updatePackageJson(packageJson, packageJsonPath);
    await this.installDependencies(packageJson, useTypescript);
    import_termx_markup.Output.print(import_termx_markup.html` <span color="green">Done.</span> `);
  }
};
function execute(command) {
  return new Promise((resolve) => {
    (0, import_child_process.exec)(command, (err, stdout, stderr) => {
      if (err) {
        resolve({ stdout, stderr, code: err.code ?? null });
      } else {
        resolve({ stdout, stderr, code: 0 });
      }
    });
  });
}