@babelize/engine 0.0.0-stage → 0.1.0

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,116 @@
+"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");
+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) {
+        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,107 @@
+"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);
+    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,
+        },
+    };
+}
+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);
+    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/locale-builder/po.d.ts

@@ -0,0 +1,33 @@
+import type { TranslationTable } from 'gettext-parser';
+/**
+ * Read a .po file content and return key-value pairs (msgid → msgstr).
+ * For untranslated entries, msgstr will be an empty string.
+ */
+export declare function readPoFile(content: string): Record<string, string>;
+/**
+ * Read a .po file and return the full gettext-parser translation table
+ * (preserves comments, msgctxt, plural forms, etc.)
+ */
+export declare function readPoFileRaw(content: string): TranslationTable;
+/**
+ * Write a .po file from key-value pairs.
+ * Uses a gettext-parser translation table as the base for preserving
+ * comments, msgctxt, and header metadata.
+ */
+export declare function writePoFile(translations: Record<string, string>, options?: {
+    context?: string;
+    pluralForms?: string;
+    baseContent?: string;
+}): string;
+/**
+ * Compile a .po file to .mo binary format.
+ */
+export declare function compileMo(poContent: string): Buffer;
+/**
+ * Build a gettext-parser table from flat translation entries.
+ * Useful when generating a fresh .po file from extracted keys.
+ */
+export declare function buildPoTable(translations: Record<string, string>, options?: {
+    sourceLanguage?: string;
+    pluralForms?: string;
+}): TranslationTable;

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

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPoFile = readPoFile;
+exports.readPoFileRaw = readPoFileRaw;
+exports.writePoFile = writePoFile;
+exports.compileMo = compileMo;
+exports.buildPoTable = buildPoTable;
+const gettext_parser_1 = __importDefault(require("gettext-parser"));
+/**
+ * Read a .po file content and return key-value pairs (msgid → msgstr).
+ * For untranslated entries, msgstr will be an empty string.
+ */
+function readPoFile(content) {
+    const parsed = gettext_parser_1.default.po.parse(content);
+    const result = {};
+    for (const context of Object.values(parsed.translations)) {
+        for (const [msgid, entry] of Object.entries(context)) {
+            if (!msgid)
+                continue; // skip header entry
+            const msgstr = entry.msgstr?.[0] || '';
+            result[msgid] = msgstr;
+        }
+    }
+    return result;
+}
+/**
+ * Read a .po file and return the full gettext-parser translation table
+ * (preserves comments, msgctxt, plural forms, etc.)
+ */
+function readPoFileRaw(content) {
+    return gettext_parser_1.default.po.parse(content);
+}
+/**
+ * Write a .po file from key-value pairs.
+ * Uses a gettext-parser translation table as the base for preserving
+ * comments, msgctxt, and header metadata.
+ */
+function writePoFile(translations, options) {
+    const ctx = options?.context || '';
+    // Build the gettext-parser table structure
+    const table = {
+        charset: 'utf-8',
+        headers: {
+            'content-type': 'text/plain; charset=utf-8',
+            'plural-forms': options?.pluralForms || 'nplurals=2; plural=(n!=1);',
+        },
+        translations: {
+            [ctx]: {},
+        },
+    };
+    // If base content is provided, merge existing metadata
+    if (options?.baseContent) {
+        const base = gettext_parser_1.default.po.parse(options.baseContent);
+        table.headers = { ...base.headers, ...table.headers };
+        if (base.charset)
+            table.charset = base.charset;
+        // Preserve existing entries for context
+        if (base.translations[ctx]) {
+            for (const [msgid, entry] of Object.entries(base.translations[ctx])) {
+                if (!msgid)
+                    continue;
+                table.translations[ctx][msgid] = entry;
+            }
+        }
+    }
+    // Apply translations
+    for (const [msgid, msgstr] of Object.entries(translations)) {
+        if (!msgid)
+            continue;
+        if (table.translations[ctx][msgid]) {
+            table.translations[ctx][msgid].msgstr = [msgstr];
+        }
+        else {
+            table.translations[ctx][msgid] = {
+                msgid,
+                msgstr: [msgstr],
+            };
+        }
+    }
+    const compiled = gettext_parser_1.default.po.compile(table, {
+        foldLength: 0,
+        sort: false,
+        escapeCharacters: true,
+    });
+    return compiled.toString('utf-8');
+}
+/**
+ * Compile a .po file to .mo binary format.
+ */
+function compileMo(poContent) {
+    const parsed = gettext_parser_1.default.po.parse(poContent);
+    return gettext_parser_1.default.mo.compile(parsed);
+}
+/**
+ * Build a gettext-parser table from flat translation entries.
+ * Useful when generating a fresh .po file from extracted keys.
+ */
+function buildPoTable(translations, options) {
+    const ctx = '';
+    const headers = {
+        'content-type': 'text/plain; charset=utf-8',
+        'plural-forms': options?.pluralForms || 'nplurals=2; plural=(n!=1);',
+    };
+    if (options?.sourceLanguage) {
+        headers['language'] = options.sourceLanguage;
+    }
+    const table = {
+        charset: 'utf-8',
+        headers,
+        translations: {
+            [ctx]: {},
+        },
+    };
+    // Add header entry
+    table.translations[ctx][''] = {
+        msgid: '',
+        msgstr: [Object.entries(headers).map(([k, v]) => `${k}: ${v}`).join('\n')],
+    };
+    for (const [msgid, msgstr] of Object.entries(translations)) {
+        if (!msgid)
+            continue;
+        table.translations[ctx][msgid] = {
+            msgid,
+            msgstr: [msgstr],
+        };
+    }
+    return table;
+}

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, type LockfileReadOptions, } from './lockfile-manager';

package/dist/modules/lockfile/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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; } });