@next-vibe/checker 1.0.52 → 3.0.1

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

@@ -1,381 +0,0 @@
-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
-};