@babelize/engine 0.0.0-stage → 0.1.2

package/dist/modules/glossary/rules.d.ts

@@ -0,0 +1,81 @@
+import type { AlwaysTranslateAsEntry, GlossaryEntryType } from './types';
+/**
+ * Regex source matching `term` as a whole term: not preceded or followed by a
+ * letter, digit or underscore in any script ("Café" matches in "Café menu",
+ * "app" does not match in "apply" or "appé"). Use with the `u` flag.
+ */
+export declare function termPattern(term: string): string;
+/** Whether `text` contains `term` as a whole term, ignoring case. */
+export declare function containsTerm(text: string, term: string): boolean;
+/**
+ * The words of a source string a glossary rule can apply to: placeholders,
+ * tags, URLs, emails and code removed, and for an ICU message its argument
+ * names and selector keys too. "Open https://x.com/dashboard" has no
+ * "dashboard" a translator would translate. With `neverTranslate`, those
+ * terms are removed too: "Dashboard" in "Babelize Dashboard" (never
+ * translated) is not a use of a "Dashboard" rule.
+ */
+export declare function translatableText(source: string, neverTranslate?: readonly string[]): string;
+/**
+ * Whether a glossary term occurs in a source string's translatable text (see
+ * translatableText). Pass the never-translate terms when asking about an
+ * "always translate as" term: inside a never-translate term it doesn't count.
+ */
+export declare function sourceHasTerm(source: string, term: string, neverTranslate?: readonly string[]): boolean;
+/**
+ * BCP-47 casing for a locale code: `pt_br` / `PT-br` → `pt-BR`,
+ * `zh-hant` → `zh-Hant`, `es-419` stays. Anything that isn't
+ * language[-Script][-REGION] is returned trimmed, otherwise unchanged.
+ */
+export declare function canonicalLocale(code: string): string;
+/** Keys of a locale → value record in canonical form; on a clash the first key (in insertion order) wins. */
+export declare function canonicalizeLocaleKeys(record: Record<string, string> | null | undefined): Record<string, string>;
+/**
+ * The value for `locale` in a locale-keyed record: the exact locale (in any
+ * casing / separator), else its base language (`pt` serves `pt-BR`).
+ */
+export declare function localeValue(record: Record<string, string> | null | undefined, locale: string): string | undefined;
+export interface GlossaryRuleInput {
+    term: string;
+    type: GlossaryEntryType | string;
+    translations?: Record<string, string> | null;
+}
+/** A project's glossary after normalization: deduplicated, deterministic, conflicts resolved. */
+export interface GlossaryRules {
+    neverTranslate: string[];
+    alwaysTranslateAs: AlwaysTranslateAsEntry[];
+    /** Terms that had conflicting rules, with how the conflict was resolved (for QA notes). */
+    conflicts: Array<{
+        term: string;
+        message: string;
+    }>;
+}
+export declare const EMPTY_GLOSSARY: GlossaryRules;
+/**
+ * Normalize raw glossary entries. Terms match case-insensitively, so entries
+ * are grouped by lowercased term:
+ * - never-translate wins over always-translate-as for the same term (keeping
+ *   a term as-is can't corrupt the output; a translation for the wrong sense can);
+ * - several always-translate-as entries merge their locales (the first entry,
+ *   in term order, wins a locale they both define);
+ * - locale keys are canonicalized (`pt_br` → `pt-BR`).
+ * The result doesn't depend on the input order.
+ */
+export declare function normalizeGlossary(entries: GlossaryRuleInput[]): GlossaryRules;
+/** Always-translate-as terms with a translation for `locale` (exact, then base language). */
+export declare function fixedTermsFor(rules: GlossaryRules, locale: string): Array<{
+    term: string;
+    translation: string;
+}>;
+/** Whether `source` contains an always-translate-as term that has a translation for `locale`. */
+export declare function hasFixedTerm(source: string, rules: GlossaryRules, locale: string): boolean;
+/**
+ * Fingerprint of the glossary rules that shape `source`'s translation into
+ * `locale`: the never-translate terms it contains and the always-translate-as
+ * terms it contains with their translation for the locale. Empty when no rule
+ * applies, so adding a rule for an unrelated term changes nothing. Stored per
+ * locale in the lockfile: a key is re-translated when this changes.
+ */
+export declare function glossaryFingerprint(source: string, locale: string, rules: GlossaryRules): string;
+/** QA notes for conflicting rules whose term occurs in `source`. */
+export declare function conflictNotes(source: string, rules: GlossaryRules): string[];

