@babelize/engine 0.0.0-stage → 0.1.2

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

@@ -0,0 +1 @@
+export { generateKeys, keysToNestedLocale, mergeLocaleData, createKeyMapping, flattenLocaleData, unflattenLocaleData, setNestedValue, } from './public';

package/dist/modules/keygen/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setNestedValue = exports.unflattenLocaleData = exports.flattenLocaleData = exports.createKeyMapping = exports.mergeLocaleData = exports.keysToNestedLocale = exports.generateKeys = void 0;
+var public_1 = require("./public");
+Object.defineProperty(exports, "generateKeys", { enumerable: true, get: function () { return public_1.generateKeys; } });
+Object.defineProperty(exports, "keysToNestedLocale", { enumerable: true, get: function () { return public_1.keysToNestedLocale; } });
+Object.defineProperty(exports, "mergeLocaleData", { enumerable: true, get: function () { return public_1.mergeLocaleData; } });
+Object.defineProperty(exports, "createKeyMapping", { enumerable: true, get: function () { return public_1.createKeyMapping; } });
+Object.defineProperty(exports, "flattenLocaleData", { enumerable: true, get: function () { return public_1.flattenLocaleData; } });
+Object.defineProperty(exports, "unflattenLocaleData", { enumerable: true, get: function () { return public_1.unflattenLocaleData; } });
+Object.defineProperty(exports, "setNestedValue", { enumerable: true, get: function () { return public_1.setNestedValue; } });

package/dist/modules/keygen/keygen.d.ts

@@ -0,0 +1,4 @@
+import type { ExtractedString, KeyGenerationResult, LocaleData } from '../../runtime/types';
+export declare function generateKeys(extractedStrings: ExtractedString[], existingKeys?: LocaleData): {
+    keyGeneration: KeyGenerationResult;
+};

