gt 2.14.35 → 2.14.36

package/dist/fs/config/downloadedVersions.js

@@ -1,203 +1,189 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { logger } from '../../console/logger.js';
-const GT_LOCK_FILE = 'gt-lock.json';
-// ── Conversion helpers ──────────────────────────────────────────────
+import { logger } from "../../console/logger.js";
+import path from "node:path";
+import fs from "node:fs";
+//#region src/fs/config/downloadedVersions.ts
+const GT_LOCK_FILE = "gt-lock.json";
 function convertV1ToV2(v1, branchId) {
-    const branchEntries = v1.entries?.[branchId];
-    if (!branchEntries) {
-        return { version: 2, branchId, entries: [] };
-    }
-    const entries = [];
-    for (const [fileId, versions] of Object.entries(branchEntries)) {
-        const versionIds = Object.keys(versions);
-        if (versionIds.length === 0)
-            continue;
-        // Pick the versionId with the most recent updatedAt, defaulting to the first
-        let latestVersionId = versionIds[0];
-        let latestTime = 0;
-        for (const [versionId, locales] of Object.entries(versions)) {
-            for (const entry of Object.values(locales)) {
-                const t = entry.updatedAt ? Date.parse(entry.updatedAt) : 0;
-                if (t > latestTime) {
-                    latestTime = t;
-                    latestVersionId = versionId;
-                }
-            }
-        }
-        const localeEntries = versions[latestVersionId];
-        const translations = {};
-        for (const [locale, entry] of Object.entries(localeEntries)) {
-            translations[locale] = {
-                ...(entry.updatedAt ? { updatedAt: entry.updatedAt } : {}),
-                ...(entry.postProcessHash
-                    ? { postProcessHash: entry.postProcessHash }
-                    : {}),
-            };
-        }
-        entries.push({
-            fileId,
-            versionId: latestVersionId,
-            translations,
-        });
-    }
-    return { version: 2, branchId, entries };
+	const branchEntries = v1.entries?.[branchId];
+	if (!branchEntries) return {
+		version: 2,
+		branchId,
+		entries: []
+	};
+	const entries = [];
+	for (const [fileId, versions] of Object.entries(branchEntries)) {
+		const versionIds = Object.keys(versions);
+		if (versionIds.length === 0) continue;
+		let latestVersionId = versionIds[0];
+		let latestTime = 0;
+		for (const [versionId, locales] of Object.entries(versions)) for (const entry of Object.values(locales)) {
+			const t = entry.updatedAt ? Date.parse(entry.updatedAt) : 0;
+			if (t > latestTime) {
+				latestTime = t;
+				latestVersionId = versionId;
+			}
+		}
+		const localeEntries = versions[latestVersionId];
+		const translations = {};
+		for (const [locale, entry] of Object.entries(localeEntries)) translations[locale] = {
+			...entry.updatedAt ? { updatedAt: entry.updatedAt } : {},
+			...entry.postProcessHash ? { postProcessHash: entry.postProcessHash } : {}
+		};
+		entries.push({
+			fileId,
+			versionId: latestVersionId,
+			translations
+		});
+	}
+	return {
+		version: 2,
+		branchId,
+		entries
+	};
 }
 function convertV2ToV1Branch(v2) {
-    const branch = {};
-    for (const entry of v2.entries) {
-        if (!branch[entry.fileId]) {
-            branch[entry.fileId] = {};
-        }
-        if (!branch[entry.fileId][entry.versionId]) {
-            branch[entry.fileId][entry.versionId] = {};
-        }
-        for (const [locale, translation] of Object.entries(entry.translations)) {
-            branch[entry.fileId][entry.versionId][locale] = {
-                ...(translation.updatedAt ? { updatedAt: translation.updatedAt } : {}),
-                ...(translation.postProcessHash
-                    ? { postProcessHash: translation.postProcessHash }
-                    : {}),
-            };
-        }
-    }
-    return branch;
+	const branch = {};
+	for (const entry of v2.entries) {
+		if (!branch[entry.fileId]) branch[entry.fileId] = {};
+		if (!branch[entry.fileId][entry.versionId]) branch[entry.fileId][entry.versionId] = {};
+		for (const [locale, translation] of Object.entries(entry.translations)) branch[entry.fileId][entry.versionId][locale] = {
+			...translation.updatedAt ? { updatedAt: translation.updatedAt } : {},
+			...translation.postProcessHash ? { postProcessHash: translation.postProcessHash } : {}
+		};
+	}
+	return branch;
 }
