@mdbase-dev/i18n 0.0.0-stage → 0.1.0-beta.148

package/scripts/config.d.mts

@@ -0,0 +1,6 @@
+import type { LinguiConfig } from "@lingui/conf";
+export declare const locales: readonly ["en", "fr", "de", "es", "ja", "ko", "pt", "ru", "zh", "it"];
+export declare function i18nConfig(options?: Omit<LinguiConfig,
+  "locales" | "sourceLocale" | "fallbackLocales" | "format" | "catalogs" | "compileNamespace"> & {
+    include?: string[]; exclude?: string[]; path?: string;
+  }): LinguiConfig;

package/scripts/config.mjs

@@ -0,0 +1,13 @@
+import { defineConfig } from "@lingui/conf";
+import { formatter } from "@lingui/format-po";
+
+export const locales = ["en", "fr", "de", "es", "ja", "ko", "pt", "ru", "zh", "it"];
+/** Source/context generated IDs are Lingui's default; never supply explicit IDs. */
+export function i18nConfig({ include = ["<rootDir>/src"], exclude = ["**/*.test.*", "**/*.spec.*"],
+  path = "<rootDir>/src/i18n/locales/{locale}/messages", ...options } = {}) {
+  return defineConfig({
+    ...options, locales, sourceLocale: "en", fallbackLocales: { default: "en" },
+    format: formatter({ origins: true, lineNumbers: false }),
+    catalogs: [{ path, include, exclude }], compileNamespace: "json",
+  });
+}

package/scripts/source.mjs