package/dist/modules/keygen/keygen.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateKeys = generateKeys;
+const string_utils_1 = require("../../utils/string-utils");
+const jsx_message_1 = require("../../utils/jsx-message");
+const keys_1 = require("../../django/keys");
+function generateKeys(extractedStrings, existingKeys = {}) {
+    const keys = [];
+    const duplicates = [];
+    const usedKeys = new Set();
+    collectExistingKeys(existingKeys, '', usedKeys);
+    const existingValues = new Map();
+    collectExistingValues(existingKeys, '', existingValues);
+    // Existing keys already given to a string this run (prefer an unclaimed one).
+    const claimed = new Set();
+    /**
+     * A string re-extracted on a later run (e.g. one the injector couldn't wire
+     * up, so the literal is still in the code) must get the key it already has,
+     * not a new `_2` copy. Reuse an existing key with the same base name and
+     * identical source text; otherwise mint a unique one.
+     */
+    const keyFor = (baseFullKey, text) => {
+        const candidates = [baseFullKey];
+        for (let n = 2; existingValues.has(`${baseFullKey}_${n}`); n++)
+            candidates.push(`${baseFullKey}_${n}`);
+        const matching = candidates.filter((k) => existingValues.get(k) === text);
+        const pick = matching.find((k) => !claimed.has(k)) ?? matching[0];
+        if (pick) {
+            claimed.add(pick);
+            return { key: pick, reused: true };
+        }
+        return { key: (0, string_utils_1.generateUniqueKey)(baseFullKey, usedKeys), reused: false };
+    };
+    // Generate locale-appropriate plural categories.
+    // Always use all 6 CLDR categories since target locale may be unknown at extraction time.
+    // The translation engine will only generate entries for categories the target locale needs.
+    const pluralCategories = ['zero', 'one', 'two', 'few', 'many', 'other'];
+    for (const extracted of extractedStrings) {
+        // gettext messages (Django) are looked up by their text; their keys are
+        // derived from the message, so they are stable without a source file.
+        if (extracted.gettext) {
+            keys.push(...(0, keys_1.gettextKeys)(extracted));
+            continue;
+        }
+        const namespace = (0, string_utils_1.inferNamespace)(extracted.file);
+        // A sentence message is named from its words: "Welcome back, {user}" → welcomeBack.
+        const truncatedText = (0, string_utils_1.truncateForKey)(extracted.icuMessage ? (0, jsx_message_1.messageKeyText)(extracted.text) : extracted.text, 5);
+        const baseKeyName = (0, string_utils_1.toCamelCase)(truncatedText);
+        const baseFullKey = `${namespace}.${baseKeyName}`;
+        // Check if this is a plural string - generate base key + 6 CLDR plural-category keys
+        // ICU sentence messages carry their own plural forms ({count, plural, …}).
+        if (!extracted.icuMessage && (0, string_utils_1.isLikelyPlural)(extracted.text)) {
+            // Generate the unsuffixed base key - this is what gets mapped to extractionId for code injection.
+            // i18next callers use the base key (e.g. t('items.count', { count })) and resolve suffixed
+            // variants (_one, _other, etc.) internally.
+            const { key: uniqueBaseKey, reused: baseReused } = keyFor(baseFullKey, extracted.text);
+            if (!baseReused && uniqueBaseKey !== baseFullKey)
+                duplicates.push({ original: baseFullKey, renamed: uniqueBaseKey });
+            usedKeys.add(uniqueBaseKey);
+            keys.push({
+                key: uniqueBaseKey,
+                namespace,
+                value: extracted.text,
+                extractionId: extracted.id,
+                parentContext: extracted.parentContext,
+                extractionContext: extracted.context,
+            });
+            // Generate the 6 CLDR plural-category keys as suffixed variants.
+            // Each gets a distinct extractionId so createKeyMapping keeps all 6 entries.
+            for (const category of pluralCategories) {
+                const pluralKey = `${uniqueBaseKey}_${category}`;
+                const uniquePluralKey = baseReused && existingValues.has(pluralKey) ? pluralKey : (0, string_utils_1.generateUniqueKey)(pluralKey, usedKeys);
+                if (uniquePluralKey !== pluralKey)
+                    duplicates.push({ original: pluralKey, renamed: uniquePluralKey });
+                usedKeys.add(uniquePluralKey);
+                keys.push({
+                    key: uniquePluralKey,
+                    namespace,
+                    value: extracted.text,
+                    extractionId: `${extracted.id}_${category}`,
+                    isPlural: true,
+                    pluralCategory: category,
+                    parentContext: extracted.parentContext,
+                    extractionContext: extracted.context,
+                });
+            }
+        }
+        else {
+            const { key: uniqueKey, reused } = keyFor(baseFullKey, extracted.text);
+            if (!reused && uniqueKey !== baseFullKey)
+                duplicates.push({ original: baseFullKey, renamed: uniqueKey });
+            usedKeys.add(uniqueKey);
+            keys.push({
+                key: uniqueKey,
+                namespace,
+                value: extracted.text,
+                extractionId: extracted.id,
+                parentContext: extracted.parentContext,
+                extractionContext: extracted.context,
+            });
+        }
+    }
+    const keyGeneration = { keys, duplicates };
+    return { keyGeneration };
+}
+function collectExistingValues(data, prefix, out) {
+    for (const [key, value] of Object.entries(data)) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        if (typeof value === 'string')
+            out.set(fullKey, value);
+        else if (typeof value === 'object' && value !== null)
+            collectExistingValues(value, fullKey, out);
+    }
+}
+function collectExistingKeys(data, prefix, keys) {
+    for (const [key, value] of Object.entries(data)) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        if (typeof value === 'string')
+            keys.add(fullKey);
+        else if (typeof value === 'object' && value !== null)
+            collectExistingKeys(value, fullKey, keys);
+    }
+}

package/dist/modules/keygen/locale-data.d.ts

@@ -0,0 +1,7 @@
+import type { GeneratedKey, LocaleData } from '../../runtime/types';
+export declare function keysToNestedLocale(keys: GeneratedKey[]): LocaleData;
+export declare function setNestedValue(obj: LocaleData, key: string, value: string): void;
+export declare function mergeLocaleData(existing: LocaleData, newData: LocaleData): LocaleData;
+export declare function createKeyMapping(keys: GeneratedKey[]): Map<string, string>;
+export declare function flattenLocaleData(data: LocaleData, prefix?: string): Record<string, string>;
+export declare function unflattenLocaleData(flat: Record<string, string>): LocaleData;