-// ── Public API ──────────────────────────────────────────────────────
 /**
- * Reads the lockfile and returns v2 data regardless of the on-disk format.
- * If the file is v1, `originalV1` contains the full v1 data so that
- * `writeLockfile` can merge changes back without losing other branches.
- */
-export function readLockfile(settings) {
-    let branchId = settings._branchId ?? '';
-    let data;
-    let originalV1 = null;
-    try {
-        const rootPath = path.join(process.cwd(), GT_LOCK_FILE);
-        if (!fs.existsSync(rootPath)) {
-            data = { version: 2, branchId, entries: [] };
-        }
-        else {
-            const raw = JSON.parse(fs.readFileSync(rootPath, 'utf8'));
-            if (!raw || typeof raw !== 'object' || !raw.entries) {
-                data = { version: 2, branchId, entries: [] };
-            }
-            else if (raw.version === 2 && Array.isArray(raw.entries)) {
-                data = raw;
-                if (branchId)
-                    data.branchId = branchId;
-            }
-            else {
-                originalV1 = raw;
-                if (!branchId) {
-                    const branches = Object.keys(originalV1.entries);
-                    if (branches.length > 0)
-                        branchId = branches[0];
-                }
-                data = convertV1ToV2(originalV1, branchId);
-            }
-        }
-    }
-    catch (error) {
-        logger.error(`An error occurred while reading ${GT_LOCK_FILE}: ${error}`);
-        data = { version: 2, branchId, entries: [] };
-    }
-    return { data, entryMap: buildEntryMap(data.entries), originalV1 };
+* Reads the lockfile and returns v2 data regardless of the on-disk format.
+* If the file is v1, `originalV1` contains the full v1 data so that
+* `writeLockfile` can merge changes back without losing other branches.
+*/
+function readLockfile(settings) {
+	let branchId = settings._branchId ?? "";
+	let data;
+	let originalV1 = null;
+	try {
+		const rootPath = path.join(process.cwd(), GT_LOCK_FILE);
+		if (!fs.existsSync(rootPath)) data = {
+			version: 2,
+			branchId,
+			entries: []
+		};
+		else {
+			const raw = JSON.parse(fs.readFileSync(rootPath, "utf8"));
+			if (!raw || typeof raw !== "object" || !raw.entries) data = {
+				version: 2,
+				branchId,
+				entries: []
+			};
+			else if (raw.version === 2 && Array.isArray(raw.entries)) {
+				data = raw;
+				if (branchId) data.branchId = branchId;
+			} else {
+				originalV1 = raw;
+				if (!branchId) {
+					const branches = Object.keys(originalV1.entries);
+					if (branches.length > 0) branchId = branches[0];
+				}
+				data = convertV1ToV2(originalV1, branchId);
+			}
+		}
+	} catch (error) {
+		logger.error(`An error occurred while reading ${GT_LOCK_FILE}: ${error}`);
+		data = {
+			version: 2,
+			branchId,
+			entries: []
+		};
+	}
+	return {
+		data,
+		entryMap: buildEntryMap(data.entries),
+		originalV1
+	};
 }
 /**
- * Writes the lockfile. If `originalV1` is provided, merges the current
- * branch's data back into the v1 structure (preserving other branches)
- * and writes v1 format. Otherwise writes v2.
- */
-export function writeLockfile(data, originalV1) {
-    try {
-        const filepath = path.join(process.cwd(), GT_LOCK_FILE);
-        fs.mkdirSync(path.dirname(filepath), { recursive: true });
-        // V1 format can't represent the staged flag — upgrade to V2 if any entries are staged
-        if (originalV1 && !data.entries.some((e) => e.staged)) {
-            const mergedV1 = {
-                ...originalV1,
-                entries: {
-                    ...originalV1.entries,
-                    [data.branchId]: convertV2ToV1Branch(data),
-                },
-            };
-            fs.writeFileSync(filepath, JSON.stringify(mergedV1, null, 2));
-        }
-        else {
-            fs.writeFileSync(filepath, JSON.stringify(data, null, 2));
-        }
-    }
-    catch (error) {
-        logger.error(`An error occurred while updating ${GT_LOCK_FILE}: ${error}`);
-    }
+* Writes the lockfile. If `originalV1` is provided, merges the current
+* branch's data back into the v1 structure (preserving other branches)
+* and writes v1 format. Otherwise writes v2.
+*/
+function writeLockfile(data, originalV1) {
+	try {
+		const filepath = path.join(process.cwd(), GT_LOCK_FILE);
+		fs.mkdirSync(path.dirname(filepath), { recursive: true });
+		if (originalV1 && !data.entries.some((e) => e.staged)) {
+			const mergedV1 = {
+				...originalV1,
+				entries: {
+					...originalV1.entries,
+					[data.branchId]: convertV2ToV1Branch(data)
+				}
+			};
+			fs.writeFileSync(filepath, JSON.stringify(mergedV1, null, 2));
+		} else fs.writeFileSync(filepath, JSON.stringify(data, null, 2));
+	} catch (error) {
+		logger.error(`An error occurred while updating ${GT_LOCK_FILE}: ${error}`);
+	}
 }
-export function buildEntryMap(entries) {
-    return new Map(entries.map((e) => [e.fileId, e]));
+function buildEntryMap(entries) {
+	return new Map(entries.map((e) => [e.fileId, e]));
 }
 /**
- * Finds or creates an entry, keeping the map and backing array in sync.
- * If the fileId exists but versionId changed, replaces it in-place.
- */
-export function findOrCreateEntry(entryMap, entries, fileId, versionId) {
-    const existing = entryMap.get(fileId);
-    if (existing) {
-        if (existing.versionId === versionId)
-            return existing;
-        // Version changed — replace in array and map
-        const updated = {
-            fileId,
-            versionId,
-            translations: {},
-        };
-        const idx = entries.indexOf(existing);
-        if (idx !== -1)
-            entries[idx] = updated;
-        entryMap.set(fileId, updated);
-        return updated;
-    }
-    const entry = {
-        fileId,
-        versionId,
-        translations: {},
-    };
-    entries.push(entry);
-    entryMap.set(fileId, entry);
-    return entry;
+* Finds or creates an entry, keeping the map and backing array in sync.
+* If the fileId exists but versionId changed, replaces it in-place.
+*/
+function findOrCreateEntry(entryMap, entries, fileId, versionId) {
+	const existing = entryMap.get(fileId);
+	if (existing) {
+		if (existing.versionId === versionId) return existing;
+		const updated = {
+			fileId,
+			versionId,
+			translations: {}
+		};
+		const idx = entries.indexOf(existing);
+		if (idx !== -1) entries[idx] = updated;
+		entryMap.set(fileId, updated);
+		return updated;
+	}
+	const entry = {
+		fileId,
+		versionId,
+		translations: {}
+	};
+	entries.push(entry);
+	entryMap.set(fileId, entry);
+	return entry;
 }
-// ── Staging helpers ─────────────────────────────────────────────────
 /**
- * Writes staged file entries into the lockfile.
- * Each entry is marked with `staged: true` and empty translations.
- */
-export function writeStagedEntries(settings, stagedFiles, branchId) {
-    const { data, entryMap, originalV1 } = readLockfile(settings);
-    if (branchId) {
-        data.branchId = branchId;
-    }
-    for (const file of stagedFiles) {
-        const entry = findOrCreateEntry(entryMap, data.entries, file.fileId, file.versionId);
-        entry.fileName = file.fileName;
-        entry.staged = true;
-    }
-    writeLockfile(data, originalV1);
+* Writes staged file entries into the lockfile.
+* Each entry is marked with `staged: true` and empty translations.
+*/
+function writeStagedEntries(settings, stagedFiles, branchId) {
+	const { data, entryMap, originalV1 } = readLockfile(settings);
+	if (branchId) data.branchId = branchId;
+	for (const file of stagedFiles) {
+		const entry = findOrCreateEntry(entryMap, data.entries, file.fileId, file.versionId);
+		entry.fileName = file.fileName;
+		entry.staged = true;
+	}
+	writeLockfile(data, originalV1);
 }
 /**
- * Reads staged entries from the lockfile.
- * Returns the same shape as FileTranslationData for compatibility
- * with the download workflow.
- */
-export function getStagedEntriesFromLockfile(settings) {
-    const { data } = readLockfile(settings);
-    const result = {};
-    for (const entry of data.entries) {
-        if (entry.staged && entry.fileName) {
-            result[entry.fileId] = {
-                versionId: entry.versionId,
-                fileName: entry.fileName,
-            };
-        }
-    }
-    return result;
+* Reads staged entries from the lockfile.
+* Returns the same shape as FileTranslationData for compatibility
+* with the download workflow.
+*/
+function getStagedEntriesFromLockfile(settings) {
+	const { data } = readLockfile(settings);
+	const result = {};
+	for (const entry of data.entries) if (entry.staged && entry.fileName) result[entry.fileId] = {
+		versionId: entry.versionId,
+		fileName: entry.fileName
+	};
+	return result;
 }
+//#endregion
+export { buildEntryMap, findOrCreateEntry, getStagedEntriesFromLockfile, readLockfile, writeLockfile, writeStagedEntries };
+
+//# sourceMappingURL=downloadedVersions.js.map

package/dist/fs/config/downloadedVersions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"downloadedVersions.js","names":[],"sources":["../../../src/fs/config/downloadedVersions.ts"],"sourcesContent":["import fs from 'node:fs';\nimport path from 'node:path';\nimport { logger } from '../../console/logger.js';\nimport type { Settings } from '../../types/index.js';\n\nconst GT_LOCK_FILE = 'gt-lock.json';\n\n// ── V2 types (internal working format) ──────────────────────────────\n\nexport type DownloadedTranslation = {\n  updatedAt?: string;\n  postProcessHash?: string;\n  fileName?: string; // output path for this locale, e.g. \"es-US/my/file/path.mdx\"\n};\n\nexport type DownloadedVersionEntry = {\n  fileId: string;\n  versionId: string;\n  fileName?: string; // source file path\n  staged?: boolean; // true if this entry was staged but not yet downloaded\n  translations: {\n    [locale: string]: DownloadedTranslation;\n  };\n};\n\nexport type DownloadedVersions = {\n  version: 2;\n  branchId: string;\n  entries: DownloadedVersionEntry[];\n};\n\n// ── V1 types (backwards compatibility) ──────────────────────────────\n\nexport type DownloadedVersionEntryV1 = {\n  fileName?: string;\n  updatedAt?: string;\n  postProcessHash?: string;\n  sourceHash?: string;\n};\n\nexport type DownloadedVersionsV1 = {\n  version: number;\n  entries: {\n    [branchId: string]: {\n      [fileId: string]: {\n        [versionId: string]: { [locale: string]: DownloadedVersionEntryV1 };\n      };\n    };\n  };\n};\n\n// ── Conversion helpers ──────────────────────────────────────────────\n\nfunction convertV1ToV2(\n  v1: DownloadedVersionsV1,\n  branchId: string\n): DownloadedVersions {\n  const branchEntries = v1.entries?.[branchId];\n  if (!branchEntries) {\n    return { version: 2, branchId, entries: [] };\n  }\n\n  const entries: DownloadedVersionEntry[] = [];\n\n  for (const [fileId, versions] of Object.entries(branchEntries)) {\n    const versionIds = Object.keys(versions);\n    if (versionIds.length === 0) continue;\n\n    // Pick the versionId with the most recent updatedAt, defaulting to the first\n    let latestVersionId = versionIds[0];\n    let latestTime = 0;\n\n    for (const [versionId, locales] of Object.entries(versions)) {\n      for (const entry of Object.values(locales)) {\n        const t = entry.updatedAt ? Date.parse(entry.updatedAt) : 0;\n        if (t > latestTime) {\n          latestTime = t;\n          latestVersionId = versionId;\n        }\n      }\n    }\n\n    const localeEntries = versions[latestVersionId];\n    const translations: { [locale: string]: DownloadedTranslation } = {};\n\n    for (const [locale, entry] of Object.entries(localeEntries)) {\n      translations[locale] = {\n        ...(entry.updatedAt ? { updatedAt: entry.updatedAt } : {}),\n        ...(entry.postProcessHash\n          ? { postProcessHash: entry.postProcessHash }\n          : {}),\n      };\n    }\n\n    entries.push({\n      fileId,\n      versionId: latestVersionId,\n      translations,\n    });\n  }\n\n  return { version: 2, branchId, entries };\n}\n\nfunction convertV2ToV1Branch(\n  v2: DownloadedVersions\n): DownloadedVersionsV1['entries'][string] {\n  const branch: DownloadedVersionsV1['entries'][string] = {};\n\n  for (const entry of v2.entries) {\n    if (!branch[entry.fileId]) {\n      branch[entry.fileId] = {};\n    }\n    if (!branch[entry.fileId][entry.versionId]) {\n      branch[entry.fileId][entry.versionId] = {};\n    }\n\n    for (const [locale, translation] of Object.entries(entry.translations)) {\n      branch[entry.fileId][entry.versionId][locale] = {\n        ...(translation.updatedAt ? { updatedAt: translation.updatedAt } : {}),\n        ...(translation.postProcessHash\n          ? { postProcessHash: translation.postProcessHash }\n          : {}),\n      };\n    }\n  }\n\n  return branch;\n}\n\n// ── Public API ──────────────────────────────────────────────────────\n\n/**\n * Reads the lockfile and returns v2 data regardless of the on-disk format.\n * If the file is v1, `originalV1` contains the full v1 data so that\n * `writeLockfile` can merge changes back without losing other branches.\n */\nexport function readLockfile(settings: Settings): {\n  data: DownloadedVersions;\n  entryMap: EntryMap;\n  originalV1: DownloadedVersionsV1 | null;\n} {\n  let branchId = settings._branchId ?? '';\n\n  let data: DownloadedVersions;\n  let originalV1: DownloadedVersionsV1 | null = null;\n\n  try {\n    const rootPath = path.join(process.cwd(), GT_LOCK_FILE);\n    if (!fs.existsSync(rootPath)) {\n      data = { version: 2, branchId, entries: [] };\n    } else {\n      const raw = JSON.parse(fs.readFileSync(rootPath, 'utf8'));\n      if (!raw || typeof raw !== 'object' || !raw.entries) {\n        data = { version: 2, branchId, entries: [] };\n      } else if (raw.version === 2 && Array.isArray(raw.entries)) {\n        data = raw as DownloadedVersions;\n        if (branchId) data.branchId = branchId;\n      } else {\n        originalV1 = raw as DownloadedVersionsV1;\n        if (!branchId) {\n          const branches = Object.keys(originalV1.entries);\n          if (branches.length > 0) branchId = branches[0];\n        }\n        data = convertV1ToV2(originalV1, branchId);\n      }\n    }\n  } catch (error) {\n    logger.error(`An error occurred while reading ${GT_LOCK_FILE}: ${error}`);\n    data = { version: 2, branchId, entries: [] };\n  }\n\n  return { data, entryMap: buildEntryMap(data.entries), originalV1 };\n}\n\n/**\n * Writes the lockfile. If `originalV1` is provided, merges the current\n * branch's data back into the v1 structure (preserving other branches)\n * and writes v1 format. Otherwise writes v2.\n */\nexport function writeLockfile(\n  data: DownloadedVersions,\n  originalV1: DownloadedVersionsV1 | null\n): void {\n  try {\n    const filepath = path.join(process.cwd(), GT_LOCK_FILE);\n    fs.mkdirSync(path.dirname(filepath), { recursive: true });\n\n    // V1 format can't represent the staged flag — upgrade to V2 if any entries are staged\n    if (originalV1 && !data.entries.some((e) => e.staged)) {\n      const mergedV1: DownloadedVersionsV1 = {\n        ...originalV1,\n        entries: {\n          ...originalV1.entries,\n          [data.branchId]: convertV2ToV1Branch(data),\n        },\n      };\n      fs.writeFileSync(filepath, JSON.stringify(mergedV1, null, 2));\n    } else {\n      fs.writeFileSync(filepath, JSON.stringify(data, null, 2));\n    }\n  } catch (error) {\n    logger.error(`An error occurred while updating ${GT_LOCK_FILE}: ${error}`);\n  }\n}\n\n// ── Lookup helpers ──────────────────────────────────────────────────\n\nexport type EntryMap = Map<string, DownloadedVersionEntry>;\n\nexport function buildEntryMap(entries: DownloadedVersionEntry[]): EntryMap {\n  return new Map(entries.map((e) => [e.fileId, e]));\n}\n\n/**\n * Finds or creates an entry, keeping the map and backing array in sync.\n * If the fileId exists but versionId changed, replaces it in-place.\n */\nexport function findOrCreateEntry(\n  entryMap: EntryMap,\n  entries: DownloadedVersionEntry[],\n  fileId: string,\n  versionId: string\n): DownloadedVersionEntry {\n  const existing = entryMap.get(fileId);\n  if (existing) {\n    if (existing.versionId === versionId) return existing;\n    // Version changed — replace in array and map\n    const updated: DownloadedVersionEntry = {\n      fileId,\n      versionId,\n      translations: {},\n    };\n    const idx = entries.indexOf(existing);\n    if (idx !== -1) entries[idx] = updated;\n    entryMap.set(fileId, updated);\n    return updated;\n  }\n  const entry: DownloadedVersionEntry = {\n    fileId,\n    versionId,\n    translations: {},\n  };\n  entries.push(entry);\n  entryMap.set(fileId, entry);\n  return entry;\n}\n\n// ── Staging helpers ─────────────────────────────────────────────────\n\n/**\n * Writes staged file entries into the lockfile.\n * Each entry is marked with `staged: true` and empty translations.\n */\nexport function writeStagedEntries(\n  settings: Settings,\n  stagedFiles: { fileId: string; versionId: string; fileName: string }[],\n  branchId?: string\n): void {\n  const { data, entryMap, originalV1 } = readLockfile(settings);\n\n  if (branchId) {\n    data.branchId = branchId;\n  }\n\n  for (const file of stagedFiles) {\n    const entry = findOrCreateEntry(\n      entryMap,\n      data.entries,\n      file.fileId,\n      file.versionId\n    );\n    entry.fileName = file.fileName;\n    entry.staged = true;\n  }\n\n  writeLockfile(data, originalV1);\n}\n\n/**\n * Reads staged entries from the lockfile.\n * Returns the same shape as FileTranslationData for compatibility\n * with the download workflow.\n */\nexport function getStagedEntriesFromLockfile(\n  settings: Settings\n): Record<string, { versionId: string; fileName: string }> {\n  const { data } = readLockfile(settings);\n  const result: Record<string, { versionId: string; fileName: string }> = {};\n\n  for (const entry of data.entries) {\n    if (entry.staged && entry.fileName) {\n      result[entry.fileId] = {\n        versionId: entry.versionId,\n        fileName: entry.fileName,\n      };\n    }\n  }\n\n  return result;\n}\n"],"mappings":"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"}

package/dist/fs/config/loadConfig.js

@@ -1,9 +1,13 @@
-import fs from 'node:fs';
-export function loadConfig(filepath) {
-    try {
-        return JSON.parse(fs.readFileSync(filepath, 'utf-8'));
-    }
-    catch {
-        return {};
-    }
+import fs from "node:fs";
+//#region src/fs/config/loadConfig.ts
+function loadConfig(filepath) {
+	try {
+		return JSON.parse(fs.readFileSync(filepath, "utf-8"));
+	} catch {
+		return {};
+	}
 }
+//#endregion
+export { loadConfig };
+
+//# sourceMappingURL=loadConfig.js.map

package/dist/fs/config/loadConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadConfig.js","names":[],"sources":["../../../src/fs/config/loadConfig.ts"],"sourcesContent":["import fs from 'node:fs';\n\nexport function loadConfig(filepath: string): Record<string, unknown> {\n  try {\n    return JSON.parse(fs.readFileSync(filepath, 'utf-8')) as Record<\n      string,\n      unknown\n    >;\n  } catch {\n    return {};\n  }\n}\n"],"mappings":";;AAEA,SAAgB,WAAW,UAA2C;AACpE,KAAI;AACF,SAAO,KAAK,MAAM,GAAG,aAAa,UAAU,QAAQ,CAAC;SAI/C;AACN,SAAO,EAAE"}