@intlayer/engine 9.0.0-canary.12

package/dist/cjs/loadDictionaries/getIntlayerBundle.cjs

@@ -0,0 +1,56 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let _intlayer_config_utils = require("@intlayer/config/utils");
+let _intlayer_config_file = require("@intlayer/config/file");
+let node_module = require("node:module");
+
+//#region src/loadDictionaries/getIntlayerBundle.ts
+/**
+* Rewrites bare specifiers to absolute paths on the user's disk and externalizes them
+* to preserve directory context (__dirname/import.meta.url).
+*/
+const localResolvePlugin = (aliases, rootRequire) => {
+	return {
+		name: "local-resolve",
+		setup(build) {
+			build.onResolve({ filter: /.*/ }, (args) => {
+				if (aliases[args.path]) return {
+					path: aliases[args.path],
+					external: true
+				};
+				if (args.path === "defu" || args.path.startsWith("@intlayer/")) try {
+					return {
+						path: rootRequire.resolve(args.path),
+						external: true
+					};
+				} catch {
+					return null;
+				}
+				return null;
+			});
+		}
+	};
+};
+const getIntlayerBundle = async (configuration) => {
+	const rootRequire = (0, _intlayer_config_utils.getProjectRequire)(configuration.system.baseDir);
+	const aliases = { "@intlayer/config/built": (0, node_path.join)(configuration.system.configDir, `configuration.cjs`) };
+	const filePath = rootRequire.resolve("intlayer");
+	return await (0, _intlayer_config_file.bundleFile)(await (0, node_fs_promises.readFile)(filePath, "utf-8"), filePath, {
+		bundle: true,
+		platform: "node",
+		external: [
+			...node_module.builtinModules,
+			...node_module.builtinModules.map((mod) => `node:${mod}`),
+			"vscode",
+			"esbuild"
+		],
+		minify: true,
+		plugins: [localResolvePlugin(aliases, rootRequire)]
+	}) ?? "";
+};
+
+//#endregion
+exports.getIntlayerBundle = getIntlayerBundle;
+//# sourceMappingURL=getIntlayerBundle.cjs.map