package/dist/modules/keygen/locale-data.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keysToNestedLocale = keysToNestedLocale;
+exports.setNestedValue = setNestedValue;
+exports.mergeLocaleData = mergeLocaleData;
+exports.createKeyMapping = createKeyMapping;
+exports.flattenLocaleData = flattenLocaleData;
+exports.unflattenLocaleData = unflattenLocaleData;
+function keysToNestedLocale(keys) {
+    const result = {};
+    for (const { key, value } of keys)
+        setNestedValue(result, key, value);
+    return result;
+}
+function setNestedValue(obj, key, value) {
+    const parts = key.split('.');
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (!(part in current)) {
+            current[part] = {};
+        }
+        else if (typeof current[part] === 'string') {
+            // Key conflict: a flat key (e.g. "homepage") and nested key (e.g. "homepage.title")
+            // both exist. This is a data model error in the generated keys.
+            throw new Error(`Key conflict in locale data: "${key}" — intermediate key "${part}" is already a string value and cannot be an object path`);
+        }
+        current = current[part];
+    }
+    current[parts[parts.length - 1]] = value;
+}
+function mergeLocaleData(existing, newData) {
+    const result = JSON.parse(JSON.stringify(existing));
+    function merge(target, source) {
+        for (const [key, value] of Object.entries(source)) {
+            if (!(key in target)) {
+                target[key] = value;
+            }
+            else if (typeof target[key] === 'object' &&
+                typeof value === 'object' &&
+                target[key] !== null &&
+                value !== null) {
+                merge(target[key], value);
+            }
+        }
+    }
+    merge(result, newData);
+    return result;
+}
+function createKeyMapping(keys) {
+    const mapping = new Map();
+    for (const { key, extractionId } of keys)
+        mapping.set(extractionId, key);
+    return mapping;
+}
+function flattenLocaleData(data, prefix = '') {
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        if (typeof value === 'string')
+            result[fullKey] = value;
+        else if (typeof value === 'object' && value !== null)
+            Object.assign(result, flattenLocaleData(value, fullKey));
+    }
+    return result;
+}
+function unflattenLocaleData(flat) {
+    const result = {};
+    for (const [key, value] of Object.entries(flat)) {
+        setNestedValue(result, key, value);
+    }
+    return result;
+}

package/dist/modules/keygen/public.d.ts

@@ -0,0 +1,2 @@
+export { generateKeys } from './keygen';
+export { keysToNestedLocale, mergeLocaleData, createKeyMapping, flattenLocaleData, unflattenLocaleData, setNestedValue } from './locale-data';

package/dist/modules/keygen/public.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setNestedValue = exports.unflattenLocaleData = exports.flattenLocaleData = exports.createKeyMapping = exports.mergeLocaleData = exports.keysToNestedLocale = exports.generateKeys = void 0;
+var keygen_1 = require("./keygen");
+Object.defineProperty(exports, "generateKeys", { enumerable: true, get: function () { return keygen_1.generateKeys; } });
+var locale_data_1 = require("./locale-data");
+Object.defineProperty(exports, "keysToNestedLocale", { enumerable: true, get: function () { return locale_data_1.keysToNestedLocale; } });
+Object.defineProperty(exports, "mergeLocaleData", { enumerable: true, get: function () { return locale_data_1.mergeLocaleData; } });
+Object.defineProperty(exports, "createKeyMapping", { enumerable: true, get: function () { return locale_data_1.createKeyMapping; } });
+Object.defineProperty(exports, "flattenLocaleData", { enumerable: true, get: function () { return locale_data_1.flattenLocaleData; } });
+Object.defineProperty(exports, "unflattenLocaleData", { enumerable: true, get: function () { return locale_data_1.unflattenLocaleData; } });
+Object.defineProperty(exports, "setNestedValue", { enumerable: true, get: function () { return locale_data_1.setNestedValue; } });

package/dist/modules/locale-builder/index.d.ts

@@ -0,0 +1 @@
+export { handleBaseLocale, readLocaleFile, checkExistingTargetLocales } from './locales';

