@next-vibe/checker 1.0.13 → 1.0.15

package/.dist/oxlint-plugins/i18n.js

@@ -1,4 +1,381 @@
-(function() {
-  "use strict";
-})();
-//# sourceMappingURL=i18n.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/i18n/src/index.ts
+var DEFAULT_CONFIG = {
+  words: {
+    exclude: [
+      String.raw`^[\[\]{}—<>•+%#@.:_*;,/()\-]+$`,
+      String.raw`^\s+$`,
+      String.raw`^\d+$`,
+      String.raw`^[^\s]+\.[^\s]+$`,
+      String.raw`^(?:https?://|/)[^\s]*$`
+    ]
+  },
+  "jsx-attributes": {
+    exclude: [
+      "className",
+      "href",
+      "src",
+      "alt",
+      "id",
+      "name",
+      "type",
+      "value",
+      "key",
+      "ref",
+      "*ClassName",
+      "*Style",
+      "*Variant",
+      "*Size",
+      "*Color"
+    ]
+  },
+  "object-properties": {
+    exclude: []
+  }
+};
+var DEFAULT_MESSAGES = {
+  jsxText: 'Literal string "{value}" should be translated using i18n.',
+  jsxExpression: 'Literal string "{value}" in JSX expression should be translated.',
+  jsxAttribute: 'Literal string "{value}" in JSX attribute should be translated.'
+};
+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 loadI18nConfig() {
+  if (cachedConfig !== null) {
+    return cachedConfig;
+  }
+  const loader = getConfigLoader();
+  if (loader) {
+    const result = loader.loadPluginConfig("oxlint-plugin-i18n/no-literal-string", 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-i18n/no-literal-string"];
+    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, value) {
+  return template.replaceAll("{value}", value);
+}
+var noLiteralStringRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow literal strings that should be internationalized",
+      category: "Best Practices",
+      recommended: true
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          words: {
+            type: "object",
+            properties: {
+              exclude: { type: "array", items: { type: "string" } }
+            }
+          },
+          "jsx-attributes": {
+            type: "object",
+            properties: {
+              exclude: { type: "array", items: { type: "string" } }
+            }
+          },
+          "object-properties": {
+            type: "object",
+            properties: {
+              exclude: { type: "array", items: { type: "string" } }
+            }
+          }
+        }
+      }
+    ]
+  },
+  create(context) {
+    const configFromFile = loadI18nConfig();
+    const ruleOptions = context.options?.[0] ?? {};
+    const options = {
+      ...configFromFile,
+      ...ruleOptions,
+      words: {
+        ...configFromFile.words,
+        ...ruleOptions.words
+      },
+      "jsx-attributes": {
+        ...configFromFile["jsx-attributes"],
+        ...ruleOptions["jsx-attributes"]
+      }
+    };
+    const messages = getMessages();
+    const wordExclusionPatterns = (options.words?.exclude ?? []).map((pattern) => new RegExp(pattern, "u"));
+    const excludedAttributes = options["jsx-attributes"]?.exclude ?? [];
+    const shouldExcludeString = (value) => {
+      if (!value || typeof value !== "string") {
+        return true;
+      }
+      for (const pattern of wordExclusionPatterns) {
+        if (pattern.test(value)) {
+          return true;
+        }
+      }
+      return false;
+    };
+    const isExcludedAttribute = (attrName) => {
+      return excludedAttributes.some((excluded) => {
+        if (excluded.startsWith("*")) {
+          return attrName.endsWith(excluded.slice(1));
+        }
+        return attrName === excluded;
+      });
+    };
+    return {
+      JSXText(node) {
+        const value = node.value;
+        if (typeof value !== "string") {
+          return;
+        }
+        const trimmed = value.trim();
+        if (trimmed && !shouldExcludeString(trimmed)) {
+          context.report({
+            node,
+            message: formatMessage(messages.jsxText, trimmed)
+          });
+        }
+      },
+      "JSXExpressionContainer > Literal"(node) {
+        const value = node.value;
+        if (typeof value === "string" && !shouldExcludeString(value)) {
+          context.report({
+            node,
+            message: formatMessage(messages.jsxExpression, value)
+          });
+        }
+      },
+      JSXAttribute(node) {
+        const attrNode = node;
+        const nameNode = attrNode.name;
+        if (!nameNode) {
+          return;
+        }
+        const attrName = nameNode.name ?? String(nameNode);
+        if (isExcludedAttribute(attrName)) {
+          return;
+        }
+        const valueNode = attrNode.value;
+        if (!valueNode) {
+          return;
+        }
+        if (valueNode.type === "Literal") {
+          const literalValue = valueNode.value;
+          if (typeof literalValue === "string" && !shouldExcludeString(literalValue)) {
+            context.report({
+              node: valueNode,
+              message: formatMessage(messages.jsxAttribute, literalValue)
+            });
+          }
+        }
+      }
+    };
+  }
+};
+var src_default = {
+  meta: {
+    name: "oxlint-plugin-i18n",
+    version: "1.0.0"
+  },
+  rules: {
+    "no-literal-string": noLiteralStringRule
+  }
+};
+export {
+  DEFAULT_MESSAGES as defaultMessages,
+  DEFAULT_CONFIG as defaultConfig,
+  src_default as default
+};