@configjs/cli 1.1.4 → 1.1.5

package/dist/chunk-D37FHAGO.js

@@ -0,0 +1,569 @@
+import {
+  pluginRegistry
+} from "./chunk-V75HW2AM.js";
+import {
+  logger
+} from "./chunk-HM2JWJOO.js";
+
+// src/core/compatibility-generator.ts
+function generateCompatibilityRules(plugins) {
+  logger.debug(
+    `Generating compatibility rules from ${plugins.length} plugin(s)`
+  );
+  const rules = [];
+  rules.push(...generateExclusiveRules(plugins));
+  rules.push(...generateConflictRules(plugins));
+  rules.push(...generateRequiresRules(plugins));
+  rules.push(...generateRecommendsRules(plugins));
+  logger.debug(`Generated ${rules.length} compatibility rule(s)`);
+  return rules;
+}
+function generateExclusiveRules(plugins) {
+  const rules = [];
+  const pluginsByCategory = /* @__PURE__ */ new Map();
+  for (const plugin of plugins) {
+    const category = plugin.category;
+    if (!pluginsByCategory.has(category)) {
+      pluginsByCategory.set(category, []);
+    }
+    const arr = pluginsByCategory.get(category);
+    if (arr) {
+      arr.push(plugin);
+    }
+  }
+  for (const [category, categoryPlugins] of pluginsByCategory.entries()) {
+    if (categoryPlugins.length < 2) {
+      continue;
+    }
+    const exclusiveCategories = [
+      "state" /* STATE */,
+      // Un seul state management
+      "routing" /* ROUTING */,
+      // Un seul routing
+      "css" /* CSS */
+      // Un seul framework CSS (peut être flexible selon le cas)
+    ];
+    if (!exclusiveCategories.includes(category)) {
+      continue;
+    }
+    const pluginNames = categoryPlugins.map((p) => p.name);
+    const severity = category === "css" /* CSS */ ? "warning" : "error";
+    const allowOverride = category === "css" /* CSS */;
+    rules.push({
+      type: "EXCLUSIVE",
+      plugins: pluginNames,
+      reason: getExclusiveReason(category),
+      severity,
+      allowOverride
+    });
+  }
+  return rules;
+}
+function getExclusiveReason(category) {
+  switch (category) {
+    case "state" /* STATE */:
+      return "Une seule solution de state management est recommand\xE9e";
+    case "routing" /* ROUTING */:
+      return "Un seul syst\xE8me de routing est recommand\xE9";
+    case "css" /* CSS */:
+      return "Approches CSS potentiellement conflictuelles";
+    default:
+      return "Ces plugins sont mutuellement exclusifs";
+  }
+}
+function generateConflictRules(plugins) {
+  const rules = [];
+  for (const plugin of plugins) {
+    if (!plugin.incompatibleWith || plugin.incompatibleWith.length === 0) {
+      continue;
+    }
+    for (const incompatiblePluginName of plugin.incompatibleWith) {
+      const incompatiblePlugin = plugins.find(
+        (p) => p.name === incompatiblePluginName
+      );
+      if (!incompatiblePlugin) {
+        logger.warn(
+          `Plugin ${plugin.name} declares incompatibleWith ${incompatiblePluginName}, but plugin not found in registry`
+        );
+        continue;
+      }
+      const commonFrameworks = plugin.frameworks.filter(
+        (f) => incompatiblePlugin.frameworks.includes(f)
+      );
+      const isCssConflict = plugin.category === "css" /* CSS */ && incompatiblePlugin.category === "css" /* CSS */;
+      const severity = isCssConflict ? "warning" : "error";
+      const allowOverride = isCssConflict;
+      if (commonFrameworks.length === 0) {
+        rules.push({
+          type: "CONFLICT",
+          plugins: [plugin.name, incompatiblePluginName],
+          reason: `${plugin.displayName} est incompatible avec ${incompatiblePlugin.displayName}`,
+          severity,
+          allowOverride
+        });
+      } else {
+        for (const framework of commonFrameworks) {
+          rules.push({
+            type: "CONFLICT",
+            plugins: [plugin.name, incompatiblePluginName],
+            framework,
+            reason: `${plugin.displayName} est incompatible avec ${incompatiblePlugin.displayName} pour ${framework}`,
+            severity,
+            allowOverride
+          });
+        }
+      }
+    }
+  }
+  return rules;
+}
+function generateRequiresRules(plugins) {
+  const rules = [];
+  for (const plugin of plugins) {
+    if (!plugin.requires || plugin.requires.length === 0) {
+      continue;
+    }
+    for (const framework of plugin.frameworks) {
+      rules.push({
+        type: "REQUIRES",
+        plugin: plugin.name,
+        requires: plugin.requires,
+        framework,
+        reason: `${plugin.displayName} n\xE9cessite les d\xE9pendances suivantes: ${plugin.requires.join(", ")}`,
+        severity: "error",
+        allowOverride: false
+      });
+    }
+  }
+  return rules;
+}
+function generateRecommendsRules(plugins) {
+  const rules = [];
+  for (const plugin of plugins) {
+    if (!plugin.recommends || plugin.recommends.length === 0) {
+      continue;
+    }
+    for (const framework of plugin.frameworks) {
+      rules.push({
+        type: "RECOMMENDS",
+        plugin: plugin.name,
+        recommends: plugin.recommends,
+        framework,
+        reason: `${plugin.displayName} recommande d'installer: ${plugin.recommends.join(", ")}`,
+        severity: "info"
+      });
+    }
+  }
+  return rules;
+}
+
+// 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
+   * @param ctx - Contexte du projet (optionnel, pour règles spécifiques framework)
+   * @returns Résultat de la validation avec erreurs, warnings et suggestions
+   *
+   * @example
+   * ```typescript
+   * const result = validator.validate([plugin1, plugin2, plugin3], ctx)
+   * if (!result.valid) {
+   *   // Gérer les erreurs
+   * }
+   * ```
+   */
+  validate(plugins, ctx) {
+    logger.debug(`Validating ${plugins.length} plugin(s)`);
+    const pluginNames = new Set(plugins.map((p) => p.name));
+    const applicableRules = ctx ? this.rules.filter(
+      (rule) => !rule.framework || rule.framework === ctx.framework
+    ) : this.rules.filter((rule) => !rule.framework);
+    const allConflicts = this.checkConflicts(
+      plugins,
+      pluginNames,
+      applicableRules
+    );
+    const conflictErrors = [];
+    const conflictWarnings = [];
+    for (const conflict of allConflicts) {
+      const rule = applicableRules.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 frameworkConflicts = ctx ? this.checkFrameworkConflicts(plugins, pluginNames, ctx, applicableRules) : [];
+    const frameworkErrors = [];
+    const frameworkWarnings = [];
+    for (const conflict of frameworkConflicts) {
+      const rule = applicableRules.find(
+        (r) => r.type === "CONFLICT" && r.framework === ctx?.framework && r.plugins?.some((p) => conflict.plugins?.includes(p))
+      );
+      if (rule?.severity === "error") {
+        frameworkErrors.push(conflict);
+      } else {
+        frameworkWarnings.push(conflict);
+      }
+    }
+    const exclusivityResults = this.checkExclusivity(
+      plugins,
+      pluginNames,
+      applicableRules
+    );
+    const exclusivityErrors = [];
+    const exclusivityWarnings = [];
+    for (const result of exclusivityResults) {
+      const rule = applicableRules.find(
+        (r) => r.type === "EXCLUSIVE" && result.plugins?.every((p) => r.plugins?.includes(p))
+      );
+      if (rule?.severity === "warning") {
+        exclusivityWarnings.push(result);
+      } else {
+        exclusivityErrors.push(result);
+      }
+    }
+    const errors = [
+      ...exclusivityErrors,
+      ...conflictErrors,
+      ...this.checkDependencies(plugins, pluginNames, applicableRules, ctx),
+      ...frameworkErrors
+    ];
+    const warnings = [
+      ...exclusivityWarnings,
+      ...conflictWarnings,
+      ...frameworkWarnings
+    ];
+    const suggestions = this.checkRecommendations(
+      plugins,
+      pluginNames,
+      applicableRules
+    );
+    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 conflits avec le framework
+   *
+   * @param _plugins - Liste des plugins (non utilisée, conservée pour cohérence)
+   * @param pluginNames - Set des noms de plugins pour lookup rapide
+   * @param ctx - Contexte du projet
+   * @param rules - Règles applicables
+   * @returns Liste des erreurs/warnings de conflit framework
+   *
+   * @internal
+   */
+  checkFrameworkConflicts(_plugins, pluginNames, ctx, rules) {
+    const conflicts = [];
+    for (const rule of rules) {
+      if (rule.type !== "CONFLICT" || !rule.framework || rule.framework !== ctx.framework) {
+        continue;
+      }
+      if (rule.plugins && rule.plugins.length > 0) {
+        const conflictingPlugins = rule.plugins.filter(
+          (pluginName) => pluginNames.has(pluginName)
+        );
+        const isFrameworkIncompatible = rule.plugins.length === 1;
+        const shouldReportConflict = isFrameworkIncompatible ? conflictingPlugins.length > 0 : conflictingPlugins.length > 1;
+        if (shouldReportConflict) {
+          conflicts.push({
+            type: "CONFLICT",
+            plugins: conflictingPlugins,
+            message: rule.reason,
+            canOverride: rule.allowOverride ?? true
+          });
+        }
+      }
+    }
+    return conflicts;
+  }
+  /**
+   * 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
+   * @param rules - Règles applicables
+   * @returns Liste des erreurs d'exclusivité
+   *
+   * @internal
+   */
+  checkExclusivity(_plugins, pluginNames, rules = this.rules) {
+    const errors = [];
+    for (const rule of 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
+   * @param rules - Règles applicables
+   * @returns Liste des warnings/erreurs de conflit
+   *
+   * @internal
+   */
+  checkConflicts(_plugins, pluginNames, rules = this.rules) {
+    const conflicts = [];
+    for (const rule of rules) {
+      if (rule.framework) {
+        continue;
+      }
+      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
+   * @param rules - Règles applicables
+   * @param ctx - Contexte du projet (optionnel)
+   * @returns Liste des erreurs de dépendances manquantes
+   *
+   * @internal
+   */
+  checkDependencies(_plugins, pluginNames, rules = this.rules, ctx) {
+    const errors = [];
+    for (const rule of rules) {
+      if (rule.type !== "REQUIRES" || !rule.plugin || !rule.requires) {
+        continue;
+      }
+      if (!pluginNames.has(rule.plugin)) {
+        continue;
+      }
+      const missingDependencies = [];
+      for (const dep of rule.requires) {
+        const pluginName = dep.split("@")[0];
+        if (!pluginName) {
+          continue;
+        }
+        if (dep.includes("@") && ctx) {
+          const allDeps = { ...ctx.dependencies, ...ctx.devDependencies };
+          if (!allDeps[pluginName]) {
+            missingDependencies.push(dep);
+          }
+        } else {
+          if (!pluginNames.has(pluginName)) {
+            missingDependencies.push(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
+   * @param rules - Règles applicables
+   * @returns Liste des suggestions de plugins recommandés
+   *
+   * @internal
+   */
+  checkRecommendations(_plugins, pluginNames, rules = this.rules) {
+    const suggestions = [];
+    for (const rule of 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 = generateCompatibilityRules(pluginRegistry);
+var additionalCompatibilityRules = [
+  // ====================================================================
+  // Règles spécifiques Next.js
+  // ====================================================================
+  // React Router incompatible avec Next.js (routing intégré)
+  {
+    type: "CONFLICT",
+    plugins: ["react-router-dom"],
+    framework: "nextjs",
+    reason: "React Router est incompatible avec Next.js. Next.js a son propre syst\xE8me de routing int\xE9gr\xE9.",
+    severity: "error",
+    allowOverride: false
+  },
+  // Framer Motion peut causer des problèmes SSR avec Next.js
+  {
+    type: "CONFLICT",
+    plugins: ["framer-motion"],
+    framework: "nextjs",
+    reason: "Framer Motion peut causer des probl\xE8mes avec le Server-Side Rendering (SSR) de Next.js. Utilisez des alternatives compatibles SSR ou configurez correctement le dynamic import.",
+    severity: "warning",
+    allowOverride: true
+  },
+  // Shadcn/ui nécessite une configuration spéciale pour Next.js
+  {
+    type: "RECOMMENDS",
+    plugin: "shadcn-ui",
+    recommends: ["shadcn-ui-nextjs"],
+    framework: "nextjs",
+    reason: "Pour Next.js, utilisez la variante shadcn-ui-nextjs qui est optimis\xE9e pour React Server Components.",
+    severity: "info"
+  },
+  // ====================================================================
+  // Règles spécifiques Vue.js
+  // ====================================================================
+  // React Router incompatible avec Vue.js (utiliser Vue Router)
+  {
+    type: "CONFLICT",
+    plugins: ["react-router-dom"],
+    framework: "vue",
+    reason: "React Router est incompatible avec Vue.js. Utilisez Vue Router (vue-router) pour Vue.js.",
+    severity: "error",
+    allowOverride: false
+  },
+  // State management React incompatible avec Vue.js
+  {
+    type: "CONFLICT",
+    plugins: ["zustand", "@reduxjs/toolkit", "jotai"],
+    framework: "vue",
+    reason: "Zustand, Redux Toolkit et Jotai sont sp\xE9cifiques \xE0 React. Pour Vue.js, utilisez Pinia (state management officiel).",
+    severity: "error",
+    allowOverride: false
+  },
+  // Shadcn/ui incompatible avec Vue.js (spécifique React)
+  {
+    type: "CONFLICT",
+    plugins: ["shadcn-ui"],
+    framework: "vue",
+    reason: "Shadcn/ui est sp\xE9cifique \xE0 React. Pour Vue.js, utilisez Vuetify ou Quasar (frameworks UI Vue.js).",
+    severity: "error",
+    allowOverride: false
+  },
+  // Pinia nécessite Vue 3
+  {
+    type: "REQUIRES",
+    plugin: "pinia",
+    requires: ["vue@^3.0.0"],
+    framework: "vue",
+    reason: "Pinia n\xE9cessite Vue 3. Vue 2 n'est plus support\xE9.",
+    severity: "error",
+    allowOverride: false
+  },
+  // Vue Router version doit correspondre à Vue version
+  {
+    type: "CONFLICT",
+    plugins: ["vue-router"],
+    framework: "vue",
+    reason: "Assurez-vous que la version de Vue Router correspond \xE0 la version de Vue.js (Vue Router 4 pour Vue 3).",
+    severity: "warning",
+    allowOverride: true
+  }
+];
+function normalizeArray(values) {
+  if (!values || values.length === 0) {
+    return [];
+  }
+  return [...values].sort();
+}
+function buildRuleKey(rule) {
+  const plugins = normalizeArray(rule.plugins).join("|");
+  const requires = normalizeArray(rule.requires).join("|");
+  const recommends = normalizeArray(rule.recommends).join("|");
+  return [
+    rule.type,
+    rule.framework ?? "*",
+    rule.plugin ?? "",
+    plugins,
+    requires,
+    recommends,
+    rule.severity,
+    String(rule.allowOverride ?? false),
+    String(rule.autoInstall ?? false),
+    String(rule.prompt ?? false)
+  ].join("::");
+}
+function deduplicateCompatibilityRules(rules) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduplicated = [];
+  for (const rule of rules) {
+    const key = buildRuleKey(rule);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    deduplicated.push(rule);
+  }
+  return deduplicated;
+}
+var allCompatibilityRules = deduplicateCompatibilityRules([
+  ...compatibilityRules,
+  ...additionalCompatibilityRules
+]);
+
+export {
+  CompatibilityValidator,
+  allCompatibilityRules
+};