create-next-pro-cli 0.1.14 → 0.1.17

package/dist/bin.node.js

@@ -0,0 +1,682 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import prompts5 from "prompts";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname, resolve } from "path";
+
+// src/lib/addComponent.ts
+import { join as join2 } from "path";
+import { mkdir, readFile as readFile2, writeFile, readdir } from "fs/promises";
+import prompts from "prompts";
+
+// src/lib/utils.ts
+import { readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+async function loadConfig() {
+  const configPath = join(process.cwd(), "cnp.config.json");
+  if (!existsSync(configPath)) return null;
+  try {
+    const raw = await readFile(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function toFileName(key) {
+  switch (key) {
+    case "layout":
+      return "layout.tsx";
+    case "page":
+      return "page.tsx";
+    case "loading":
+      return "loading.tsx";
+    case "not-found":
+      return "not-found.tsx";
+    case "error":
+      return "error.tsx";
+    case "global-error":
+      return "global-error.tsx";
+    case "route":
+      return "route.ts";
+    case "template":
+      return "template.tsx";
+    case "default":
+      return "default.tsx";
+    default:
+      return `${key}.tsx`;
+  }
+}
+
+// src/lib/addComponent.ts
+import { existsSync as existsSync2, statSync } from "fs";
+async function addComponent(args) {
+  let componentName = args[1];
+  let pageScope = null;
+  let pageIndex = args.findIndex((arg) => arg === "-P" || arg === "--page");
+  if (pageIndex !== -1 && args[pageIndex + 1]) {
+    pageScope = args[pageIndex + 1];
+  }
+  let nestedPath = null;
+  if (pageScope && pageScope.includes(".")) {
+    nestedPath = join2(...pageScope.split("."));
+  }
+  if (!componentName || componentName.startsWith("-")) {
+    const response = await prompts.prompt({
+      type: "text",
+      name: "componentName",
+      message: "\u{1F9E9} Component name to add:",
+      validate: (name) => name ? true : "Component name is required"
+    });
+    componentName = response.componentName;
+  }
+  const config = await loadConfig();
+  if (!config) {
+    console.error(
+      "\u274C Configuration file cnp.config.json not found. Run this command from the project root."
+    );
+    return;
+  }
+  const useI18n = !!config.useI18n;
+  const componentNameUpper = capitalize(componentName);
+  const templatePath = join2(
+    import.meta.dir,
+    "..",
+    "..",
+    "templates",
+    "Component"
+  );
+  let messagesPath = null;
+  if (useI18n) {
+    messagesPath = join2(process.cwd(), "messages");
+    if (!existsSync2(messagesPath)) {
+      console.error("\u274C Messages directory missing. Ensure i18n was configured.");
+      return;
+    }
+  }
+  let componentTargetPath;
+  let translationKey;
+  if (pageScope) {
+    if (nestedPath) {
+      componentTargetPath = join2(process.cwd(), "src", "ui", nestedPath);
+      translationKey = pageScope;
+    } else {
+      componentTargetPath = join2(process.cwd(), "src", "ui", pageScope);
+      translationKey = pageScope;
+    }
+  } else {
+    componentTargetPath = join2(process.cwd(), "src", "ui", "_global");
+    translationKey = "_global_ui";
+  }
+  if (!existsSync2(componentTargetPath)) {
+    await mkdir(componentTargetPath, { recursive: true });
+  }
+  const componentFile = join2(componentTargetPath, `${componentNameUpper}.tsx`);
+  const templateComponentPath = join2(templatePath, "Component.tsx");
+  if (existsSync2(templateComponentPath)) {
+    let content = await readFile2(templateComponentPath, "utf-8");
+    content = content.replace(/Component/g, componentNameUpper).replace(/componentPage/g, translationKey);
+    await writeFile(componentFile, content);
+    console.log(`\u{1F4C4} File created: ${componentFile}`);
+  } else {
+    console.error(
+      "\u274C Template Component.tsx introuvable :",
+      templateComponentPath
+    );
+  }
+  if (useI18n && messagesPath) {
+    const entries = await readdir(messagesPath, { withFileTypes: true });
+    const langDirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    const jsonTemplate = join2(templatePath, "component.json");
+    if (!existsSync2(jsonTemplate)) {
+      console.error("\u274C Template component.json not found:", jsonTemplate);
+      return;
+    }
+    const jsonContent = await readFile2(jsonTemplate, "utf-8");
+    const parsed = JSON.parse(jsonContent);
+    for (const locale of langDirs) {
+      const localeDir = join2(messagesPath, locale);
+      if (!existsSync2(localeDir) || !statSync(localeDir).isDirectory())
+        continue;
+      let jsonTarget;
+      if (pageScope) {
+        jsonTarget = join2(messagesPath, locale, `${pageScope}.json`);
+      } else {
+        jsonTarget = join2(messagesPath, locale, `_global_ui.json`);
+      }
+      let current = {};
+      if (existsSync2(jsonTarget)) {
+        const jsonFile = await readFile2(jsonTarget, "utf-8");
+        current = JSON.parse(jsonFile);
+      }
+      current[componentNameUpper] = parsed;
+      await writeFile(jsonTarget, JSON.stringify(current, null, 2));
+    }
+  } else {
+    console.log("\u2139\uFE0F Skipping translation entries; next-intl not enabled.");
+  }
+  console.log(
+    `\u2705 Component "${componentNameUpper}" added ${pageScope ? `to page ${pageScope}` : "globally"}${useI18n ? " with localized messages" : ""}.`
+  );
+}
+
+// src/lib/addPage.ts
+import { join as join3 } from "path";
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2, readdir as readdir2 } from "fs/promises";
+import prompts2 from "prompts";
+import { existsSync as existsSync3, statSync as statSync2 } from "fs";
+async function addPage(args) {
+  let pageName = args[1];
+  if (!pageName || pageName.startsWith("-")) {
+    const response = await prompts2.prompt({
+      type: "text",
+      name: "pageName",
+      message: "\u{1F4DD} Page name to add:",
+      validate: (name) => name ? true : "Page name is required"
+    });
+    pageName = response.pageName;
+  }
+  let parentName = null;
+  let childName = null;
+  if (pageName.includes(".")) {
+    [parentName, childName] = pageName.split(".");
+  }
+  let shortFlags = args.find((arg) => /^-[A-Za-z]+$/.test(arg));
+  let longFlags = new Set(args.filter((a) => a.startsWith("--")));
+  const flags = /* @__PURE__ */ new Set();
+  if (!shortFlags && Array.from(longFlags).length === 0) {
+    shortFlags = "-LPl";
+  }
+  if (shortFlags) {
+    for (const char of shortFlags.slice(1)) {
+      switch (char) {
+        case "L":
+          flags.add("layout");
+          break;
+        case "P":
+          flags.add("page");
+          break;
+        case "l":
+          flags.add("loading");
+          break;
+        case "n":
+          flags.add("not-found");
+          break;
+        case "e":
+          flags.add("error");
+          break;
+        case "g":
+          flags.add("global-error");
+          break;
+        case "r":
+          flags.add("route");
+          break;
+        case "t":
+          flags.add("template");
+          break;
+        case "d":
+          flags.add("default");
+          break;
+      }
+    }
+  }
+  for (const flag of [
+    "layout",
+    "page",
+    "loading",
+    "not-found",
+    "error",
+    "global-error",
+    "route",
+    "template",
+    "default"
+  ]) {
+    if (longFlags.has("--" + flag)) flags.add(flag);
+  }
+  const config = await loadConfig();
+  if (!config) {
+    console.error("\u274C Configuration file cnp.config.json not found. Run this command from the project root.");
+    return;
+  }
+  const useI18n = !!config.useI18n;
+  const srcSegments = ["src", "app"];
+  if (useI18n) srcSegments.push("[locale]");
+  const srcPath = join3(process.cwd(), ...srcSegments);
+  if (!existsSync3(srcPath)) {
+    console.error(`\u274C Expected directory not found: ${srcPath}`);
+    return;
+  }
+  let messagesPath = null;
+  let locales = [];
+  if (useI18n) {
+    messagesPath = join3(process.cwd(), "messages");
+    if (!existsSync3(messagesPath)) {
+      console.error("\u274C Messages directory missing. Ensure i18n was configured.");
+      return;
+    }
+    const entries = await readdir2(messagesPath, { withFileTypes: true });
+    locales = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  }
+  const templatePath = join3(import.meta.dir, "..", "..", "templates", "Page");
+  let uiPageDir, localePagePath, jsonFileName;
+  if (parentName && childName) {
+    uiPageDir = join3(process.cwd(), "src", "ui", parentName, childName);
+    localePagePath = join3(srcPath, parentName, childName);
+    jsonFileName = parentName;
+  } else {
+    uiPageDir = join3(process.cwd(), "src", "ui", pageName);
+    localePagePath = join3(srcPath, pageName);
+    jsonFileName = pageName;
+  }
+  if (!existsSync3(uiPageDir)) {
+    await mkdir2(uiPageDir, { recursive: true });
+  }
+  const uiPageFile = join3(uiPageDir, "page-ui.tsx");
+  const uiPageTemplate = join3(templatePath, "page-ui.tsx");
+  if (existsSync3(uiPageTemplate)) {
+    let uiContent = await readFile3(uiPageTemplate, "utf-8");
+    uiContent = uiContent.replace(/template/g, childName || pageName).replace(/Template/g, capitalize(childName || pageName));
+    await writeFile2(uiPageFile, uiContent);
+    console.log(`\u{1F4C4} File created: ${uiPageFile}`);
+  } else {
+    console.warn("\u26A0\uFE0F Template page-ui.tsx manquant.");
+  }
+  if (!existsSync3(localePagePath)) {
+    await mkdir2(localePagePath, { recursive: true });
+  }
+  for (const flag of flags) {
+    const filename = toFileName(flag);
+    const src = join3(templatePath, filename);
+    const dst = join3(localePagePath, filename);
+    if (!existsSync3(src)) {
+      console.warn(`\u26A0\uFE0F Missing template file: ${filename}`);
+      continue;
+    }
+    const content = await readFile3(src, "utf-8");
+    const replaced = content.replace(/template/g, childName || pageName).replace(/Template/g, capitalize(childName || pageName));
+    await writeFile2(dst, replaced);
+    console.log(`\u{1F4C4} File created: ${dst}`);
+  }
+  if (useI18n && messagesPath) {
+    const jsonTemplate = join3(templatePath, "page.json");
+    if (!existsSync3(jsonTemplate)) {
+      console.warn("\u26A0\uFE0F Missing template page.json.");
+    } else {
+      const content = await readFile3(jsonTemplate, "utf-8");
+      const replaced = content.replace(/template/g, childName || pageName).replace(/Template/g, capitalize(childName || pageName));
+      for (const locale of locales) {
+        const localeDir = join3(messagesPath, locale);
+        if (!existsSync3(localeDir) || !statSync2(localeDir).isDirectory())
+          continue;
+        const jsonTarget = join3(messagesPath, locale, `${jsonFileName}.json`);
+        let current = {};
+        if (existsSync3(jsonTarget)) {
+          const jsonFile = await readFile3(jsonTarget, "utf-8");
+          try {
+            current = JSON.parse(jsonFile);
+          } catch {
+            current = {};
+          }
+        }
+        if (parentName && childName) {
+          current[childName] = JSON.parse(replaced);
+        } else {
+          current = JSON.parse(replaced);
+        }
+        await writeFile2(jsonTarget, JSON.stringify(current, null, 2));
+      }
+    }
+  } else {
+    console.log("\u2139\uFE0F Skipping translation templates; next-intl not enabled.");
+  }
+  console.log(
+    `\u2705 Page "${pageName}" with templates added${useI18n ? " for each locale" : ""}.`
+  );
+}
+
+// src/lib/rmPage.ts
+import { join as join4 } from "path";
+import { writeFile as writeFile3, readdir as readdir3 } from "fs/promises";
+import prompts3 from "prompts";
+import { existsSync as existsSync4 } from "fs";
+async function rmPage(args) {
+  let pageName = args[1];
+  if (!pageName || pageName.startsWith("-")) {
+    const response = await prompts3.prompt({
+      type: "text",
+      name: "pageName",
+      message: "\u{1F5D1}\uFE0F Page name to remove:",
+      validate: (name) => name ? true : "Page name is required"
+    });
+    pageName = response.pageName;
+  }
+  const messagesPath = join4(process.cwd(), "messages");
+  const entries = await readdir3(messagesPath, { withFileTypes: true });
+  const langDirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  for (const locale of langDirs) {
+    const jsonTarget = join4(messagesPath, locale, `${pageName}.json`);
+    if (existsSync4(jsonTarget)) {
+      await writeFile3(jsonTarget, "");
+      await import("child_process").then(
+        (cp2) => cp2.execSync(`rm -f '${jsonTarget}'`)
+      );
+      console.log(`\u{1F5D1}\uFE0F Deleted: ${jsonTarget}`);
+    }
+  }
+  const uiPageDir = join4(process.cwd(), "src", "ui", pageName);
+  if (existsSync4(uiPageDir)) {
+    await import("child_process").then(
+      (cp2) => cp2.execSync(`rm -rf '${uiPageDir}'`)
+    );
+    console.log(`\u{1F5D1}\uFE0F Deleted: ${uiPageDir}`);
+  }
+  const appLocaleDir = join4(process.cwd(), "src", "app", "[locale]", pageName);
+  if (existsSync4(appLocaleDir)) {
+    await import("child_process").then(
+      (cp2) => cp2.execSync(`rm -rf '${appLocaleDir}'`)
+    );
+    console.log(`\u{1F5D1}\uFE0F Deleted: ${appLocaleDir}`);
+  }
+  console.log(`\u2705 Page "${pageName}" deleted.`);
+}
+
+// src/scaffold.ts
+import { cp, mkdir as mkdir3, rm, writeFile as writeFile4, readFile as readFile4 } from "fs/promises";
+import { join as join5 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { fileURLToPath } from "url";
+async function scaffoldProject(options) {
+  const targetPath = join5(process.cwd(), options.projectName);
+  const __dirname2 = new URL(".", import.meta.url);
+  const templatePath = join5(
+    fileURLToPath(__dirname2),
+    "..",
+    "templates",
+    "Projects",
+    "default"
+  );
+  if (existsSync5(targetPath)) {
+    if (options.force) {
+      console.warn("\u26A0\uFE0F Target directory already exists, removing...");
+      await rm(targetPath, { recursive: true, force: true });
+    } else {
+      console.error(
+        "\u274C Target directory already exists. Use --force to overwrite."
+      );
+      process.exit(1);
+    }
+  }
+  try {
+    console.log("\u{1F4C1} Creating project directory...");
+    await mkdir3(targetPath, { recursive: true });
+    console.log("\u{1F4E6} Copying files from template...");
+    await cp(templatePath, targetPath, { recursive: true });
+    const pkgPath = join5(targetPath, "package.json");
+    if (existsSync5(pkgPath)) {
+      const pkg = JSON.parse(await readFile4(pkgPath, "utf-8"));
+      pkg.dependencies = pkg.dependencies || {};
+      if (options.useI18n) {
+        pkg.dependencies["next-intl"] = pkg.dependencies["next-intl"] || "^4.3.5";
+      }
+      await writeFile4(pkgPath, JSON.stringify(pkg, null, 2));
+    }
+    await writeFile4(
+      join5(targetPath, "cnp.config.json"),
+      JSON.stringify(options, null, 2)
+    );
+    console.log("\u2705 Project scaffolded successfully!");
+    console.log(`\u27A1\uFE0F  cd ${options.projectName} && bun install && bun dev`);
+  } catch (err) {
+    console.error("\u274C Error during scaffolding:", err);
+    process.exit(1);
+  }
+}
+
+// src/lib/createProject.ts
+async function createProject(nameArg, force) {
+  const response = {
+    projectName: nameArg,
+    useTypescript: true,
+    useEslint: true,
+    useTailwind: true,
+    useSrcDir: true,
+    useTurbopack: true,
+    useI18n: true,
+    customAlias: true,
+    importAlias: "@/*",
+    force
+  };
+  console.log(`\u{1F4E6} Creating project "${response.projectName}"...`);
+  await scaffoldProject(response);
+}
+
+// src/lib/createProjectWithPrompt.ts
+import prompts4 from "prompts";
+async function createProjectWithPrompt() {
+  const response = await prompts4.prompt([
+    {
+      type: "text",
+      name: "projectName",
+      message: "\u{1F9F1} Project name:",
+      initial: "my-next-app"
+    },
+    {
+      type: "toggle",
+      name: "useTypescript",
+      message: "\u2714 Use TypeScript?",
+      initial: true,
+      active: "Yes",
+      inactive: "No"
+    },
+    {
+      type: "toggle",
+      name: "useEslint",
+      message: "\u2714 Use ESLint?",
+      initial: true,
+      active: "Yes",
+      inactive: "No"
+    },
+    {
+      type: "toggle",
+      name: "useTailwind",
+      message: "\u2714 Use Tailwind CSS?",
+      initial: true,
+      active: "Yes",
+      inactive: "No"
+    },
+    {
+      type: "toggle",
+      name: "useSrcDir",
+      message: "\u2714 Use `src/` directory?",
+      initial: true,
+      active: "Yes",
+      inactive: "No"
+    },
+    {
+      type: "toggle",
+      name: "useTurbopack",
+      message: "\u2714 Use Turbopack for `next dev`?",
+      initial: true,
+      active: "Yes",
+      inactive: "No"
+    },
+    {
+      type: "toggle",
+      name: "useI18n",
+      message: "\u2714 Use i18n with next-intl for translations?",
+      initial: true,
+      active: "Yes",
+      inactive: "No"
+    },
+    {
+      type: "toggle",
+      name: "customAlias",
+      message: "\u2714 Customize import alias (`@/*` by default)?",
+      initial: true,
+      active: "Yes",
+      inactive: "No"
+    },
+    {
+      type: (prev) => prev ? "text" : null,
+      name: "importAlias",
+      message: "\u2714 What import alias would you like?",
+      initial: "@core/*"
+    }
+  ]);
+  console.log("\n\u2705 Your choices:");
+  console.log(response);
+  await scaffoldProject(response);
+}
+
+// src/index.ts
+var CONFIG_DIR = process.env.XDG_CONFIG_HOME ? path.join(process.env.XDG_CONFIG_HOME, "create-next-pro") : path.join(os.homedir(), ".config", "create-next-pro");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+function readCfg() {
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeCfg(cfg) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2));
+}
+function rcFile(shell) {
+  return path.join(os.homedir(), shell === "zsh" ? ".zshrc" : ".bashrc");
+}
+function ensureLineInRc(file, line) {
+  try {
+    const cur = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+    if (!cur.includes(line)) fs.appendFileSync(file, `
+${line}
+`);
+  } catch {
+  }
+}
+async function installCompletion(shell) {
+  const __dirname2 = path.dirname(fileURLToPath2(import.meta.url));
+  const completionSrc = path.resolve(
+    __dirname2,
+    "../create-next-pro-completion.sh"
+  );
+  const completionDst = path.join(CONFIG_DIR, "completion.sh");
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.copyFileSync(completionSrc, completionDst);
+  ensureLineInRc(rcFile(shell), `source "${completionDst}"`);
+}
+var __filename = fileURLToPath2(import.meta.url);
+var __dirname = dirname(__filename);
+var packageJsonPath = resolve(__dirname, "../package.json");
+var packageJson = fs.readFileSync(packageJsonPath, "utf8");
+async function onboarding() {
+  const pkg = JSON.parse(packageJson);
+  console.log(`\u{1F680} Welcome to create-next-pro v${pkg.version}
+`);
+  const res = await prompts5(
+    [
+      {
+        type: "select",
+        name: "shell",
+        message: "Which shell do you use?",
+        choices: [
+          { title: "zsh", value: "zsh" },
+          { title: "bash", value: "bash" }
+        ],
+        initial: (os.userInfo().shell || "").includes("zsh") ? 0 : 1
+      },
+      {
+        type: "toggle",
+        name: "completion",
+        message: "Install autocompletion?",
+        initial: true,
+        active: "Yes",
+        inactive: "No"
+      }
+    ],
+    { onCancel: () => process.exit(1) }
+  );
+  const cfg = {
+    version: 1,
+    shell: res.shell,
+    completionInstalled: !!res.completion,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (cfg.completionInstalled) await installCompletion(cfg.shell);
+  writeCfg(cfg);
+  console.log("\n\u2705 Configuration saved.");
+  console.log("you can now use the CLI ! ex : create-next-pro <project-name>");
+  console.log(
+    "For more information, visit: https://github.com/Rising-Corporation/create-next-pro-cli"
+  );
+  console.log("Happy coding!  \u{1F389}");
+  return cfg;
+}
+function showHelp() {
+  console.log(`create-next-pro
+
+Usage:
+  create-next-pro <project-name> [--force]
+  create-next-pro addpage [options]
+  create-next-pro addcomponent [options]
+  create-next-pro rmpage [options]
+
+Options:
+  --help          Show this help message
+  --reconfigure   Run the configuration assistant again
+`);
+}
+function showVersion() {
+  const pkg = JSON.parse(packageJson);
+  console.log(`v${pkg.version}`);
+}
+async function main() {
+  let args;
+  if (typeof Bun !== "undefined") {
+    args = Bun.argv.slice(2);
+  } else if (typeof process !== "undefined" && process.argv) {
+    args = process.argv.slice(2);
+  } else {
+    args = [];
+  }
+  if (args.includes("--help")) return showHelp();
+  if (args.includes("--version") || args.includes("-v")) return showVersion();
+  if (args.includes("--reconfigure") || !readCfg()) {
+    await onboarding();
+    return;
+  }
+  const force = args.includes("--force");
+  if (args[0] === "addpage" && args.length === 1) {
+    args.push("-LPl");
+  }
+  if (args[0] === "addcomponent") {
+    addComponent(args);
+    return;
+  }
+  if (args[0] === "addpage") {
+    addPage(args);
+    return;
+  }
+  if (args[0] === "rmpage") {
+    rmPage(args);
+    return;
+  }
+  const nameArg = args.find((arg) => !arg.startsWith("--"));
+  if (nameArg) {
+    createProject(nameArg, force);
+    return;
+  }
+  await createProjectWithPrompt();
+}
+
+// bin.node.ts
+main();
+//# sourceMappingURL=bin.node.js.map