package/dist/modules/locale-builder/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkExistingTargetLocales = exports.readLocaleFile = exports.handleBaseLocale = void 0;
+var locales_1 = require("./locales");
+Object.defineProperty(exports, "handleBaseLocale", { enumerable: true, get: function () { return locales_1.handleBaseLocale; } });
+Object.defineProperty(exports, "readLocaleFile", { enumerable: true, get: function () { return locales_1.readLocaleFile; } });
+Object.defineProperty(exports, "checkExistingTargetLocales", { enumerable: true, get: function () { return locales_1.checkExistingTargetLocales; } });

package/dist/modules/locale-builder/locales.d.ts

@@ -0,0 +1,13 @@
+import type { GeneratedKey, LocaleData, LocaleFile, WorkspaceInfo } from '../../runtime/types';
+export declare function handleBaseLocale(workspace: WorkspaceInfo, generatedKeys: GeneratedKey[], sourceLocale?: string, dryRun?: boolean): Promise<{
+    localeHandling: {
+        sourceLocale: LocaleFile;
+        newKeysCount: number;
+        existingKeysCount: number;
+    };
+}>;
+export declare function readLocaleFile(workspace: WorkspaceInfo, locale: string): Promise<LocaleData | null>;
+export declare function checkExistingTargetLocales(workspace: WorkspaceInfo, targetLocales: string[]): Promise<{
+    existing: string[];
+    missing: string[];
+}>;

package/dist/modules/locale-builder/locales.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleBaseLocale = handleBaseLocale;
+exports.readLocaleFile = readLocaleFile;
+exports.checkExistingTargetLocales = checkExistingTargetLocales;
+const file_utils_1 = require("../../utils/file-utils");
+const keygen_1 = require("../keygen");
+const language_codes_1 = require("../translator/language-codes");
+function assertSafeLocale(locale) {
+    // Allow common locale identifiers only (examples: en, en-US, pt_BR, zh-Hant).
+    // Disallow path separators and other special characters to prevent path traversal.
+    const localePattern = /^[A-Za-z0-9]+(?:[-_][A-Za-z0-9]+)*$/;
+    if (!localePattern.test(locale)) {
+        throw new Error(`Invalid locale: ${locale}`);
+    }
+}
+async function handleBaseLocale(workspace, generatedKeys, sourceLocale = 'en', dryRun = false) {
+    assertSafeLocale(sourceLocale);
+    if (workspace.localeFormat === 'po')
+        return gettextSourceLocale(generatedKeys, sourceLocale);
+    const localePaths = (0, file_utils_1.localeFilePath)(workspace.path, workspace.publicDir, workspace.localeFormat, sourceLocale);
+    const localesDir = localePaths.dir;
+    const localeFilePathTarget = localePaths.file;
+    const relativeLocaleFilePath = localePaths.relativeFile;
+    if (!dryRun)
+        await (0, file_utils_1.ensureDir)(localesDir);
+    const exists = await (0, file_utils_1.pathExists)(localeFilePathTarget);
+    let existingData = {};
+    let existingKeysCount = 0;
+    if (exists) {
+        if (workspace.localeFormat !== 'json') {
+            throw new Error(`Locale format '${workspace.localeFormat}' not yet supported for base locale handling`);
+        }
+        existingData = (await (0, file_utils_1.readJsonFile)(localeFilePathTarget)) || {};
+        existingKeysCount = countKeys(existingData);
+    }
+    const newData = (0, keygen_1.keysToNestedLocale)(generatedKeys);
+    const mergedData = (0, keygen_1.mergeLocaleData)(existingData, newData);
+    const mergedKeysCount = countKeys(mergedData);
+    const newKeysCount = mergedKeysCount - existingKeysCount;
+    const MAX_KEYS_PER_RUN = 10000;
+    if (mergedKeysCount > MAX_KEYS_PER_RUN) {
+        throw new Error(`Project exceeds maximum keys per run (Found: ${mergedKeysCount}, Limit: ${MAX_KEYS_PER_RUN}). Please reduce project size or split into multiple runs.`);
+    }
+    // Add _meta with direction and language info.
+    // Spread mergedData first, then override _meta so the computed dir/language
+    // always takes precedence over any stale _meta already present in the file.
+    const existingMeta = typeof mergedData._meta === 'object' && mergedData._meta !== null
+        ? mergedData._meta
+        : {};
+    const dataWithMeta = {
+        ...mergedData,
+        _meta: {
+            ...existingMeta,
+            dir: (0, language_codes_1.isRTL)(sourceLocale) ? 'rtl' : 'ltr',
+            language: sourceLocale,
+        },
+    };
+    if (!dryRun)
+        await (0, file_utils_1.writeJsonFile)(localeFilePathTarget, dataWithMeta, true);
+    const sourceLocaleFile = {
+        locale: sourceLocale,
+        path: relativeLocaleFilePath,
+        data: dataWithMeta,
+        isNew: !exists,
+        isRTL: (0, language_codes_1.isRTL)(sourceLocale),
+    };
+    return {
+        localeHandling: {
+            sourceLocale: sourceLocaleFile,
+            newKeysCount,
+            existingKeysCount,
+        },
+    };
+}
+/**
+ * gettext (Django): the source language has no catalogue file — the msgids
+ * in the code are the source text. The run's keys are the source locale.
+ */
+function gettextSourceLocale(generatedKeys, sourceLocale) {
+    const data = {};
+    for (const k of generatedKeys)
+        data[k.key] = k.value;
+    const sourceLocaleFile = {
+        locale: sourceLocale,
+        path: '',
+        data,
+        isNew: false,
+        isRTL: (0, language_codes_1.isRTL)(sourceLocale),
+        noFile: true,
+    };
+    return { localeHandling: { sourceLocale: sourceLocaleFile, newKeysCount: 0, existingKeysCount: Object.keys(data).length } };
+}
+function countKeys(data) {
+    let count = 0;
+    function traverse(obj) {
+        for (const value of Object.values(obj)) {
+            if (typeof value === 'string')
+                count++;
+            else if (typeof value === 'object' && value !== null)
+                traverse(value);
+        }
+    }
+    traverse(data);
+    return count;
+}
+async function readLocaleFile(workspace, locale) {
+    assertSafeLocale(locale);
+    // gettext projects have no source-locale file: the code is the catalogue.
+    if (workspace.localeFormat === 'po')
+        return null;
+    if (workspace.localeFormat !== 'json') {
+        throw new Error(`Locale format '${workspace.localeFormat}' reading not yet implemented`);
+    }
+    const { file } = (0, file_utils_1.localeFilePath)(workspace.path, workspace.publicDir, workspace.localeFormat, locale);
+    return (0, file_utils_1.readJsonFile)(file);
+}
+async function checkExistingTargetLocales(workspace, targetLocales) {
+    const existing = [];
+    const missing = [];
+    for (const locale of targetLocales) {
+        assertSafeLocale(locale);
+        const { file } = (0, file_utils_1.localeFilePath)(workspace.path, workspace.publicDir, workspace.localeFormat, locale);
+        if (await (0, file_utils_1.pathExists)(file))
+            existing.push(locale);
+        else
+            missing.push(locale);
+    }
+    return { existing, missing };
+}

