@next-vibe/checker 1.0.13 → 1.0.15

package/.dist/oxlint-plugins/jsx-capitalization.js

@@ -1,4 +1,460 @@
-(function() {
-  "use strict";
-})();
-//# sourceMappingURL=jsx-capitalization.js.map
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/app/api/[locale]/system/check/oxlint/plugins/shared/config-loader.ts
+var exports_config_loader = {};
+__export(exports_config_loader, {
+  loadPluginConfig: () => loadPluginConfig,
+  getCheckConfig: () => getCheckConfig,
+  createPluginMessages: () => createPluginMessages,
+  clearConfigCache: () => clearConfigCache
+});
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+function findProjectRoot() {
+  const cwd = process.cwd();
+  let currentDir = cwd;
+  const root = resolve("/");
+  while (currentDir !== root) {
+    const configPath = resolve(currentDir, "check.config.ts");
+    if (existsSync(configPath)) {
+      return currentDir;
+    }
+    const jsConfigPath = resolve(currentDir, "check.config.js");
+    if (existsSync(jsConfigPath)) {
+      return currentDir;
+    }
+    currentDir = dirname(currentDir);
+  }
+  return cwd;
+}
+function getConfigPaths() {
+  const projectRoot = findProjectRoot();
+  return [
+    resolve(projectRoot, "check.config.ts"),
+    resolve(projectRoot, "check.config.js"),
+    resolve(projectRoot, "node_modules", "next-vibe", "check.config.js"),
+    resolve(projectRoot, "node_modules", "next-vibe", "dist", "check.config.js")
+  ];
+}
+function loadCheckConfigSync() {
+  if (configLoadAttempted) {
+    return cachedCheckConfig;
+  }
+  configLoadAttempted = true;
+  const configPaths = getConfigPaths();
+  for (const configPath of configPaths) {
+    if (!existsSync(configPath)) {
+      continue;
+    }
+    try {
+      const configModule = __require(configPath);
+      const exportedValue = configModule.default ?? configModule.config;
+      if (!exportedValue) {
+        continue;
+      }
+      const config = typeof exportedValue === "function" ? exportedValue() : exportedValue;
+      cachedCheckConfig = config;
+      return config;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function extractPluginOptions(checkConfig, pluginName) {
+  if (!checkConfig.oxlint.enabled) {
+    return null;
+  }
+  const rules = checkConfig.oxlint.rules;
+  if (!rules) {
+    return null;
+  }
+  const ruleConfig = rules[pluginName];
+  if (Array.isArray(ruleConfig) && ruleConfig.length >= 2) {
+    return ruleConfig[1];
+  }
+  return null;
+}
+function loadPluginConfig(pluginName, defaultConfig) {
+  const cached = pluginConfigCache.get(pluginName);
+  if (cached) {
+    return cached;
+  }
+  const checkConfig = loadCheckConfigSync();
+  if (checkConfig) {
+    const pluginOptions = extractPluginOptions(checkConfig, pluginName);
+    if (pluginOptions) {
+      const result2 = {
+        success: true,
+        config: pluginOptions,
+        source: "rule-config"
+      };
+      pluginConfigCache.set(pluginName, result2);
+      return result2;
+    }
+  }
+  if (defaultConfig) {
+    const result2 = {
+      success: true,
+      config: defaultConfig,
+      source: "default"
+    };
+    pluginConfigCache.set(pluginName, result2);
+    return result2;
+  }
+  const result = {
+    success: false,
+    config: null,
+    source: "error",
+    error: `No configuration found for ${pluginName}`
+  };
+  pluginConfigCache.set(pluginName, result);
+  return result;
+}
+function getCheckConfig() {
+  return loadCheckConfigSync();
+}
+function clearConfigCache() {
+  cachedCheckConfig = null;
+  configLoadAttempted = false;
+  pluginConfigCache.clear();
+}
+function createPluginMessages(defaults, overrides) {
+  return { ...defaults, ...overrides };
+}
+var cachedCheckConfig = null, configLoadAttempted = false, pluginConfigCache;
+var init_config_loader = __esm(() => {
+  pluginConfigCache = new Map;
+});
+
+// src/app/api/[locale]/system/check/oxlint/plugins/jsx-capitalization/src/index.ts
+var DEFAULT_CONFIG = {
+  excludedPaths: [],
+  excludedFilePatterns: [".email.tsx", ".test.tsx", ".spec.tsx"],
+  typographyElements: [
+    "p",
+    "span",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "strong",
+    "em",
+    "small",
+    "blockquote",
+    "code",
+    "pre"
+  ],
+  standaloneElements: [
+    "div",
+    "button",
+    "input",
+    "label",
+    "form",
+    "table",
+    "ul",
+    "ol",
+    "li"
+  ],
+  svgElements: [
+    "svg",
+    "path",
+    "circle",
+    "rect",
+    "line",
+    "polygon",
+    "polyline",
+    "ellipse",
+    "g"
+  ],
+  imageElements: ["img", "picture", "source", "video", "audio"],
+  commonUiElements: [
+    "nav",
+    "header",
+    "footer",
+    "main",
+    "section",
+    "article",
+    "aside"
+  ]
+};
+var DEFAULT_MESSAGES = {
+  anchorTag: 'Use platform-independent <Link> component instead of <a>. import { Link } from "next-vibe-ui/ui/link";',
+  typographyElement: 'Use typography component <{capitalizedName}> instead of <{elementName}>. import { {capitalizedName} } from "next-vibe-ui/ui/typography";',
+  standaloneElement: 'Use platform-independent <{capitalizedName}> component instead of <{elementName}>. import { {capitalizedName} } from "next-vibe-ui/ui/{elementName}";',
+  svgElement: "SVG element <{elementName}> detected. For icons, use components from next-vibe-ui/ui/icons instead. For custom SVG, create platform-independent components using react-native-svg that work on both web and native.",
+  imageElement: 'Use platform-independent <Image> component instead of <{elementName}>. import { Image } from "next-vibe-ui/ui/image";',
+  commonUiElement: 'Use platform-independent <{capitalizedName}> component instead of <{elementName}>. import { {capitalizedName} } from "next-vibe-ui/ui/{elementName}";',
+  genericElement: "Lowercase element <{elementName}> detected. Create platform-independent components: 1) Create next-vibe-ui/web/ui/{elementName}.tsx for web, 2) Create next-vibe-ui/native/ui/{elementName}.tsx for React Native, or 3) Use an existing component if available."
+};
+var configLoader = null;
+var cachedConfig = null;
+var cachedMessages = null;
+function getConfigLoader() {
+  if (configLoader) {
+    return configLoader;
+  }
+  try {
+    configLoader = (init_config_loader(), __toCommonJS(exports_config_loader));
+    return configLoader;
+  } catch {
+    return null;
+  }
+}
+function loadJsxCapitalizationConfig() {
+  if (cachedConfig !== null) {
+    return cachedConfig;
+  }
+  const loader = getConfigLoader();
+  if (loader) {
+    const result = loader.loadPluginConfig("oxlint-plugin-jsx-capitalization/jsx-capitalization", DEFAULT_CONFIG);
+    cachedConfig = result.config ?? DEFAULT_CONFIG;
+  } else {
+    cachedConfig = loadConfigFallback();
+  }
+  return cachedConfig;
+}
+function loadConfigFallback() {
+  try {
+    const config = __require(`${process.cwd()}/check.config.ts`);
+    const checkConfig = config.default ?? config;
+    const exported = typeof checkConfig === "function" ? checkConfig() : checkConfig;
+    const ruleConfig = exported?.oxlint?.rules?.["oxlint-plugin-jsx-capitalization/jsx-capitalization"];
+    if (Array.isArray(ruleConfig) && ruleConfig[1]) {
+      return ruleConfig[1];
+    }
+  } catch {}
+  return DEFAULT_CONFIG;
+}
+function getMessages() {
+  if (cachedMessages !== null) {
+    return cachedMessages;
+  }
+  cachedMessages = DEFAULT_MESSAGES;
+  return cachedMessages;
+}
+function formatMessage(template, elementName, capitalizedName) {
+  return template.replaceAll("{elementName}", elementName).replaceAll("{capitalizedName}", capitalizedName);
+}
+function isLowercaseElement(elementName) {
+  const firstChar = elementName.charAt(0);
+  return firstChar === firstChar.toLowerCase() && firstChar !== firstChar.toUpperCase();
+}
+function isExcludedPath(context, excludedPaths, excludedFilePatterns) {
+  let filename = "";
+  if (typeof context.getFilename === "function") {
+    filename = context.getFilename();
+  } else if (typeof context.filename === "string") {
+    filename = context.filename;
+  }
+  if (!filename) {
+    return false;
+  }
+  const normalizedPath = filename.replaceAll("\\", "/");
+  for (const excludedPath of excludedPaths) {
+    if (normalizedPath.includes(excludedPath)) {
+      return true;
+    }
+  }
+  for (const pattern of excludedFilePatterns) {
+    if (normalizedPath.includes(pattern) || normalizedPath.endsWith(pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasDisableComment(context, node) {
+  const getComments = context.getCommentsBefore ?? context.sourceCode?.getCommentsBefore;
+  if (typeof getComments !== "function") {
+    return false;
+  }
+  try {
+    const comments = getComments(node);
+    if (!comments || !Array.isArray(comments)) {
+      return false;
+    }
+    for (const comment of comments) {
+      if (!comment || typeof comment.value !== "string") {
+        continue;
+      }
+      const commentText = comment.value.trim();
+      if ((commentText.includes("eslint-disable-next-line") || commentText.includes("oxlint-disable-next-line")) && (commentText.includes("jsx-capitalization") || commentText.includes("no-lowercase-jsx"))) {
+        return true;
+      }
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+function getElementName(node) {
+  const name = node.name;
+  if (!name) {
+    return null;
+  }
+  if (name.type === "JSXIdentifier") {
+    return name.name;
+  }
+  if (name.type === "JSXMemberExpression") {
+    return null;
+  }
+  if (name.type === "JSXNamespacedName") {
+    return null;
+  }
+  return null;
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function getElementSets(context) {
+  const ruleOptions = context.options?.[0];
+  if (ruleOptions) {
+    return {
+      typography: new Set(ruleOptions.typographyElements ?? []),
+      standalone: new Set(ruleOptions.standaloneElements ?? []),
+      svg: new Set(ruleOptions.svgElements ?? []),
+      image: new Set(ruleOptions.imageElements ?? []),
+      commonUi: new Set(ruleOptions.commonUiElements ?? [])
+    };
+  }
+  const config = loadJsxCapitalizationConfig();
+  return {
+    typography: new Set(config.typographyElements ?? []),
+    standalone: new Set(config.standaloneElements ?? []),
+    svg: new Set(config.svgElements ?? []),
+    image: new Set(config.imageElements ?? []),
+    commonUi: new Set(config.commonUiElements ?? [])
+  };
+}
+function getExcludedPaths(context) {
+  const ruleOptions = context.options?.[0];
+  if (ruleOptions) {
+    return {
+      excludedPaths: ruleOptions.excludedPaths ?? [],
+      excludedFilePatterns: ruleOptions.excludedFilePatterns ?? []
+    };
+  }
+  const config = loadJsxCapitalizationConfig();
+  return {
+    excludedPaths: config.excludedPaths ?? [],
+    excludedFilePatterns: config.excludedFilePatterns ?? []
+  };
+}
+function getErrorMessage(elementName, elementSets) {
+  const capitalizedName = capitalize(elementName);
+  const messages = getMessages();
+  if (elementName === "a") {
+    return messages.anchorTag;
+  }
+  if (elementSets.typography.has(elementName)) {
+    return formatMessage(messages.typographyElement, elementName, capitalizedName);
+  }
+  if (elementSets.standalone.has(elementName)) {
+    return formatMessage(messages.standaloneElement, elementName, capitalizedName);
+  }
+  if (elementSets.svg.has(elementName)) {
+    return formatMessage(messages.svgElement, elementName, capitalizedName);
+  }
+  if (elementSets.image.has(elementName)) {
+    return formatMessage(messages.imageElement, elementName, capitalizedName);
+  }
+  if (elementSets.commonUi.has(elementName)) {
+    return formatMessage(messages.commonUiElement, elementName, capitalizedName);
+  }
+  return formatMessage(messages.genericElement, elementName, capitalizedName);
+}
+var jsxCapitalizationRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforces the use of capitalized JSX components instead of lowercase HTML elements",
+      category: "Best Practices",
+      recommended: true
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          excludedPaths: { type: "array", items: { type: "string" } },
+          excludedFilePatterns: { type: "array", items: { type: "string" } },
+          typographyElements: { type: "array", items: { type: "string" } },
+          standaloneElements: { type: "array", items: { type: "string" } },
+          svgElements: { type: "array", items: { type: "string" } },
+          imageElements: { type: "array", items: { type: "string" } },
+          commonUiElements: { type: "array", items: { type: "string" } }
+        }
+      }
+    ]
+  },
+  create(context) {
+    const { excludedPaths, excludedFilePatterns } = getExcludedPaths(context);
+    const elementSets = getElementSets(context);
+    const isExcluded = isExcludedPath(context, excludedPaths, excludedFilePatterns);
+    return {
+      JSXOpeningElement(node) {
+        if (isExcluded) {
+          return;
+        }
+        if (hasDisableComment(context, node)) {
+          return;
+        }
+        const openingElement = node;
+        const elementName = getElementName(openingElement);
+        if (!elementName) {
+          return;
+        }
+        if (isLowercaseElement(elementName)) {
+          context.report({
+            node,
+            message: getErrorMessage(elementName, elementSets)
+          });
+        }
+      }
+    };
+  }
+};
+var src_default = {
+  meta: {
+    name: "oxlint-plugin-jsx-capitalization",
+    version: "1.0.0"
+  },
+  rules: {
+    "jsx-capitalization": jsxCapitalizationRule
+  }
+};
+export {
+  DEFAULT_MESSAGES as defaultMessages,
+  DEFAULT_CONFIG as defaultConfig,
+  src_default as default
+};