@configjs/cli 1.1.3 → 1.1.5

package/dist/vue-setup-X65P3CZX.js

@@ -0,0 +1,91 @@
+import {
+  getTranslations
+} from "./chunk-3V72QFFY.js";
+import "./chunk-QGM4M3NI.js";
+
+// src/cli/prompts/vue-setup.ts
+import inquirer from "inquirer";
+async function promptVueSetup(language) {
+  const t = getTranslations(language);
+  const answers = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "shouldCreate",
+      message: t.vue.proposeSetup,
+      default: true
+    },
+    {
+      type: "input",
+      name: "projectName",
+      message: t.vue.projectName,
+      default: t.vue.projectNamePlaceholder,
+      when: (answers2) => answers2.shouldCreate === true,
+      validate: (input) => {
+        if (!input || input.trim().length === 0) {
+          return t.vue.validation.empty;
+        }
+        if (!/^[a-z0-9-_]+$/i.test(input)) {
+          return t.vue.validation.invalid;
+        }
+        return true;
+      }
+    },
+    {
+      type: "confirm",
+      name: "typescript",
+      message: t.vue.typescript,
+      default: true,
+      when: (answers2) => answers2.shouldCreate === true
+    },
+    {
+      type: "confirm",
+      name: "router",
+      message: t.vue.router,
+      default: true,
+      when: (answers2) => answers2.shouldCreate === true
+    },
+    {
+      type: "confirm",
+      name: "pinia",
+      message: t.vue.pinia,
+      default: true,
+      when: (answers2) => answers2.shouldCreate === true
+    },
+    {
+      type: "confirm",
+      name: "vitest",
+      message: t.vue.vitest,
+      default: true,
+      when: (answers2) => answers2.shouldCreate === true
+    },
+    {
+      type: "confirm",
+      name: "eslint",
+      message: t.vue.eslint,
+      default: true,
+      when: (answers2) => answers2.shouldCreate === true
+    },
+    {
+      type: "confirm",
+      name: "prettier",
+      message: t.vue.prettier,
+      default: true,
+      when: (answers2) => answers2.shouldCreate === true
+    }
+  ]);
+  if (!answers.shouldCreate) {
+    return null;
+  }
+  return {
+    projectName: answers.projectName.trim(),
+    typescript: answers.typescript,
+    router: answers.router,
+    pinia: answers.pinia,
+    vitest: answers.vitest,
+    eslint: answers.eslint,
+    prettier: answers.prettier
+  };
+}
+export {
+  promptVueSetup
+};

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@configjs/cli",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "type": "module",
   "description": "Configure your frontend stack, instantly - Utilitaire CLI d'installation modulaire de bibliothèques frontend",
   "keywords": [
     "cli",
     "react",
+    "nextjs",
+    "vue",
     "installer",
     "configuration",
     "setup",
@@ -77,6 +79,7 @@
     "eslint-plugin-prettier": "^5.5.4",
     "husky": "^9.1.7",
     "lint-staged": "^16.2.7",
+    "memfs": "^4.51.1",
     "prettier": "^3.7.4",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
@@ -92,4 +95,4 @@
       "prettier --write"
     ]
   }
-}
+}

package/dist/chunk-QRFLHLFE.js

