@intlayer/engine 9.0.0-canary.12

package/dist/cjs/writeFileIfChanged.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeFileIfChanged.cjs","names":[],"sources":["../../src/writeFileIfChanged.ts"],"sourcesContent":["import { createHash, randomBytes } from 'node:crypto';\nimport { createReadStream, rmSync } from 'node:fs';\nimport { chmod, mkdir, rename, rm, stat, writeFile } from 'node:fs/promises';\nimport { basename, join } from 'node:path';\n\nconst activeTempFiles = new Set<string>();\n\n// Synchronous cleanup on process exit\nprocess.on('exit', () => {\n  for (const file of activeTempFiles) {\n    try {\n      rmSync(file, { force: true });\n    } catch {}\n  }\n});\n\n// Helper to hash existing file via stream\nconst getFileHash = (path: string): Promise<string | null> => {\n  return new Promise((resolve) => {\n    const hash = createHash('sha256');\n    const stream = createReadStream(path);\n    stream.on('data', (chunk) => hash.update(chunk));\n    stream.on('end', () => resolve(hash.digest('hex')));\n    stream.on('error', () => resolve(null));\n  });\n};\n\nexport const writeFileIfChanged = async (\n  path: string,\n  data: string,\n  {\n    encoding = 'utf8',\n    tempDir,\n  }: { encoding?: BufferEncoding; tempDir?: string } = {}\n): Promise<boolean> => {\n  const newDataHash = createHash('sha256').update(data, encoding).digest('hex');\n  const existingHash = await getFileHash(path);\n\n  if (newDataHash === existingHash) {\n    return false;\n  }\n\n  if (tempDir) {\n    await mkdir(tempDir, { recursive: true });\n  }\n\n  const tempFileName = `${basename(path)}.${Date.now()}-${randomBytes(4).toString('hex')}.tmp`;\n  const tempPath = tempDir\n    ? join(tempDir, tempFileName)\n    : `${path}.${tempFileName}`;\n  activeTempFiles.add(tempPath);\n\n  try {\n    let mode: number | undefined;\n    try {\n      mode = (await stat(path)).mode;\n    } catch {}\n\n    await writeFile(tempPath, data, { encoding });\n\n    if (mode !== undefined) {\n      await chmod(tempPath, mode);\n    }\n\n    await rename(tempPath, path);\n  } catch (error) {\n    try {\n      await rm(tempPath, { force: true });\n    } catch {}\n    throw error;\n  } finally {\n    activeTempFiles.delete(tempPath);\n  }\n\n  return true;\n};\n"],"mappings":";;;;;;;;AAKA,MAAM,kCAAkB,IAAI,KAAa;AAGzC,QAAQ,GAAG,cAAc;AACvB,MAAK,MAAM,QAAQ,gBACjB,KAAI;AACF,sBAAO,MAAM,EAAE,OAAO,MAAM,CAAC;SACvB;EAEV;AAGF,MAAM,eAAe,SAAyC;AAC5D,QAAO,IAAI,SAAS,YAAY;EAC9B,MAAM,mCAAkB,SAAS;EACjC,MAAM,uCAA0B,KAAK;AACrC,SAAO,GAAG,SAAS,UAAU,KAAK,OAAO,MAAM,CAAC;AAChD,SAAO,GAAG,aAAa,QAAQ,KAAK,OAAO,MAAM,CAAC,CAAC;AACnD,SAAO,GAAG,eAAe,QAAQ,KAAK,CAAC;GACvC;;AAGJ,MAAa,qBAAqB,OAChC,MACA,MACA,EACE,WAAW,QACX,YACmD,EAAE,KAClC;AAIrB,iCAH+B,SAAS,CAAC,OAAO,MAAM,SAAS,CAAC,OAAO,MAGxD,KAAK,MAFO,YAAY,KAAK,CAG1C,QAAO;AAGT,KAAI,QACF,mCAAY,SAAS,EAAE,WAAW,MAAM,CAAC;CAG3C,MAAM,eAAe,2BAAY,KAAK,CAAC,GAAG,KAAK,KAAK,CAAC,gCAAe,EAAE,CAAC,SAAS,MAAM,CAAC;CACvF,MAAM,WAAW,8BACR,SAAS,aAAa,GAC3B,GAAG,KAAK,GAAG;AACf,iBAAgB,IAAI,SAAS;AAE7B,KAAI;EACF,IAAI;AACJ,MAAI;AACF,WAAQ,iCAAW,KAAK,EAAE;UACpB;AAER,wCAAgB,UAAU,MAAM,EAAE,UAAU,CAAC;AAE7C,MAAI,SAAS,OACX,mCAAY,UAAU,KAAK;AAG7B,qCAAa,UAAU,KAAK;UACrB,OAAO;AACd,MAAI;AACF,kCAAS,UAAU,EAAE,OAAO,MAAM,CAAC;UAC7B;AACR,QAAM;WACE;AACR,kBAAgB,OAAO,SAAS;;AAGlC,QAAO"}

package/dist/cjs/writeJsonIfChanged.cjs

@@ -0,0 +1,18 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_writeFileIfChanged = require('./writeFileIfChanged.cjs');
+
+//#region src/writeJsonIfChanged.ts
+const writeJsonIfChanged = async (path, data, { pretty = process.env.NODE_ENV === "development" } = {}) => {
+	const space = pretty ? 2 : void 0;
+	let json = "{}";
+	try {
+		json = JSON.stringify(data, null, space);
+	} catch (error) {
+		console.error(`Error while parsing data to JSON for ${path}:`, error);
+	}
+	return await require_writeFileIfChanged.writeFileIfChanged(path, json);
+};
+
+//#endregion
+exports.writeJsonIfChanged = writeJsonIfChanged;
+//# sourceMappingURL=writeJsonIfChanged.cjs.map

package/dist/cjs/writeJsonIfChanged.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeJsonIfChanged.cjs","names":["writeFileIfChanged"],"sources":["../../src/writeJsonIfChanged.ts"],"sourcesContent":["import { writeFileIfChanged } from './writeFileIfChanged';\n\nexport const writeJsonIfChanged = async <T>(\n  path: string,\n  data: T,\n  { pretty = process.env.NODE_ENV === 'development' } = {}\n): Promise<boolean> => {\n  const space = pretty ? 2 : undefined;\n\n  let json = '{}';\n\n  try {\n    json = JSON.stringify(data, null, space);\n  } catch (error) {\n    console.error(`Error while parsing data to JSON for ${path}:`, error);\n  }\n\n  return await writeFileIfChanged(path, json);\n};\n"],"mappings":";;;;AAEA,MAAa,qBAAqB,OAChC,MACA,MACA,EAAE,SAAS,QAAQ,IAAI,aAAa,kBAAkB,EAAE,KACnC;CACrB,MAAM,QAAQ,SAAS,IAAI;CAE3B,IAAI,OAAO;AAEX,KAAI;AACF,SAAO,KAAK,UAAU,MAAM,MAAM,MAAM;UACjC,OAAO;AACd,UAAQ,MAAM,wCAAwC,KAAK,IAAI,MAAM;;AAGvE,QAAO,MAAMA,8CAAmB,MAAM,KAAK"}

package/dist/esm/_virtual/_rolldown/runtime.mjs

@@ -0,0 +1,8 @@
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
+	if (typeof require !== "undefined") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
+});
+
+//#endregion
+export { __require };

package/dist/esm/_virtual/_utils_asset.mjs

