hanzio 2.2.0 → 3.1.0

package/dist/index-5n2e326q.js

@@ -0,0 +1,409 @@
+import {
+  extractPlaceholders2,
+  flattenMessages2
+} from "./index-najbyzpr.js";
+import {
+  isPlainObject2
+} from "./index-8r2vdzjg.js";
+
+// src/i18n/check.ts
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, join, relative, sep } from "node:path";
+
+// src/i18n/catalog.ts
+var MOJIBAKE = /(?:Ã.|Â.|â€|�)/;
+var I18NEXT_PLURAL_SUFFIX = /_(zero|one|two|few|many|other)$/;
+function parseMessages2(value, catalog, locale) {
+  const issues = [];
+  const issue = (message) => issues.push({ catalog, locale, message });
+  function visit(node, path) {
+    if (typeof node === "string") {
+      if (node.normalize("NFC") !== node) {
+        issue(`"${path}" is not Unicode NFC-normalized`);
+      }
+      if (MOJIBAKE.test(node))
+        issue(`"${path}" contains likely mojibake`);
+      return node;
+    }
+    if (!isPlainObject2(node)) {
+      issue(`"${path || "<root>"}" must be an object or string`);
+      return;
+    }
+    const result = {};
+    for (const [key, child] of Object.entries(node)) {
+      if (!key || key.includes(".")) {
+        issue(`"${path ? `${path}.` : ""}${key}" has an invalid key segment`);
+        continue;
+      }
+      const parsed = visit(child, path ? `${path}.${key}` : key);
+      if (parsed !== undefined)
+        result[key] = parsed;
+    }
+    return result;
+  }
+  const messages = visit(value, "");
+  return {
+    messages: typeof messages === "object" ? messages : undefined,
+    issues
+  };
+}
+function flattenCatalog(messages) {
+  return new Map(Object.entries(flattenMessages2(messages)));
+}
+var quote = (value) => `'${value.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
+function generateCatalogTypes2(catalog, baseMessages, command = "hanzio-i18n generate") {
+  const entries = new Map;
+  for (const [rawKey, template] of flattenCatalog(baseMessages)) {
+    const isI18nextPlural = catalog.runtime === "i18next" && I18NEXT_PLURAL_SUFFIX.test(rawKey);
+    const key = isI18nextPlural ? rawKey.replace(I18NEXT_PLURAL_SUFFIX, "") : rawKey;
+    const params = entries.get(key) ?? new Set;
+    for (const name of extractPlaceholders2(template))
+      params.add(name);
+    const isVuePlural = catalog.runtime === "vue-i18n" && template.split("|").map((part) => part.trim()).filter(Boolean).length > 1;
+    if (isVuePlural || isI18nextPlural)
+      params.add("count");
+    entries.set(key, params);
+  }
+  const lines = [...entries].sort(([a], [b]) => a.localeCompare(b)).map(([key, params]) => {
+    const value = params.size === 0 ? "never" : [...params].sort().map(quote).join(" | ");
+    return `	${quote(key)}: ${value}`;
+  });
+  return [
+    "/**",
+    ` * Generated by \`${command}\` from the base catalog.`,
+    " * Do not edit by hand.",
+    " */",
+    `export type ${catalog.generatedTypeName ?? "TranslationParams"} = {`,
+    ...lines,
+    "}",
+    ""
+  ].join(`
+`);
+}
+
+// src/i18n/content-rules.ts
+var PLACEHOLDER_MASK = "";
+var EXPRESSION_FRAGMENT = /(?:\?\?|=>|\bas\s+(?:string|number|boolean)\b)/;
+var maskPlaceholders = (value) => value.replace(/\{[^}]*\}/g, PLACEHOLDER_MASK);
+var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var wordPattern = (words, flags) => new RegExp(`\\b(?:${words.map(escapeRegExp).join("|")})\\w*`, flags);
+var CODE_SHAPES = [
+  { name: "call expression", pattern: /^[A-Za-z_$][\w$]*\([^)]*\)$/ },
+  { name: "index expression", pattern: /^[A-Za-z_$][\w$]*\[[^\]]*\]$/ },
+  {
+    name: "member expression",
+    pattern: /^[a-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+$/
+  },
+  { name: "constant reference", pattern: /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+$/ },
+  { name: "identifier", pattern: /^[a-z][a-z0-9]*(?:[A-Z][a-zA-Z0-9]*)+$/ },
+  { name: "expression fragment", pattern: EXPRESSION_FRAGMENT }
+];
+var DEFAULT_BRANDS = ["API", "URL", "SMS", "CSV", "PDF", "ID", "OK"];
+var NON_ASCII_LETTER = /(?![A-Za-z])\p{L}/u;
+var NON_PROSE = /[/@#=_{}[\]<>]|\.[a-z]{2,}/;
+function createContentRules(config = {}) {
+  const exempt = config.exemptKeyPrefixes ?? [];
+  const isExempt = (key) => exempt.some((prefix) => key.startsWith(prefix));
+  const codeAllow = new Set(config.allowCodeShapes ?? []);
+  const wrongLanguage = config.wrongLanguage;
+  const markerPattern = wrongLanguage?.markers.length ? new RegExp(`\\b(?:${wrongLanguage.markers.map(escapeRegExp).join("|")})\\b`, "giu") : undefined;
+  const markerLetters = wrongLanguage?.letters ? new RegExp(`[${escapeRegExp(wrongLanguage.letters)}]`, "u") : undefined;
+  const wrongLanguageAllow = new Set(wrongLanguage?.allowKeys ?? []);
+  const everywhere = config.bannedWords?.everywhere ?? [];
+  const translations = config.bannedWords?.translations ?? [];
+  const bannedInBase = everywhere.length ? wordPattern(everywhere, "iu") : undefined;
+  const bannedInTranslations = everywhere.length || translations.length ? wordPattern([...translations, ...everywhere], "iu") : undefined;
+  const bannedAllow = new Set(config.bannedWords?.allowKeys ?? []);
+  const brands = [...DEFAULT_BRANDS, ...config.identical?.brands ?? []];
+  const brandOrSymbols = new RegExp(`^[\\W\\d]*$|^(?:${brands.map(escapeRegExp).join("|")})\\b`, "i");
+  const identicalAllow = config.identical?.allowKeys ?? {};
+  const isAllowedIdentical = (key, locale) => {
+    const locales = Object.hasOwn(identicalAllow, key) ? identicalAllow[key] : undefined;
+    return locales === "all" || (locales?.includes(locale) ?? false);
+  };
+  return {
+    codeShape(value) {
+      const trimmed = value.trim();
+      if (!trimmed || codeAllow.has(trimmed))
+        return null;
+      const masked = maskPlaceholders(trimmed);
+      if (masked.includes(PLACEHOLDER_MASK))
+        return null;
+      if (/\s/.test(masked) && !EXPRESSION_FRAGMENT.test(masked))
+        return null;
+      return CODE_SHAPES.find(({ pattern }) => pattern.test(masked))?.name ?? null;
+    },
+    wrongLanguage(key, value) {
+      if (!markerPattern || wrongLanguageAllow.has(key))
+        return null;
+      const distinct = new Set((value.match(markerPattern) ?? []).map((m) => m.toLowerCase()));
+      if (distinct.size === 0)
+        return null;
+      if (distinct.size >= 2 || markerLetters?.test(value)) {
+        return [...distinct].sort().join(", ");
+      }
+      return null;
+    },
+    bannedWord(key, value, isBase) {
+      if (bannedAllow.has(key) || isExempt(key))
+        return null;
+      const pattern = isBase ? bannedInBase : bannedInTranslations;
+      return pattern?.exec(maskPlaceholders(value))?.[0] ?? null;
+    },
+    identicalLabel(key, locale, source, translated) {
+      if (source !== translated)
+        return false;
+      if (isAllowedIdentical(key, locale) || isExempt(key))
+        return false;
+      const value = translated.trim();
+      if (NON_PROSE.test(value) || brandOrSymbols.test(value))
+        return false;
+      if (NON_ASCII_LETTER.test(value))
+        return false;
+      return (value.match(/\p{L}{2,}/gu) ?? []).length >= 2;
+    }
+  };
+}
+
+// src/i18n/check.ts
+function defineI18nConfig2(config) {
+  return config;
+}
+function vueSyntaxIssues(compiler, key, value) {
+  const issues = [];
+  if (compiler.detectHtmlTag(value)) {
+    issues.push(`"${key}" contains HTML, which vue-i18n rejects with strictMessage: "${value}"`);
+  }
+  const errors = [];
+  compiler.baseCompile(value, {
+    onError: (error) => errors.push(error.message)
+  });
+  if (errors.length > 0) {
+    issues.push(`"${key}" is not valid vue-i18n syntax (${errors.join("; ")}): "${value}" - escape literal { } and @ with {'{'} {'}'} {'@'}`);
+  }
+  return issues;
+}
+function readCatalog(path, catalog, locale) {
+  try {
+    return parseMessages2(JSON.parse(readFileSync(path, "utf8")), catalog, locale);
+  } catch (error) {
+    return {
+      messages: undefined,
+      issues: [{ catalog, locale, message: `invalid JSON - ${String(error)}` }]
+    };
+  }
+}
+function collectSourceFiles(path, files = []) {
+  if (!existsSync(path))
+    return files;
+  if (statSync(path).isFile()) {
+    if (/\.(tsx?|jsx?|vue|svelte)$/.test(path) && !/\.test\./.test(path)) {
+      files.push(path);
+    }
+    return files;
+  }
+  for (const name of readdirSync(path)) {
+    if (name !== "node_modules")
+      collectSourceFiles(join(path, name), files);
+  }
+  return files;
+}
+var KEY_REFERENCE = /[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z0-9_]+)+/g;
+var KEY_FAMILY_PREFIX = /([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z0-9_]+)*\.)\$\{/g;
+function findUnusedKeys(root, catalog, keys) {
+  const references = new Set;
+  const prefixes = new Set(catalog.dynamicKeyPrefixes ?? []);
+  const catalogDir = join(root, catalog.dir) + sep;
+  const files = (catalog.sourceRoots ?? []).flatMap((dir) => collectSourceFiles(join(root, dir)));
+  for (const path of files) {
+    if (path.startsWith(catalogDir))
+      continue;
+    const source = readFileSync(path, "utf8");
+    for (const [reference] of source.matchAll(KEY_REFERENCE)) {
+      references.add(reference);
+    }
+    for (const [, prefix] of source.matchAll(KEY_FAMILY_PREFIX)) {
+      if (prefix)
+        prefixes.add(prefix);
+    }
+  }
+  return [...keys].filter((key) => !references.has(key) && ![...prefixes].some((prefix) => key.startsWith(prefix)));
+}
+var placeholderSet = (template) => extractPlaceholders2(template).sort().join(",");
+async function validateCatalogs2(config, options) {
+  const { root, checkGeneratedTypes = true } = options;
+  const { baseLocale } = config;
+  const locales = [...config.locales].sort();
+  const rules = createContentRules(config.rules);
+  const issues = [];
+  const baseByCatalog = new Map;
+  let compiler;
+  if (config.catalogs.some((catalog) => catalog.runtime === "vue-i18n")) {
+    try {
+      compiler = await import("@intlify/message-compiler");
+    } catch {
+      issues.push({
+        catalog: "config",
+        message: "vue-i18n catalogs need @intlify/message-compiler installed to check message syntax"
+      });
+    }
+  }
+  for (const catalog of config.catalogs) {
+    const report = (message, locale) => issues.push({ catalog: catalog.name, locale, message });
+    const syntax = (locale, key, value) => {
+      if (catalog.runtime !== "vue-i18n" || !compiler)
+        return;
+      for (const message of vueSyntaxIssues(compiler, key, value)) {
+        report(message, locale);
+      }
+    };
+    const dir = join(root, catalog.dir);
+    if (!existsSync(dir)) {
+      report(`catalog directory does not exist: ${catalog.dir}`);
+      continue;
+    }
+    const files = readdirSync(dir).filter((file) => file.endsWith(".json")).map((file) => file.slice(0, -".json".length));
+    const missingFiles = locales.filter((locale) => !files.includes(locale));
+    const extraFiles = files.filter((locale) => !locales.includes(locale));
+    if (missingFiles.length > 0) {
+      report(`missing locale file(s): ${missingFiles.join(", ")}`);
+    }
+    if (extraFiles.length > 0) {
+      report(`unregistered locale file(s): ${extraFiles.sort().join(", ")}`);
+    }
+    const basePath = join(dir, `${baseLocale}.json`);
+    if (!existsSync(basePath))
+      continue;
+    const baseResult = readCatalog(basePath, catalog.name, baseLocale);
+    issues.push(...baseResult.issues);
+    if (!baseResult.messages)
+      continue;
+    baseByCatalog.set(catalog.name, baseResult.messages);
+    const base = flattenCatalog(baseResult.messages);
+    for (const [key, value] of base) {
+      const shape = rules.codeShape(value);
+      if (shape) {
+        report(`"${key}" looks like source code, not copy (${shape}): "${value}" - restore the expression at the call site instead of translating it`, baseLocale);
+      }
+      const markers = rules.wrongLanguage(key, value);
+      if (markers) {
+        report(`"${key}" is not ${baseLocale} (${markers}): "${value}"`, baseLocale);
+      }
+      const banned = rules.bannedWord(key, value, true);
+      if (banned) {
+        report(`"${key}" uses banned vocabulary "${banned}": "${value}"`, baseLocale);
+      }
+      syntax(baseLocale, key, value);
+    }
+    for (const locale of locales) {
+      if (locale === baseLocale)
+        continue;
+      const path = join(dir, `${locale}.json`);
+      if (!existsSync(path))
+        continue;
+      const result = readCatalog(path, catalog.name, locale);
+      issues.push(...result.issues);
+      if (!result.messages)
+        continue;
+      const translated = flattenCatalog(result.messages);
+      const stale = [...translated.keys()].filter((key) => !base.has(key));
+      const missing = [...base.keys()].filter((key) => !translated.has(key));
+      if (stale.length > 0) {
+        report(`stale key(s) not in ${baseLocale}.json: ${stale.join(", ")}`, locale);
+      }
+      if (missing.length > 0) {
+        report(`missing translation key(s): ${missing.join(", ")}`, locale);
+      }
+      for (const [key, value] of translated) {
+        const shape = rules.codeShape(value);
+        if (shape) {
+          report(`"${key}" looks like source code, not copy (${shape}): "${value}"`, locale);
+        }
+        const banned = rules.bannedWord(key, value, false);
+        if (banned) {
+          report(`"${key}" uses banned vocabulary "${banned}": "${value}"`, locale);
+        }
+        const source = base.get(key);
+        if (source !== undefined) {
+          if (rules.identicalLabel(key, locale, source, value)) {
+            report(`"${key}" is identical to ${baseLocale}: "${value}" - translate it, or allow it in rules.identical.allowKeys if it is correct as-is`, locale);
+          }
+          if (placeholderSet(source) !== placeholderSet(value)) {
+            report(`placeholder mismatch on "${key}" (${baseLocale}: "${source}" vs ${locale}: "${value}")`, locale);
+          }
+        }
+        syntax(locale, key, value);
+      }
+    }
+    if (catalog.sourceRoots?.length) {
+      const byNamespace = new Map;
+      for (const key of findUnusedKeys(root, catalog, base.keys())) {
+        const namespace = key.split(".")[0] ?? key;
+        byNamespace.set(namespace, [...byNamespace.get(namespace) ?? [], key]);
+      }
+      const scanned = catalog.sourceRoots.join(", ");
+      for (const [namespace, keys] of [...byNamespace].sort(([a], [b]) => a.localeCompare(b))) {
+        report(`${keys.length} unused key(s) under "${namespace}" - nothing in ${scanned} references them: ${keys.join(", ")}`);
+      }
+    }
+    if (checkGeneratedTypes && catalog.generatedTypes) {
+      const path = join(root, catalog.generatedTypes);
+      const expected = generateCatalogTypes2(catalog, baseResult.messages);
+      const actual = existsSync(path) ? readFileSync(path, "utf8") : null;
+      if (actual !== expected) {
+        report(`generated types are stale; run hanzio-i18n generate (${relative(root, path)})`);
+      }
+    }
+  }
+  for (const group of config.disjointNamespaces ?? []) {
+    const owners = new Map;
+    const collisions = new Set;
+    for (const name of group) {
+      for (const namespace of Object.keys(baseByCatalog.get(name) ?? {})) {
+        if (owners.has(namespace))
+          collisions.add(namespace);
+        else
+          owners.set(namespace, name);
+      }
+    }
+    if (collisions.size > 0) {
+      issues.push({
+        catalog: group.join("/"),
+        message: `shared top-level namespace(s): ${[...collisions].join(", ")}`
+      });
+    }
+  }
+  return issues;
+}
+function writeCatalogTypes2(config, options) {
+  const outputs = [];
+  const issues = [];
+  for (const catalog of config.catalogs) {
+    if (!catalog.generatedTypes)
+      continue;
+    const parsed = readCatalog(join(options.root, catalog.dir, `${config.baseLocale}.json`), catalog.name, config.baseLocale);
+    issues.push(...parsed.issues);
+    if (!parsed.messages)
+      continue;
+    outputs.push({
+      path: join(options.root, catalog.generatedTypes),
+      contents: generateCatalogTypes2(catalog, parsed.messages)
+    });
+  }
+  if (issues.length > 0)
+    return { written: [], issues };
+  for (const { path, contents } of outputs) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, contents);
+  }
+  return { written: outputs.map(({ path }) => path), issues };
+}
+
+export { parseMessages2, generateCatalogTypes2, defineI18nConfig2, validateCatalogs2, writeCatalogTypes2 };