@@ -1,300 +0,0 @@
-// src/utils/logger.ts
-import pc from "picocolors";
-var Logger = class {
-  level = 1 /* INFO */;
-  setLevel(level) {
-    this.level = level;
-  }
-  debug(message, ...args) {
-    if (this.level <= 0 /* DEBUG */) {
-      console.log(pc.gray(`[DEBUG] ${message}`), ...args);
-    }
-  }
-  info(message, ...args) {
-    if (this.level <= 1 /* INFO */) {
-      console.log(pc.cyan(`\u2139 ${message}`), ...args);
-    }
-  }
-  success(message, ...args) {
-    if (this.level <= 1 /* INFO */) {
-      console.log(pc.green(`\u2713 ${message}`), ...args);
-    }
-  }
-  warn(message, ...args) {
-    if (this.level <= 2 /* WARN */) {
-      console.warn(pc.yellow(`\u26A0\uFE0F  ${message}`), ...args);
-    }
-  }
-  error(message, ...args) {
-    if (this.level <= 3 /* ERROR */) {
-      console.error(pc.red(`\u2716 ${message}`), ...args);
-    }
-  }
-  header(message) {
-    if (this.level <= 1 /* INFO */) {
-      console.log();
-      console.log(pc.bold(pc.magenta(`\u25C6 ${message}`)));
-      console.log();
-    }
-  }
-  section(title) {
-    if (this.level <= 1 /* INFO */) {
-      console.log();
-      console.log(pc.bold(pc.cyan(`\u25B8 ${title}`)));
-    }
-  }
-  item(message, color = "gray") {
-    if (this.level <= 1 /* INFO */) {
-      const colorFn = pc[color];
-      console.log(colorFn(`  \u2022 ${message}`));
-    }
-  }
-  dim(message) {
-    if (this.level <= 1 /* INFO */) {
-      console.log(pc.gray(`  ${message}`));
-    }
-  }
-  step(message) {
-    if (this.level <= 1 /* INFO */) {
-      console.log(pc.cyan(`
-\u2192 ${message}`));
-    }
-  }
-  box(title, content) {
-    if (this.level <= 1 /* INFO */) {
-      const maxLength = Math.max(
-        title.length,
-        ...content.map((line) => line.length)
-      );
-      const border = "\u2500".repeat(maxLength + 4);
-      console.log(pc.cyan(`\u250C${border}\u2510`));
-      console.log(pc.cyan(`\u2502  ${title.padEnd(maxLength)}  \u2502`));
-      console.log(pc.cyan(`\u251C${border}\u2524`));
-      content.forEach((line) => {
-        console.log(pc.cyan(`\u2502  ${line.padEnd(maxLength)}  \u2502`));
-      });
-      console.log(pc.cyan(`\u2514${border}\u2518`));
-    }
-  }
-};
-var logger = new Logger();
-
-// src/utils/fs-helpers.ts
-import fs from "fs-extra";
-import { resolve, dirname, extname } from "path";
-function normalizePath(path) {
-  return path.replace(/\\/g, "/");
-}
-async function readPackageJson(root) {
-  const packageJsonPath = resolve(root, "package.json");
-  if (!await fs.pathExists(packageJsonPath)) {
-    throw new Error(`package.json not found at ${packageJsonPath}`);
-  }
-  try {
-    const pkg = await fs.readJson(packageJsonPath);
-    logger.debug(`Read package.json from ${packageJsonPath}`);
-    return pkg;
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(
-      `Failed to read package.json: ${errorMessage}. File may be invalid JSON.`
-    );
-  }
-}
-async function writePackageJson(root, pkg) {
-  const packageJsonPath = resolve(root, "package.json");
-  try {
-    await fs.writeJson(packageJsonPath, pkg, {
-      spaces: 2,
-      EOL: "\n"
-    });
-    logger.debug(`Wrote package.json to ${packageJsonPath}`);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to write package.json: ${errorMessage}`);
-  }
-}
-async function readTsConfig(root) {
-  const possiblePaths = [
-    resolve(root, "tsconfig.json"),
-    resolve(root, "tsconfig.app.json"),
-    resolve(root, "tsconfig.node.json")
-  ];
-  for (const tsconfigPath of possiblePaths) {
-    if (await fs.pathExists(tsconfigPath)) {
-      try {
-        const config = await fs.readJson(tsconfigPath);
-        logger.debug(`Read tsconfig.json from ${tsconfigPath}`);
-        return config;
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logger.warn(
-          `Failed to parse tsconfig.json at ${tsconfigPath}: ${errorMessage}`
-        );
-        return null;
-      }
-    }
-  }
-  logger.debug("No tsconfig.json found");
-  return null;
-}
-async function checkPathExists(path) {
-  const fullPath = resolve(path);
-  return fs.pathExists(fullPath);
-}
-async function ensureDirectory(path) {
-  const fullPath = resolve(path);
-  try {
-    await fs.ensureDir(fullPath);
-    logger.debug(`Ensured directory exists: ${fullPath}`);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to create directory ${fullPath}: ${errorMessage}`);
-  }
-}
-async function readFileContent(filePath, encoding = "utf-8") {
-  const fullPath = resolve(filePath);
-  if (!await fs.pathExists(fullPath)) {
-    throw new Error(`File not found: ${fullPath}`);
-  }
-  try {
-    const content = await fs.readFile(fullPath, encoding);
-    logger.debug(`Read file: ${fullPath}`);
-    return content;
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to read file ${fullPath}: ${errorMessage}`);
-  }
-}
-async function writeFileContent(filePath, content, encoding = "utf-8") {
-  const fullPath = resolve(filePath);
-  const parentDir = dirname(fullPath);
-  await ensureDirectory(parentDir);
-  try {
-    await fs.writeFile(fullPath, content, encoding);
-    logger.debug(`Wrote file: ${fullPath}`);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to write file ${fullPath}: ${errorMessage}`);
-  }
-}
-
-// src/utils/package-manager.ts
-import { execa } from "execa";
-import fs2 from "fs-extra";
-import { resolve as resolve2, join } from "path";
-async function detectPackageManager(projectRoot) {
-  const root = resolve2(projectRoot);
-  const lockfiles = [
-    { file: "pnpm-lock.yaml", manager: "pnpm" },
-    { file: "yarn.lock", manager: "yarn" },
-    { file: "package-lock.json", manager: "npm" },
-    { file: "bun.lockb", manager: "bun" }
-  ];
-  for (const { file, manager } of lockfiles) {
-    const lockfilePath = join(root, file);
-    if (await fs2.pathExists(lockfilePath)) {
-      logger.debug(`Detected package manager: ${manager} (found ${file})`);
-      return manager;
-    }
-  }
-  logger.debug("No lockfile found, defaulting to npm");
-  return "npm";
-}
-async function installPackages(packages, options) {
-  if (packages.length === 0) {
-    logger.warn("No packages to install");
-    return { success: true, packages: [] };
-  }
-  const {
-    packageManager,
-    projectRoot,
-    dev = false,
-    exact = false,
-    silent = false
-  } = options;
-  logger.info(
-    `Installing ${packages.length} package(s) with ${packageManager}...`
-  );
-  try {
-    const command = getInstallCommand(packageManager, packages, { dev, exact });
-    const cwd = resolve2(projectRoot);
-    logger.debug(`Executing: ${command.join(" ")} in ${cwd}`);
-    const [cmd, ...args] = command;
-    if (!cmd) {
-      throw new Error("Command is empty");
-    }
-    const result = await execa(cmd, args, {
-      cwd,
-      stdio: silent ? "pipe" : "inherit",
-      env: {
-        ...process.env,
-        // Désactiver les prompts interactifs
-        npm_config_yes: "true",
-        YARN_ENABLE_IMMUTABLE_INSTALLS: "false"
-      }
-    });
-    if (result.exitCode !== 0) {
-      throw new Error(`Installation failed with exit code ${result.exitCode}`);
-    }
-    logger.success(`Successfully installed ${packages.length} package(s)`);
-    return {
-      success: true,
-      packages
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    logger.error(`Failed to install packages: ${errorMessage}`);
-    return {
-      success: false,
-      packages,
-      error: errorMessage
-    };
-  }
-}
-function getInstallCommand(packageManager, packages, options) {
-  const { dev, exact } = options;
-  switch (packageManager) {
-    case "pnpm":
-      return [
-        "pnpm",
-        "add",
-        ...dev ? ["-D"] : [],
-        ...exact ? ["--save-exact"] : [],
-        ...packages
-      ];
-    case "yarn":
-      return [
-        "yarn",
-        "add",
-        ...dev ? ["--dev"] : [],
-        ...exact ? ["--exact"] : [],
-        ...packages
-      ];
-    case "bun":
-      return ["bun", "add", ...dev ? ["--dev"] : [], ...packages];
-    case "npm":
-    default:
-      return [
-        "npm",
-        "install",
-        ...dev ? ["--save-dev"] : [],
-        ...exact ? ["--save-exact"] : [],
-        ...packages
-      ];
-  }
-}
-
-export {
-  logger,
-  normalizePath,
-  readPackageJson,
-  writePackageJson,
-  readTsConfig,
-  checkPathExists,
-  ensureDirectory,
-  readFileContent,
-  writeFileContent,
-  detectPackageManager,
-  installPackages
-};

package/dist/chunk-VJ254HJY.js

@@ -1,214 +0,0 @@
-import {
-  logger
-} from "./chunk-QRFLHLFE.js";
-
-// src/core/validator.ts
-var CompatibilityValidator = class {
-  /**
-   * @param rules - Règles de compatibilité à appliquer
-   */
-  constructor(rules) {
-    this.rules = rules;
-  }
-  /**
-   * Valide la compatibilité d'un ensemble de plugins
-   *
-   * @param plugins - Liste des plugins à valider
-   * @returns Résultat de la validation avec erreurs, warnings et suggestions
-   *
-   * @example
-   * ```typescript
-   * const result = validator.validate([plugin1, plugin2, plugin3])
-   * if (!result.valid) {
-   *   // Gérer les erreurs
-   * }
-   * ```
-   */
-  validate(plugins) {
-    logger.debug(`Validating ${plugins.length} plugin(s)`);
-    const pluginNames = new Set(plugins.map((p) => p.name));
-    const allConflicts = this.checkConflicts(plugins, pluginNames);
-    const conflictErrors = [];
-    const conflictWarnings = [];
-    for (const conflict of allConflicts) {
-      const rule = this.rules.find(
-        (r) => r.type === "CONFLICT" && r.plugins?.every((p) => conflict.plugins?.includes(p))
-      );
-      if (rule?.severity === "error") {
-        conflictErrors.push(conflict);
-      } else {
-        conflictWarnings.push(conflict);
-      }
-    }
-    const errors = [
-      ...this.checkExclusivity(plugins, pluginNames),
-      ...conflictErrors,
-      ...this.checkDependencies(plugins, pluginNames)
-    ];
-    const warnings = conflictWarnings;
-    const suggestions = this.checkRecommendations(plugins, pluginNames);
-    const valid = errors.length === 0;
-    logger.debug(`Validation result: ${valid ? "valid" : "invalid"}`, {
-      errors: errors.length,
-      warnings: warnings.length,
-      suggestions: suggestions.length
-    });
-    return {
-      valid,
-      errors,
-      warnings,
-      suggestions
-    };
-  }
-  /**
-   * Vérifie les règles d'exclusivité (EXCLUSIVE)
-   *
-   * @param _plugins - Liste des plugins (non utilisée, conservée pour cohérence)
-   * @param pluginNames - Set des noms de plugins pour lookup rapide
-   * @returns Liste des erreurs d'exclusivité
-   *
-   * @internal
-   */
-  checkExclusivity(_plugins, pluginNames) {
-    const errors = [];
-    for (const rule of this.rules) {
-      if (rule.type !== "EXCLUSIVE" || !rule.plugins) {
-        continue;
-      }
-      const selectedExclusivePlugins = rule.plugins.filter(
-        (pluginName) => pluginNames.has(pluginName)
-      );
-      if (selectedExclusivePlugins.length > 1) {
-        errors.push({
-          type: "EXCLUSIVE",
-          plugins: selectedExclusivePlugins,
-          message: rule.reason,
-          canOverride: rule.allowOverride ?? false
-        });
-      }
-    }
-    return errors;
-  }
-  /**
-   * Vérifie les conflits entre plugins (CONFLICT)
-   *
-   * @param _plugins - Liste des plugins (non utilisée, conservée pour cohérence)
-   * @param pluginNames - Set des noms de plugins pour lookup rapide
-   * @returns Liste des warnings/erreurs de conflit
-   *
-   * @internal
-   */
-  checkConflicts(_plugins, pluginNames) {
-    const conflicts = [];
-    for (const rule of this.rules) {
-      if (rule.type !== "CONFLICT" || !rule.plugins) {
-        continue;
-      }
-      const conflictingPlugins = rule.plugins.filter(
-        (pluginName) => pluginNames.has(pluginName)
-      );
-      if (conflictingPlugins.length > 1) {
-        conflicts.push({
-          type: "CONFLICT",
-          plugins: conflictingPlugins,
-          message: rule.reason,
-          canOverride: rule.allowOverride ?? true
-        });
-      }
-    }
-    return conflicts;
-  }
-  /**
-   * Vérifie les dépendances requises (REQUIRES)
-   *
-   * @param _plugins - Liste des plugins (non utilisée, conservée pour cohérence)
-   * @param pluginNames - Set des noms de plugins pour lookup rapide
-   * @returns Liste des erreurs de dépendances manquantes
-   *
-   * @internal
-   */
-  checkDependencies(_plugins, pluginNames) {
-    const errors = [];
-    for (const rule of this.rules) {
-      if (rule.type !== "REQUIRES" || !rule.plugin || !rule.requires) {
-        continue;
-      }
-      if (!pluginNames.has(rule.plugin)) {
-        continue;
-      }
-      const missingDependencies = rule.requires.filter(
-        (dep) => !pluginNames.has(dep)
-      );
-      if (missingDependencies.length > 0) {
-        errors.push({
-          type: "REQUIRES",
-          plugin: rule.plugin,
-          required: missingDependencies.join(", "),
-          message: `${rule.plugin} requires: ${missingDependencies.join(", ")}. ${rule.reason}`,
-          canOverride: rule.allowOverride ?? false
-        });
-      }
-    }
-    return errors;
-  }
-  /**
-   * Vérifie les recommandations (RECOMMENDS)
-   *
-   * @param _plugins - Liste des plugins (non utilisée, conservée pour cohérence)
-   * @param pluginNames - Set des noms de plugins pour lookup rapide
-   * @returns Liste des suggestions de plugins recommandés
-   *
-   * @internal
-   */
-  checkRecommendations(_plugins, pluginNames) {
-    const suggestions = [];
-    for (const rule of this.rules) {
-      if (rule.type !== "RECOMMENDS" || !rule.plugin || !rule.recommends) {
-        continue;
-      }
-      if (!pluginNames.has(rule.plugin)) {
-        continue;
-      }
-      const missingRecommendations = rule.recommends.filter(
-        (rec) => !pluginNames.has(rec)
-      );
-      if (missingRecommendations.length > 0) {
-        suggestions.push(
-          `${rule.plugin} recommends: ${missingRecommendations.join(", ")}. ${rule.reason}`
-        );
-      }
-    }
-    return suggestions;
-  }
-};
-var compatibilityRules = [
-  // Exclusivités - State Management
-  {
-    type: "EXCLUSIVE",
-    plugins: ["@reduxjs/toolkit", "zustand", "jotai"],
-    reason: "Une seule solution de state management est recommand\xE9e",
-    severity: "error",
-    allowOverride: false
-  },
-  // Conflits - CSS Frameworks
-  {
-    type: "CONFLICT",
-    plugins: ["tailwindcss", "bootstrap"],
-    reason: "Approches CSS potentiellement conflictuelles",
-    severity: "warning",
-    allowOverride: true
-  },
-  // Recommandations - React Router
-  {
-    type: "RECOMMENDS",
-    plugin: "react-router-dom",
-    recommends: ["@types/react-router-dom"],
-    reason: "Types TypeScript recommand\xE9s pour une meilleure exp\xE9rience de d\xE9veloppement",
-    severity: "info"
-  }
-];
-
-export {
-  CompatibilityValidator,
-  compatibilityRules
-};