package/dist/modules/lockfile/hasher.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Compute a SHA-256 hex digest of the given source string.
+ *
+ * The hash is case-sensitive and whitespace-sensitive by design,
+ * so "Hello" and "hello" and " Hello" all produce different hashes.
+ */
+export declare function hashSourceString(text: string): string;

package/dist/modules/lockfile/hasher.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashSourceString = hashSourceString;
+const crypto_1 = require("crypto");
+/**
+ * Compute a SHA-256 hex digest of the given source string.
+ *
+ * The hash is case-sensitive and whitespace-sensitive by design,
+ * so "Hello" and "hello" and " Hello" all produce different hashes.
+ */
+function hashSourceString(text) {
+    return (0, crypto_1.createHash)('sha256').update(text, 'utf8').digest('hex');
+}

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

@@ -0,0 +1,3 @@
+export { hashSourceString } from './hasher';
+export { type LockfileData, type LockfileEntry, type LockfilePartition, type LockfileStats, type PartitionedKey, createEmptyLockfile, } from './schema';
+export { buildKeysToTranslateByTargetLocale, clearLockfile, removeLocaleFromLockfile, collectCachedTranslations, computeLockfileStats, getLockfilePath, loadLockfile, partitionKeys, saveLockfile, updateLockfile, lockfileChanged, dropFailedTranslations, isStalePseudoEntry, glossaryChanged, type LockfileReadOptions, } from './lockfile-manager';