@@ -0,0 +1,297 @@
+import ts from "typescript";
+
+const visibleAttributes = new Set([
+  "aria-label",
+  "ariaLabel",
+  "title",
+  "label",
+  "legend",
+  "placeholder",
+  "actionLabel",
+  "allDayText",
+  "noEventsText",
+  "description",
+  "detail",
+  "body",
+  "summary",
+  "action",
+  "recovery",
+  "alt",
+  "data-swipe-hint",
+]);
+const visibleProperties = new Set([
+  "label",
+  "description",
+  "ariaLabel",
+  "placeholder",
+]);
+const brands = new Set(["TaskNotes", "mdbase", "Markdown", "ICS"]);
+const macros = new Set([
+  "t",
+  "translate",
+  "msg",
+  "defineMessage",
+  "plural",
+  "select",
+  "selectOrdinal",
+]);
+const comparisons = new Set([
+  ts.SyntaxKind.EqualsEqualsEqualsToken,
+  ts.SyntaxKind.ExclamationEqualsEqualsToken,
+  ts.SyntaxKind.EqualsEqualsToken,
+  ts.SyntaxKind.ExclamationEqualsToken,
+]);
+
+/** Structural guard, not an assertion that arbitrary English in every layer is UI copy. */
+export function inspectUiSource(source, file = "component.tsx", options = {}) {
+  const allowedBrands = new Set([...brands, ...(options.brands ?? [])]);
+  const ast = ts.createSourceFile(
+    file,
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    /\.[jt]sx$/.test(file) ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
+  );
+  const issues = [];
+  const add = (node, kind, text) =>
+    issues.push({
+      file,
+      line: ast.getLineAndCharacterOfPosition(node.getStart(ast)).line + 1,
+      kind,
+      text,
+    });
+  const tag = (node) => node.tagName?.getText(ast);
+  // Core macros may bind an explicit instance: t(i18n)`...` / t(i18n)({...}).
+  const macroName = (expression) => {
+    if (ts.isIdentifier(expression)) return expression.text;
+    if (ts.isCallExpression(expression) && expression.arguments.length === 1 &&
+      ["t", "translate"].includes(expression.expression.getText(ast)))
+      return expression.expression.getText(ast);
+    return undefined;
+  };
+  const isTranslation = (node) => {
+    if (ts.isTaggedTemplateExpression(node))
+      return ["t", "translate"].includes(macroName(node.tag));
+    if (!ts.isCallExpression(node) ||
+      !["t", "translate", "plural", "select", "selectOrdinal"].includes(macroName(node.expression))) return false;
+    // The inner t(i18n) selects an instance; it is not itself a translation.
+    return !((ts.isTaggedTemplateExpression(node.parent) && node.parent.tag === node) ||
+      (ts.isCallExpression(node.parent) && node.parent.expression === node));
+  };
+  function covered(node) {
+    let expression = ts.isJsxExpression(node);
+    for (let p = node.parent; p; p = p.parent) {
+      if (ts.isJsxExpression(p)) expression = true;
+      if (isTranslation(p) ||
+        (ts.isCallExpression(p) && macros.has(macroName(p.expression)))) return true;
+      if (
+        ts.isJsxElement(p) &&
+        ["Trans", "Plural", "Select", "SelectOrdinal"].includes(
+          tag(p.openingElement),
+        ) &&
+        !expression
+      )
+        return true;
+      if (
+        ts.isJsxSelfClosingElement(p) &&
+        ["Plural", "Select", "SelectOrdinal"].includes(tag(p))
+      )
+        return true;
+    }
+    return false;
+  }
+  const human = (text) => /[A-Za-z]/.test(text) && !allowedBrands.has(text.trim());
+  const identifiers = new Set([
+    "className",
+    "id",
+    "key",
+    "href",
+    "src",
+    "role",
+    "type",
+  ]);
+  const stateBindings = new Map();
+  const owner = (node) => {
+    for (let p = node.parent; p; p = p.parent) if (ts.isFunctionLike(p)) return p;
+  };
+  function collectState(node) {
+    if (ts.isVariableDeclaration(node) && ts.isArrayBindingPattern(node.name) &&
+      node.initializer && ts.isCallExpression(node.initializer) &&
+      /^(React\.)?useState$/.test(node.initializer.expression.getText(ast))) {
+      const [value, setter] = node.name.elements;
+      if (value && ts.isBindingElement(value) && ts.isIdentifier(value.name) &&
+        (!setter || (ts.isBindingElement(setter) && ts.isIdentifier(setter.name)))) {
+        const scope = owner(node);
+        if (!stateBindings.has(scope)) stateBindings.set(scope, []);
+        stateBindings.get(scope).push({ value: value.name.text, setter: setter?.name.text, declaration: node });
+      }
+    }
+    ts.forEachChild(node, collectState);
+  }
+  collectState(ast);
+  // Each binding carries the member paths that reach copy, not the whole object.
+  // An empty path means the state value itself is rendered.
+  const visibleState = new Map();
+  const propertyName = (name) => {
+    if (ts.isComputedPropertyName(name)) {
+      name = name.expression;
+      if (!ts.isStringLiteralLike(name) && !ts.isNumericLiteral(name)) return "*";
+    }
+    return ts.isIdentifier(name) || ts.isStringLiteralLike(name) || ts.isNumericLiteral(name)
+      ? name.text : "*";
+  };
+  const reachesStateOutput = (binding, path) => visibleState.get(binding)?.some((rendered) =>
+    rendered.length <= path.length && rendered.every((key, i) =>
+      key === "*" || path[i] === "*" || key === path[i]));
+  function stateFor(node, name) {
+    for (let p = node; p; p = p.parent) {
+      const binding = stateBindings.get(p)?.find((binding) => binding.value === name || binding.setter === name);
+      if (binding) return binding;
+    }
+  }
+  const isStateSetter = (node) => ts.isCallExpression(node) && ts.isIdentifier(node.expression) &&
+    visibleState.has(stateFor(node, node.expression.text)) &&
+    stateFor(node, node.expression.text)?.setter === node.expression.text;
+  function output(node) {
+    let property = false;
+    const path = [];
+    for (let p = node.parent; p; p = p.parent) {
+      // Types and opaque prop spreads do not render a value at this boundary.
+      if (ts.isTypeNode(p) || ts.isJsxSpreadAttribute(p)) return false;
+      if (ts.isBinaryExpression(p) && comparisons.has(p.operatorToken.kind))
+        return false;
+      if (
+        ts.isConditionalExpression(p) &&
+        p.condition.pos <= node.pos &&
+        p.condition.end >= node.end
+      )
+        return false;
+      // The left operand of && controls whether the right operand is rendered;
+      // it does not render an object's fields (notice && <p>{notice.text}</p>).
+      if (ts.isBinaryExpression(p) && p.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken &&
+        p.left.pos <= node.pos && p.left.end >= node.end) return false;
+      if (ts.isElementAccessExpression(p) && p.argumentExpression.pos <= node.pos &&
+        p.argumentExpression.end >= node.end) return false;
+      if (ts.isCallExpression(p)) {
+        const binding = isStateSetter(p) ? stateFor(p, p.expression.text) :
+          [...visibleState.keys()].find((binding) => binding.declaration.initializer === p);
+        return reachesStateOutput(binding, path) ?? false;
+      }
+      if (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) {
+        if (p.name.pos <= node.pos && p.name.end >= node.end && !ts.isShorthandPropertyAssignment(p))
+          return false;
+        path.unshift(propertyName(p.name));
+        property = visibleProperties.has(propertyName(p.name));
+      }
+      if (ts.isJsxAttribute(p))
+        return property || visibleAttributes.has(p.name.getText(ast));
+      if (ts.isJsxExpression(p)) {
+        if (ts.isJsxElement(p.parent) || ts.isJsxFragment(p.parent))
+          return true;
+      }
+      if (ts.isVariableDeclaration(p)) {
+        const binding = [...visibleState.keys()].find((binding) => binding.declaration === p);
+        if (binding) return reachesStateOutput(binding, path);
+      }
+      if (ts.isFunctionLike(p) && !isStateSetter(p.parent)) return false;
+    }
+    return false;
+  }
+  // Follow local React state only when its value is actually rendered as copy.
+  // Enum comparisons, input values, protocol state and arbitrary calls stay opaque.
+  function collectVisibleState(node) {
+    if (ts.isIdentifier(node)) {
+      const binding = stateFor(node, node.text);
+      if (binding?.value === node.text) {
+        let reference = node;
+        const path = [];
+        while ((ts.isPropertyAccessExpression(reference.parent) || ts.isElementAccessExpression(reference.parent)) &&
+          reference.parent.expression === reference) {
+          reference = reference.parent;
+          path.push(ts.isPropertyAccessExpression(reference) ? reference.name.text :
+            ts.isStringLiteralLike(reference.argumentExpression) || ts.isNumericLiteral(reference.argumentExpression)
+              ? reference.argumentExpression.text : "*");
+        }
+        // Member names and computed keys are not references to the state value.
+        if (!(ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) &&
+          output(reference)) {
+          if (!visibleState.has(binding)) visibleState.set(binding, []);
+          visibleState.get(binding).push(path);
+        }
+      }
+    }
+    ts.forEachChild(node, collectVisibleState);
+  }
+  collectVisibleState(ast);
+  function visit(node) {
+    if (ts.isJsxText(node) && human(node.text.trim()) && !covered(node))
+      add(node, "unmarked JSX text", node.text.trim());
+    if (
+      ts.isStringLiteralLike(node) &&
+      human(node.text) &&
+      !covered(node) &&
+      output(node)
+    )
+      add(node, "unmarked visible string", node.text);
+    if (
+      ts.isTemplateExpression(node) &&
+      human(
+        node.head.text + node.templateSpans.map((s) => s.literal.text).join(""),
+      ) &&
+      !covered(node) &&
+      output(node)
+    )
+      add(node, "unmarked visible interpolation", node.getText(ast));
+    if (isTranslation(node)) {
+      const parent = node.parent;
+      if (
+        ts.isBinaryExpression(parent) &&
+        comparisons.has(parent.operatorToken.kind)
+      )
+        add(node, "translation in control-flow comparison", node.getText(ast));
+      if (
+        ts.isCallExpression(parent) &&
+        /\.(includes|has|get|startsWith|endsWith)$/.test(
+          parent.expression.getText(ast),
+        )
+      )
+        add(node, "translation in identifier lookup", node.getText(ast));
+      if (
+        ts.isCallExpression(parent) &&
+        parent.expression.getText(ast) === "countLabel" &&
+        parent.arguments[1] === node
+      )
+        add(node, "translation in count-kind identifier", node.getText(ast));
+      for (let p = node.parent; p; p = p.parent) {
+        if (
+          ts.isTaggedTemplateExpression(p) &&
+          ["t", "translate"].includes(macroName(p.tag)) &&
+          // Lingui folds plural/select helpers into the enclosing ICU descriptor.
+          !(ts.isCallExpression(node) &&
+            ["plural", "select", "selectOrdinal"].includes(macroName(node.expression)))
+        ) {
+          add(node, "uncompiled nested translation macro", node.getText(ast));
+          break;
+        }
+        if (ts.isJsxAttribute(p) && identifiers.has(p.name.getText(ast)))
+          add(node, "translation in identifier attribute", p.name.getText(ast));
+        if ((ts.isPropertyAssignment(p) || ts.isPropertyDeclaration(p)) && identifiers.has(p.name.getText(ast)))
+          add(node, "translation in identifier property", p.name.getText(ast));
+        if (
+          ts.isVariableDeclaration(p) &&
+          /Class(?:Name)?$/.test(p.name.getText(ast))
+        )
+          add(node, "translation in CSS class variable", p.name.getText(ast));
+        if (ts.isFunctionLike(p)) break;
+      }
+      let fn = node.parent;
+      while (fn && !ts.isFunctionLike(fn) &&
+        !(ts.isPropertyDeclaration(fn) &&
+          !fn.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))) fn = fn.parent;
+      if (!fn) add(node, "eager module-level translation", node.getText(ast));
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(ast);
+  return issues;
+}