package/dist/cjs/loadDictionaries/getIntlayerBundle.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getIntlayerBundle.cjs","names":["builtinModules"],"sources":["../../../src/loadDictionaries/getIntlayerBundle.ts"],"sourcesContent":["import { readFile } from 'node:fs/promises';\nimport { builtinModules } from 'node:module';\nimport { join } from 'node:path';\nimport { bundleFile, type ESBuildPlugin } from '@intlayer/config/file';\nimport { getProjectRequire } from '@intlayer/config/utils';\nimport type { IntlayerConfig } from '@intlayer/types/config';\n\n/**\n * Rewrites bare specifiers to absolute paths on the user's disk and externalizes them\n * to preserve directory context (__dirname/import.meta.url).\n */\nconst localResolvePlugin = (\n  aliases: Record<string, string>,\n  rootRequire: NodeJS.Require\n): ESBuildPlugin => {\n  return {\n    name: 'local-resolve',\n    setup(build) {\n      build.onResolve({ filter: /.*/ }, (args) => {\n        // Direct alias match\n        if (aliases[args.path]) {\n          return {\n            path: aliases[args.path],\n            external: true, // Prevents inlining and context loss\n          };\n        }\n\n        // Dynamic resolution via user workspace\n        if (args.path === 'defu' || args.path.startsWith('@intlayer/')) {\n          try {\n            const absolutePath = rootRequire.resolve(args.path);\n            return {\n              path: absolutePath,\n              external: true, // Injects `require('/absolute/path')`\n            };\n          } catch {\n            return null;\n          }\n        }\n\n        return null;\n      });\n    },\n  };\n};\n\nexport const getIntlayerBundle = async (configuration: IntlayerConfig) => {\n  const rootRequire = getProjectRequire(configuration.system.baseDir);\n\n  const configurationPath = join(\n    configuration.system.configDir,\n    `configuration.cjs`\n  );\n\n  const aliases = {\n    '@intlayer/config/built': configurationPath,\n  };\n\n  const filePath = rootRequire.resolve('intlayer');\n  const code = await readFile(filePath, 'utf-8');\n\n  const output = await bundleFile(code, filePath, {\n    bundle: true,\n    platform: 'node',\n    external: [\n      ...builtinModules,\n      ...builtinModules.map((mod) => `node:${mod}`),\n      'vscode',\n      'esbuild',\n    ],\n    minify: true,\n    plugins: [localResolvePlugin(aliases, rootRequire)],\n  });\n\n  return output ?? '';\n};\n"],"mappings":";;;;;;;;;;;;;AAWA,MAAM,sBACJ,SACA,gBACkB;AAClB,QAAO;EACL,MAAM;EACN,MAAM,OAAO;AACX,SAAM,UAAU,EAAE,QAAQ,MAAM,GAAG,SAAS;AAE1C,QAAI,QAAQ,KAAK,MACf,QAAO;KACL,MAAM,QAAQ,KAAK;KACnB,UAAU;KACX;AAIH,QAAI,KAAK,SAAS,UAAU,KAAK,KAAK,WAAW,aAAa,CAC5D,KAAI;AAEF,YAAO;MACL,MAFmB,YAAY,QAAQ,KAAK,KAE1B;MAClB,UAAU;MACX;YACK;AACN,YAAO;;AAIX,WAAO;KACP;;EAEL;;AAGH,MAAa,oBAAoB,OAAO,kBAAkC;CACxE,MAAM,4DAAgC,cAAc,OAAO,QAAQ;CAOnE,MAAM,UAAU,EACd,8CALA,cAAc,OAAO,WACrB,oBAI2C,EAC5C;CAED,MAAM,WAAW,YAAY,QAAQ,WAAW;AAgBhD,QAAO,4CAbyB,qCAFJ,UAAU,QAAQ,EAER,UAAU;EAC9C,QAAQ;EACR,UAAU;EACV,UAAU;GACR,GAAGA;GACH,GAAGA,2BAAe,KAAK,QAAQ,QAAQ,MAAM;GAC7C;GACA;GACD;EACD,QAAQ;EACR,SAAS,CAAC,mBAAmB,SAAS,YAAY,CAAC;EACpD,CAAC,IAEe"}

package/dist/cjs/loadDictionaries/index.cjs

@@ -0,0 +1,14 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_loadDictionaries_loadContentDeclaration = require('./loadContentDeclaration.cjs');
+const require_loadDictionaries_loadLocalDictionaries = require('./loadLocalDictionaries.cjs');
+const require_loadDictionaries_loadRemoteDictionaries = require('./loadRemoteDictionaries.cjs');
+const require_loadDictionaries_loadDictionaries = require('./loadDictionaries.cjs');
+
+exports.ensureIntlayerBundle = require_loadDictionaries_loadContentDeclaration.ensureIntlayerBundle;
+exports.formatDistantDictionaries = require_loadDictionaries_loadRemoteDictionaries.formatDistantDictionaries;
+exports.formatLocalDictionaries = require_loadDictionaries_loadContentDeclaration.formatLocalDictionaries;
+exports.loadContentDeclaration = require_loadDictionaries_loadContentDeclaration.loadContentDeclaration;
+exports.loadContentDeclarations = require_loadDictionaries_loadContentDeclaration.loadContentDeclarations;
+exports.loadDictionaries = require_loadDictionaries_loadDictionaries.loadDictionaries;
+exports.loadLocalDictionaries = require_loadDictionaries_loadLocalDictionaries.loadLocalDictionaries;
+exports.loadRemoteDictionaries = require_loadDictionaries_loadRemoteDictionaries.loadRemoteDictionaries;

package/dist/cjs/loadDictionaries/loadContentDeclaration.cjs

@@ -0,0 +1,133 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_utils_parallelize = require('../utils/parallelize.cjs');
+const require_filterInvalidDictionaries = require('../filterInvalidDictionaries.cjs');
+const require_buildIntlayerDictionary_processContentDeclaration = require('../buildIntlayerDictionary/processContentDeclaration.cjs');
+const require_loadDictionaries_getIntlayerBundle = require('./getIntlayerBundle.cjs');
+const require_loadDictionaries_loadMarkdownContentDeclaration = require('./loadMarkdownContentDeclaration.cjs');
+const require_loadDictionaries_loadYamlContentDeclaration = require('./loadYamlContentDeclaration.cjs');
+const require_loadDictionaries_logTypeScriptErrors = require('./logTypeScriptErrors.cjs');
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let _intlayer_config_utils = require("@intlayer/config/utils");
+let _intlayer_config_file = require("@intlayer/config/file");
+
+//#region src/loadDictionaries/loadContentDeclaration.ts
+const formatLocalDictionaries = (dictionariesRecord, configuration) => Object.entries(dictionariesRecord).map(([relativePath, dict]) => ({
+	...dict,
+	location: dict.location ?? configuration.dictionary?.location ?? "local",
+	localId: `${dict.key}::local::${relativePath}`,
+	filePath: relativePath
+}));
+const ensureIntlayerBundle = async (configuration) => {
+	const { system } = configuration;
+	const { set, isValid } = (0, _intlayer_config_utils.cacheDisk)(configuration, ["intlayer-bundle"], { ttlMs: 1e3 * 60 * 60 * 24 * 5 });
+	const filePath = (0, node_path.join)(system.cacheDir, "intlayer-bundle.cjs");
+	if (!await isValid()) {
+		await (0, node_fs_promises.writeFile)(filePath, await require_loadDictionaries_getIntlayerBundle.getIntlayerBundle(configuration));
+		await set("ok");
+	}
+	return filePath;
+};
+let cachedExternalDeps = null;
+const getExternalDeps = async (baseDir) => {
+	if (cachedExternalDeps) return cachedExternalDeps;
+	try {
+		const packageJSON = await (0, node_fs_promises.readFile)((0, _intlayer_config_utils.getPackageJsonPath)(baseDir).packageJsonPath, "utf-8");
+		const parsedPackages = JSON.parse(packageJSON);
+		const allDependencies = Object.keys({
+			...parsedPackages.dependencies,
+			...parsedPackages.devDependencies
+		});
+		const esmPackagesToBundle = [];
+		const externalDeps = allDependencies.filter((dep) => !esmPackagesToBundle.includes(dep));
+		externalDeps.push("esbuild");
+		cachedExternalDeps = externalDeps;
+	} catch (error) {
+		console.warn("Could not read package.json for externalizing dependencies, fallback to empty array", error);
+		cachedExternalDeps = ["esbuild"];
+	}
+	return cachedExternalDeps;
+};
+const loadContentDeclaration = async (path, configuration, bundleFilePath, options) => {
+	if ((0, node_path.extname)(path) === ".md" || (0, node_path.extname)(path) === ".mdx") return require_loadDictionaries_loadMarkdownContentDeclaration.loadMarkdownContentDeclaration(path);
+	if ((0, node_path.extname)(path) === ".yaml" || (0, node_path.extname)(path) === ".yml") return require_loadDictionaries_loadYamlContentDeclaration.loadYamlContentDeclaration(path);
+	const { build, system } = configuration;
+	const externalDeps = await getExternalDeps(system.baseDir);
+	const resolvedBundleFilePath = bundleFilePath ?? await ensureIntlayerBundle(configuration);
+	try {
+		return await (0, _intlayer_config_file.loadExternalFile)(path, {
+			logError: options?.logError,
+			projectRequire: build.require ?? (0, _intlayer_config_utils.getProjectRequire)(),
+			buildOptions: {
+				packages: void 0,
+				external: externalDeps,
+				banner: { js: [
+					`var __filename = ${JSON.stringify(path)};`,
+					`var __dirname = ${JSON.stringify((0, node_path.dirname)(path))};`,
+					`globalThis.INTLAYER_FILE_PATH = '${path}';`,
+					`globalThis.INTLAYER_BASE_DIR = '${configuration.system.baseDir}';`
+				].join("\n") }
+			},
+			aliases: { intlayer: resolvedBundleFilePath },
+			preloadGlobals: {
+				INTLAYER_FILE_PATH: path,
+				INTLAYER_BASE_DIR: configuration.system.baseDir
+			}
+		});
+	} catch (error) {
+		console.error(`Error loading content declaration at ${path}:`, error);
+		return;
+	}
+};
+const loadContentDeclarations = async (contentDeclarationFilePath, configuration, onStatusUpdate, options) => {
+	const { build, system } = configuration;
+	if (build.checkTypes) require_loadDictionaries_logTypeScriptErrors.logTypeScriptErrors(contentDeclarationFilePath, configuration).catch((e) => {
+		console.error("Error during TypeScript validation:", e);
+	});
+	const bundleFilePath = await ensureIntlayerBundle(configuration);
+	try {
+		const dictionariesPromises = contentDeclarationFilePath.map(async (path) => {
+			return {
+				relativePath: (0, node_path.relative)(system.baseDir, path),
+				dictionary: await loadContentDeclaration(path, configuration, bundleFilePath, options)
+			};
+		});
+		const contentDeclarations = formatLocalDictionaries((await Promise.all(dictionariesPromises)).reduce((acc, { relativePath, dictionary }) => {
+			if (dictionary) acc[relativePath] = dictionary;
+			return acc;
+		}, {}), configuration).filter((dictionary) => dictionary.location !== "remote");
+		const listFoundDictionaries = contentDeclarations.map((declaration) => ({
+			dictionaryKey: declaration.key,
+			type: "local",
+			status: "found"
+		}));
+		onStatusUpdate?.(listFoundDictionaries);
+		return require_filterInvalidDictionaries.filterInvalidDictionaries(await require_utils_parallelize.parallelize(contentDeclarations, async (contentDeclaration) => {
+			if (!contentDeclaration) return;
+			onStatusUpdate?.([{
+				dictionaryKey: contentDeclaration.key,
+				type: "local",
+				status: "building"
+			}]);
+			const processedContentDeclaration = await require_buildIntlayerDictionary_processContentDeclaration.processContentDeclaration(contentDeclaration, configuration);
+			if (!processedContentDeclaration) return;
+			onStatusUpdate?.([{
+				dictionaryKey: processedContentDeclaration.key,
+				type: "local",
+				status: "built"
+			}]);
+			return processedContentDeclaration;
+		}), configuration, { checkSchema: false });
+	} catch {
+		console.error("Error loading content declarations");
+	}
+	return [];
+};
+
+//#endregion
+exports.ensureIntlayerBundle = ensureIntlayerBundle;
+exports.formatLocalDictionaries = formatLocalDictionaries;
+exports.loadContentDeclaration = loadContentDeclaration;
+exports.loadContentDeclarations = loadContentDeclarations;
+//# sourceMappingURL=loadContentDeclaration.cjs.map

package/dist/cjs/loadDictionaries/loadContentDeclaration.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadContentDeclaration.cjs","names":["getIntlayerBundle","loadMarkdownContentDeclaration","loadYamlContentDeclaration","filterInvalidDictionaries","parallelize","processContentDeclaration"],"sources":["../../../src/loadDictionaries/loadContentDeclaration.ts"],"sourcesContent":["import { readFile, writeFile } from 'node:fs/promises';\nimport { dirname, extname, join, relative } from 'node:path';\nimport { loadExternalFile } from '@intlayer/config/file';\nimport {\n  cacheDisk,\n  getPackageJsonPath,\n  getProjectRequire,\n} from '@intlayer/config/utils';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { processContentDeclaration } from '../buildIntlayerDictionary/processContentDeclaration';\nimport { filterInvalidDictionaries } from '../filterInvalidDictionaries';\nimport { parallelize } from '../utils/parallelize';\nimport { getIntlayerBundle } from './getIntlayerBundle';\nimport type { DictionariesStatus } from './loadDictionaries';\nimport { loadMarkdownContentDeclaration } from './loadMarkdownContentDeclaration';\nimport { loadYamlContentDeclaration } from './loadYamlContentDeclaration';\nimport { logTypeScriptErrors } from './logTypeScriptErrors';\n\nexport const formatLocalDictionaries = (\n  dictionariesRecord: Record<string, Dictionary>,\n  configuration: IntlayerConfig\n): Dictionary[] =>\n  Object.entries(dictionariesRecord).map(([relativePath, dict]) => ({\n    ...dict,\n    location: dict.location ?? configuration.dictionary?.location ?? 'local',\n    localId: `${dict.key}::local::${relativePath}`,\n    filePath: relativePath,\n  }));\n\nexport const ensureIntlayerBundle = async (\n  configuration: IntlayerConfig\n): Promise<string> => {\n  const { system } = configuration;\n\n  const { set, isValid } = cacheDisk(configuration, ['intlayer-bundle'], {\n    ttlMs: 1000 * 60 * 60 * 24 * 5, // 5 days\n  });\n\n  const filePath = join(system.cacheDir, 'intlayer-bundle.cjs');\n  const hasIntlayerBundle = await isValid();\n\n  if (!hasIntlayerBundle) {\n    const intlayerBundle = await getIntlayerBundle(configuration);\n    await writeFile(filePath, intlayerBundle);\n    await set('ok');\n  }\n\n  return filePath;\n};\n\ntype LoadContentDeclarationOptions = {\n  logError?: boolean;\n};\n\n// Initialize a module-level cache\nlet cachedExternalDeps: string[] | null = null;\n\n// Helper to fetch and cache the dependencies\nconst getExternalDeps = async (baseDir: string): Promise<string[]> => {\n  if (cachedExternalDeps) {\n    return cachedExternalDeps; // Return instantly on subsequent calls\n  }\n\n  try {\n    const packageJsonPath = getPackageJsonPath(baseDir);\n\n    const packageJSON = await readFile(\n      packageJsonPath.packageJsonPath,\n      'utf-8'\n    );\n    const parsedPackages = JSON.parse(packageJSON);\n    const allDependencies = Object.keys({\n      ...parsedPackages.dependencies,\n      ...parsedPackages.devDependencies,\n    });\n\n    // Specify the ESM packages to bundle\n    const esmPackagesToBundle: string[] = [];\n\n    const externalDeps = allDependencies.filter(\n      (dep) => !esmPackagesToBundle.includes(dep)\n    );\n\n    externalDeps.push('esbuild');\n\n    // Save to cache\n    cachedExternalDeps = externalDeps;\n  } catch (error) {\n    console.warn(\n      'Could not read package.json for externalizing dependencies, fallback to empty array',\n      error\n    );\n    cachedExternalDeps = ['esbuild'];\n  }\n\n  return cachedExternalDeps;\n};\n\nexport const loadContentDeclaration = async (\n  path: string,\n  configuration: IntlayerConfig,\n  bundleFilePath?: string,\n  options?: LoadContentDeclarationOptions\n): Promise<Dictionary | undefined> => {\n  if (extname(path) === '.md' || extname(path) === '.mdx') {\n    return loadMarkdownContentDeclaration(path);\n  }\n\n  if (extname(path) === '.yaml' || extname(path) === '.yml') {\n    return loadYamlContentDeclaration(path);\n  }\n\n  const { build, system } = configuration;\n\n  // Call the cached helper\n  const externalDeps = await getExternalDeps(system.baseDir);\n\n  const resolvedBundleFilePath =\n    bundleFilePath ?? (await ensureIntlayerBundle(configuration));\n\n  try {\n    const dictionary = await loadExternalFile(path, {\n      logError: options?.logError,\n      projectRequire: build.require ?? getProjectRequire(),\n      buildOptions: {\n        packages: undefined, // It fixes the import of ESM packages in the content declaration\n        external: externalDeps,\n        banner: {\n          js: [\n            `var __filename = ${JSON.stringify(path)};`,\n            `var __dirname = ${JSON.stringify(dirname(path))};`,\n            // Also set on the VM sandbox's globalThis for VM-internal code.\n            // External modules (e.g. @intlayer/core's file()) run in the main\n            // Node.js context and are handled by preloadGlobals below.\n            `globalThis.INTLAYER_FILE_PATH = '${path}';`,\n            `globalThis.INTLAYER_BASE_DIR = '${configuration.system.baseDir}';`,\n          ].join('\\n'),\n        },\n      },\n      aliases: {\n        intlayer: resolvedBundleFilePath,\n      },\n      // Temporarily expose these on the main Node.js globalThis so that external\n      // modules required inside the VM (e.g. @intlayer/core's file() helper)\n      // can resolve relative paths against the correct content declaration path.\n      preloadGlobals: {\n        INTLAYER_FILE_PATH: path,\n        INTLAYER_BASE_DIR: configuration.system.baseDir,\n      },\n    });\n\n    return dictionary;\n  } catch (error) {\n    console.error(`Error loading content declaration at ${path}:`, error);\n    return undefined;\n  }\n};\n\nexport const loadContentDeclarations = async (\n  contentDeclarationFilePath: string[],\n  configuration: IntlayerConfig,\n  onStatusUpdate?: (status: DictionariesStatus[]) => void,\n  options?: LoadContentDeclarationOptions\n): Promise<Dictionary[]> => {\n  const { build, system } = configuration;\n\n  // Check for TypeScript warnings before we build\n  if (build.checkTypes) {\n    logTypeScriptErrors(contentDeclarationFilePath, configuration).catch(\n      (e) => {\n        console.error('Error during TypeScript validation:', e);\n      }\n    );\n  }\n\n  const bundleFilePath = await ensureIntlayerBundle(configuration);\n\n  try {\n    const dictionariesPromises = contentDeclarationFilePath.map(\n      async (path) => {\n        const relativePath = relative(system.baseDir, path);\n\n        const dictionary = await loadContentDeclaration(\n          path,\n          configuration,\n          bundleFilePath,\n          options\n        );\n\n        return { relativePath, dictionary };\n      }\n    );\n\n    const dictionariesArray = await Promise.all(dictionariesPromises);\n    const dictionariesRecord = dictionariesArray.reduce(\n      (acc, { relativePath, dictionary }) => {\n        if (dictionary) {\n          acc[relativePath] = dictionary;\n        }\n        return acc;\n      },\n      {} as Record<string, Dictionary>\n    );\n\n    const contentDeclarations: Dictionary[] = formatLocalDictionaries(\n      dictionariesRecord,\n      configuration\n    ).filter((dictionary) => dictionary.location !== 'remote');\n\n    const listFoundDictionaries = contentDeclarations.map((declaration) => ({\n      dictionaryKey: declaration.key,\n      type: 'local' as const,\n      status: 'found' as const,\n    }));\n\n    onStatusUpdate?.(listFoundDictionaries);\n\n    const processedDictionaries = await parallelize(\n      contentDeclarations,\n      async (contentDeclaration): Promise<Dictionary | undefined> => {\n        if (!contentDeclaration) {\n          return undefined;\n        }\n\n        onStatusUpdate?.([\n          {\n            dictionaryKey: contentDeclaration.key,\n            type: 'local',\n            status: 'building',\n          },\n        ]);\n\n        const processedContentDeclaration = await processContentDeclaration(\n          contentDeclaration as Dictionary,\n          configuration\n        );\n\n        if (!processedContentDeclaration) {\n          return undefined;\n        }\n\n        onStatusUpdate?.([\n          {\n            dictionaryKey: processedContentDeclaration.key,\n            type: 'local',\n            status: 'built',\n          },\n        ]);\n\n        return processedContentDeclaration;\n      }\n    );\n\n    return filterInvalidDictionaries(processedDictionaries, configuration, {\n      checkSchema: false,\n    });\n  } catch {\n    console.error('Error loading content declarations');\n  }\n\n  return [];\n};\n"],"mappings":"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"}

package/dist/cjs/loadDictionaries/loadDictionaries.cjs

@@ -0,0 +1,128 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_filterInvalidDictionaries = require('../filterInvalidDictionaries.cjs');
+const require_loadDictionaries_loadContentDeclaration = require('./loadContentDeclaration.cjs');
+const require_formatDictionary = require('../formatDictionary.cjs');
+const require_loadDictionaries_loadRemoteDictionaries = require('./loadRemoteDictionaries.cjs');
+const require_loadDictionaries_log = require('./log.cjs');
+let _intlayer_config_logger = require("@intlayer/config/logger");
+let _intlayer_config_colors = require("@intlayer/config/colors");
+_intlayer_config_colors = require_runtime.__toESM(_intlayer_config_colors);
+
+//#region src/loadDictionaries/loadDictionaries.ts
+let loadDictionariesStatus = [];
+const logger = new require_loadDictionaries_log.DictionariesLogger();
+const setLoadDictionariesStatus = (statuses) => {
+	const updated = [...loadDictionariesStatus];
+	for (const incoming of statuses) {
+		const index = updated.findIndex((s) => s.dictionaryKey === incoming.dictionaryKey && s.type === incoming.type);
+		if (index >= 0) updated[index] = incoming;
+		else updated.push(incoming);
+	}
+	loadDictionariesStatus = updated;
+	logger.update(statuses);
+	return updated;
+};
+const iconFor = (status) => {
+	switch (status) {
+		case "built":
+		case "imported":
+		case "fetched": return "✔";
+		case "error": return "✖";
+		default: return "⏲";
+	}
+};
+const colorFor = (status) => {
+	switch (status) {
+		case "built":
+		case "imported":
+		case "fetched": return _intlayer_config_colors.GREEN;
+		case "error": return _intlayer_config_colors.RED;
+		default: return _intlayer_config_colors.BLUE;
+	}
+};
+const printSummary = (configuration) => {
+	if (configuration.log.mode !== "verbose") return;
+	const appLogger = (0, _intlayer_config_logger.getAppLogger)(configuration);
+	const byKey = /* @__PURE__ */ new Map();
+	for (const status of loadDictionariesStatus) {
+		const rec = byKey.get(status.dictionaryKey) ?? {};
+		if (status.type === "local") rec.local = status.status;
+		if (status.type === "remote") rec.remote = status.status;
+		byKey.set(status.dictionaryKey, rec);
+	}
+	const keys = Array.from(byKey.keys()).sort((a, b) => a.localeCompare(b));
+	let maxLocalLabelLen = 0;
+	for (const key of keys) {
+		const rec = byKey.get(key);
+		if (rec.local) {
+			const visibleLocal = `[local: ${iconFor(rec.local)} ${rec.local}]`;
+			if (visibleLocal.length > maxLocalLabelLen) maxLocalLabelLen = visibleLocal.length;
+		}
+	}
+	for (const key of keys) {
+		const rec = byKey.get(key);
+		const labels = [];
+		if (rec.local) {
+			const inner = (0, _intlayer_config_logger.colorize)(`${iconFor(rec.local)} ${rec.local}`, colorFor(rec.local));
+			const coloredLocal = `${_intlayer_config_colors.GREY}[` + (0, _intlayer_config_logger.colorize)("local: ", _intlayer_config_colors.GREY) + inner + `${_intlayer_config_colors.GREY}]${_intlayer_config_colors.RESET}`;
+			const visibleLocal = `[local: ${iconFor(rec.local)} ${rec.local}]`;
+			const pad = Math.max(0, maxLocalLabelLen - visibleLocal.length);
+			labels.push(coloredLocal + " ".repeat(pad));
+		} else labels.push(" ".repeat(maxLocalLabelLen));
+		if (rec.remote) {
+			const inner = (0, _intlayer_config_logger.colorize)(`${iconFor(rec.remote)} ${rec.remote}`, colorFor(rec.remote));
+			labels.push(`${_intlayer_config_colors.GREY}[` + (0, _intlayer_config_logger.colorize)("distant: ", _intlayer_config_colors.GREY) + inner + `${_intlayer_config_colors.GREY}]${_intlayer_config_colors.RESET}`);
+		}
+		appLogger(` - ${(0, _intlayer_config_logger.colon)((0, _intlayer_config_logger.colorizeKey)(key), { colSize: keys })} ${labels.join(" ")}`);
+	}
+};
+const loadDictionaries = async (contentDeclarationsPaths, configuration) => {
+	const { plugins } = configuration;
+	const loadDictionariesStartTime = Date.now();
+	(0, _intlayer_config_logger.getAppLogger)(configuration)("Dictionaries:", { isVerbose: true });
+	const loadPluginDictionariesPromise = (await Promise.all(plugins ?? [])).filter((plugin) => plugin.loadDictionaries).map(async (plugin) => {
+		try {
+			return await plugin.loadDictionaries?.({ configuration }) ?? [];
+		} catch (error) {
+			logger.setPluginError(error);
+			return [];
+		}
+	});
+	const pluginDictionaries = await Promise.all(loadPluginDictionariesPromise).then((dictionaries) => dictionaries.flat()).then((dictionaries) => require_filterInvalidDictionaries.filterInvalidDictionaries(dictionaries, configuration)).then((dictionaries) => require_formatDictionary.formatDictionaries(dictionaries));
+	logger.setPluginTotal(pluginDictionaries.length);
+	logger.setPluginDone(pluginDictionaries.length);
+	const pluginDictionariesTime = Date.now();
+	const localDictionaries = await require_loadDictionaries_loadContentDeclaration.loadContentDeclarations(Array.isArray(contentDeclarationsPaths) ? contentDeclarationsPaths : [contentDeclarationsPaths], configuration, setLoadDictionariesStatus).then((dictionaries) => require_filterInvalidDictionaries.filterInvalidDictionaries(dictionaries, configuration)).then((dictionaries) => require_formatDictionary.formatDictionaries(dictionaries));
+	const localDictionariesTime = Date.now();
+	setLoadDictionariesStatus(localDictionaries.map((dictionary) => ({
+		dictionaryKey: dictionary.key,
+		type: "local",
+		status: "built"
+	})));
+	const hasRemoteDictionaries = Boolean(configuration.editor.clientId && configuration.editor.clientSecret);
+	if (hasRemoteDictionaries) logger.setExpectRemote(true);
+	let remoteDictionaries = [];
+	if (hasRemoteDictionaries) remoteDictionaries = await require_loadDictionaries_loadRemoteDictionaries.loadRemoteDictionaries(configuration, setLoadDictionariesStatus, {
+		onStartRemoteCheck: () => logger.startRemoteCheck(),
+		onStopRemoteCheck: () => logger.stopRemoteCheck(),
+		onError: (e) => logger.setRemoteError(e)
+	}).then((dictionaries) => require_filterInvalidDictionaries.filterInvalidDictionaries(dictionaries, configuration)).then((dictionaries) => require_formatDictionary.formatDictionaries(dictionaries));
+	const remoteDictionariesTime = Date.now();
+	logger.finish();
+	printSummary(configuration);
+	return {
+		localDictionaries,
+		remoteDictionaries,
+		pluginDictionaries,
+		time: {
+			localDictionaries: localDictionariesTime - pluginDictionariesTime,
+			remoteDictionaries: remoteDictionariesTime - localDictionariesTime,
+			pluginDictionaries: pluginDictionariesTime - loadDictionariesStartTime
+		}
+	};
+};
+
+//#endregion
+exports.loadDictionaries = loadDictionaries;
+//# sourceMappingURL=loadDictionaries.cjs.map

package/dist/cjs/loadDictionaries/loadDictionaries.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadDictionaries.cjs","names":["DictionariesLogger","ANSIColors","filterInvalidDictionaries","formatDictionaries","loadContentDeclarations","loadRemoteDictionaries"],"sources":["../../../src/loadDictionaries/loadDictionaries.ts"],"sourcesContent":["import * as ANSIColors from '@intlayer/config/colors';\nimport {\n  colon,\n  colorize,\n  colorizeKey,\n  getAppLogger,\n} from '@intlayer/config/logger';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { filterInvalidDictionaries } from '../filterInvalidDictionaries';\nimport { formatDictionaries } from '../formatDictionary';\nimport { loadContentDeclarations } from './loadContentDeclaration';\nimport { loadRemoteDictionaries } from './loadRemoteDictionaries';\nimport { DictionariesLogger } from './log';\n\nexport type DictionariesStatus = {\n  dictionaryKey: string;\n  type: 'local' | 'remote';\n  status:\n    | 'pending' // Key found but not fetched yet\n    | 'fetching' // If dictionary fetch is in progress\n    | 'fetched' // If dictionary fetch succeeded\n    | 'error' // If dictionary fetch failed\n    | 'imported' // If dictionary already fetched and still up to date\n    | 'found' // If dictionary key is found but promise is not resolved yet (ex: fetching distant content)\n    | 'building' // If dictionary is being built\n    | 'built'; // If dictionary is built;\n  error?: string;\n};\n\nlet loadDictionariesStatus: DictionariesStatus[] = [];\nconst logger = new DictionariesLogger();\n\nconst setLoadDictionariesStatus = (statuses: DictionariesStatus[]) => {\n  const updated: DictionariesStatus[] = [...loadDictionariesStatus];\n\n  for (const incoming of statuses) {\n    const index = updated.findIndex(\n      (s) =>\n        s.dictionaryKey === incoming.dictionaryKey && s.type === incoming.type\n    );\n    if (index >= 0) {\n      updated[index] = incoming;\n    } else {\n      updated.push(incoming);\n    }\n  }\n\n  loadDictionariesStatus = updated;\n  logger.update(statuses);\n\n  return updated;\n};\n\ntype StatusRecord = {\n  local?: DictionariesStatus['status'];\n  remote?: DictionariesStatus['status'];\n};\n\nconst iconFor = (status: DictionariesStatus['status']) => {\n  switch (status) {\n    case 'built':\n    case 'imported':\n    case 'fetched':\n      return '✔';\n    case 'error':\n      return '✖';\n    default:\n      return '⏲';\n  }\n};\n\nconst colorFor = (status: DictionariesStatus['status']) => {\n  switch (status) {\n    case 'built':\n    case 'imported':\n    case 'fetched':\n      return ANSIColors.GREEN;\n    case 'error':\n      return ANSIColors.RED;\n    default:\n      return ANSIColors.BLUE;\n  }\n};\n\nconst printSummary = (configuration: IntlayerConfig) => {\n  if (configuration.log.mode !== 'verbose') return;\n\n  const appLogger = getAppLogger(configuration);\n\n  // Aggregate by dictionary key\n  const byKey = new Map<string, StatusRecord>();\n  for (const status of loadDictionariesStatus) {\n    const rec = byKey.get(status.dictionaryKey) ?? {};\n    if (status.type === 'local') rec.local = status.status;\n    if (status.type === 'remote') rec.remote = status.status;\n    byKey.set(status.dictionaryKey, rec);\n  }\n\n  const keys = Array.from(byKey.keys()).sort((a, b) => a.localeCompare(b));\n\n  // Compute the max visible length of the local label to align distant labels\n  let maxLocalLabelLen = 0;\n  for (const key of keys) {\n    const rec = byKey.get(key)!;\n    if (rec.local) {\n      const visibleLocal = `[local: ${iconFor(rec.local)} ${rec.local}]`;\n      if (visibleLocal.length > maxLocalLabelLen) {\n        maxLocalLabelLen = visibleLocal.length;\n      }\n    }\n  }\n\n  for (const key of keys) {\n    const rec = byKey.get(key)!;\n    const labels: string[] = [];\n\n    if (rec.local) {\n      const inner = colorize(\n        `${iconFor(rec.local)} ${rec.local}`,\n        colorFor(rec.local)\n      );\n      const coloredLocal =\n        `${ANSIColors.GREY}[` +\n        colorize('local: ', ANSIColors.GREY) +\n        inner +\n        `${ANSIColors.GREY}]${ANSIColors.RESET}`;\n\n      // Pad to align distant label across rows\n      const visibleLocal = `[local: ${iconFor(rec.local)} ${rec.local}]`;\n      const pad = Math.max(0, maxLocalLabelLen - visibleLocal.length);\n      labels.push(coloredLocal + ' '.repeat(pad));\n    } else {\n      // If no local label, insert spaces to keep distant aligned\n      labels.push(' '.repeat(maxLocalLabelLen));\n    }\n\n    if (rec.remote) {\n      const inner = colorize(\n        `${iconFor(rec.remote)} ${rec.remote}`,\n        colorFor(rec.remote)\n      );\n      labels.push(\n        `${ANSIColors.GREY}[` +\n          colorize('distant: ', ANSIColors.GREY) +\n          inner +\n          `${ANSIColors.GREY}]${ANSIColors.RESET}`\n      );\n    }\n\n    appLogger(\n      ` - ${colon(colorizeKey(key), { colSize: keys })} ${labels.join(' ')}`\n    );\n  }\n};\n\nexport const loadDictionaries = async (\n  contentDeclarationsPaths: string[] | string,\n  configuration: IntlayerConfig\n): Promise<{\n  localDictionaries: Dictionary[];\n  remoteDictionaries: Dictionary[];\n  pluginDictionaries: Dictionary[];\n  time: {\n    localDictionaries: number;\n    remoteDictionaries: number;\n    pluginDictionaries: number;\n  };\n}> => {\n  const { plugins } = configuration;\n  const loadDictionariesStartTime = Date.now();\n  const appLogger = getAppLogger(configuration);\n\n  appLogger('Dictionaries:', { isVerbose: true });\n\n  // Load additional dictionaries via plugins (e.g., ICU JSON ingestion)\n  const resolvedPlugins = await Promise.all(plugins ?? []);\n\n  const pluginsWithLoadDictionaries = resolvedPlugins.filter(\n    (plugin) => plugin.loadDictionaries\n  );\n\n  const loadPluginDictionariesPromise = pluginsWithLoadDictionaries.map(\n    async (plugin) => {\n      try {\n        const res = await plugin.loadDictionaries?.({\n          configuration,\n        });\n\n        return (res as Dictionary[] | undefined) ?? [];\n      } catch (error) {\n        logger.setPluginError(error as Error);\n\n        return [];\n      }\n    }\n  );\n\n  const pluginDictionaries: Dictionary[] = await Promise.all(\n    loadPluginDictionariesPromise as Promise<Dictionary[]>[]\n  )\n    .then((dictionaries) => dictionaries.flat())\n    .then((dictionaries) =>\n      filterInvalidDictionaries(dictionaries, configuration)\n    )\n    .then((dictionaries) => formatDictionaries(dictionaries));\n\n  logger.setPluginTotal(pluginDictionaries.length);\n  logger.setPluginDone(pluginDictionaries.length);\n\n  const pluginDictionariesTime = Date.now();\n\n  const files = Array.isArray(contentDeclarationsPaths)\n    ? contentDeclarationsPaths\n    : [contentDeclarationsPaths];\n\n  const localDictionaries: Dictionary[] = await loadContentDeclarations(\n    files,\n    configuration,\n    setLoadDictionariesStatus\n  )\n    .then((dictionaries) =>\n      filterInvalidDictionaries(dictionaries, configuration)\n    )\n    .then((dictionaries) => formatDictionaries(dictionaries));\n\n  const localDictionariesTime = Date.now();\n\n  const localDictionariesStatus = localDictionaries.map(\n    (dictionary) =>\n      ({\n        dictionaryKey: dictionary.key,\n        type: 'local',\n        status: 'built',\n      }) as const\n  );\n\n  setLoadDictionariesStatus(localDictionariesStatus);\n\n  const hasRemoteDictionaries = Boolean(\n    configuration.editor.clientId && configuration.editor.clientSecret\n  );\n\n  if (hasRemoteDictionaries) {\n    // We expect to fetch remote dictionaries soon; suppress a transient local-only render\n    logger.setExpectRemote(true);\n  }\n\n  let remoteDictionaries: Dictionary[] = [];\n\n  if (hasRemoteDictionaries) {\n    remoteDictionaries = await loadRemoteDictionaries(\n      configuration,\n      setLoadDictionariesStatus,\n      {\n        onStartRemoteCheck: () => logger.startRemoteCheck(),\n        onStopRemoteCheck: () => logger.stopRemoteCheck(),\n        onError: (e) => logger.setRemoteError(e),\n      }\n    )\n      .then((dictionaries) =>\n        filterInvalidDictionaries(dictionaries, configuration)\n      )\n      .then((dictionaries) => formatDictionaries(dictionaries));\n  }\n\n  const remoteDictionariesTime = Date.now();\n\n  // Stop spinner and show final progress line(s)\n  logger.finish();\n\n  printSummary(configuration);\n\n  return {\n    localDictionaries,\n    remoteDictionaries,\n    pluginDictionaries,\n    time: {\n      localDictionaries: localDictionariesTime - pluginDictionariesTime,\n      remoteDictionaries: remoteDictionariesTime - localDictionariesTime,\n      pluginDictionaries: pluginDictionariesTime - loadDictionariesStartTime,\n    },\n  };\n};\n"],"mappings":"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"}

package/dist/cjs/loadDictionaries/loadLocalDictionaries.cjs

@@ -0,0 +1,28 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_loadDictionaries_loadContentDeclaration = require('./loadContentDeclaration.cjs');
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+
+//#region src/loadDictionaries/loadLocalDictionaries.ts
+const loadLocalDictionaries = async (contentDeclarationsPaths, configuration) => {
+	const { system } = configuration;
+	const { dictionariesDir, baseDir } = system;
+	if (typeof contentDeclarationsPaths === "string") contentDeclarationsPaths = [contentDeclarationsPaths];
+	await (0, node_fs_promises.mkdir)((0, node_path.resolve)(dictionariesDir), { recursive: true });
+	const result = [];
+	for await (const contentDeclarationPath of contentDeclarationsPaths) {
+		const dictionary = await require_loadDictionaries_loadContentDeclaration.loadContentDeclarations([contentDeclarationPath], configuration);
+		const relativeFilePath = (0, node_path.relative)(baseDir, contentDeclarationPath);
+		const dictionaryWithPath = {
+			...dictionary[0],
+			filePath: relativeFilePath
+		};
+		result.push(dictionaryWithPath);
+	}
+	return result;
+};
+
+//#endregion
+exports.loadLocalDictionaries = loadLocalDictionaries;
+//# sourceMappingURL=loadLocalDictionaries.cjs.map

package/dist/cjs/loadDictionaries/loadLocalDictionaries.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadLocalDictionaries.cjs","names":["loadContentDeclarations"],"sources":["../../../src/loadDictionaries/loadLocalDictionaries.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { relative, resolve } from 'node:path';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { loadContentDeclarations } from './loadContentDeclaration';\n\nexport const loadLocalDictionaries = async (\n  contentDeclarationsPaths: string[] | string,\n  configuration: IntlayerConfig\n): Promise<Dictionary[]> => {\n  const { system } = configuration;\n  const { dictionariesDir, baseDir } = system;\n\n  if (typeof contentDeclarationsPaths === 'string') {\n    contentDeclarationsPaths = [contentDeclarationsPaths];\n  }\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(dictionariesDir), { recursive: true });\n\n  const result: Dictionary[] = [];\n\n  for await (const contentDeclarationPath of contentDeclarationsPaths) {\n    const dictionary = await loadContentDeclarations(\n      [contentDeclarationPath],\n      configuration\n    );\n\n    const relativeFilePath = relative(baseDir, contentDeclarationPath);\n\n    const dictionaryWithPath: Dictionary = {\n      ...dictionary[0],\n      filePath: relativeFilePath,\n    };\n\n    result.push(dictionaryWithPath);\n  }\n\n  return result;\n};\n"],"mappings":";;;;;;;AAMA,MAAa,wBAAwB,OACnC,0BACA,kBAC0B;CAC1B,MAAM,EAAE,WAAW;CACnB,MAAM,EAAE,iBAAiB,YAAY;AAErC,KAAI,OAAO,6BAA6B,SACtC,4BAA2B,CAAC,yBAAyB;AAIvD,0DAAoB,gBAAgB,EAAE,EAAE,WAAW,MAAM,CAAC;CAE1D,MAAM,SAAuB,EAAE;AAE/B,YAAW,MAAM,0BAA0B,0BAA0B;EACnE,MAAM,aAAa,MAAMA,wEACvB,CAAC,uBAAuB,EACxB,cACD;EAED,MAAM,2CAA4B,SAAS,uBAAuB;EAElE,MAAM,qBAAiC;GACrC,GAAG,WAAW;GACd,UAAU;GACX;AAED,SAAO,KAAK,mBAAmB;;AAGjC,QAAO"}

package/dist/cjs/loadDictionaries/loadMarkdownContentDeclaration.cjs

@@ -0,0 +1,45 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let _intlayer_core_markdown = require("@intlayer/core/markdown");
+let _intlayer_types_nodeType = require("@intlayer/types/nodeType");
+
+//#region src/loadDictionaries/loadMarkdownContentDeclaration.ts
+const loadMarkdownContentDeclaration = async (path) => {
+	try {
+		const fileContent = await (0, node_fs_promises.readFile)(path, "utf-8");
+		const frontmatter = (0, _intlayer_core_markdown.getMarkdownMetadata)(fileContent);
+		const fileName = (0, node_path.basename)(path).replace(/\.content\.md$/, "");
+		const key = frontmatter.key ?? fileName;
+		if (!key) {
+			console.error(`[intlayer] Missing key in markdown content declaration: ${path}`);
+			return;
+		}
+		const { key: _key, locale, title, description, tags, fill, importMode, location, priority, version } = frontmatter;
+		return {
+			key,
+			...locale !== void 0 && { locale },
+			...title !== void 0 && { title },
+			...description !== void 0 && { description },
+			...tags !== void 0 && { tags },
+			...fill !== void 0 && { fill },
+			...importMode !== void 0 && { importMode },
+			...location !== void 0 && { location },
+			...priority !== void 0 && { priority },
+			...version !== void 0 && { version },
+			content: {
+				nodeType: _intlayer_types_nodeType.MARKDOWN,
+				[_intlayer_types_nodeType.MARKDOWN]: fileContent,
+				metadata: frontmatter
+			}
+		};
+	} catch (error) {
+		console.error(`Error loading markdown content declaration at ${path}:`, error);
+		return;
+	}
+};
+
+//#endregion
+exports.loadMarkdownContentDeclaration = loadMarkdownContentDeclaration;
+//# sourceMappingURL=loadMarkdownContentDeclaration.cjs.map

package/dist/cjs/loadDictionaries/loadMarkdownContentDeclaration.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadMarkdownContentDeclaration.cjs","names":["MARKDOWN"],"sources":["../../../src/loadDictionaries/loadMarkdownContentDeclaration.ts"],"sourcesContent":["import { readFile } from 'node:fs/promises';\nimport { basename } from 'node:path';\nimport { getMarkdownMetadata } from '@intlayer/core/markdown';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { MARKDOWN } from '@intlayer/types/nodeType';\n\ntype MarkdownFrontmatter = {\n  key?: string;\n  locale?: string;\n  title?: string;\n  description?: string;\n  tags?: string[];\n  fill?: any;\n  importMode?: string;\n  location?: string;\n  priority?: number;\n  version?: string;\n  [key: string]: any;\n};\n\nexport const loadMarkdownContentDeclaration = async (\n  path: string\n): Promise<Dictionary | undefined> => {\n  try {\n    const fileContent = await readFile(path, 'utf-8');\n    const frontmatter = getMarkdownMetadata<MarkdownFrontmatter>(fileContent);\n\n    // Derive key from filename (e.g. \"my-doc.content.md\" → \"my-doc\") if not in frontmatter\n    const fileName = basename(path).replace(/\\.content\\.md$/, '');\n    const key = frontmatter.key ?? fileName;\n\n    if (!key) {\n      console.error(\n        `[intlayer] Missing key in markdown content declaration: ${path}`\n      );\n      return undefined;\n    }\n\n    const {\n      key: _key,\n      locale,\n      title,\n      description,\n      tags,\n      fill,\n      importMode,\n      location,\n      priority,\n      version,\n    } = frontmatter;\n\n    return {\n      key,\n      ...(locale !== undefined && { locale }),\n      ...(title !== undefined && { title }),\n      ...(description !== undefined && { description }),\n      ...(tags !== undefined && { tags }),\n      ...(fill !== undefined && { fill }),\n      ...(importMode !== undefined && { importMode }),\n      ...(location !== undefined && { location }),\n      ...(priority !== undefined && { priority }),\n      ...(version !== undefined && { version }),\n      content: {\n        nodeType: MARKDOWN,\n        [MARKDOWN]: fileContent,\n        metadata: frontmatter,\n      },\n    } as Dictionary;\n  } catch (error) {\n    console.error(\n      `Error loading markdown content declaration at ${path}:`,\n      error\n    );\n    return undefined;\n  }\n};\n"],"mappings":";;;;;;;;AAoBA,MAAa,iCAAiC,OAC5C,SACoC;AACpC,KAAI;EACF,MAAM,cAAc,qCAAe,MAAM,QAAQ;EACjD,MAAM,+DAAuD,YAAY;EAGzE,MAAM,mCAAoB,KAAK,CAAC,QAAQ,kBAAkB,GAAG;EAC7D,MAAM,MAAM,YAAY,OAAO;AAE/B,MAAI,CAAC,KAAK;AACR,WAAQ,MACN,2DAA2D,OAC5D;AACD;;EAGF,MAAM,EACJ,KAAK,MACL,QACA,OACA,aACA,MACA,MACA,YACA,UACA,UACA,YACE;AAEJ,SAAO;GACL;GACA,GAAI,WAAW,UAAa,EAAE,QAAQ;GACtC,GAAI,UAAU,UAAa,EAAE,OAAO;GACpC,GAAI,gBAAgB,UAAa,EAAE,aAAa;GAChD,GAAI,SAAS,UAAa,EAAE,MAAM;GAClC,GAAI,SAAS,UAAa,EAAE,MAAM;GAClC,GAAI,eAAe,UAAa,EAAE,YAAY;GAC9C,GAAI,aAAa,UAAa,EAAE,UAAU;GAC1C,GAAI,aAAa,UAAa,EAAE,UAAU;GAC1C,GAAI,YAAY,UAAa,EAAE,SAAS;GACxC,SAAS;IACP,UAAUA;KACTA,oCAAW;IACZ,UAAU;IACX;GACF;UACM,OAAO;AACd,UAAQ,MACN,iDAAiD,KAAK,IACtD,MACD;AACD"}

package/dist/cjs/loadDictionaries/loadRemoteDictionaries.cjs

@@ -0,0 +1,63 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_utils_sortAlphabetically = require('../utils/sortAlphabetically.cjs');
+const require_fetchDistantDictionaries = require('../fetchDistantDictionaries.cjs');
+let _intlayer_config_node = require("@intlayer/config/node");
+let _intlayer_api = require("@intlayer/api");
+let _intlayer_api_dictionary = require("@intlayer/api/dictionary");
+let _intlayer_remote_dictionaries_entry = require("@intlayer/remote-dictionaries-entry");
+
+//#region src/loadDictionaries/loadRemoteDictionaries.ts
+const formatDistantDictionaries = (dictionaries) => dictionaries.map((dict) => ({
+	...dict,
+	localId: `${dict.key}::remote::${dict.id}`,
+	location: "remote"
+}));
+const loadRemoteDictionaries = async (configuration = (0, _intlayer_config_node.getConfiguration)(), onStatusUpdate, options) => {
+	const { editor } = configuration;
+	const remoteDictionariesRecord = (0, _intlayer_remote_dictionaries_entry.getRemoteDictionaries)(configuration);
+	if (!Boolean(editor.clientId && editor.clientSecret)) return [];
+	try {
+		options?.onStartRemoteCheck?.();
+		const distantDictionaryUpdateTimeStamp = (await (0, _intlayer_api_dictionary.dictionaryEndpoint)((0, _intlayer_api.createIntlayerCMS)(configuration)).getDictionariesUpdateTimestamp()).data;
+		if (!distantDictionaryUpdateTimeStamp) throw new Error("No distant dictionaries found");
+		const dictionariesIdToFetch = Object.entries(distantDictionaryUpdateTimeStamp).filter(([dictionaryId, data]) => {
+			if (!data.updatedAt) return true;
+			const local = remoteDictionariesRecord[data.key]?.find((dictionary) => dictionary.id === dictionaryId);
+			if (!local) return true;
+			const localUpdatedAtRaw = local?.updatedAt;
+			const localUpdatedAt = typeof localUpdatedAtRaw === "number" ? localUpdatedAtRaw : localUpdatedAtRaw ? new Date(localUpdatedAtRaw).getTime() : void 0;
+			if (typeof localUpdatedAt !== "number") return true;
+			return data.updatedAt > localUpdatedAt;
+		});
+		const cachedDictionaries = Object.values(remoteDictionariesRecord).flat().filter((dictionary) => {
+			const remoteUpdatedAt = distantDictionaryUpdateTimeStamp[dictionary.id].updatedAt;
+			const localUpdatedAtRaw = dictionary.updatedAt;
+			const localUpdatedAt = typeof localUpdatedAtRaw === "number" ? localUpdatedAtRaw : localUpdatedAtRaw ? new Date(localUpdatedAtRaw).getTime() : void 0;
+			return typeof localUpdatedAt === "number" && typeof remoteUpdatedAt === "number" && localUpdatedAt >= remoteUpdatedAt;
+		});
+		if (cachedDictionaries.length > 0) onStatusUpdate?.(cachedDictionaries.map((dictionary) => ({
+			dictionaryKey: dictionary.key,
+			type: "remote",
+			status: "imported"
+		})));
+		const orderedDistantDictionaryKeys = dictionariesIdToFetch.map(([, data]) => data.key).sort(require_utils_sortAlphabetically.sortAlphabetically);
+		if (orderedDistantDictionaryKeys.length > 0) onStatusUpdate?.(orderedDistantDictionaryKeys.map((key) => ({
+			dictionaryKey: key,
+			type: "remote",
+			status: "pending"
+		})));
+		const distantDictionaries = formatDistantDictionaries(await require_fetchDistantDictionaries.fetchDistantDictionaries({ dictionaryKeys: orderedDistantDictionaryKeys }, onStatusUpdate));
+		return [...cachedDictionaries, ...distantDictionaries];
+	} catch (error) {
+		options?.onError?.(error);
+		return [];
+	} finally {
+		options?.onStopRemoteCheck?.();
+	}
+};
+
+//#endregion
+exports.formatDistantDictionaries = formatDistantDictionaries;
+exports.loadRemoteDictionaries = loadRemoteDictionaries;
+//# sourceMappingURL=loadRemoteDictionaries.cjs.map

package/dist/cjs/loadDictionaries/loadRemoteDictionaries.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadRemoteDictionaries.cjs","names":["sortAlphabetically","fetchDistantDictionaries"],"sources":["../../../src/loadDictionaries/loadRemoteDictionaries.ts"],"sourcesContent":["import { createIntlayerCMS } from '@intlayer/api';\nimport { dictionaryEndpoint } from '@intlayer/api/dictionary';\n// @ts-ignore @intlayer/backend is not build yet\nimport type { DictionaryAPI } from '@intlayer/backend';\nimport { getConfiguration } from '@intlayer/config/node';\nimport { getRemoteDictionaries } from '@intlayer/remote-dictionaries-entry';\nimport type {\n  Dictionary,\n  DictionaryId,\n  DictionaryKey,\n} from '@intlayer/types/dictionary';\nimport { fetchDistantDictionaries } from '../fetchDistantDictionaries';\nimport { sortAlphabetically } from '../utils/sortAlphabetically';\nimport type { DictionariesStatus } from './loadDictionaries';\n\nexport const formatDistantDictionaries = (\n  dictionaries: (DictionaryAPI | Dictionary)[]\n): Dictionary[] =>\n  dictionaries.map((dict) => ({\n    ...dict,\n    localId: `${dict.key}::remote::${dict.id}`,\n    location: 'remote' as const,\n  }));\n\nexport const loadRemoteDictionaries = async (\n  configuration = getConfiguration(),\n  onStatusUpdate?: (status: DictionariesStatus[]) => void,\n  options?: {\n    onStartRemoteCheck?: () => void;\n    onStopRemoteCheck?: () => void;\n    onError?: (error: Error) => void;\n  }\n): Promise<Dictionary[]> => {\n  const { editor } = configuration;\n  const remoteDictionariesRecord = getRemoteDictionaries(configuration);\n\n  const hasRemoteDictionaries = Boolean(editor.clientId && editor.clientSecret);\n\n  if (!hasRemoteDictionaries) return [];\n\n  try {\n    options?.onStartRemoteCheck?.();\n\n    const dictionary = dictionaryEndpoint(createIntlayerCMS(configuration));\n\n    // Get the list of dictionary keys\n    const getDictionariesKeysResult =\n      await dictionary.getDictionariesUpdateTimestamp();\n\n    const distantDictionaryUpdateTimeStamp: Record<\n      DictionaryId,\n      { key: DictionaryKey; updatedAt: number }\n    > | null = getDictionariesKeysResult.data;\n\n    if (!distantDictionaryUpdateTimeStamp) {\n      throw new Error('No distant dictionaries found');\n    }\n\n    const dictionariesIdToFetch = Object.entries(\n      distantDictionaryUpdateTimeStamp\n    ).filter(([dictionaryId, data]) => {\n      // If remote doesn't provide updatedAt, fetch to be safe\n      if (!data.updatedAt) return true;\n\n      // If no local cache exists, fetch\n      const local: Dictionary | undefined = remoteDictionariesRecord[\n        data.key\n      ]?.find((dictionary) => dictionary.id === dictionaryId);\n      if (!local) return true;\n\n      const localUpdatedAtRaw = (local as any)?.updatedAt as\n        | number\n        | string\n        | undefined;\n\n      const localUpdatedAt =\n        typeof localUpdatedAtRaw === 'number'\n          ? localUpdatedAtRaw\n          : localUpdatedAtRaw\n            ? new Date(localUpdatedAtRaw).getTime()\n            : undefined;\n\n      // If local timestamp missing or older than remote, fetch\n      if (typeof localUpdatedAt !== 'number') return true;\n\n      return data.updatedAt > localUpdatedAt;\n    });\n\n    const flatRemoteDictionariesRecord: DictionaryAPI[] = Object.values(\n      remoteDictionariesRecord\n    ).flat();\n\n    const cachedDictionaries: Dictionary[] =\n      flatRemoteDictionariesRecord.filter((dictionary) => {\n        const remoteUpdatedAt =\n          distantDictionaryUpdateTimeStamp[dictionary.id!].updatedAt;\n\n        const localUpdatedAtRaw = dictionary.updatedAt;\n\n        const localUpdatedAt =\n          typeof localUpdatedAtRaw === 'number'\n            ? localUpdatedAtRaw\n            : localUpdatedAtRaw\n              ? new Date(localUpdatedAtRaw).getTime()\n              : undefined;\n\n        // Consider as cached/imported when local exists and is up-to-date or newer\n        return (\n          typeof localUpdatedAt === 'number' &&\n          typeof remoteUpdatedAt === 'number' &&\n          localUpdatedAt >= remoteUpdatedAt\n        );\n      });\n\n    // Report cached as already imported\n    if (cachedDictionaries.length > 0) {\n      onStatusUpdate?.(\n        cachedDictionaries.map((dictionary) => ({\n          dictionaryKey: dictionary.key,\n          type: 'remote',\n          status: 'imported',\n        }))\n      );\n    }\n\n    const orderedDistantDictionaryKeys = dictionariesIdToFetch\n      .map(([, data]) => data.key)\n      .sort(sortAlphabetically);\n\n    // Report pending for keys to be fetched so totals are visible immediately\n    if (orderedDistantDictionaryKeys.length > 0) {\n      onStatusUpdate?.(\n        orderedDistantDictionaryKeys.map((key) => ({\n          dictionaryKey: key,\n          type: 'remote',\n          status: 'pending',\n        }))\n      );\n    }\n\n    const distantDictionariesData = await fetchDistantDictionaries(\n      {\n        dictionaryKeys: orderedDistantDictionaryKeys,\n      },\n      onStatusUpdate\n    );\n\n    const distantDictionaries: Dictionary[] = formatDistantDictionaries(\n      distantDictionariesData\n    );\n\n    return [...cachedDictionaries, ...distantDictionaries];\n  } catch (error) {\n    options?.onError?.(error as Error);\n    return [];\n  } finally {\n    options?.onStopRemoteCheck?.();\n  }\n};\n"],"mappings":";;;;;;;;;;AAeA,MAAa,6BACX,iBAEA,aAAa,KAAK,UAAU;CAC1B,GAAG;CACH,SAAS,GAAG,KAAK,IAAI,YAAY,KAAK;CACtC,UAAU;CACX,EAAE;AAEL,MAAa,yBAAyB,OACpC,6DAAkC,EAClC,gBACA,YAK0B;CAC1B,MAAM,EAAE,WAAW;CACnB,MAAM,0FAAiD,cAAc;AAIrE,KAAI,CAF0B,QAAQ,OAAO,YAAY,OAAO,aAEtC,CAAE,QAAO,EAAE;AAErC,KAAI;AACF,WAAS,sBAAsB;EAQ/B,MAAM,oCAGK,4FAT6C,cAAc,CAIpD,CAAC,gCAAgC,EAKd;AAErC,MAAI,CAAC,iCACH,OAAM,IAAI,MAAM,gCAAgC;EAGlD,MAAM,wBAAwB,OAAO,QACnC,iCACD,CAAC,QAAQ,CAAC,cAAc,UAAU;AAEjC,OAAI,CAAC,KAAK,UAAW,QAAO;GAG5B,MAAM,QAAgC,yBACpC,KAAK,MACJ,MAAM,eAAe,WAAW,OAAO,aAAa;AACvD,OAAI,CAAC,MAAO,QAAO;GAEnB,MAAM,oBAAqB,OAAe;GAK1C,MAAM,iBACJ,OAAO,sBAAsB,WACzB,oBACA,oBACE,IAAI,KAAK,kBAAkB,CAAC,SAAS,GACrC;AAGR,OAAI,OAAO,mBAAmB,SAAU,QAAO;AAE/C,UAAO,KAAK,YAAY;IACxB;EAMF,MAAM,qBAJgD,OAAO,OAC3D,yBACD,CAAC,MAG4B,CAAC,QAAQ,eAAe;GAClD,MAAM,kBACJ,iCAAiC,WAAW,IAAK;GAEnD,MAAM,oBAAoB,WAAW;GAErC,MAAM,iBACJ,OAAO,sBAAsB,WACzB,oBACA,oBACE,IAAI,KAAK,kBAAkB,CAAC,SAAS,GACrC;AAGR,UACE,OAAO,mBAAmB,YAC1B,OAAO,oBAAoB,YAC3B,kBAAkB;IAEpB;AAGJ,MAAI,mBAAmB,SAAS,EAC9B,kBACE,mBAAmB,KAAK,gBAAgB;GACtC,eAAe,WAAW;GAC1B,MAAM;GACN,QAAQ;GACT,EAAE,CACJ;EAGH,MAAM,+BAA+B,sBAClC,KAAK,GAAG,UAAU,KAAK,IAAI,CAC3B,KAAKA,oDAAmB;AAG3B,MAAI,6BAA6B,SAAS,EACxC,kBACE,6BAA6B,KAAK,SAAS;GACzC,eAAe;GACf,MAAM;GACN,QAAQ;GACT,EAAE,CACJ;EAUH,MAAM,sBAAoC,0BACxC,MARoCC,0DACpC,EACE,gBAAgB,8BACjB,EACD,eACD,CAIA;AAED,SAAO,CAAC,GAAG,oBAAoB,GAAG,oBAAoB;UAC/C,OAAO;AACd,WAAS,UAAU,MAAe;AAClC,SAAO,EAAE;WACD;AACR,WAAS,qBAAqB"}

package/dist/cjs/loadDictionaries/loadYamlContentDeclaration.cjs

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+let node_fs_promises = require("node:fs/promises");
+let _intlayer_core_utils = require("@intlayer/core/utils");
+
+//#region src/loadDictionaries/loadYamlContentDeclaration.ts
+const loadYamlContentDeclaration = async (path) => {
+	try {
+		const parsed = (0, _intlayer_core_utils.parseYaml)(await (0, node_fs_promises.readFile)(path, "utf-8"));
+		if (!parsed || typeof parsed !== "object") {
+			console.error(`[intlayer] Invalid YAML content declaration: ${path}`);
+			return;
+		}
+		if (!parsed.key) {
+			console.error(`[intlayer] Missing key in YAML content declaration: ${path}`);
+			return;
+		}
+		return parsed;
+	} catch (error) {
+		console.error(`Error loading YAML content declaration at ${path}:`, error);
+		return;
+	}
+};
+
+//#endregion
+exports.loadYamlContentDeclaration = loadYamlContentDeclaration;
+//# sourceMappingURL=loadYamlContentDeclaration.cjs.map

package/dist/cjs/loadDictionaries/loadYamlContentDeclaration.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadYamlContentDeclaration.cjs","names":[],"sources":["../../../src/loadDictionaries/loadYamlContentDeclaration.ts"],"sourcesContent":["import { readFile } from 'node:fs/promises';\nimport { parseYaml } from '@intlayer/core/utils';\nimport type { Dictionary } from '@intlayer/types/dictionary';\n\nexport const loadYamlContentDeclaration = async (\n  path: string\n): Promise<Dictionary | undefined> => {\n  try {\n    const fileContent = await readFile(path, 'utf-8');\n    const parsed = parseYaml<Dictionary>(fileContent);\n\n    if (!parsed || typeof parsed !== 'object') {\n      console.error(`[intlayer] Invalid YAML content declaration: ${path}`);\n      return undefined;\n    }\n\n    if (!parsed.key) {\n      console.error(\n        `[intlayer] Missing key in YAML content declaration: ${path}`\n      );\n      return undefined;\n    }\n\n    return parsed;\n  } catch (error) {\n    console.error(`Error loading YAML content declaration at ${path}:`, error);\n    return undefined;\n  }\n};\n"],"mappings":";;;;;;AAIA,MAAa,6BAA6B,OACxC,SACoC;AACpC,KAAI;EAEF,MAAM,6CAA+B,qCADF,MAAM,QAAQ,CACA;AAEjD,MAAI,CAAC,UAAU,OAAO,WAAW,UAAU;AACzC,WAAQ,MAAM,gDAAgD,OAAO;AACrE;;AAGF,MAAI,CAAC,OAAO,KAAK;AACf,WAAQ,MACN,uDAAuD,OACxD;AACD;;AAGF,SAAO;UACA,OAAO;AACd,UAAQ,MAAM,6CAA6C,KAAK,IAAI,MAAM;AAC1E"}