package/dist/modules/glossary/rules.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMPTY_GLOSSARY = void 0;
+exports.termPattern = termPattern;
+exports.containsTerm = containsTerm;
+exports.translatableText = translatableText;
+exports.sourceHasTerm = sourceHasTerm;
+exports.canonicalLocale = canonicalLocale;
+exports.canonicalizeLocaleKeys = canonicalizeLocaleKeys;
+exports.localeValue = localeValue;
+exports.normalizeGlossary = normalizeGlossary;
+exports.fixedTermsFor = fixedTermsFor;
+exports.hasFixedTerm = hasFixedTerm;
+exports.glossaryFingerprint = glossaryFingerprint;
+exports.conflictNotes = conflictNotes;
+/**
+ * Project glossary rules, shared by the translate phase, locale QA, prompt
+ * hints and the CLI/MCP. One place decides how a term matches, which
+ * translation applies to a locale, and what happens when rules conflict.
+ */
+const crypto_1 = require("crypto");
+const placeholder_protection_1 = require("../../utils/placeholder-protection");
+const icu_message_1 = require("../../utils/icu-message");
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Regex source matching `term` as a whole term: not preceded or followed by a
+ * letter, digit or underscore in any script ("Café" matches in "Café menu",
+ * "app" does not match in "apply" or "appé"). Use with the `u` flag.
+ */
+function termPattern(term) {
+    return `(?<![\\p{L}\\p{N}_])${escapeRegex(term)}(?![\\p{L}\\p{N}_])`;
+}
+const termRegexes = new Map();
+/** Whether `text` contains `term` as a whole term, ignoring case. */
+function containsTerm(text, term) {
+    if (!term.trim())
+        return false;
+    // Cheap pre-check: most (key, term) pairs share nothing.
+    if (!text.toLowerCase().includes(term.toLowerCase())) {
+        // toLowerCase can change length for a few letters (İ); fall through only then.
+        if (text.length === text.toLowerCase().length && term.length === term.toLowerCase().length)
+            return false;
+    }
+    let re = termRegexes.get(term);
+    if (!re) {
+        if (termRegexes.size > 10000)
+            termRegexes.clear();
+        re = new RegExp(termPattern(term), 'iu');
+        termRegexes.set(term, re);
+    }
+    return re.test(text);
+}
+const NO_TERMS = [];
+/** Per never-translate list (by identity), source → translatable text. */
+const translatableCache = new WeakMap();
+/**
+ * The words of a source string a glossary rule can apply to: placeholders,
+ * tags, URLs, emails and code removed, and for an ICU message its argument
+ * names and selector keys too. "Open https://x.com/dashboard" has no
+ * "dashboard" a translator would translate. With `neverTranslate`, those
+ * terms are removed too: "Dashboard" in "Babelize Dashboard" (never
+ * translated) is not a use of a "Dashboard" rule.
+ */
+function translatableText(source, neverTranslate = NO_TERMS) {
+    let cache = translatableCache.get(neverTranslate);
+    if (!cache) {
+        cache = new Map();
+        translatableCache.set(neverTranslate, cache);
+    }
+    const hit = cache.get(source);
+    if (hit !== undefined)
+        return hit;
+    let text = (0, placeholder_protection_1.protectText)(source, [...neverTranslate]).text.replace(/\[#VAR_\d+#\]/g, ' ');
+    if ((0, icu_message_1.isIcuMessage)(source)) {
+        text = text
+            .replace(/\{\s*[\w.]+\s*,\s*(?:plural|select|selectordinal)\s*,(?:\s*offset\s*:\s*\d+)?/g, ' ')
+            .replace(/(?:=\d+|[\p{L}\p{N}_]+)\s*\{/gu, ' ');
+    }
+    if (cache.size > 20000)
+        cache.clear();
+    cache.set(source, text);
+    return text;
+}
+/**
+ * Whether a glossary term occurs in a source string's translatable text (see
+ * translatableText). Pass the never-translate terms when asking about an
+ * "always translate as" term: inside a never-translate term it doesn't count.
+ */
+function sourceHasTerm(source, term, neverTranslate = NO_TERMS) {
+    return containsTerm(translatableText(source, neverTranslate), term);
+}
+/**
+ * BCP-47 casing for a locale code: `pt_br` / `PT-br` → `pt-BR`,
+ * `zh-hant` → `zh-Hant`, `es-419` stays. Anything that isn't
+ * language[-Script][-REGION] is returned trimmed, otherwise unchanged.
+ */
+function canonicalLocale(code) {
+    const parts = code.trim().replace(/_/g, '-').split('-');
+    if (!/^[a-z]{2,3}$/i.test(parts[0] ?? ''))
+        return code.trim();
+    const out = [parts[0].toLowerCase()];
+    for (let i = 1; i < parts.length; i++) {
+        const p = parts[i];
+        if (/^[a-z]{4}$/i.test(p))
+            out.push(p.charAt(0).toUpperCase() + p.slice(1).toLowerCase());
+        else if (/^[a-z]{2}$/i.test(p))
+            out.push(p.toUpperCase());
+        else if (/^\d{3}$/.test(p))
+            out.push(p);
+        else
+            return code.trim();
+    }
+    return out.join('-');
+}
+/** Keys of a locale → value record in canonical form; on a clash the first key (in insertion order) wins. */
+function canonicalizeLocaleKeys(record) {
+    const out = {};
+    for (const [k, v] of Object.entries(record ?? {})) {
+        if (typeof v !== 'string' || !v.trim())
+            continue;
+        const key = canonicalLocale(k);
+        if (!(key in out))
+            out[key] = v;
+    }
+    return out;
+}
+/**
+ * The value for `locale` in a locale-keyed record: the exact locale (in any
+ * casing / separator), else its base language (`pt` serves `pt-BR`).
+ */
+function localeValue(record, locale) {
+    if (!record || !locale)
+        return undefined;
+    const want = canonicalLocale(locale);
+    let base;
+    const baseLang = want.split('-')[0];
+    for (const [k, v] of Object.entries(record)) {
+        if (typeof v !== 'string' || !v.trim())
+            continue;
+        const key = canonicalLocale(k);
+        if (key === want)
+            return v;
+        if (key === baseLang && base === undefined)
+            base = v;
+    }
+    return base;
+}
+exports.EMPTY_GLOSSARY = { neverTranslate: [], alwaysTranslateAs: [], conflicts: [] };
+/**
+ * Normalize raw glossary entries. Terms match case-insensitively, so entries
+ * are grouped by lowercased term:
+ * - never-translate wins over always-translate-as for the same term (keeping
+ *   a term as-is can't corrupt the output; a translation for the wrong sense can);
+ * - several always-translate-as entries merge their locales (the first entry,
+ *   in term order, wins a locale they both define);
+ * - locale keys are canonicalized (`pt_br` → `pt-BR`).
+ * The result doesn't depend on the input order.
+ */
+function normalizeGlossary(entries) {
+    const groups = new Map();
+    for (const e of entries) {
+        if (!e || typeof e.term !== 'string')
+            continue;
+        const term = e.term.trim();
+        if (!term)
+            continue;
+        if (e.type !== 'never_translate' && e.type !== 'always_translate_as')
+            continue;
+        const k = term.toLowerCase();
+        const list = groups.get(k) ?? [];
+        list.push({ ...e, term });
+        groups.set(k, list);
+    }
+    const neverTranslate = [];
+    const alwaysTranslateAs = [];
+    const conflicts = [];
+    const byTerm = (a, b) => (a.term < b.term ? -1 : a.term > b.term ? 1 : 0);
+    for (const k of [...groups.keys()].sort()) {
+        const list = groups.get(k).slice().sort(byTerm);
+        const never = list.filter((e) => e.type === 'never_translate');
+        const always = list.filter((e) => e.type === 'always_translate_as');
+        if (never.length > 0) {
+            neverTranslate.push(never[0].term);
+            if (always.length > 0) {
+                const names = [...new Set(list.map((e) => `"${e.term}"`))].join(' / ');
+                conflicts.push({
+                    term: never[0].term,
+                    message: `Glossary: ${names} is both "never translate" and "always translate as" (terms match ignoring case); "never translate" was applied`,
+                });
+            }
+            continue;
+        }
+        const translations = {};
+        for (const e of always) {
+            for (const [loc, v] of Object.entries(canonicalizeLocaleKeys(e.translations))) {
+                if (!(loc in translations))
+                    translations[loc] = v.trim();
+            }
+        }
+        alwaysTranslateAs.push({ term: always[0].term, type: 'always_translate_as', translations });
+    }
+    return { neverTranslate, alwaysTranslateAs, conflicts };
+}
+/** Always-translate-as terms with a translation for `locale` (exact, then base language). */
+function fixedTermsFor(rules, locale) {
+    const out = [];
+    for (const e of rules.alwaysTranslateAs) {
+        const translation = localeValue(e.translations, locale);
+        if (translation)
+            out.push({ term: e.term, translation });
+    }
+    return out;
+}
+/** Whether `source` contains an always-translate-as term that has a translation for `locale`. */
+function hasFixedTerm(source, rules, locale) {
+    return fixedTermsFor(rules, locale).some((g) => sourceHasTerm(source, g.term, rules.neverTranslate));
+}
+/**
+ * Fingerprint of the glossary rules that shape `source`'s translation into
+ * `locale`: the never-translate terms it contains and the always-translate-as
+ * terms it contains with their translation for the locale. Empty when no rule
+ * applies, so adding a rule for an unrelated term changes nothing. Stored per
+ * locale in the lockfile: a key is re-translated when this changes.
+ */
+function glossaryFingerprint(source, locale, rules) {
+    const parts = [];
+    for (const t of rules.neverTranslate) {
+        if (sourceHasTerm(source, t))
+            parts.push(`n\u0000${t.toLowerCase()}`);
+    }
+    for (const g of fixedTermsFor(rules, locale)) {
+        if (sourceHasTerm(source, g.term, rules.neverTranslate))
+            parts.push(`a\u0000${g.term.toLowerCase()}\u0000${g.translation}`);
+    }
+    if (parts.length === 0)
+        return '';
+    return (0, crypto_1.createHash)('sha256').update(parts.sort().join('\u0001'), 'utf8').digest('hex').slice(0, 16);
+}
+/** QA notes for conflicting rules whose term occurs in `source`. */
+function conflictNotes(source, rules) {
+    return rules.conflicts.filter((c) => sourceHasTerm(source, c.term)).map((c) => c.message);
+}

package/dist/modules/glossary/types.d.ts

@@ -0,0 +1,22 @@
+export type GlossaryEntryType = 'never_translate' | 'always_translate_as';
+export interface GlossaryEntry {
+    id?: string;
+    project_id: string;
+    term: string;
+    type: GlossaryEntryType;
+    /** For always_translate_as: locale code → fixed translation */
+    translations?: Record<string, string>;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface BrandVoice {
+    name: string;
+    description?: string;
+    guidelines?: string[];
+}
+/** Subset used by the masker and translation pipeline */
+export interface AlwaysTranslateAsEntry {
+    term: string;
+    type: 'always_translate_as';
+    translations: Record<string, string>;
+}

package/dist/modules/glossary/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/modules/injection/index.d.ts

@@ -0,0 +1 @@
+export { injectTranslations, checkIdempotency } from './inject';

package/dist/modules/injection/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIdempotency = exports.injectTranslations = void 0;
+var inject_1 = require("./inject");
+Object.defineProperty(exports, "injectTranslations", { enumerable: true, get: function () { return inject_1.injectTranslations; } });
+Object.defineProperty(exports, "checkIdempotency", { enumerable: true, get: function () { return inject_1.checkIdempotency; } });

package/dist/modules/injection/inject.d.ts

@@ -0,0 +1,29 @@
+import type { FileInjection, InjectionResult, WorkspaceInfo } from '../../runtime/types';
+/**
+ * Phase 5: Injection
+ *
+ * Injects i18n into source files — JS/TS gets Babel AST injection,
+ * HTML files get DOM-based data-i18n attribute injection.
+ */
+export declare function injectTranslations(workspace: WorkspaceInfo, keyMapping: Map<string, string>, // extractionId -> key
+confidenceThreshold?: number, dryRun?: boolean, 
+/** extractionId → source offsets of the nodes extraction selected. */
+positions?: Map<string, Set<number>>): Promise<InjectionResult>;
+/**
+ * Inject translations into a single file
+ */
+export declare function injectIntoFile(content: string, filePath: string, keyMapping: Map<string, string>, confidenceThreshold: number, framework: string, existingDeps?: Record<string, string>, forceTypeScript?: boolean, 
+/** extractionId → source offsets of the nodes extraction selected (see ExtractedString.offsets). */
+positions?: Map<string, Set<number>>): FileInjection;
+/**
+ * Inject translations into a Vue SFC file.
+ * Uses @vue/compiler-sfc to parse, vue/template-scan to find translatable
+ * units, vue/template-rewrite to inject $t() calls, and vue/script-inject
+ * to add useI18n() in <script setup>.
+ */
+export declare function injectIntoVueFile(content: string, filePath: string, keyMapping: Map<string, string>, _confidenceThreshold: number, _framework: string, _existingDeps?: Record<string, string>): Promise<FileInjection>;
+/**
+ * Check if injection would be idempotent
+ * (running again would produce the same output)
+ */
+export declare function checkIdempotency(originalContent: string, modifiedContent: string, filePath: string, keyMapping: Map<string, string>, framework?: string): boolean;