@@ -0,0 +1,97 @@
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+//#region \0utils:asset
+const hereDirname = () => {
+	try {
+		return dirname(fileURLToPath(import.meta.url));
+	} catch {
+		return typeof __dirname !== "undefined" ? __dirname : process.cwd();
+	}
+};
+const findDistRoot = (startDir) => {
+	let dir = startDir;
+	for (let i = 0; i < 12; i++) {
+		if (basename(dir) === "dist") return dir;
+		const parent = resolve(dir, "..");
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return null;
+};
+const normalizeFrameFile = (file) => {
+	if (!file) return null;
+	try {
+		if (file.startsWith("file://")) return fileURLToPath(file);
+	} catch {}
+	return file;
+};
+/**
+* Returns the directory of the *caller* module that invoked readAsset.
+* Prefers non-virtual frames; falls back to the first real frame.
+*/
+const getCallerDir = () => {
+	const prev = Error.prepareStackTrace;
+	try {
+		Error.prepareStackTrace = (_, structured) => structured;
+		const err = /* @__PURE__ */ new Error();
+		Error.captureStackTrace(err, getCallerDir);
+		/** @type {import('node:vm').CallSite[]} */
+		const frames = err.stack || [];
+		const isVirtualPath = (p) => p.includes(`${sep}_virtual${sep}`) || p.includes("/_virtual/");
+		for (const frame of frames) {
+			const file = normalizeFrameFile(typeof frame.getFileName === "function" ? frame.getFileName() : null);
+			if (!file) continue;
+			if (file.includes("node:internal") || file.includes(`${sep}internal${sep}modules${sep}`)) continue;
+			if (!isVirtualPath(file)) return dirname(file);
+		}
+		for (const frame of frames) {
+			const file = normalizeFrameFile(typeof frame.getFileName === "function" ? frame.getFileName() : null);
+			if (file) return dirname(file);
+		}
+	} catch {} finally {
+		Error.prepareStackTrace = prev;
+	}
+	return hereDirname();
+};
+/**
+* Read an asset copied from src/** to dist/assets/**.
+* - './' or '../' is resolved relative to the *caller module's* emitted directory.
+* - otherwise, treat as src-relative.
+*
+* @param {string} relPath - e.g. './PROMPT.md' or 'utils/AI/askDocQuestion/embeddings/<fileKey>.json'
+* @param {BufferEncoding} [encoding='utf8']
+*/
+const readAsset = (relPath, encoding = "utf8") => {
+	const here = hereDirname();
+	const distRoot = findDistRoot(here) ?? resolve(here, "..", "..", "dist");
+	const assetsRoot = join(distRoot, "assets");
+	const tried = [];
+	/**
+	* Transform dist/(esm|cjs)/... and _virtual/ prefix to clean subpath (Windows-safe)
+	*/
+	const callerSubpath = relative(distRoot, getCallerDir()).split("\\").join("/").replace(/^(?:dist\/)?(?:esm|cjs)\//, "").replace(/^_virtual\//, "");
+	if (relPath.startsWith("./") || relPath.startsWith("../")) {
+		const fromCallerAbs = resolve(assetsRoot, callerSubpath, relPath);
+		tried.push(fromCallerAbs);
+		if (existsSync(fromCallerAbs)) return readFileSync(fromCallerAbs, encoding);
+	}
+	const directPath = join(assetsRoot, relPath);
+	tried.push(directPath);
+	if (existsSync(directPath)) return readFileSync(directPath, encoding);
+	if (callerSubpath) {
+		const nested = join(assetsRoot, callerSubpath, relPath);
+		tried.push(nested);
+		if (existsSync(nested)) return readFileSync(nested, encoding);
+	}
+	const msg = [
+		"readAsset: file not found.",
+		"Searched:",
+		...tried.map((p) => `- ${p}`)
+	].join("\n");
+	throw new Error(msg);
+};
+
+//#endregion
+export { readAsset };

package/dist/esm/build.mjs

@@ -0,0 +1,26 @@
+import { generateDictionaryListContent } from "./createDictionaryEntryPoint/generateDictionaryListContent.mjs";
+import { getBuiltDictionariesPath } from "./createDictionaryEntryPoint/getBuiltDictionariesPath.mjs";
+import { getBuiltDynamicDictionariesPath } from "./createDictionaryEntryPoint/getBuiltDynamicDictionariesPath.mjs";
+import { getBuiltFetchDictionariesPath } from "./createDictionaryEntryPoint/getBuiltFetchDictionariesPath.mjs";
+import { getBuiltRemoteDictionariesPath } from "./createDictionaryEntryPoint/getBuiltRemoteDictionariesPath.mjs";
+import { getBuiltUnmergedDictionariesPath } from "./createDictionaryEntryPoint/getBuiltUnmergedDictionariesPath.mjs";
+import { createDictionaryEntryPoint } from "./createDictionaryEntryPoint/createDictionaryEntryPoint.mjs";
+import { readDictionariesFromDisk } from "./utils/readDictionariesFromDisk.mjs";
+import { buildDictionary } from "./buildIntlayerDictionary/buildIntlayerDictionary.mjs";
+import { createModuleAugmentation, getTypeName } from "./createType/createModuleAugmentation.mjs";
+import { createTypes, generateTypeScriptType } from "./createType/createType.mjs";
+import { processContentDeclaration } from "./buildIntlayerDictionary/processContentDeclaration.mjs";
+import { ensureIntlayerBundle, formatLocalDictionaries, loadContentDeclaration, loadContentDeclarations } from "./loadDictionaries/loadContentDeclaration.mjs";
+import { loadLocalDictionaries } from "./loadDictionaries/loadLocalDictionaries.mjs";
+import { formatDictionaries, formatDictionariesOutput, formatDictionary, formatDictionaryOutput } from "./formatDictionary.mjs";
+import { formatDistantDictionaries, loadRemoteDictionaries } from "./loadDictionaries/loadRemoteDictionaries.mjs";
+import { loadDictionaries } from "./loadDictionaries/loadDictionaries.mjs";
+import { cleanOutputDir } from "./cleanOutputDir.mjs";
+import { isCachedConfigurationUpToDate, writeConfiguration } from "./writeConfiguration/index.mjs";
+import { prepareIntlayer } from "./prepareIntlayer.mjs";
+import { detectExportedComponentName } from "./writeContentDeclaration/detectExportedComponentName.mjs";
+import { transformJSFile } from "./writeContentDeclaration/transformJSFile.mjs";
+import { writeJSFile } from "./writeContentDeclaration/writeJSFile.mjs";
+import { writeContentDeclaration } from "./writeContentDeclaration/writeContentDeclaration.mjs";
+
+export { buildDictionary, cleanOutputDir, createDictionaryEntryPoint, createModuleAugmentation, createTypes, detectExportedComponentName, ensureIntlayerBundle, formatDictionaries, formatDictionariesOutput, formatDictionary, formatDictionaryOutput, formatDistantDictionaries, formatLocalDictionaries, generateDictionaryListContent, generateTypeScriptType, getBuiltDictionariesPath, getBuiltDynamicDictionariesPath, getBuiltFetchDictionariesPath, getBuiltRemoteDictionariesPath, getBuiltUnmergedDictionariesPath, getTypeName, isCachedConfigurationUpToDate, loadContentDeclaration, loadContentDeclarations, loadDictionaries, loadLocalDictionaries, loadRemoteDictionaries, prepareIntlayer, processContentDeclaration, readDictionariesFromDisk, transformJSFile, writeConfiguration, writeContentDeclaration, writeJSFile };

package/dist/esm/buildIntlayerDictionary/buildIntlayerDictionary.mjs

@@ -0,0 +1,78 @@
+import { readDictionariesFromDisk } from "../utils/readDictionariesFromDisk.mjs";
+import { writeDynamicDictionary, writeDynamicQualifiedDictionaries } from "./writeDynamicDictionary.mjs";
+import { writeFetchDictionary } from "./writeFetchDictionary.mjs";
+import { writeMergedDictionaries } from "./writeMergedDictionary.mjs";
+import { writeUnmergedDictionaries } from "./writeUnmergedDictionary.mjs";
+import { colorizeKey, getAppLogger } from "@intlayer/config/logger";
+import { IMPORT_MODE, OUTPUT_FORMAT } from "@intlayer/config/defaultValues";
+import { isQualifiedDictionaryGroup } from "@intlayer/core/dictionaryManipulator";
+
+//#region src/buildIntlayerDictionary/buildIntlayerDictionary.ts
+const defaultOptions = {
+	formats: OUTPUT_FORMAT,
+	importOtherDictionaries: true,
+	env: "dev"
+};
+/**
+* This function transpile the bundled code to to make dictionaries as JSON files
+*/
+const buildDictionary = async (localDictionariesEntries, configuration, options) => {
+	const importMode = configuration?.build?.importMode ?? configuration?.dictionary?.importMode ?? IMPORT_MODE;
+	const { importOtherDictionaries, env, formats } = {
+		...defaultOptions,
+		...options
+	};
+	const unmergedDictionariesToUpdate = [...localDictionariesEntries];
+	if (importOtherDictionaries) {
+		const prevUnmergedDictionaries = readDictionariesFromDisk(configuration.system.unmergedDictionariesDir);
+		for (const dictionaryToWrite of localDictionariesEntries) {
+			const allPrebuiltUnmergedDictionaries = prevUnmergedDictionaries[dictionaryToWrite.key];
+			if (allPrebuiltUnmergedDictionaries?.length > 0) {
+				const otherUnmergedDictionaries = allPrebuiltUnmergedDictionaries?.filter((unmergedDictionary) => unmergedDictionary.localId !== dictionaryToWrite.localId);
+				unmergedDictionariesToUpdate.push(...otherUnmergedDictionaries ?? []);
+			}
+		}
+	}
+	const unmergedDictionaries = await writeUnmergedDictionaries(unmergedDictionariesToUpdate, configuration, env);
+	const mergedDictionaries = await writeMergedDictionaries(unmergedDictionaries, configuration);
+	const dictionariesToBuildDynamic = {};
+	const qualifiedDictionariesToBuildDynamic = {};
+	const keysToBuildFetch = /* @__PURE__ */ new Set();
+	for (const [key, mergedResult] of Object.entries(mergedDictionaries)) {
+		const dictionary = mergedResult.dictionary;
+		if (isQualifiedDictionaryGroup(dictionary)) {
+			const entryMode = dictionary.importMode ?? importMode;
+			if (entryMode === "dynamic") qualifiedDictionariesToBuildDynamic[key] = {
+				dictionaryPath: mergedResult.dictionaryPath,
+				dictionary
+			};
+			else if (entryMode === "fetch") getAppLogger(configuration)(`Dictionary ${colorizeKey(key)} uses 'fetch' import mode with (${dictionary.qualifierTypes.join(", ")}) entries — fetch mode is not qualifier-aware yet, falling back to static import.`, { level: "warn" });
+			continue;
+		}
+		const mode = dictionary.importMode ?? importMode;
+		if (mode === "dynamic" || mode === "fetch") dictionariesToBuildDynamic[key] = {
+			dictionaryPath: mergedResult.dictionaryPath,
+			dictionary
+		};
+		if (mode === "fetch") keysToBuildFetch.add(key);
+	}
+	let dynamicDictionaries = null;
+	if (Object.keys(dictionariesToBuildDynamic).length > 0) dynamicDictionaries = await writeDynamicDictionary(dictionariesToBuildDynamic, configuration, formats);
+	if (Object.keys(qualifiedDictionariesToBuildDynamic).length > 0) await writeDynamicQualifiedDictionaries(qualifiedDictionariesToBuildDynamic, configuration, formats);
+	let fetchDictionaries = null;
+	if (dynamicDictionaries && keysToBuildFetch.size > 0) {
+		const dictionariesToBuildFetch = {};
+		for (const key of keysToBuildFetch) if (dynamicDictionaries[key]) dictionariesToBuildFetch[key] = dynamicDictionaries[key];
+		if (Object.keys(dictionariesToBuildFetch).length > 0) fetchDictionaries = await writeFetchDictionary(dictionariesToBuildFetch, configuration, formats);
+	}
+	return {
+		unmergedDictionaries,
+		mergedDictionaries,
+		dynamicDictionaries,
+		fetchDictionaries
+	};
+};
+
+//#endregion
+export { buildDictionary };
+//# sourceMappingURL=buildIntlayerDictionary.mjs.map

package/dist/esm/buildIntlayerDictionary/buildIntlayerDictionary.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildIntlayerDictionary.mjs","names":[],"sources":["../../../src/buildIntlayerDictionary/buildIntlayerDictionary.ts"],"sourcesContent":["import { IMPORT_MODE, OUTPUT_FORMAT } from '@intlayer/config/defaultValues';\nimport { colorizeKey, getAppLogger } from '@intlayer/config/logger';\nimport { isQualifiedDictionaryGroup } from '@intlayer/core/dictionaryManipulator';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { readDictionariesFromDisk } from '../utils/readDictionariesFromDisk';\nimport {\n  type LocalizedDictionaryOutput,\n  type QualifiedMergedDictionaryOutput,\n  writeDynamicDictionary,\n  writeDynamicQualifiedDictionaries,\n} from './writeDynamicDictionary';\nimport { writeFetchDictionary } from './writeFetchDictionary';\nimport {\n  type PlainMergedDictionaryOutput,\n  writeMergedDictionaries,\n} from './writeMergedDictionary';\nimport { writeUnmergedDictionaries } from './writeUnmergedDictionary';\n\nexport type BuildDictionariesOptions = Partial<{\n  formats: typeof OUTPUT_FORMAT;\n  importOtherDictionaries: boolean;\n  env: 'prod' | 'dev';\n}>;\n\nconst defaultOptions = {\n  formats: OUTPUT_FORMAT,\n  importOtherDictionaries: true,\n  env: 'dev',\n} as const satisfies BuildDictionariesOptions;\n\n/**\n * This function transpile the bundled code to to make dictionaries as JSON files\n */\nexport const buildDictionary = async (\n  localDictionariesEntries: Dictionary[],\n  configuration: IntlayerConfig,\n  options?: BuildDictionariesOptions\n) => {\n  const importMode =\n    configuration?.build?.importMode ??\n    configuration?.dictionary?.importMode ??\n    IMPORT_MODE;\n\n  const { importOtherDictionaries, env, formats } = {\n    ...defaultOptions,\n    ...options,\n  };\n\n  const unmergedDictionariesToUpdate: Dictionary[] = [\n    ...localDictionariesEntries,\n  ];\n\n  if (importOtherDictionaries) {\n    const prevUnmergedDictionaries: Record<string, Dictionary[]> =\n      readDictionariesFromDisk(configuration.system.unmergedDictionariesDir);\n\n    // Reinsert other dictionaries with the same key to avoid merging errors\n    for (const dictionaryToWrite of localDictionariesEntries) {\n      const allPrebuiltUnmergedDictionaries =\n        prevUnmergedDictionaries[dictionaryToWrite.key]!;\n\n      if (allPrebuiltUnmergedDictionaries?.length > 0) {\n        // Do not add the same dictionary again by filtering out the one with the same localId\n        const otherUnmergedDictionaries =\n          allPrebuiltUnmergedDictionaries?.filter(\n            (unmergedDictionary) =>\n              unmergedDictionary.localId !== dictionaryToWrite.localId\n          );\n\n        unmergedDictionariesToUpdate.push(...(otherUnmergedDictionaries ?? []));\n      }\n    }\n  }\n\n  const unmergedDictionaries = await writeUnmergedDictionaries(\n    unmergedDictionariesToUpdate,\n    configuration,\n    env\n  );\n\n  const mergedDictionaries = await writeMergedDictionaries(\n    unmergedDictionaries,\n    configuration\n  );\n\n  const dictionariesToBuildDynamic: PlainMergedDictionaryOutput = {};\n  const qualifiedDictionariesToBuildDynamic: QualifiedMergedDictionaryOutput =\n    {};\n  const keysToBuildFetch = new Set<string>();\n\n  for (const [key, mergedResult] of Object.entries(mergedDictionaries)) {\n    const dictionary = mergedResult.dictionary;\n\n    if (isQualifiedDictionaryGroup(dictionary)) {\n      // Collections / variants resolve their qualifier at\n      // runtime from a selector. Static mode keeps every entry in one JSON;\n      // dynamic mode splits them into one chunk per (locale, qualifierId).\n      const entryMode = dictionary.importMode ?? importMode;\n\n      if (entryMode === 'dynamic') {\n        qualifiedDictionariesToBuildDynamic[key] = {\n          dictionaryPath: mergedResult.dictionaryPath,\n          dictionary,\n        };\n      } else if (entryMode === 'fetch') {\n        const appLogger = getAppLogger(configuration);\n        appLogger(\n          `Dictionary ${colorizeKey(key)} uses 'fetch' import mode with (${dictionary.qualifierTypes.join(', ')}) entries — fetch mode is not qualifier-aware yet, falling back to static import.`,\n          { level: 'warn' }\n        );\n      }\n\n      continue;\n    }\n\n    const mode = dictionary.importMode ?? importMode;\n\n    if (mode === 'dynamic' || mode === 'fetch') {\n      dictionariesToBuildDynamic[key] = {\n        dictionaryPath: mergedResult.dictionaryPath,\n        dictionary,\n      };\n    }\n\n    if (mode === 'fetch') {\n      keysToBuildFetch.add(key);\n    }\n  }\n\n  let dynamicDictionaries: LocalizedDictionaryOutput | null = null;\n\n  if (Object.keys(dictionariesToBuildDynamic).length > 0) {\n    dynamicDictionaries = await writeDynamicDictionary(\n      dictionariesToBuildDynamic,\n      configuration,\n      formats\n    );\n  }\n\n  if (Object.keys(qualifiedDictionariesToBuildDynamic).length > 0) {\n    await writeDynamicQualifiedDictionaries(\n      qualifiedDictionariesToBuildDynamic,\n      configuration,\n      formats\n    );\n  }\n\n  let fetchDictionaries: LocalizedDictionaryOutput | null = null;\n\n  if (dynamicDictionaries && keysToBuildFetch.size > 0) {\n    const dictionariesToBuildFetch: LocalizedDictionaryOutput = {};\n\n    for (const key of keysToBuildFetch) {\n      if (dynamicDictionaries[key]) {\n        dictionariesToBuildFetch[key] = dynamicDictionaries[key];\n      }\n    }\n\n    if (Object.keys(dictionariesToBuildFetch).length > 0) {\n      fetchDictionaries = await writeFetchDictionary(\n        dictionariesToBuildFetch,\n        configuration,\n        formats\n      );\n    }\n  }\n\n  return {\n    unmergedDictionaries,\n    mergedDictionaries,\n    dynamicDictionaries,\n    fetchDictionaries,\n  };\n};\n"],"mappings":";;;;;;;;;;AAyBA,MAAM,iBAAiB;CACrB,SAAS;CACT,yBAAyB;CACzB,KAAK;CACN;;;;AAKD,MAAa,kBAAkB,OAC7B,0BACA,eACA,YACG;CACH,MAAM,aACJ,eAAe,OAAO,cACtB,eAAe,YAAY,cAC3B;CAEF,MAAM,EAAE,yBAAyB,KAAK,YAAY;EAChD,GAAG;EACH,GAAG;EACJ;CAED,MAAM,+BAA6C,CACjD,GAAG,yBACJ;AAED,KAAI,yBAAyB;EAC3B,MAAM,2BACJ,yBAAyB,cAAc,OAAO,wBAAwB;AAGxE,OAAK,MAAM,qBAAqB,0BAA0B;GACxD,MAAM,kCACJ,yBAAyB,kBAAkB;AAE7C,OAAI,iCAAiC,SAAS,GAAG;IAE/C,MAAM,4BACJ,iCAAiC,QAC9B,uBACC,mBAAmB,YAAY,kBAAkB,QACpD;AAEH,iCAA6B,KAAK,GAAI,6BAA6B,EAAE,CAAE;;;;CAK7E,MAAM,uBAAuB,MAAM,0BACjC,8BACA,eACA,IACD;CAED,MAAM,qBAAqB,MAAM,wBAC/B,sBACA,cACD;CAED,MAAM,6BAA0D,EAAE;CAClE,MAAM,sCACJ,EAAE;CACJ,MAAM,mCAAmB,IAAI,KAAa;AAE1C,MAAK,MAAM,CAAC,KAAK,iBAAiB,OAAO,QAAQ,mBAAmB,EAAE;EACpE,MAAM,aAAa,aAAa;AAEhC,MAAI,2BAA2B,WAAW,EAAE;GAI1C,MAAM,YAAY,WAAW,cAAc;AAE3C,OAAI,cAAc,UAChB,qCAAoC,OAAO;IACzC,gBAAgB,aAAa;IAC7B;IACD;YACQ,cAAc,QAEvB,CADkB,aAAa,cACtB,CACP,cAAc,YAAY,IAAI,CAAC,kCAAkC,WAAW,eAAe,KAAK,KAAK,CAAC,oFACtG,EAAE,OAAO,QAAQ,CAClB;AAGH;;EAGF,MAAM,OAAO,WAAW,cAAc;AAEtC,MAAI,SAAS,aAAa,SAAS,QACjC,4BAA2B,OAAO;GAChC,gBAAgB,aAAa;GAC7B;GACD;AAGH,MAAI,SAAS,QACX,kBAAiB,IAAI,IAAI;;CAI7B,IAAI,sBAAwD;AAE5D,KAAI,OAAO,KAAK,2BAA2B,CAAC,SAAS,EACnD,uBAAsB,MAAM,uBAC1B,4BACA,eACA,QACD;AAGH,KAAI,OAAO,KAAK,oCAAoC,CAAC,SAAS,EAC5D,OAAM,kCACJ,qCACA,eACA,QACD;CAGH,IAAI,oBAAsD;AAE1D,KAAI,uBAAuB,iBAAiB,OAAO,GAAG;EACpD,MAAM,2BAAsD,EAAE;AAE9D,OAAK,MAAM,OAAO,iBAChB,KAAI,oBAAoB,KACtB,0BAAyB,OAAO,oBAAoB;AAIxD,MAAI,OAAO,KAAK,yBAAyB,CAAC,SAAS,EACjD,qBAAoB,MAAM,qBACxB,0BACA,eACA,QACD;;AAIL,QAAO;EACL;EACA;EACA;EACA;EACD"}

package/dist/esm/buildIntlayerDictionary/index.mjs

@@ -0,0 +1,4 @@
+import { buildDictionary } from "./buildIntlayerDictionary.mjs";
+import { processContentDeclaration } from "./processContentDeclaration.mjs";
+
+export { buildDictionary, processContentDeclaration };

package/dist/esm/buildIntlayerDictionary/processContentDeclaration.mjs

@@ -0,0 +1,25 @@
+import { autoDecorateContent } from "../utils/autoDecorateContent.mjs";
+import { resolveObjectPromises } from "../utils/resolveObjectPromises.mjs";
+import { logger } from "@intlayer/config/logger";
+
+//#region src/buildIntlayerDictionary/processContentDeclaration.ts
+/**
+* Function to load, process the module and return the Intlayer Dictionary from the module file
+*/
+const processContentDeclaration = async (contentDeclaration, configuration) => {
+	try {
+		const resolvedContent = await resolveObjectPromises(contentDeclaration.content);
+		const isAutoDecorateContentEnabled = contentDeclaration.contentAutoTransformation ?? configuration.dictionary?.contentAutoTransformation ?? false;
+		const decoratedContent = isAutoDecorateContentEnabled ? autoDecorateContent(resolvedContent, isAutoDecorateContentEnabled) : resolvedContent;
+		return {
+			...contentDeclaration,
+			content: decoratedContent
+		};
+	} catch (error) {
+		logger(error, { level: "error" });
+	}
+};
+
+//#endregion
+export { processContentDeclaration };
+//# sourceMappingURL=processContentDeclaration.mjs.map

package/dist/esm/buildIntlayerDictionary/processContentDeclaration.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"processContentDeclaration.mjs","names":[],"sources":["../../../src/buildIntlayerDictionary/processContentDeclaration.ts"],"sourcesContent":["import { logger } from '@intlayer/config/logger';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { autoDecorateContent } from '../utils/autoDecorateContent';\nimport { resolveObjectPromises } from '../utils/resolveObjectPromises';\n\n/**\n * Function to load, process the module and return the Intlayer Dictionary from the module file\n */\nexport const processContentDeclaration = async (\n  contentDeclaration: Dictionary,\n  configuration: IntlayerConfig\n): Promise<Dictionary | undefined> => {\n  try {\n    const resolvedContent = (await resolveObjectPromises(\n      contentDeclaration.content\n    )) as Dictionary['content'];\n\n    const isAutoDecorateContentEnabled =\n      contentDeclaration.contentAutoTransformation ??\n      configuration.dictionary?.contentAutoTransformation ??\n      false;\n\n    const decoratedContent = isAutoDecorateContentEnabled\n      ? autoDecorateContent(resolvedContent, isAutoDecorateContentEnabled)\n      : resolvedContent;\n\n    return {\n      ...contentDeclaration,\n      content: decoratedContent,\n    } as Dictionary;\n  } catch (error) {\n    logger(error, {\n      level: 'error',\n    });\n  }\n};\n"],"mappings":";;;;;;;;AASA,MAAa,4BAA4B,OACvC,oBACA,kBACoC;AACpC,KAAI;EACF,MAAM,kBAAmB,MAAM,sBAC7B,mBAAmB,QACpB;EAED,MAAM,+BACJ,mBAAmB,6BACnB,cAAc,YAAY,6BAC1B;EAEF,MAAM,mBAAmB,+BACrB,oBAAoB,iBAAiB,6BAA6B,GAClE;AAEJ,SAAO;GACL,GAAG;GACH,SAAS;GACV;UACM,OAAO;AACd,SAAO,OAAO,EACZ,OAAO,SACR,CAAC"}

package/dist/esm/buildIntlayerDictionary/writeDynamicDictionary.mjs

@@ -0,0 +1,201 @@
+import { parallelize } from "../utils/parallelize.mjs";
+import { writeFileIfChanged } from "../writeFileIfChanged.mjs";
+import { writeJsonIfChanged } from "../writeJsonIfChanged.mjs";
+import { mkdir } from "node:fs/promises";
+import { resolve } from "node:path";
+import { colorizePath } from "@intlayer/config/logger";
+import { assertPathWithin } from "@intlayer/config/utils";
+import { OUTPUT_FORMAT } from "@intlayer/config/defaultValues";
+import { COMPOSITE_ID_SEPARATOR, QUALIFIER_DYNAMIC_TYPES_KEY, reconstructQualifiedEntry } from "@intlayer/core/dictionaryManipulator";
+import { getPerLocaleDictionary } from "@intlayer/core/plugins";
+
+//#region src/buildIntlayerDictionary/writeDynamicDictionary.ts
+const DICTIONARIES_SUBDIR = "json";
+/**
+* Escapes a value interpolated into a single-quoted literal of a generated
+* loader module, so keys or segments containing `'` or `\` cannot break the
+* emitted JavaScript.
+*/
+const escapeJsLiteral = (value) => value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+/**
+* Generates the content of a dictionary entry point file.
+*/
+const generateDictionaryEntryPoint = (key, locales, format = "esm") => {
+	const sortedLocales = [...locales].sort((a, b) => String(a).localeCompare(String(b)));
+	const safeKey = escapeJsLiteral(key);
+	const localeEntries = sortedLocales.map((locale) => {
+		const safeLocale = escapeJsLiteral(locale);
+		return format === "esm" ? `  '${safeLocale}': () => import('./${DICTIONARIES_SUBDIR}/${safeKey}/${safeLocale}.json').then(m => m.default)` : `  '${safeLocale}': () => Promise.resolve(require('./${DICTIONARIES_SUBDIR}/${safeKey}/${safeLocale}.json'))`;
+	}).join(",\n");
+	if (format === "esm") return `const content = {\n${localeEntries}\n};\n\nexport default content;\n`;
+	return `module.exports = {\n${localeEntries}\n};\n`;
+};
+const buildLoaderExpression = (key, chunkSegments, locale, format) => {
+	const path = escapeJsLiteral(`./${DICTIONARIES_SUBDIR}/${key}/${chunkSegments.join("/")}/${locale}.json`);
+	return format === "esm" ? `() => import('${path}').then(m => m.default)` : `() => Promise.resolve(require('${path}'))`;
+};
+const buildLoaderTree = (key, entries, locale, format) => {
+	const root = {};
+	for (const { treeSegments, chunkSegments } of entries) {
+		let node = root;
+		treeSegments.forEach((segment, index) => {
+			if (index === treeSegments.length - 1) {
+				node[segment] = buildLoaderExpression(key, chunkSegments, locale, format);
+				return;
+			}
+			node[segment] = node[segment] ?? {};
+			node = node[segment];
+		});
+	}
+	return root;
+};
+const serializeLoaderTree = (tree, indentLevel) => {
+	const pad = "  ".repeat(indentLevel);
+	const innerPad = "  ".repeat(indentLevel + 1);
+	return `{\n${Object.keys(tree).sort((a, b) => a.localeCompare(b)).map((segment) => {
+		const value = tree[segment];
+		const serialized = typeof value === "string" ? value : serializeLoaderTree(value, indentLevel + 1);
+		return `${innerPad}'${escapeJsLiteral(segment)}': ${serialized}`;
+	}).join(",\n")}\n${pad}}`;
+};
+/**
+* Generates the entry point of a qualified dictionary (collection / variant,
+* possibly combined). Under each locale the loader map nests one
+* level per declared dimension (canonical order) and carries a marker listing
+* those dimensions so the runtime can walk the tree.
+*
+* One static `import()` is emitted per leaf `(locale, …segments)` chunk, which
+* keeps the output compatible with bundlers that reject template-literal
+* dynamic imports (Turbopack). Entries whose content is identical share one
+* chunk: their leaves point at the canonical entry's import path.
+*/
+const generateQualifiedDictionaryEntryPoint = (key, qualifierTypes, entries, locales, format = "esm") => {
+	const localeEntries = [...locales].sort((a, b) => String(a).localeCompare(String(b))).map((locale) => {
+		const tree = buildLoaderTree(key, entries, locale, format);
+		return `  '${escapeJsLiteral(locale)}': ${serializeLoaderTree(tree, 1)}`;
+	}).join(",\n");
+	const marker = `  '${QUALIFIER_DYNAMIC_TYPES_KEY}': ${JSON.stringify(qualifierTypes)}`;
+	if (format === "esm") return `const content = {\n${marker},\n${localeEntries}\n};\n\nexport default content;\n`;
+	return `module.exports = {\n${marker},\n${localeEntries}\n};\n`;
+};
+/**
+* Write the localized dictionaries to the dictionariesDir
+* @param mergedDictionaries - The merged dictionaries
+* @param configuration - The configuration
+* @returns The final dictionaries
+*
+* @example
+* ```ts
+* const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);
+* const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);
+* console.log(finalDictionaries);
+*
+* // .intlayer/dynamic_dictionary/dictionaries/en_home.json
+* // .intlayer/dynamic_dictionary/dictionaries/fr_home.json
+* ```
+*/
+const writeDynamicDictionary = async (mergedDictionaries, configuration, formats = OUTPUT_FORMAT) => {
+	const { locales, defaultLocale } = configuration.internationalization;
+	const { dynamicDictionariesDir } = configuration.system;
+	const dictDir = resolve(dynamicDictionariesDir, DICTIONARIES_SUBDIR);
+	await mkdir(dictDir, { recursive: true });
+	const resultDictionariesPaths = {};
+	await parallelize(Object.entries(mergedDictionaries).sort(([a], [b]) => String(a).localeCompare(String(b))), async ([key, dictionaryEntry]) => {
+		if (key === "undefined") return;
+		const localizedDictionariesPathsRecord = {};
+		const keyDir = resolve(dictDir, key);
+		assertPathWithin(keyDir, dictDir);
+		await mkdir(keyDir, { recursive: true });
+		await parallelize(locales, async (locale) => {
+			const localizedDictionary = getPerLocaleDictionary(dictionaryEntry.dictionary, locale, defaultLocale);
+			const resultFilePath = resolve(keyDir, `${locale}.json`);
+			await writeJsonIfChanged(resultFilePath, localizedDictionary).catch((err) => {
+				console.error(`Error creating localized ${key}/${locale}.json:`, err);
+			});
+			localizedDictionariesPathsRecord[locale] = {
+				dictionaryPath: resultFilePath,
+				dictionary: localizedDictionary
+			};
+		});
+		resultDictionariesPaths[key] = localizedDictionariesPathsRecord;
+		await parallelize(formats, async (format) => {
+			const extension = format === "cjs" ? "cjs" : "mjs";
+			const content = generateDictionaryEntryPoint(key, locales, format);
+			const dynEntryPath = resolve(dynamicDictionariesDir, `${key}.${extension}`);
+			assertPathWithin(dynEntryPath, dynamicDictionariesDir);
+			await writeFileIfChanged(dynEntryPath, content).catch((err) => {
+				console.error(`Error creating dynamic ${colorizePath(dynEntryPath)}:`, err);
+			});
+		});
+	});
+	return resultDictionariesPaths;
+};
+/**
+* Writes the dynamic chunks and entry points of qualified dictionaries
+* (collections, variants — possibly combined) in
+* `importMode: 'dynamic'`.
+*
+* Each entry is reduced to one per-locale chunk written to a path nested by
+* dimension — `json/{key}/{seg1}/{seg2}/{locale}.json` — and a single
+* `{key}.{ext}` entry point exposes the matching nested loader tree, so the
+* entry point is discovered and aggregated exactly like a plain dynamic one.
+*/
+const writeDynamicQualifiedDictionaries = async (qualifiedDictionaries, configuration, formats = OUTPUT_FORMAT) => {
+	const { locales, defaultLocale } = configuration.internationalization;
+	const { dynamicDictionariesDir } = configuration.system;
+	const dictDir = resolve(dynamicDictionariesDir, DICTIONARIES_SUBDIR);
+	await mkdir(dictDir, { recursive: true });
+	await parallelize(Object.entries(qualifiedDictionaries).sort(([a], [b]) => String(a).localeCompare(String(b))), async ([key, { dictionary: group }]) => {
+		if (key === "undefined") return;
+		const entryIds = Object.keys(group.content);
+		const keyDir = resolve(dictDir, key);
+		assertPathWithin(keyDir, dictDir);
+		const canonicalSegmentsByContent = /* @__PURE__ */ new Map();
+		const entries = [];
+		const canonicalEntryIds = [];
+		for (const entryId of entryIds) {
+			const treeSegments = entryId.split(COMPOSITE_ID_SEPARATOR);
+			const contentIdentity = JSON.stringify(group.content[entryId]);
+			const canonicalSegments = canonicalSegmentsByContent.get(contentIdentity);
+			if (canonicalSegments) {
+				entries.push({
+					treeSegments,
+					chunkSegments: canonicalSegments
+				});
+				continue;
+			}
+			canonicalSegmentsByContent.set(contentIdentity, treeSegments);
+			entries.push({
+				treeSegments,
+				chunkSegments: treeSegments
+			});
+			canonicalEntryIds.push(entryId);
+		}
+		await parallelize(canonicalEntryIds, async (entryId) => {
+			const entry = reconstructQualifiedEntry(group, entryId);
+			const segments = entryId.split(COMPOSITE_ID_SEPARATOR);
+			const entryDir = resolve(keyDir, ...segments);
+			assertPathWithin(entryDir, keyDir);
+			await mkdir(entryDir, { recursive: true });
+			await parallelize(locales, async (locale) => {
+				const localizedDictionary = getPerLocaleDictionary(entry, locale, defaultLocale);
+				await writeJsonIfChanged(resolve(entryDir, `${locale}.json`), localizedDictionary).catch((err) => {
+					console.error(`Error creating localized ${key}/${segments.join("/")}/${locale}.json:`, err);
+				});
+			});
+		});
+		await parallelize(formats, async (format) => {
+			const extension = format === "cjs" ? "cjs" : "mjs";
+			const content = generateQualifiedDictionaryEntryPoint(key, group.qualifierTypes, entries, locales, format);
+			const dynEntryPath = resolve(dynamicDictionariesDir, `${key}.${extension}`);
+			assertPathWithin(dynEntryPath, dynamicDictionariesDir);
+			await writeFileIfChanged(dynEntryPath, content).catch((err) => {
+				console.error(`Error creating dynamic ${colorizePath(dynEntryPath)}:`, err);
+			});
+		});
+	});
+};
+
+//#endregion
+export { generateDictionaryEntryPoint, generateQualifiedDictionaryEntryPoint, writeDynamicDictionary, writeDynamicQualifiedDictionaries };
+//# sourceMappingURL=writeDynamicDictionary.mjs.map

package/dist/esm/buildIntlayerDictionary/writeDynamicDictionary.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeDynamicDictionary.mjs","names":[],"sources":["../../../src/buildIntlayerDictionary/writeDynamicDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { resolve } from 'node:path';\nimport { OUTPUT_FORMAT } from '@intlayer/config/defaultValues';\nimport { colorizePath } from '@intlayer/config/logger';\nimport { assertPathWithin } from '@intlayer/config/utils';\nimport {\n  COMPOSITE_ID_SEPARATOR,\n  QUALIFIER_DYNAMIC_TYPES_KEY,\n  reconstructQualifiedEntry,\n} from '@intlayer/core/dictionaryManipulator';\nimport { getPerLocaleDictionary } from '@intlayer/core/plugins';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type {\n  Dictionary,\n  DictionaryQualifierType,\n  QualifiedDictionaryGroup,\n} from '@intlayer/types/dictionary';\nimport { parallelize } from '../utils/parallelize';\nimport { writeFileIfChanged } from '../writeFileIfChanged';\nimport { writeJsonIfChanged } from '../writeJsonIfChanged';\nimport type { PlainMergedDictionaryOutput } from './writeMergedDictionary';\n\nexport type DictionaryResult = {\n  dictionaryPath: string;\n  dictionary: Dictionary;\n};\n\nexport type LocalizedDictionaryResult = Partial<\n  Record<Locale, DictionaryResult>\n>;\n\nexport type LocalizedDictionaryOutput = Record<\n  string,\n  LocalizedDictionaryResult\n>;\n\nconst DICTIONARIES_SUBDIR = 'json'; // Necessary to add a static first dir for Turbopack\n\n/**\n * Escapes a value interpolated into a single-quoted literal of a generated\n * loader module, so keys or segments containing `'` or `\\` cannot break the\n * emitted JavaScript.\n */\nconst escapeJsLiteral = (value: string): string =>\n  value.replace(/\\\\/g, '\\\\\\\\').replace(/'/g, \"\\\\'\");\n\n/**\n * Generates the content of a dictionary entry point file.\n */\nexport const generateDictionaryEntryPoint = (\n  key: string,\n  locales: string[],\n  format: 'cjs' | 'esm' = 'esm'\n): string => {\n  const sortedLocales = [...locales].sort((a, b) =>\n    String(a).localeCompare(String(b))\n  );\n\n  const safeKey = escapeJsLiteral(key);\n\n  const localeEntries = sortedLocales\n    .map((locale) => {\n      const safeLocale = escapeJsLiteral(locale);\n      return format === 'esm'\n        ? `  '${safeLocale}': () => import('./${DICTIONARIES_SUBDIR}/${safeKey}/${safeLocale}.json').then(m => m.default)`\n        : `  '${safeLocale}': () => Promise.resolve(require('./${DICTIONARIES_SUBDIR}/${safeKey}/${safeLocale}.json'))`;\n    })\n    .join(',\\n');\n\n  if (format === 'esm') {\n    return (\n      `const content = {\\n${localeEntries}\\n};\\n\\n` +\n      `export default content;\\n`\n    );\n  }\n  return `module.exports = {\\n${localeEntries}\\n};\\n`;\n};\n\n/**\n * A nested loader tree: one level per declared dimension, leaves are loader\n * expression strings.\n */\ntype LoaderTree = { [segment: string]: LoaderTree | string };\n\n/**\n * One entry of a qualified loader map.\n *\n * `treeSegments` is where the entry lives in the loader tree (its composite id\n * segments); `chunkSegments` is the chunk path it loads. They differ when the\n * entry aliases another entry with identical content (e.g. array-variant\n * fan-out): the alias keeps its own tree position but points at the canonical\n * entry's chunk, so equal content is emitted — and downloaded — only once.\n */\nexport type QualifiedEntrySegments = {\n  treeSegments: string[];\n  chunkSegments: string[];\n};\n\nconst buildLoaderExpression = (\n  key: string,\n  chunkSegments: string[],\n  locale: string,\n  format: 'cjs' | 'esm'\n): string => {\n  const path = escapeJsLiteral(\n    `./${DICTIONARIES_SUBDIR}/${key}/${chunkSegments.join('/')}/${locale}.json`\n  );\n\n  return format === 'esm'\n    ? `() => import('${path}').then(m => m.default)`\n    : `() => Promise.resolve(require('${path}'))`;\n};\n\nconst buildLoaderTree = (\n  key: string,\n  entries: QualifiedEntrySegments[],\n  locale: string,\n  format: 'cjs' | 'esm'\n): LoaderTree => {\n  const root: LoaderTree = {};\n\n  for (const { treeSegments, chunkSegments } of entries) {\n    let node = root;\n\n    treeSegments.forEach((segment, index) => {\n      if (index === treeSegments.length - 1) {\n        node[segment] = buildLoaderExpression(\n          key,\n          chunkSegments,\n          locale,\n          format\n        );\n        return;\n      }\n\n      node[segment] = (node[segment] as LoaderTree | undefined) ?? {};\n      node = node[segment] as LoaderTree;\n    });\n  }\n\n  return root;\n};\n\nconst serializeLoaderTree = (tree: LoaderTree, indentLevel: number): string => {\n  const pad = '  '.repeat(indentLevel);\n  const innerPad = '  '.repeat(indentLevel + 1);\n\n  const lines = Object.keys(tree)\n    .sort((a, b) => a.localeCompare(b))\n    .map((segment) => {\n      const value = tree[segment]!;\n      const serialized =\n        typeof value === 'string'\n          ? value\n          : serializeLoaderTree(value, indentLevel + 1);\n\n      return `${innerPad}'${escapeJsLiteral(segment)}': ${serialized}`;\n    });\n\n  return `{\\n${lines.join(',\\n')}\\n${pad}}`;\n};\n\n/**\n * Generates the entry point of a qualified dictionary (collection / variant,\n * possibly combined). Under each locale the loader map nests one\n * level per declared dimension (canonical order) and carries a marker listing\n * those dimensions so the runtime can walk the tree.\n *\n * One static `import()` is emitted per leaf `(locale, …segments)` chunk, which\n * keeps the output compatible with bundlers that reject template-literal\n * dynamic imports (Turbopack). Entries whose content is identical share one\n * chunk: their leaves point at the canonical entry's import path.\n */\nexport const generateQualifiedDictionaryEntryPoint = (\n  key: string,\n  qualifierTypes: DictionaryQualifierType[],\n  entries: QualifiedEntrySegments[],\n  locales: string[],\n  format: 'cjs' | 'esm' = 'esm'\n): string => {\n  const sortedLocales = [...locales].sort((a, b) =>\n    String(a).localeCompare(String(b))\n  );\n\n  const localeEntries = sortedLocales\n    .map((locale) => {\n      const tree = buildLoaderTree(key, entries, locale, format);\n      return `  '${escapeJsLiteral(locale)}': ${serializeLoaderTree(tree, 1)}`;\n    })\n    .join(',\\n');\n\n  const marker = `  '${QUALIFIER_DYNAMIC_TYPES_KEY}': ${JSON.stringify(qualifierTypes)}`;\n\n  if (format === 'esm') {\n    return (\n      `const content = {\\n${marker},\\n${localeEntries}\\n};\\n\\n` +\n      `export default content;\\n`\n    );\n  }\n  return `module.exports = {\\n${marker},\\n${localeEntries}\\n};\\n`;\n};\n\n/**\n * Write the localized dictionaries to the dictionariesDir\n * @param mergedDictionaries - The merged dictionaries\n * @param configuration - The configuration\n * @returns The final dictionaries\n *\n * @example\n * ```ts\n * const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);\n * const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);\n * console.log(finalDictionaries);\n *\n * // .intlayer/dynamic_dictionary/dictionaries/en_home.json\n * // .intlayer/dynamic_dictionary/dictionaries/fr_home.json\n * ```\n */\nexport const writeDynamicDictionary = async (\n  mergedDictionaries: PlainMergedDictionaryOutput,\n  configuration: IntlayerConfig,\n  formats: ('cjs' | 'esm')[] = OUTPUT_FORMAT\n): Promise<LocalizedDictionaryOutput> => {\n  const { locales, defaultLocale } = configuration.internationalization;\n  const { dynamicDictionariesDir } = configuration.system;\n\n  const dictDir = resolve(dynamicDictionariesDir, DICTIONARIES_SUBDIR);\n  await mkdir(dictDir, { recursive: true });\n\n  const resultDictionariesPaths: LocalizedDictionaryOutput = {};\n\n  // Merge dictionaries with the same key and write to dictionariesDir\n  await parallelize(\n    Object.entries(mergedDictionaries).sort(([a], [b]) =>\n      String(a).localeCompare(String(b))\n    ),\n    async ([key, dictionaryEntry]) => {\n      if (key === 'undefined') return;\n\n      const localizedDictionariesPathsRecord: LocalizedDictionaryResult = {};\n\n      const keyDir = resolve(dictDir, key);\n      assertPathWithin(keyDir, dictDir);\n      await mkdir(keyDir, { recursive: true });\n\n      await parallelize(locales, async (locale) => {\n        const localizedDictionary = getPerLocaleDictionary(\n          dictionaryEntry.dictionary,\n          locale,\n          defaultLocale\n        );\n\n        // Directory structure: json/key/locale.json\n        const resultFilePath = resolve(keyDir, `${locale}.json`);\n\n        await writeJsonIfChanged(resultFilePath, localizedDictionary).catch(\n          (err) => {\n            console.error(\n              `Error creating localized ${key}/${locale}.json:`,\n              err\n            );\n          }\n        );\n\n        localizedDictionariesPathsRecord[locale] = {\n          dictionaryPath: resultFilePath,\n          dictionary: localizedDictionary,\n        };\n      });\n\n      resultDictionariesPaths[key] = localizedDictionariesPathsRecord;\n\n      await parallelize(formats, async (format) => {\n        const extension = format === 'cjs' ? 'cjs' : 'mjs';\n        const content = generateDictionaryEntryPoint(key, locales, format);\n\n        const dynEntryPath = resolve(\n          dynamicDictionariesDir,\n          `${key}.${extension}`\n        );\n        assertPathWithin(dynEntryPath, dynamicDictionariesDir);\n\n        await writeFileIfChanged(dynEntryPath, content).catch((err) => {\n          console.error(\n            `Error creating dynamic ${colorizePath(dynEntryPath)}:`,\n            err\n          );\n        });\n      });\n    }\n  );\n\n  return resultDictionariesPaths;\n};\n\nexport type QualifiedMergedDictionaryResult = {\n  dictionaryPath: string;\n  dictionary: QualifiedDictionaryGroup;\n};\n\nexport type QualifiedMergedDictionaryOutput = Record<\n  string,\n  QualifiedMergedDictionaryResult\n>;\n\n/**\n * Writes the dynamic chunks and entry points of qualified dictionaries\n * (collections, variants — possibly combined) in\n * `importMode: 'dynamic'`.\n *\n * Each entry is reduced to one per-locale chunk written to a path nested by\n * dimension — `json/{key}/{seg1}/{seg2}/{locale}.json` — and a single\n * `{key}.{ext}` entry point exposes the matching nested loader tree, so the\n * entry point is discovered and aggregated exactly like a plain dynamic one.\n */\nexport const writeDynamicQualifiedDictionaries = async (\n  qualifiedDictionaries: QualifiedMergedDictionaryOutput,\n  configuration: IntlayerConfig,\n  formats: ('cjs' | 'esm')[] = OUTPUT_FORMAT\n): Promise<void> => {\n  const { locales, defaultLocale } = configuration.internationalization;\n  const { dynamicDictionariesDir } = configuration.system;\n\n  const dictDir = resolve(dynamicDictionariesDir, DICTIONARIES_SUBDIR);\n  await mkdir(dictDir, { recursive: true });\n\n  await parallelize(\n    Object.entries(qualifiedDictionaries).sort(([a], [b]) =>\n      String(a).localeCompare(String(b))\n    ),\n    async ([key, { dictionary: group }]) => {\n      if (key === 'undefined') return;\n\n      const entryIds = Object.keys(group.content);\n\n      const keyDir = resolve(dictDir, key);\n      assertPathWithin(keyDir, dictDir);\n\n      // Entries with identical content (e.g. array-variant fan-out) share one\n      // chunk: only the first entry per content identity writes files; the\n      // others become aliases whose loaders point at the canonical chunk path.\n      const canonicalSegmentsByContent = new Map<string, string[]>();\n      const entries: QualifiedEntrySegments[] = [];\n      const canonicalEntryIds: string[] = [];\n\n      for (const entryId of entryIds) {\n        const treeSegments = entryId.split(COMPOSITE_ID_SEPARATOR);\n        const contentIdentity = JSON.stringify(group.content[entryId]);\n        const canonicalSegments =\n          canonicalSegmentsByContent.get(contentIdentity);\n\n        if (canonicalSegments) {\n          entries.push({ treeSegments, chunkSegments: canonicalSegments });\n          continue;\n        }\n\n        canonicalSegmentsByContent.set(contentIdentity, treeSegments);\n        entries.push({ treeSegments, chunkSegments: treeSegments });\n        canonicalEntryIds.push(entryId);\n      }\n\n      await parallelize(canonicalEntryIds, async (entryId) => {\n        // Rebuild a resolvable dictionary from the content node + composite id\n        // so per-locale extraction sees the same `{ key, content }` shape.\n        const entry = reconstructQualifiedEntry(group, entryId);\n\n        const segments = entryId.split(COMPOSITE_ID_SEPARATOR);\n\n        const entryDir = resolve(keyDir, ...segments);\n        assertPathWithin(entryDir, keyDir);\n        await mkdir(entryDir, { recursive: true });\n\n        await parallelize(locales, async (locale) => {\n          const localizedDictionary = getPerLocaleDictionary(\n            entry,\n            locale,\n            defaultLocale\n          );\n\n          // Directory structure: json/key/<…segments>/locale.json\n          const resultFilePath = resolve(entryDir, `${locale}.json`);\n\n          await writeJsonIfChanged(resultFilePath, localizedDictionary).catch(\n            (err) => {\n              console.error(\n                `Error creating localized ${key}/${segments.join('/')}/${locale}.json:`,\n                err\n              );\n            }\n          );\n        });\n      });\n\n      await parallelize(formats, async (format) => {\n        const extension = format === 'cjs' ? 'cjs' : 'mjs';\n        const content = generateQualifiedDictionaryEntryPoint(\n          key,\n          group.qualifierTypes,\n          entries,\n          locales,\n          format\n        );\n\n        const dynEntryPath = resolve(\n          dynamicDictionariesDir,\n          `${key}.${extension}`\n        );\n        assertPathWithin(dynEntryPath, dynamicDictionariesDir);\n\n        await writeFileIfChanged(dynEntryPath, content).catch((err) => {\n          console.error(\n            `Error creating dynamic ${colorizePath(dynEntryPath)}:`,\n            err\n          );\n        });\n      });\n    }\n  );\n};\n"],"mappings":"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"}

package/dist/esm/buildIntlayerDictionary/writeFetchDictionary.mjs

@@ -0,0 +1,56 @@
+import { parallelize } from "../utils/parallelize.mjs";
+import { writeFileIfChanged } from "../writeFileIfChanged.mjs";
+import { mkdir } from "node:fs/promises";
+import { relative, resolve } from "node:path";
+import { colorizePath } from "@intlayer/config/logger";
+import { assertPathWithin, normalizePath } from "@intlayer/config/utils";
+import { OUTPUT_FORMAT } from "@intlayer/config/defaultValues";
+
+//#region src/buildIntlayerDictionary/writeFetchDictionary.ts
+const generateDictionaryEntryPoint = (key, locales, relativePrefix, format = "esm") => {
+	const extension = format === "cjs" ? "cjs" : "mjs";
+	const localeEntries = locales.sort((a, b) => String(a).localeCompare(String(b))).map((locale) => `  '${locale}': async () => {\n    try {\n      const res = await fetch(\`\${editor.liveSyncURL}/dictionaries/${key}/${locale}\`);\n      return await res.json();\n    } catch {\n      return dynContent['${locale}']();\n    }\n  }`).join(",\n");
+	if (format === "esm") return `import { editor } from 'intlayer';\nimport dynContent from '${relativePrefix}/${key}.${extension}';\n\nconst content = {\n${localeEntries}\n};\n\nexport default content;\n`;
+	return `const { editor } = require('intlayer');\nconst dynContent = require('${relativePrefix}/${key}.${extension}');\n\nmodule.exports = {\n${localeEntries}\n};\n`;
+};
+/**
+* Write the localized dictionaries to the dictionariesDir
+* @param mergedDictionaries - The merged dictionaries
+* @param configuration - The configuration
+* @returns The final dictionaries
+*
+* @example
+* ```ts
+* const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);
+* const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);
+* console.log(finalDictionaries);
+*
+* // .intlayer/fetch_dictionary/home.mjs
+* // .intlayer/fetch_dictionary/home.cjs
+* ```
+*/
+const writeFetchDictionary = async (dynamicDictionaries, configuration, formats = OUTPUT_FORMAT) => {
+	const { fetchDictionariesDir, dynamicDictionariesDir } = configuration.system;
+	const { locales } = configuration.internationalization;
+	let relativePrefix = normalizePath(relative(fetchDictionariesDir, dynamicDictionariesDir));
+	if (!relativePrefix.startsWith(".")) relativePrefix = `./${relativePrefix}`;
+	await mkdir(resolve(fetchDictionariesDir), { recursive: true });
+	const resultDictionariesPaths = {};
+	await parallelize(Object.entries(dynamicDictionaries), async ([key]) => {
+		if (key === "undefined") return;
+		await parallelize(formats, async (format) => {
+			const extension = format === "cjs" ? "cjs" : "mjs";
+			const content = generateDictionaryEntryPoint(key, locales, relativePrefix, format);
+			const fetchEntryPath = resolve(fetchDictionariesDir, `${key}.${extension}`);
+			assertPathWithin(fetchEntryPath, fetchDictionariesDir);
+			await writeFileIfChanged(fetchEntryPath, content).catch((err) => {
+				console.error(`Error creating fetch ${colorizePath(fetchEntryPath)}:`, err);
+			});
+		});
+	});
+	return resultDictionariesPaths;
+};
+
+//#endregion
+export { generateDictionaryEntryPoint, writeFetchDictionary };
+//# sourceMappingURL=writeFetchDictionary.mjs.map

package/dist/esm/buildIntlayerDictionary/writeFetchDictionary.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeFetchDictionary.mjs","names":[],"sources":["../../../src/buildIntlayerDictionary/writeFetchDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { relative, resolve } from 'node:path';\nimport { OUTPUT_FORMAT } from '@intlayer/config/defaultValues';\nimport { colorizePath } from '@intlayer/config/logger';\nimport { assertPathWithin, normalizePath } from '@intlayer/config/utils';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport { parallelize } from '../utils/parallelize';\nimport { writeFileIfChanged } from '../writeFileIfChanged';\nimport type { LocalizedDictionaryOutput } from './writeDynamicDictionary';\n\nexport const generateDictionaryEntryPoint = (\n  key: string,\n  locales: string[],\n  relativePrefix: string,\n  format: 'cjs' | 'esm' = 'esm'\n): string => {\n  const extension = format === 'cjs' ? 'cjs' : 'mjs';\n\n  const localeEntries = locales\n    .sort((a, b) => String(a).localeCompare(String(b)))\n    .map(\n      (locale) =>\n        `  '${locale}': async () => {\\n` +\n        `    try {\\n` +\n        `      const res = await fetch(\\`\\${editor.liveSyncURL}/dictionaries/${key}/${locale}\\`);\\n` +\n        `      return await res.json();\\n` +\n        `    } catch {\\n` +\n        `      return dynContent['${locale}']();\\n` +\n        `    }\\n` +\n        `  }`\n    )\n    .join(',\\n');\n\n  if (format === 'esm') {\n    return (\n      `import { editor } from 'intlayer';\\n` +\n      `import dynContent from '${relativePrefix}/${key}.${extension}';\\n\\n` +\n      `const content = {\\n${localeEntries}\\n};\\n\\n` +\n      `export default content;\\n`\n    );\n  }\n  return (\n    `const { editor } = require('intlayer');\\n` +\n    `const dynContent = require('${relativePrefix}/${key}.${extension}');\\n\\n` +\n    `module.exports = {\\n${localeEntries}\\n};\\n`\n  );\n};\n\n/**\n * Write the localized dictionaries to the dictionariesDir\n * @param mergedDictionaries - The merged dictionaries\n * @param configuration - The configuration\n * @returns The final dictionaries\n *\n * @example\n * ```ts\n * const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);\n * const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);\n * console.log(finalDictionaries);\n *\n * // .intlayer/fetch_dictionary/home.mjs\n * // .intlayer/fetch_dictionary/home.cjs\n * ```\n */\nexport const writeFetchDictionary = async (\n  dynamicDictionaries: LocalizedDictionaryOutput,\n  configuration: IntlayerConfig,\n  formats: ('cjs' | 'esm')[] = OUTPUT_FORMAT\n): Promise<LocalizedDictionaryOutput> => {\n  const { fetchDictionariesDir, dynamicDictionariesDir } = configuration.system;\n  const { locales } = configuration.internationalization;\n\n  // Compute relative path from fetch dir to dynamic dir\n  let relativePrefix = normalizePath(\n    relative(fetchDictionariesDir, dynamicDictionariesDir)\n  );\n  if (!relativePrefix.startsWith('.')) {\n    relativePrefix = `./${relativePrefix}`;\n  }\n\n  await mkdir(resolve(fetchDictionariesDir), { recursive: true });\n\n  const resultDictionariesPaths: LocalizedDictionaryOutput = {};\n\n  // Write entry points for each dictionary in parallel\n  await parallelize(Object.entries(dynamicDictionaries), async ([key]) => {\n    if (key === 'undefined') return;\n\n    await parallelize(formats, async (format) => {\n      const extension = format === 'cjs' ? 'cjs' : 'mjs';\n      const content = generateDictionaryEntryPoint(\n        key,\n        locales,\n        relativePrefix,\n        format\n      );\n\n      const fetchEntryPath = resolve(\n        fetchDictionariesDir,\n        `${key}.${extension}`\n      );\n      assertPathWithin(fetchEntryPath, fetchDictionariesDir);\n\n      await writeFileIfChanged(fetchEntryPath, content).catch((err) => {\n        console.error(\n          `Error creating fetch ${colorizePath(fetchEntryPath)}:`,\n          err\n        );\n      });\n    });\n  });\n\n  return resultDictionariesPaths;\n};\n"],"mappings":";;;;;;;;;AAUA,MAAa,gCACX,KACA,SACA,gBACA,SAAwB,UACb;CACX,MAAM,YAAY,WAAW,QAAQ,QAAQ;CAE7C,MAAM,gBAAgB,QACnB,MAAM,GAAG,MAAM,OAAO,EAAE,CAAC,cAAc,OAAO,EAAE,CAAC,CAAC,CAClD,KACE,WACC,MAAM,OAAO,mGAE0D,IAAI,GAAG,OAAO,gFAGzD,OAAO,mBAGtC,CACA,KAAK,MAAM;AAEd,KAAI,WAAW,MACb,QACE,+DAC2B,eAAe,GAAG,IAAI,GAAG,UAAU,2BACxC,cAAc;AAIxC,QACE,wEAC+B,eAAe,GAAG,IAAI,GAAG,UAAU,6BAC3C,cAAc;;;;;;;;;;;;;;;;;;AAoBzC,MAAa,uBAAuB,OAClC,qBACA,eACA,UAA6B,kBACU;CACvC,MAAM,EAAE,sBAAsB,2BAA2B,cAAc;CACvE,MAAM,EAAE,YAAY,cAAc;CAGlC,IAAI,iBAAiB,cACnB,SAAS,sBAAsB,uBAAuB,CACvD;AACD,KAAI,CAAC,eAAe,WAAW,IAAI,CACjC,kBAAiB,KAAK;AAGxB,OAAM,MAAM,QAAQ,qBAAqB,EAAE,EAAE,WAAW,MAAM,CAAC;CAE/D,MAAM,0BAAqD,EAAE;AAG7D,OAAM,YAAY,OAAO,QAAQ,oBAAoB,EAAE,OAAO,CAAC,SAAS;AACtE,MAAI,QAAQ,YAAa;AAEzB,QAAM,YAAY,SAAS,OAAO,WAAW;GAC3C,MAAM,YAAY,WAAW,QAAQ,QAAQ;GAC7C,MAAM,UAAU,6BACd,KACA,SACA,gBACA,OACD;GAED,MAAM,iBAAiB,QACrB,sBACA,GAAG,IAAI,GAAG,YACX;AACD,oBAAiB,gBAAgB,qBAAqB;AAEtD,SAAM,mBAAmB,gBAAgB,QAAQ,CAAC,OAAO,QAAQ;AAC/D,YAAQ,MACN,wBAAwB,aAAa,eAAe,CAAC,IACrD,IACD;KACD;IACF;GACF;AAEF,QAAO"}