package/dist/modules/lockfile/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.glossaryChanged = exports.isStalePseudoEntry = exports.dropFailedTranslations = exports.lockfileChanged = exports.updateLockfile = exports.saveLockfile = exports.partitionKeys = exports.loadLockfile = exports.getLockfilePath = exports.computeLockfileStats = exports.collectCachedTranslations = exports.removeLocaleFromLockfile = exports.clearLockfile = exports.buildKeysToTranslateByTargetLocale = exports.createEmptyLockfile = exports.hashSourceString = void 0;
+var hasher_1 = require("./hasher");
+Object.defineProperty(exports, "hashSourceString", { enumerable: true, get: function () { return hasher_1.hashSourceString; } });
+var schema_1 = require("./schema");
+Object.defineProperty(exports, "createEmptyLockfile", { enumerable: true, get: function () { return schema_1.createEmptyLockfile; } });
+var lockfile_manager_1 = require("./lockfile-manager");
+Object.defineProperty(exports, "buildKeysToTranslateByTargetLocale", { enumerable: true, get: function () { return lockfile_manager_1.buildKeysToTranslateByTargetLocale; } });
+Object.defineProperty(exports, "clearLockfile", { enumerable: true, get: function () { return lockfile_manager_1.clearLockfile; } });
+Object.defineProperty(exports, "removeLocaleFromLockfile", { enumerable: true, get: function () { return lockfile_manager_1.removeLocaleFromLockfile; } });
+Object.defineProperty(exports, "collectCachedTranslations", { enumerable: true, get: function () { return lockfile_manager_1.collectCachedTranslations; } });
+Object.defineProperty(exports, "computeLockfileStats", { enumerable: true, get: function () { return lockfile_manager_1.computeLockfileStats; } });
+Object.defineProperty(exports, "getLockfilePath", { enumerable: true, get: function () { return lockfile_manager_1.getLockfilePath; } });
+Object.defineProperty(exports, "loadLockfile", { enumerable: true, get: function () { return lockfile_manager_1.loadLockfile; } });
+Object.defineProperty(exports, "partitionKeys", { enumerable: true, get: function () { return lockfile_manager_1.partitionKeys; } });
+Object.defineProperty(exports, "saveLockfile", { enumerable: true, get: function () { return lockfile_manager_1.saveLockfile; } });
+Object.defineProperty(exports, "updateLockfile", { enumerable: true, get: function () { return lockfile_manager_1.updateLockfile; } });
+Object.defineProperty(exports, "lockfileChanged", { enumerable: true, get: function () { return lockfile_manager_1.lockfileChanged; } });
+Object.defineProperty(exports, "dropFailedTranslations", { enumerable: true, get: function () { return lockfile_manager_1.dropFailedTranslations; } });
+Object.defineProperty(exports, "isStalePseudoEntry", { enumerable: true, get: function () { return lockfile_manager_1.isStalePseudoEntry; } });
+Object.defineProperty(exports, "glossaryChanged", { enumerable: true, get: function () { return lockfile_manager_1.glossaryChanged; } });

package/dist/modules/lockfile/lockfile-manager.d.ts

