@noy-db/hub 0.3.0-pre.1 → 0.3.0-pre.11

package/dist/chunk-BE7N3AXA.js

@@ -0,0 +1,621 @@
+import {
+  installViaBinder
+} from "./chunk-ARSAMO24.js";
+import {
+  LocaleNotSpecifiedError,
+  MissingTranslationError,
+  ScriptViolationError,
+  TranslatorNotConfiguredError
+} from "./chunk-FH542DDY.js";
+
+// src/port/with/i18n-strategy.ts
+function notEnabled(op) {
+  return new Error(
+    `${op} requires the i18n strategy. Import \`{ withI18n }\` from "@noy-db/hub/i18n" and pass it to \`createNoydb({ i18nStrategy: withI18n() })\`.`
+  );
+}
+var NO_I18N = {
+  applyI18nLocale(record) {
+    return record;
+  },
+  validateI18nTextValue() {
+    throw notEnabled("i18nText field validation");
+  },
+  enforceScript(value) {
+    return { value, warnings: [] };
+  },
+  computeExemptFills() {
+    return /* @__PURE__ */ new Map();
+  },
+  densify() {
+  },
+  buildDictionaryHandle() {
+    throw notEnabled("vault.dictionary()");
+  }
+};
+function isDictCollectionName(name) {
+  return name.startsWith("_dict_");
+}
+function isStaticDictDescriptor(x) {
+  return typeof x === "object" && x !== null && x._noydbStaticDict === true;
+}
+function isI18nTextDescriptor(x) {
+  return typeof x === "object" && x !== null && x._noydbI18nText === true;
+}
+function isDictKeyDescriptor(x) {
+  return typeof x === "object" && x !== null && x._noydbDictKey === true;
+}
+
+// src/kernel/paths.ts
+function getAtPath(obj, path) {
+  const arrayIdx = path.indexOf("[].");
+  if (arrayIdx !== -1) {
+    const arrayKey = path.slice(0, arrayIdx);
+    const restPath = path.slice(arrayIdx + 3);
+    const arr = obj[arrayKey];
+    if (!Array.isArray(arr)) return [];
+    return arr.flatMap((item) => {
+      if (!item || typeof item !== "object" || Array.isArray(item)) return [];
+      return getAtPath(item, restPath);
+    });
+  }
+  const dotIdx = path.indexOf(".");
+  if (dotIdx !== -1) {
+    const head = path.slice(0, dotIdx);
+    const rest = path.slice(dotIdx + 1);
+    const nested = obj[head];
+    if (!nested || typeof nested !== "object" || Array.isArray(nested)) return [];
+    return getAtPath(nested, rest);
+  }
+  const val = obj[path];
+  return val !== void 0 ? [val] : [];
+}
+function setAtPathInPlace(obj, path, value) {
+  const dotIdx = path.indexOf(".");
+  if (dotIdx !== -1) {
+    const head = path.slice(0, dotIdx);
+    const rest = path.slice(dotIdx + 1);
+    const nested = obj[head];
+    if (!nested || typeof nested !== "object" || Array.isArray(nested)) return;
+    setAtPathInPlace(nested, rest, value);
+    return;
+  }
+  obj[path] = value;
+}
+
+// src/via/i18n/policy.ts
+function resolvePolicy(onMissing, layer) {
+  const explicit = onMissing && typeof onMissing === "object" ? onMissing[layer] : void 0;
+  const scalar = typeof onMissing === "string" ? onMissing : void 0;
+  const layerDefault = layer === "guard" ? "substitute" : void 0;
+  return explicit ?? layerDefault ?? scalar ?? "throw";
+}
+
+// src/via/i18n/script.ts
+var LATIN_BASE = /* @__PURE__ */ new Set([
+  "en",
+  "fr",
+  "de",
+  "es",
+  "it",
+  "pt",
+  "nl",
+  "sv",
+  "no",
+  "da",
+  "fi",
+  "is",
+  "pl",
+  "cs",
+  "sk",
+  "hu",
+  "ro",
+  "hr",
+  "sl",
+  "et",
+  "lv",
+  "lt",
+  "tr",
+  "vi",
+  "id",
+  "ms",
+  "tl",
+  "sw",
+  "af",
+  "ca",
+  "gl",
+  "eu",
+  "cy",
+  "ga"
+]);
+var SCRIPT_TABLE = {
+  th: ["Thai"],
+  ko: ["Hangul", "Han"],
+  ja: ["Han", "Hiragana", "Katakana"],
+  zh: ["Han"],
+  ar: ["Arabic"],
+  fa: ["Arabic"],
+  ur: ["Arabic"],
+  ru: ["Cyrillic"],
+  uk: ["Cyrillic"],
+  bg: ["Cyrillic"],
+  sr: ["Cyrillic"],
+  he: ["Hebrew"],
+  el: ["Greek"],
+  hi: ["Devanagari"],
+  ta: ["Tamil"],
+  km: ["Khmer"],
+  lo: ["Lao"],
+  my: ["Myanmar"]
+};
+var SUBTAG_SCRIPTS = {
+  Latn: ["Latin"],
+  Cyrl: ["Cyrillic", "Latin"],
+  Hans: ["Han", "Latin"],
+  Hant: ["Han", "Latin"],
+  Thai: ["Thai", "Latin"],
+  Arab: ["Arabic", "Latin"]
+};
+function inferScripts(locale) {
+  const parts = locale.split("-");
+  const subtag = parts.find((t) => /^[A-Z][a-z]{3}$/.test(t));
+  if (subtag && SUBTAG_SCRIPTS[subtag]) return SUBTAG_SCRIPTS[subtag];
+  const base = (parts[0] ?? "").toLowerCase();
+  if (LATIN_BASE.has(base)) return ["Latin"];
+  const primary = SCRIPT_TABLE[base];
+  if (primary) return [...primary, "Latin"];
+  return ["Latin"];
+}
+function allowedFor(descriptor, locale) {
+  const script = descriptor.options.script;
+  if (script && script !== "auto") {
+    const explicit = script[locale];
+    if (explicit) return explicit;
+  }
+  return inferScripts(locale);
+}
+var BASELINE = String.raw`\p{White_Space}\p{Script=Common}\p{Script=Inherited}\p{Mark}`;
+function fullMatcher(scripts) {
+  const cls = scripts.map((s) => `\\p{Script=${s}}`).join("");
+  return new RegExp(`^[${BASELINE}${cls}]*$`, "u");
+}
+function charMatcher(scripts) {
+  const cls = scripts.map((s) => `\\p{Script=${s}}`).join("");
+  return new RegExp(`[${BASELINE}${cls}]`, "u");
+}
+function offendingSample(str, scripts) {
+  const ok = charMatcher(scripts);
+  const bad = [];
+  for (const ch of str) {
+    if (!ok.test(ch)) bad.push(ch);
+    if (bad.length >= 8) break;
+  }
+  return bad.join("");
+}
+function stripDisallowed(str, scripts) {
+  const ok = charMatcher(scripts);
+  let out = "";
+  for (const ch of str) if (ok.test(ch)) out += ch;
+  return out;
+}
+function enforceScript(value, field, descriptor, exempt) {
+  const opt = descriptor.options;
+  if (!opt.script) return { value, warnings: [] };
+  const mode = opt.onScriptViolation ?? "reject";
+  const warnings = [];
+  let out = value;
+  for (const [locale, raw] of Object.entries(value)) {
+    if (exempt?.has(locale)) continue;
+    if (typeof raw !== "string") continue;
+    const allowed = allowedFor(descriptor, locale);
+    if (fullMatcher(allowed).test(raw)) continue;
+    const sample = offendingSample(raw, allowed);
+    if (mode === "reject") {
+      throw new ScriptViolationError(field, locale, allowed, sample);
+    }
+    warnings.push({ field, locale, expected: allowed, sample });
+    if (mode === "filter") {
+      if (out === value) out = { ...value };
+      out[locale] = stripDisallowed(raw, allowed);
+    }
+  }
+  return { value: out, warnings };
+}
+
+// src/via/i18n/binding.ts
+async function runI18nAutoTranslate(record, i18nFields, cfg) {
+  for (const [field, descriptor] of Object.entries(i18nFields)) {
+    if (!descriptor.options.autoTranslate) continue;
+    const leafValues = getAtPath(record, field);
+    if (leafValues.length !== 1) continue;
+    const value = leafValues[0];
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    const map = value;
+    const { languages, required } = descriptor.options;
+    const missing = languages.filter(
+      (lang) => !(lang in map) || map[lang] === ""
+    );
+    if (missing.length === 0) continue;
+    const sourceLocale = languages.find((l) => l in map && map[l] !== "");
+    if (!sourceLocale) continue;
+    if (!cfg.autoTranslateHook) {
+      throw new TranslatorNotConfiguredError(field, cfg.collectionName);
+    }
+    const toTranslate = required === "any" ? [] : required === "all" ? missing : missing.filter((l) => required.includes(l));
+    const translated = { ...map };
+    for (const targetLocale of toTranslate) {
+      translated[targetLocale] = await cfg.autoTranslateHook(
+        map[sourceLocale],
+        sourceLocale,
+        targetLocale,
+        field,
+        cfg.collectionName
+      );
+    }
+    setAtPathInPlace(record, field, translated);
+  }
+}
+function runI18nScriptEnforcement(record, i18nFields, strategy, exemptFills, ctx, cfg) {
+  for (const [field, descriptor] of Object.entries(i18nFields)) {
+    if (!descriptor.options.script) continue;
+    for (const leaf of getAtPath(record, field)) {
+      if (!leaf || typeof leaf !== "object" || Array.isArray(leaf)) continue;
+      const leafMap = leaf;
+      const { value: cleaned, warnings } = strategy.enforceScript(
+        leafMap,
+        field,
+        descriptor,
+        exemptFills?.get(field)
+      );
+      if (cleaned !== leafMap) Object.assign(leafMap, cleaned);
+      const mode = descriptor.options.onScriptViolation;
+      if (mode === "warn" || mode === "filter") {
+        for (const w of warnings) {
+          ctx.emit("i18n:script-violation", {
+            vault: ctx.vault,
+            collection: cfg.collectionName,
+            id: ctx.id,
+            mode,
+            warning: w
+          });
+        }
+      }
+    }
+  }
+}
+async function runI18nWriteStages(record, ctx, cfg) {
+  const i18nFields = cfg.i18nFields;
+  const i18nDensifyFields = cfg.i18nDensifyFields;
+  const strategy = cfg.strategy;
+  if (i18nFields) {
+    await runI18nAutoTranslate(record, i18nFields, cfg);
+  }
+  let densifyPrior;
+  let exemptFills;
+  if (i18nDensifyFields) {
+    densifyPrior = await ctx.prior() ?? void 0;
+    exemptFills = strategy.computeExemptFills(densifyPrior, record, i18nDensifyFields);
+  }
+  if (i18nFields) {
+    runI18nScriptEnforcement(record, i18nFields, strategy, exemptFills, ctx, cfg);
+  }
+  cfg.i18nPutValidator?.(record);
+  if (i18nDensifyFields) {
+    strategy.densify(record, densifyPrior, i18nDensifyFields);
+  }
+  return record;
+}
+async function runI18nPresent(record, ctx, cfg) {
+  const i18nFields = cfg.i18nFields;
+  const dictKeyFields = cfg.dictKeyFields;
+  const strategy = cfg.strategy;
+  const hasI18n = i18nFields !== void 0 && Object.keys(i18nFields).length > 0;
+  const hasDict = dictKeyFields !== void 0 && Object.keys(dictKeyFields).length > 0;
+  if (!hasI18n && !hasDict) return record;
+  const locale = typeof ctx.locale === "string" ? ctx.locale : void 0;
+  const fallback = ctx.fallback;
+  const layer = ctx.layer;
+  let result = record;
+  const hasStaticDisplay = hasDict && dictKeyFields !== void 0 && Object.values(dictKeyFields).some(
+    (d) => isStaticDictDescriptor(d) && d.displayLocale !== void 0
+  );
+  if (!locale && !hasStaticDisplay) return stripI18nFilled(result);
+  if (locale && hasI18n && i18nFields) {
+    result = strategy.applyI18nLocale(result, i18nFields, locale, fallback, layer);
+  }
+  if (hasDict && dictKeyFields && cfg.dictLabelResolver && locale !== "raw") {
+    const withLabels = { ...result };
+    const resolver = cfg.dictLabelResolver;
+    for (const [field, desc] of Object.entries(dictKeyFields)) {
+      const policy = desc.onMissing ? resolvePolicy(desc.onMissing, layer) : "null";
+      const fieldFallback = policy === "substitute" ? fallback ?? desc.substitute : fallback;
+      const effLocale = locale ?? (isStaticDictDescriptor(desc) ? desc.displayLocale : void 0);
+      const resolveKey = async (key) => {
+        if (!effLocale) {
+          if (policy === "throw") {
+            throw new LocaleNotSpecifiedError(
+              field,
+              `dictKey "${field}": no locale active to resolve key "${key}".`
+            );
+          }
+          return null;
+        }
+        const label = await resolver(desc.name, key, effLocale, fieldFallback);
+        if (label === void 0) {
+          if (policy === "throw") {
+            throw new LocaleNotSpecifiedError(
+              field,
+              `dictKey "${field}": no label for key "${key}" in locale "${effLocale}".`
+            );
+          }
+          return null;
+        }
+        return label;
+      };
+      if (field.includes("[].")) {
+        const parts = field.split("[].");
+        const arrayKey = parts[0];
+        const leaf = parts[1];
+        if (!leaf || leaf.includes(".")) continue;
+        const arr = withLabels[arrayKey];
+        if (!Array.isArray(arr)) continue;
+        const labelKey = `${leaf}Label`;
+        withLabels[arrayKey] = await Promise.all(
+          arr.map(async (el) => {
+            if (!el || typeof el !== "object" || Array.isArray(el)) return el;
+            const k = el[leaf];
+            if (typeof k !== "string") return el;
+            return { ...el, [labelKey]: await resolveKey(k) };
+          })
+        );
+        continue;
+      }
+      const val = result[field];
+      if (Array.isArray(val)) {
+        withLabels[`${field}Label`] = await Promise.all(
+          val.map(async (k) => ({
+            key: k,
+            label: typeof k === "string" ? await resolveKey(k) : null
+          }))
+        );
+      } else if (typeof val === "string") {
+        const label = await resolveKey(val);
+        if (label !== null) withLabels[`${field}Label`] = label;
+      }
+    }
+    result = withLabels;
+  }
+  return stripI18nFilled(result);
+}
+function buildI18nDescribeFragment(cfg) {
+  return {
+    i18nFields: cfg.i18nFields ? Object.keys(cfg.i18nFields) : [],
+    dictKeyFields: cfg.dictKeyFields ? Object.keys(cfg.dictKeyFields) : [],
+    ...cfg.defaultLocale !== void 0 ? { defaultLocale: cfg.defaultLocale } : {}
+  };
+}
+function i18nBinding(cfg) {
+  return {
+    brand: "i18n",
+    posture: { encryptedAtRest: "envelope", queryable: "full", exportable: true, forgettable: true },
+    // DictionaryHandle's `_dict_*` reserved collections (#629 Task 4) — the
+    // codec boundary's `reservedEnvelopes` door may address any collection
+    // name under this prefix.
+    reservedPrefixes: ["_dict_"],
+    covers: (field) => cfg.i18nFields !== void 0 && field in cfg.i18nFields || cfg.dictKeyFields !== void 0 && field in cfg.dictKeyFields,
+    encodeWrite: async (record, ctx) => runI18nWriteStages(record, ctx, cfg),
+    present: async (record, ctx) => runI18nPresent(record, ctx, cfg),
+    describeFragment: () => buildI18nDescribeFragment(cfg)
+  };
+}
+function linkI18nVia() {
+  installViaBinder("i18n", (c) => i18nBinding(c));
+}
+
+// src/via/i18n/core.ts
+function i18nText(options) {
+  linkI18nVia();
+  if (options.densifyOnWrite === true && hasThrowPolicy(options.onMissing)) {
+    throw new Error(
+      `i18nText: densifyOnWrite cannot be combined with an explicit onMissing 'throw' policy \u2014 densify fills every empty slot, so a 'throw' would be unreachable. Remove the 'throw' policy or disable densifyOnWrite.`
+    );
+  }
+  return { _noydbI18nText: true, _viaBrand: "i18n", options };
+}
+function hasThrowPolicy(onMissing) {
+  if (onMissing === void 0) return false;
+  if (typeof onMissing === "string") return onMissing === "throw";
+  return Object.values(onMissing).includes("throw");
+}
+function validateI18nTextValue(value, field, descriptor) {
+  const { options } = descriptor;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new MissingTranslationError(
+      field,
+      options.languages,
+      `Field "${field}" must be a { [locale]: string } map, got ${typeof value}.`
+    );
+  }
+  const map = value;
+  for (const [locale, v] of Object.entries(map)) {
+    if (typeof v !== "string") {
+      throw new MissingTranslationError(
+        field,
+        [locale],
+        `Field "${field}": locale "${locale}" must be a string, got ${typeof v}.`
+      );
+    }
+  }
+  const { required } = options;
+  if (required === "all") {
+    const missing = options.languages.filter(
+      (lang) => !(lang in map) || map[lang] === ""
+    );
+    if (missing.length > 0) {
+      throw new MissingTranslationError(
+        field,
+        missing,
+        `Field "${field}" requires all declared languages. Missing: ${missing.join(", ")}.`
+      );
+    }
+  } else if (required === "any") {
+    const present = options.languages.some(
+      (lang) => lang in map && map[lang] !== ""
+    );
+    if (!present) {
+      throw new MissingTranslationError(
+        field,
+        options.languages,
+        `Field "${field}" requires at least one declared language. None present.`
+      );
+    }
+  } else {
+    const requiredList = required;
+    const missing = requiredList.filter(
+      (lang) => !(lang in map) || map[lang] === ""
+    );
+    if (missing.length > 0) {
+      throw new MissingTranslationError(
+        field,
+        missing,
+        `Field "${field}" requires: ${requiredList.join(", ")}. Missing: ${missing.join(", ")}.`
+      );
+    }
+  }
+}
+function toChain(fallback) {
+  return Array.isArray(fallback) ? fallback : fallback ? [fallback] : [];
+}
+function pickFromChain(value, chain) {
+  for (const fb of chain) {
+    if (fb === "any") {
+      const any = Object.values(value).find((v) => v !== "");
+      if (any !== void 0) return any;
+    } else if (value[fb] !== void 0 && value[fb] !== "") {
+      return value[fb];
+    }
+  }
+  return void 0;
+}
+function resolveI18nText(value, locale, fallback, field, opts) {
+  if (locale === "raw") {
+    return value;
+  }
+  if (!locale) {
+    throw new LocaleNotSpecifiedError(field ?? "<unknown>");
+  }
+  if (value[locale] !== void 0 && value[locale] !== "") {
+    return value[locale];
+  }
+  const policy = opts?.policy ?? "throw";
+  const callerChain = toChain(fallback);
+  const callerHit = pickFromChain(value, callerChain);
+  if (callerHit !== void 0) return callerHit;
+  if (policy === "substitute") {
+    const subHit = pickFromChain(value, toChain(opts?.substitute));
+    if (subHit !== void 0) return subHit;
+    if (opts?.smartSubstitute) {
+      const smartHit = pickNearestScript(value, locale);
+      if (smartHit !== void 0) return smartHit;
+    }
+  }
+  if (policy === "throw") {
+    throw new LocaleNotSpecifiedError(
+      field ?? "<unknown>",
+      `No translation available for locale "${locale}"` + (callerChain.length > 0 ? ` or fallback chain [${callerChain.join(", ")}]` : "") + "."
+    );
+  }
+  return null;
+}
+function pickNearestScript(value, target) {
+  const targetScript = inferScripts(target)[0] ?? "Latin";
+  let best;
+  for (const [loc, v] of Object.entries(value)) {
+    if (typeof v !== "string" || v === "") continue;
+    const s = inferScripts(loc)[0] ?? "Latin";
+    const score = s === targetScript ? 0 : s === "Latin" ? 1 : 2;
+    if (best === void 0 || score < best.score) best = { score, v };
+    if (score === 0) break;
+  }
+  return best?.v;
+}
+function applyAtPath(obj, path, locale, fallback, opts) {
+  const arrayIdx = path.indexOf("[].");
+  if (arrayIdx !== -1) {
+    const arrayKey = path.slice(0, arrayIdx);
+    const restPath = path.slice(arrayIdx + 3);
+    const arr = obj[arrayKey];
+    if (!Array.isArray(arr)) return obj;
+    return {
+      ...obj,
+      [arrayKey]: arr.map((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item)) return item;
+        return applyAtPath(item, restPath, locale, fallback, opts);
+      })
+    };
+  }
+  const dotIdx = path.indexOf(".");
+  if (dotIdx !== -1) {
+    const head = path.slice(0, dotIdx);
+    const rest = path.slice(dotIdx + 1);
+    const nested = obj[head];
+    if (!nested || typeof nested !== "object" || Array.isArray(nested)) return obj;
+    return {
+      ...obj,
+      [head]: applyAtPath(nested, rest, locale, fallback, opts)
+    };
+  }
+  const raw = obj[path];
+  if (raw === void 0 || raw === null) return obj;
+  if (typeof raw !== "object" || Array.isArray(raw)) return obj;
+  return {
+    ...obj,
+    [path]: resolveI18nText(raw, locale, fallback, path, opts)
+  };
+}
+function applyI18nLocale(record, i18nFields, locale, fallback, layer = "read") {
+  const fieldNames = Object.keys(i18nFields);
+  if (fieldNames.length === 0) return record;
+  let result = record;
+  for (const [field, descriptor] of Object.entries(i18nFields)) {
+    const { onMissing, substitute, smartSubstitute } = descriptor.options;
+    const opts = {
+      policy: resolvePolicy(onMissing, layer),
+      ...substitute !== void 0 ? { substitute } : {},
+      ...smartSubstitute ? { smartSubstitute } : {}
+    };
+    result = applyAtPath(result, field, locale, fallback, opts);
+  }
+  result = stripI18nFilled(result);
+  return result;
+}
+function presentI18nForJoin(record, i18nFields, locale) {
+  return applyI18nLocale(record, i18nFields, locale, void 0, "join");
+}
+function stripI18nFilled(record) {
+  if (!Object.prototype.hasOwnProperty.call(record, "_i18nFilled")) return record;
+  const rest = { ...record };
+  delete rest._i18nFilled;
+  return rest;
+}
+
+export {
+  NO_I18N,
+  isDictCollectionName,
+  isStaticDictDescriptor,
+  isI18nTextDescriptor,
+  isDictKeyDescriptor,
+  getAtPath,
+  setAtPathInPlace,
+  resolvePolicy,
+  inferScripts,
+  enforceScript,
+  linkI18nVia,
+  i18nText,
+  validateI18nTextValue,
+  resolveI18nText,
+  applyI18nLocale,
+  presentI18nForJoin,
+  stripI18nFilled
+};
+//# sourceMappingURL=chunk-BE7N3AXA.js.map