package/dist/{index-hy7kbb99.js → index-5tzqfmnj.js}

@@ -1,6 +1,6 @@
 import {
   stableStringify2
-} from "./index-kj1phgrx.js";
+} from "./index-29mmh343.js";
 
 // src/array/index.ts
 function chunkArray2(array, chunkSize) {

package/dist/{index-0zvtcbzy.js → index-6f2w90pp.js}

@@ -138,6 +138,74 @@ async function pMap2(items, fn, options = {}) {
   await Promise.all(Array.from({ length: Math.min(concurrency, list.length) }, worker));
   return results;
 }
+function createTaskPool2(options) {
+  const { concurrency, signal, stopOnError = true } = options;
+  if (!Number.isInteger(concurrency) || concurrency < 1)
+    throw new Error(`Task concurrency must be a positive integer, got ${concurrency}`);
+  const queued = [];
+  const idle = [];
+  let active = 0;
+  let failed = false;
+  let failure;
+  const throwIfFailed = () => {
+    signal?.throwIfAborted();
+    if (failed)
+      throw failure;
+  };
+  const stop = (error) => {
+    if (!failed) {
+      failed = true;
+      failure = error;
+    }
+    for (const task of queued.splice(0))
+      task.reject(failure);
+  };
+  const dispatch = () => {
+    if (signal?.aborted)
+      stop(signal.reason);
+    while (!failed && active < concurrency && queued.length) {
+      active += 1;
+      queued.shift().start();
+    }
+    if (!active && !queued.length)
+      for (const resolve of idle.splice(0))
+        resolve();
+  };
+  const run = (task) => {
+    const result = new Promise((resolve, reject) => {
+      if (failed || signal?.aborted) {
+        stop(signal?.aborted ? signal.reason : failure);
+        reject(failure);
+        return;
+      }
+      queued.push({
+        reject,
+        start: () => {
+          Promise.resolve().then(() => {
+            throwIfFailed();
+            return task();
+          }).then(resolve, (error) => {
+            if (stopOnError || signal?.aborted)
+              stop(error);
+            reject(error);
+          }).finally(() => {
+            active -= 1;
+            dispatch();
+          });
+        }
+      });
+      dispatch();
+    });
+    result.catch(() => {});
+    return result;
+  };
+  const drain = async () => {
+    if (active || queued.length)
+      await new Promise((resolve) => idle.push(resolve));
+    throwIfFailed();
+  };
+  return { run, drain, throwIfFailed };
+}
 var clock = () => globalThis.performance?.now() ?? Date.now();
 function startTimer2() {
   const start = clock();
@@ -221,4 +289,4 @@ function createLatestGuard2() {
   };
 }
 
-export { ok2, err2, isSuccess2, isFailure2, unwrapResult2, backgroundPromise2, backgroundPromiseSync2, promiseTimeout2, tryCatch2, PromiseTimeoutError2, withTimeout2, exponentialBackoff2, retry2, pMap2, startTimer2, timed2, anySignal2, timeoutSignal2, raceAbort2, createLatestGuard2 };
+export { ok2, err2, isSuccess2, isFailure2, unwrapResult2, backgroundPromise2, backgroundPromiseSync2, promiseTimeout2, tryCatch2, PromiseTimeoutError2, withTimeout2, exponentialBackoff2, retry2, pMap2, createTaskPool2, startTimer2, timed2, anySignal2, timeoutSignal2, raceAbort2, createLatestGuard2 };