@@ -0,0 +1,99 @@
+import type { LockfileEntry } from './schema';
+import { type LockfileData, type LockfilePartition, type LockfileStats, type PartitionedKey } from './schema';
+/**
+ * For each target locale, list of translation keys that must go through the translator
+ * (new keys, source-changed keys, or keys missing that locale in the lockfile).
+ */
+export declare function buildKeysToTranslateByTargetLocale(partition: LockfilePartition, targetLocales: string[]): Record<string, string[]>;
+/**
+ * Resolve the lockfile path for a project:
+ * `<dataDir>/.babelize/{projectId}/babelize-lock.json`. `dataDir` defaults to
+ * $BABELIZE_DATA_DIR, else `process.cwd()` (the cloud backend). Local runs
+ * pass it explicitly so concurrent runs in one process never share it.
+ */
+export declare function getLockfilePath(projectId: string, dataDir?: string): string;
+/**
+ * Load and validate the lockfile from disk.
+ * Returns an empty lockfile if the file doesn't exist or is malformed.
+ */
+export declare function loadLockfile(projectId: string, dataDir?: string): Promise<LockfileData>;
+/**
+ * Persist lockfile to disk atomically (write→tmp→rename).
+ * Uses advisory file locking via atomic mkdir to prevent concurrent writes
+ * from overwriting each other (two simultaneous runs for the same project).
+ */
+export declare function saveLockfile(projectId: string, data: LockfileData, dataDir?: string): Promise<void>;
+/**
+ * Delete the lockfile for a project (used by "Force full re-translate").
+ */
+export declare function clearLockfile(projectId: string, dataDir?: string): Promise<void>;
+/**
+ * Purge a specific locale's translations from the lockfile.
+ * Used when a language is removed from a project so re-adding it
+ * triggers fresh translation instead of resurrecting stale cache.
+ */
+export declare function removeLocaleFromLockfile(projectId: string, localeCode: string, dataDir?: string): Promise<void>;
+/**
+ * Partition generated keys into unchanged / new / changed / missingLocales
+ * by comparing source hashes against the lockfile.
+ *
+ * @param lockfile  - Current lockfile data
+ * @param keys      - Flat map of translation key → source string value
+ * @param targetLocales - Locales the user is targeting this run
+ */
+/** Options for reading the lockfile during a run. */
+export interface LockfileReadOptions {
+    /** This run is pseudo-localization: pseudo entries count as done. Otherwise they count as missing. */
+    pseudo?: boolean;
+    /**
+     * The glossary fingerprint this run's rules give a key's source for a
+     * locale ('' when no rule applies). A stored translation made under a
+     * different fingerprint counts as missing, so glossary edits reach the
+     * keys they affect — and only those. Omit when the rules couldn't be loaded.
+     */
+    glossaryHash?: (source: string, locale: string) => string;
+}
+/** True when the glossary rules for this key and locale changed since its translation was stored. */
+export declare function glossaryChanged(entry: LockfileEntry, source: string, locale: string, options?: LockfileReadOptions): boolean;
+/**
+ * True when the stored value for `locale` is pseudo-localization and this run
+ * is a real one: it must be translated, never reused. Recognised by the
+ * `pseudo` metadata flag, or by the pseudo markers for lockfiles written
+ * before the flag existed.
+ */
+export declare function isStalePseudoEntry(entry: LockfileEntry, locale: string, options?: LockfileReadOptions): boolean;
+export declare function partitionKeys(lockfile: LockfileData, keys: Record<string, string>, targetLocales: string[], options?: LockfileReadOptions): LockfilePartition;
+/**
+ * Merge newly translated values and metadata into the lockfile.
+ *
+ * @param lockfile     - Current lockfile (will be mutated)
+ * @param keys         - Flat map of key → source value (for hashing)
+ * @param translations - Map of locale → { key → translated string }
+ * @param projectId    - Project identifier
+ * @param metadata     - Map of locale → { key → metadata object }
+ */
+/**
+ * Remove the stored translation of every key that failed this run.
+ * updateLockfile records the new source fingerprint for every key and keeps
+ * the previous translation where a locale produced none — for a key whose
+ * source text changed and then failed, that previous value translates the
+ * *old* text. Dropping it makes the next run treat the locale as missing and
+ * retry it, instead of silently reusing a stale translation.
+ */
+export declare function dropFailedTranslations(lockfile: LockfileData, failures: Array<{
+    key: string;
+    locale: string;
+}>): LockfileData;
+/** True when `next` differs from `previous` in anything but timestamps worth saving. */
+export declare function lockfileChanged(previous: LockfileData, next: LockfileData): boolean;
+export declare function updateLockfile(lockfile: LockfileData, keys: Record<string, string>, translations: Record<string, Record<string, string>>, projectId: string, metadata?: Record<string, Record<string, any>>): LockfileData;
+/**
+ * Extract cached translations for unchanged keys from the lockfile.
+ *
+ * @returns Map of locale → { key → translated string }
+ */
+export declare function collectCachedTranslations(lockfile: LockfileData, unchangedKeys: PartitionedKey[], targetLocales: string[], options?: LockfileReadOptions): Record<string, Record<string, string>>;
+/**
+ * Compute stats for the UI: X translated, Y reused, Z changed.
+ */
+export declare function computeLockfileStats(partition: LockfilePartition): LockfileStats;