@intlayer/chokidar 6.1.6 → 7.0.0-canary.0

package/dist/cjs/createType/createModuleAugmentation.cjs

@@ -1,112 +1,60 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var createModuleAugmentation_exports = {};
-__export(createModuleAugmentation_exports, {
-  createModuleAugmentation: () => createModuleAugmentation,
-  getTypeName: () => getTypeName
-});
-module.exports = __toCommonJS(createModuleAugmentation_exports);
-var import_config = require("@intlayer/config");
-var import_fast_glob = __toESM(require("fast-glob"));
-var import_promises = require("fs/promises");
-var import_path = require("path");
-var import_getFileHash = require('../utils/getFileHash.cjs');
-var import_kebabCaseToCamelCase = require('../utils/kebabCaseToCamelCase.cjs');
-var import_writeFileIfChanged = require('../writeFileIfChanged.cjs');
-const getTypeName = (key) => `${(0, import_kebabCaseToCamelCase.kebabCaseToCamelCase)(key)}Content`;
-const formatLocales = (locales) => locales.map((locale) => {
-  for (const key in import_config.Locales) {
-    if (import_config.Locales[key] === locale) {
-      return `Locales.${key}`;
-    }
-  }
-}).join(" | ");
-const generateTypeIndexContent = (typeFiles, configuration = (0, import_config.getConfiguration)()) => {
-  const { content, internationalization } = configuration;
-  const { moduleAugmentationDir } = content;
-  const { locales, requiredLocales, strictMode } = internationalization;
-  let fileContent = "/* eslint-disable */\nimport { Locales } from 'intlayer';\n";
-  const dictionariesRef = typeFiles.map((dictionaryPath) => ({
-    relativePath: `./${(0, import_path.relative)(moduleAugmentationDir, dictionaryPath)}`,
-    id: (0, import_path.basename)(dictionaryPath, (0, import_path.extname)(dictionaryPath)),
-    // Get the base name as the dictionary id (without the extension)
-    hash: `_${(0, import_getFileHash.getFileHash)(dictionaryPath)}`
-    // Get the hash of the dictionary to avoid conflicts
-  }));
-  dictionariesRef.forEach((dictionary) => {
-    fileContent += `import ${dictionary.hash} from '${dictionary.relativePath}';
-`;
-  });
-  fileContent += "\n";
-  const formattedDictionaryMap = dictionariesRef.map((dictionary) => `    "${dictionary.id}": typeof ${dictionary.hash};`).join("\n");
-  const requiredLocalesValues = requiredLocales.length > 0 ? requiredLocales.filter(
-    (locale) => locales.map((locale2) => String(locale2)).includes(String(locale))
-  ) : locales;
-  const formattedLocales = formatLocales(locales);
-  const formattedRequiredLocales = formatLocales(requiredLocalesValues);
-  const strictModeRecord = strictMode === "strict" ? `interface IConfigLocales<Content> extends Record<DeclaredLocales, Content> {}` : strictMode === "inclusive" ? `interface IConfigLocales<Content> extends Record<ExtractedLocales, Content>, Partial<Record<ExcludedLocales, Content>> {}` : `interface IConfigLocales<Content> extends Partial<Record<Locales, Content>> {}`;
-  fileContent += `declare module 'intlayer' {
-`;
-  fileContent += `  interface IntlayerDictionaryTypesConnector {
-${formattedDictionaryMap}
-  }
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_writeFileIfChanged = require('../writeFileIfChanged.cjs');
+const require_utils_getFileHash = require('../utils/getFileHash.cjs');
+const require_utils_kebabCaseToCamelCase = require('../utils/kebabCaseToCamelCase.cjs');
+let __intlayer_config = require("@intlayer/config");
+__intlayer_config = require_rolldown_runtime.__toESM(__intlayer_config);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_rolldown_runtime.__toESM(node_fs_promises);
+let fast_glob = require("fast-glob");
+fast_glob = require_rolldown_runtime.__toESM(fast_glob);
 
-`;
-  fileContent += `  type DeclaredLocales = ${formattedLocales};
-`;
-  fileContent += `  type RequiredLocales = ${formattedRequiredLocales};
-`;
-  fileContent += `  type ExtractedLocales = Extract<Locales, RequiredLocales>;
-`;
-  fileContent += `  type ExcludedLocales = Exclude<Locales, RequiredLocales>;
-`;
-  fileContent += `  ${strictModeRecord}
-`;
-  fileContent += `}`;
-  return fileContent;
+//#region src/createType/createModuleAugmentation.ts
+const getTypeName = (key) => `${require_utils_kebabCaseToCamelCase.kebabCaseToCamelCase(key)}Content`;
+/** Returns lines like: [Locales.FRENCH]: 1; */
+const formatLocales = (locales) => locales.map((locale) => `    "${locale}": 1;`).join("\n");
+/** Generate the content of the module augmentation file */
+const generateTypeIndexContent = (typeFiles, configuration) => {
+	const { content, internationalization } = configuration;
+	const { moduleAugmentationDir } = content;
+	const { locales, requiredLocales, strictMode } = internationalization;
+	let fileContent = "";
+	const dictionariesRef = typeFiles.map((dictionaryPath) => ({
+		relativePath: `./${(0, node_path.relative)(moduleAugmentationDir, dictionaryPath)}`,
+		id: (0, node_path.basename)(dictionaryPath, (0, node_path.extname)(dictionaryPath)),
+		hash: `_${require_utils_getFileHash.getFileHash(dictionaryPath)}`
+	}));
+	for (const dictionary of dictionariesRef) fileContent += `import ${dictionary.hash} from '${dictionary.relativePath}';\n`;
+	fileContent += "\n";
+	const formattedDictionaryMap = dictionariesRef.map((dictionary) => `    "${dictionary.id}": typeof ${dictionary.hash};`).join("\n");
+	const declared = locales;
+	const requiredSanitized = requiredLocales?.length ? requiredLocales.filter((requiredLocales$1) => declared.includes(requiredLocales$1)) : declared;
+	const formattedDeclaredLocales = formatLocales(declared);
+	const formattedRequiredLocales = formatLocales(requiredSanitized);
+	const strictKey = strictMode === "strict" ? "strict" : strictMode === "inclusive" ? "inclusive" : "loose";
+	/**
+	* Module augmentation that ONLY adds keys to registries.
+	* No types/aliases redefined here—avoids merge conflicts.
+	*/
+	fileContent += `declare module 'intlayer' {\n`;
+	fileContent += `  interface __DictionaryRegistry {\n${formattedDictionaryMap}\n  }\n\n`;
+	fileContent += `  interface __DeclaredLocalesRegistry {\n${formattedDeclaredLocales}\n  }\n\n`;
+	fileContent += `  interface __RequiredLocalesRegistry {\n${formattedRequiredLocales}\n  }\n\n`;
+	fileContent += `  interface __StrictModeRegistry { mode: '${strictKey}' }\n`;
+	fileContent += `}\n`;
+	return fileContent;
 };
-const createModuleAugmentation = async (configuration = (0, import_config.getConfiguration)()) => {
-  const { moduleAugmentationDir, typesDir } = configuration.content;
-  await (0, import_promises.mkdir)(moduleAugmentationDir, { recursive: true });
-  const dictionariesTypesDefinitions = import_fast_glob.default.sync(
-    (0, import_config.normalizePath)(`${typesDir}/*.ts`),
-    {
-      ignore: ["**/*.d.ts"]
-    }
-  );
-  const tsContent = generateTypeIndexContent(dictionariesTypesDefinitions);
-  const tsFilePath = (0, import_path.join)(moduleAugmentationDir, "intlayer.d.ts");
-  await (0, import_writeFileIfChanged.writeFileIfChanged)(tsFilePath, tsContent);
+/** Generate the index file merging all the types */
+const createModuleAugmentation = async (configuration) => {
+	const { moduleAugmentationDir, typesDir } = configuration.content;
+	await (0, node_fs_promises.mkdir)(moduleAugmentationDir, { recursive: true });
+	const tsContent = generateTypeIndexContent(await (0, fast_glob.default)((0, __intlayer_config.normalizePath)(`${typesDir}/*.ts`), { ignore: ["**/*.d.ts"] }), configuration);
+	await require_writeFileIfChanged.writeFileIfChanged((0, node_path.join)(moduleAugmentationDir, "intlayer.d.ts"), tsContent);
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createModuleAugmentation,
-  getTypeName
-});
+
+//#endregion
+exports.createModuleAugmentation = createModuleAugmentation;
+exports.getTypeName = getTypeName;
 //# sourceMappingURL=createModuleAugmentation.cjs.map

package/dist/cjs/createType/createModuleAugmentation.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/createType/createModuleAugmentation.ts"],"sourcesContent":["import { Locales, getConfiguration, normalizePath } from '@intlayer/config';\nimport fg from 'fast-glob';\nimport { mkdir } from 'fs/promises';\nimport { basename, extname, join, relative } from 'path';\nimport { getFileHash } from '../utils/getFileHash';\nimport { kebabCaseToCamelCase } from '../utils/kebabCaseToCamelCase';\nimport { writeFileIfChanged } from '../writeFileIfChanged';\n\nexport const getTypeName = (key: string): string =>\n  `${kebabCaseToCamelCase(key)}Content`;\n\nconst formatLocales = (locales: Locales[]): string =>\n  locales\n    .map((locale) => {\n      for (const key in Locales) {\n        if (Locales[key as keyof typeof Locales] === locale) {\n          return `Locales.${key}`;\n        }\n      }\n    })\n    .join(' | ');\n\n/**\n * This function generates the content of the module augmentation file\n */\nconst generateTypeIndexContent = (\n  typeFiles: string[],\n  configuration = getConfiguration()\n): string => {\n  const { content, internationalization } = configuration;\n  const { moduleAugmentationDir } = content;\n  const { locales, requiredLocales, strictMode } = internationalization;\n\n  let fileContent =\n    \"/* eslint-disable */\\nimport { Locales } from 'intlayer';\\n\";\n\n  const dictionariesRef = typeFiles.map((dictionaryPath) => ({\n    relativePath: `./${relative(moduleAugmentationDir, dictionaryPath)}`,\n    id: basename(dictionaryPath, extname(dictionaryPath)), // Get the base name as the dictionary id (without the extension)\n    hash: `_${getFileHash(dictionaryPath)}`, // Get the hash of the dictionary to avoid conflicts\n  }));\n\n  // Import all dictionaries\n  dictionariesRef.forEach((dictionary) => {\n    fileContent += `import ${dictionary.hash} from '${dictionary.relativePath}';\\n`;\n  });\n\n  fileContent += '\\n';\n\n  // Format Dictionary Map\n  const formattedDictionaryMap: string = dictionariesRef\n    .map((dictionary) => `    \"${dictionary.id}\": typeof ${dictionary.hash};`)\n    .join('\\n');\n\n  const requiredLocalesValues =\n    requiredLocales.length > 0\n      ? requiredLocales.filter((locale) =>\n          locales.map((locale) => String(locale)).includes(String(locale))\n        )\n      : locales;\n\n  const formattedLocales = formatLocales(locales);\n  const formattedRequiredLocales = formatLocales(requiredLocalesValues);\n\n  const strictModeRecord =\n    strictMode === 'strict'\n      ? `interface IConfigLocales<Content> extends Record<DeclaredLocales, Content> {}`\n      : strictMode === 'inclusive'\n        ? `interface IConfigLocales<Content> extends Record<ExtractedLocales, Content>, Partial<Record<ExcludedLocales, Content>> {}`\n        : `interface IConfigLocales<Content> extends Partial<Record<Locales, Content>> {}`;\n\n  /**\n   * Write the module augmentation to extend the intlayer module with the dictionaries types\n   * Will suggest the type resulting of the dictionaries\n   *\n   * declare module 'intlayer' {\n   *   interface IntlayerDictionaryTypesConnector = {\n   *     dictionaries: {\n   *       id: DictionaryType;\n   *     }\n   *   }\n   *\n   *   type ConfigLocales = Locales.ENGLISH | Locales.FRENCH | Locales.SPANISH;\n   *   type ExtractedLocales = Extract<Locales, ConfigLocales>;\n   *\n   *   interface IConfigLocales<Content> extends Record<ExtractedLocales, Content>, Partial<Record<ExcludedLocales, Content>> {}\n   *\n   *\n   * }\n   * See https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation\n   */\n  fileContent += `declare module 'intlayer' {\\n`;\n  fileContent += `  interface IntlayerDictionaryTypesConnector {\\n${formattedDictionaryMap}\\n  }\\n\\n`;\n  fileContent += `  type DeclaredLocales = ${formattedLocales};\\n`;\n  fileContent += `  type RequiredLocales = ${formattedRequiredLocales};\\n`;\n  fileContent += `  type ExtractedLocales = Extract<Locales, RequiredLocales>;\\n`;\n  fileContent += `  type ExcludedLocales = Exclude<Locales, RequiredLocales>;\\n`;\n  fileContent += `  ${strictModeRecord}\\n`;\n  fileContent += `}`;\n\n  return fileContent;\n};\n\n/**\n * This function generates a index file merging all the types\n */\nexport const createModuleAugmentation = async (\n  configuration = getConfiguration()\n) => {\n  const { moduleAugmentationDir, typesDir } = configuration.content;\n\n  // Create main directory if it doesn't exist\n  await mkdir(moduleAugmentationDir, { recursive: true });\n\n  const dictionariesTypesDefinitions: string[] = fg.sync(\n    normalizePath(`${typesDir}/*.ts`),\n    {\n      ignore: ['**/*.d.ts'],\n    }\n  );\n\n  // Create the dictionary list file\n  const tsContent = generateTypeIndexContent(dictionariesTypesDefinitions);\n\n  const tsFilePath = join(moduleAugmentationDir, 'intlayer.d.ts');\n\n  await writeFileIfChanged(tsFilePath, tsContent);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAyD;AACzD,uBAAe;AACf,sBAAsB;AACtB,kBAAkD;AAClD,yBAA4B;AAC5B,kCAAqC;AACrC,gCAAmC;AAE5B,MAAM,cAAc,CAAC,QAC1B,OAAG,kDAAqB,GAAG,CAAC;AAE9B,MAAM,gBAAgB,CAAC,YACrB,QACG,IAAI,CAAC,WAAW;AACf,aAAW,OAAO,uBAAS;AACzB,QAAI,sBAAQ,GAA2B,MAAM,QAAQ;AACnD,aAAO,WAAW,GAAG;AAAA,IACvB;AAAA,EACF;AACF,CAAC,EACA,KAAK,KAAK;AAKf,MAAM,2BAA2B,CAC/B,WACA,oBAAgB,gCAAiB,MACtB;AACX,QAAM,EAAE,SAAS,qBAAqB,IAAI;AAC1C,QAAM,EAAE,sBAAsB,IAAI;AAClC,QAAM,EAAE,SAAS,iBAAiB,WAAW,IAAI;AAEjD,MAAI,cACF;AAEF,QAAM,kBAAkB,UAAU,IAAI,CAAC,oBAAoB;AAAA,IACzD,cAAc,SAAK,sBAAS,uBAAuB,cAAc,CAAC;AAAA,IAClE,QAAI,sBAAS,oBAAgB,qBAAQ,cAAc,CAAC;AAAA;AAAA,IACpD,MAAM,QAAI,gCAAY,cAAc,CAAC;AAAA;AAAA,EACvC,EAAE;AAGF,kBAAgB,QAAQ,CAAC,eAAe;AACtC,mBAAe,UAAU,WAAW,IAAI,UAAU,WAAW,YAAY;AAAA;AAAA,EAC3E,CAAC;AAED,iBAAe;AAGf,QAAM,yBAAiC,gBACpC,IAAI,CAAC,eAAe,QAAQ,WAAW,EAAE,aAAa,WAAW,IAAI,GAAG,EACxE,KAAK,IAAI;AAEZ,QAAM,wBACJ,gBAAgB,SAAS,IACrB,gBAAgB;AAAA,IAAO,CAAC,WACtB,QAAQ,IAAI,CAACA,YAAW,OAAOA,OAAM,CAAC,EAAE,SAAS,OAAO,MAAM,CAAC;AAAA,EACjE,IACA;AAEN,QAAM,mBAAmB,cAAc,OAAO;AAC9C,QAAM,2BAA2B,cAAc,qBAAqB;AAEpE,QAAM,mBACJ,eAAe,WACX,kFACA,eAAe,cACb,8HACA;AAsBR,iBAAe;AAAA;AACf,iBAAe;AAAA,EAAmD,sBAAsB;AAAA;AAAA;AAAA;AACxF,iBAAe,4BAA4B,gBAAgB;AAAA;AAC3D,iBAAe,4BAA4B,wBAAwB;AAAA;AACnE,iBAAe;AAAA;AACf,iBAAe;AAAA;AACf,iBAAe,KAAK,gBAAgB;AAAA;AACpC,iBAAe;AAEf,SAAO;AACT;AAKO,MAAM,2BAA2B,OACtC,oBAAgB,gCAAiB,MAC9B;AACH,QAAM,EAAE,uBAAuB,SAAS,IAAI,cAAc;AAG1D,YAAM,uBAAM,uBAAuB,EAAE,WAAW,KAAK,CAAC;AAEtD,QAAM,+BAAyC,iBAAAC,QAAG;AAAA,QAChD,6BAAc,GAAG,QAAQ,OAAO;AAAA,IAChC;AAAA,MACE,QAAQ,CAAC,WAAW;AAAA,IACtB;AAAA,EACF;AAGA,QAAM,YAAY,yBAAyB,4BAA4B;AAEvE,QAAM,iBAAa,kBAAK,uBAAuB,eAAe;AAE9D,YAAM,8CAAmB,YAAY,SAAS;AAChD;","names":["locale","fg"]}
+{"version":3,"file":"createModuleAugmentation.cjs","names":["kebabCaseToCamelCase","getFileHash","formattedDictionaryMap: string","requiredLocales","writeFileIfChanged"],"sources":["../../../src/createType/createModuleAugmentation.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { basename, extname, join, relative } from 'node:path';\nimport { normalizePath } from '@intlayer/config';\nimport type { IntlayerConfig, Locale } from '@intlayer/types';\nimport fg from 'fast-glob';\nimport { getFileHash } from '../utils/getFileHash';\nimport { kebabCaseToCamelCase } from '../utils/kebabCaseToCamelCase';\nimport { writeFileIfChanged } from '../writeFileIfChanged';\n\nexport const getTypeName = (key: string): string =>\n  `${kebabCaseToCamelCase(key)}Content`;\n\n/** Returns lines like: [Locales.FRENCH]: 1; */\nconst formatLocales = (locales: Locale[]) =>\n  locales.map((locale) => `    \"${locale}\": 1;`).join('\\n');\n\n/** Generate the content of the module augmentation file */\nconst generateTypeIndexContent = (\n  typeFiles: string[],\n  configuration: IntlayerConfig\n): string => {\n  const { content, internationalization } = configuration;\n  const { moduleAugmentationDir } = content;\n  const { locales, requiredLocales, strictMode } = internationalization;\n\n  let fileContent = '';\n\n  // Build dictionary refs\n  const dictionariesRef = typeFiles.map((dictionaryPath) => ({\n    relativePath: `./${relative(moduleAugmentationDir, dictionaryPath)}`,\n    id: basename(dictionaryPath, extname(dictionaryPath)),\n    hash: `_${getFileHash(dictionaryPath)}`,\n  }));\n\n  // Import all dictionaries\n  for (const dictionary of dictionariesRef) {\n    fileContent += `import ${dictionary.hash} from '${dictionary.relativePath}';\\n`;\n  }\n  fileContent += '\\n';\n\n  // Dictionary map entries (id: typeof <hash>)\n  const formattedDictionaryMap: string = dictionariesRef\n    .map((dictionary) => `    \"${dictionary.id}\": typeof ${dictionary.hash};`)\n    .join('\\n');\n\n  // Ensure required ⊆ declared; if empty, default required = declared\n  const declared = locales;\n  const requiredSanitized = requiredLocales?.length\n    ? requiredLocales.filter((requiredLocales) =>\n        declared.includes(requiredLocales)\n      )\n    : declared;\n\n  const formattedDeclaredLocales = formatLocales(declared);\n  const formattedRequiredLocales = formatLocales(requiredSanitized);\n\n  // Choose strict mode registry key\n  const strictKey =\n    strictMode === 'strict'\n      ? 'strict'\n      : strictMode === 'inclusive'\n        ? 'inclusive'\n        : 'loose';\n\n  /**\n   * Module augmentation that ONLY adds keys to registries.\n   * No types/aliases redefined here—avoids merge conflicts.\n   */\n  fileContent += `declare module 'intlayer' {\\n`;\n  // Dictionaries registry\n  fileContent += `  interface __DictionaryRegistry {\\n${formattedDictionaryMap}\\n  }\\n\\n`;\n  // Locales registries\n  fileContent += `  interface __DeclaredLocalesRegistry {\\n${formattedDeclaredLocales}\\n  }\\n\\n`;\n  fileContent += `  interface __RequiredLocalesRegistry {\\n${formattedRequiredLocales}\\n  }\\n\\n`;\n  // Resolved strict mode (narrow the literal at build time)\n  fileContent += `  interface __StrictModeRegistry { mode: '${strictKey}' }\\n`;\n  fileContent += `}\\n`;\n\n  return fileContent;\n};\n\n/** Generate the index file merging all the types */\nexport const createModuleAugmentation = async (\n  configuration: IntlayerConfig\n) => {\n  const { moduleAugmentationDir, typesDir } = configuration.content;\n\n  await mkdir(moduleAugmentationDir, { recursive: true });\n\n  const dictionariesTypesDefinitions: string[] = await fg(\n    normalizePath(`${typesDir}/*.ts`),\n    { ignore: ['**/*.d.ts'] }\n  );\n\n  const tsContent = generateTypeIndexContent(\n    dictionariesTypesDefinitions,\n    configuration\n  );\n\n  const tsFilePath = join(moduleAugmentationDir, 'intlayer.d.ts');\n  await writeFileIfChanged(tsFilePath, tsContent);\n};\n"],"mappings":";;;;;;;;;;;;;;AASA,MAAa,eAAe,QAC1B,GAAGA,wDAAqB,IAAI,CAAC;;AAG/B,MAAM,iBAAiB,YACrB,QAAQ,KAAK,WAAW,QAAQ,OAAO,OAAO,CAAC,KAAK,KAAK;;AAG3D,MAAM,4BACJ,WACA,kBACW;CACX,MAAM,EAAE,SAAS,yBAAyB;CAC1C,MAAM,EAAE,0BAA0B;CAClC,MAAM,EAAE,SAAS,iBAAiB,eAAe;CAEjD,IAAI,cAAc;CAGlB,MAAM,kBAAkB,UAAU,KAAK,oBAAoB;EACzD,cAAc,6BAAc,uBAAuB,eAAe;EAClE,4BAAa,uCAAwB,eAAe,CAAC;EACrD,MAAM,IAAIC,sCAAY,eAAe;EACtC,EAAE;AAGH,MAAK,MAAM,cAAc,gBACvB,gBAAe,UAAU,WAAW,KAAK,SAAS,WAAW,aAAa;AAE5E,gBAAe;CAGf,MAAMC,yBAAiC,gBACpC,KAAK,eAAe,QAAQ,WAAW,GAAG,YAAY,WAAW,KAAK,GAAG,CACzE,KAAK,KAAK;CAGb,MAAM,WAAW;CACjB,MAAM,oBAAoB,iBAAiB,SACvC,gBAAgB,QAAQ,sBACtB,SAAS,SAASC,kBAAgB,CACnC,GACD;CAEJ,MAAM,2BAA2B,cAAc,SAAS;CACxD,MAAM,2BAA2B,cAAc,kBAAkB;CAGjE,MAAM,YACJ,eAAe,WACX,WACA,eAAe,cACb,cACA;;;;;AAMR,gBAAe;AAEf,gBAAe,uCAAuC,uBAAuB;AAE7E,gBAAe,4CAA4C,yBAAyB;AACpF,gBAAe,4CAA4C,yBAAyB;AAEpF,gBAAe,6CAA6C,UAAU;AACtE,gBAAe;AAEf,QAAO;;;AAIT,MAAa,2BAA2B,OACtC,kBACG;CACH,MAAM,EAAE,uBAAuB,aAAa,cAAc;AAE1D,mCAAY,uBAAuB,EAAE,WAAW,MAAM,CAAC;CAOvD,MAAM,YAAY,yBAL6B,kEAC/B,GAAG,SAAS,OAAO,EACjC,EAAE,QAAQ,CAAC,YAAY,EAAE,CAC1B,EAIC,cACD;AAGD,OAAMC,kEADkB,uBAAuB,gBAAgB,EAC1B,UAAU"}

package/dist/cjs/createType/createType.cjs

@@ -1,62 +1,33 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var createType_exports = {};
-__export(createType_exports, {
-  createTypes: () => createTypes,
-  generateTypeScriptType: () => generateTypeScriptType
-});
-module.exports = __toCommonJS(createType_exports);
-var import_config = require("@intlayer/config");
-var import_promises = require("fs/promises");
-var import_path = require("path");
-var import_parallelize = require('../utils/parallelize.cjs');
-const requireUncached = (module2) => {
-  delete import_config.ESMxCJSRequire.cache[import_config.ESMxCJSRequire.resolve(module2)];
-  return (0, import_config.ESMxCJSRequire)(module2);
-};
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_utils_parallelize = require('../utils/parallelize.cjs');
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_rolldown_runtime.__toESM(node_fs_promises);
+
+//#region src/createType/createType.ts
 const generateTypeScriptType = (dictionary) => {
-  const jsonString = JSON.stringify(dictionary, null, 2);
-  return `/* eslint-disable */
-export default ${jsonString} as const;
-`;
+	return `/* eslint-disable */\nexport default ${JSON.stringify(dictionary, null, 2)} as const;\n`;
 };
-const createTypes = async (dictionariesPaths, configuration = (0, import_config.getConfiguration)()) => {
-  const { typesDir } = configuration.content;
-  await (0, import_promises.mkdir)(typesDir, { recursive: true });
-  const results = await (0, import_parallelize.parallelize)(
-    dictionariesPaths,
-    async (dictionaryPath) => {
-      const dictionary = requireUncached(dictionaryPath);
-      if (!dictionary.key) {
-        return void 0;
-      }
-      const typeDefinition = generateTypeScriptType(dictionary);
-      const outputPath = (0, import_path.resolve)(typesDir, `${dictionary.key}.ts`);
-      await (0, import_promises.writeFile)(outputPath, typeDefinition);
-      return outputPath;
-    }
-  );
-  return results.filter(Boolean);
+/**
+* This function generates a TypeScript type definition from a JSON object
+*/
+const createTypes = async (dictionariesPaths, configuration) => {
+	const { build, content } = configuration;
+	const { typesDir } = content;
+	await (0, node_fs_promises.mkdir)(typesDir, { recursive: true });
+	return (await require_utils_parallelize.parallelize(dictionariesPaths, async (dictionaryPath) => {
+		delete build.require.cache[build.require.resolve(dictionaryPath)];
+		const dictionary = build.require(dictionaryPath);
+		if (!dictionary.key) return;
+		const typeDefinition = generateTypeScriptType(dictionary);
+		const outputPath = (0, node_path.resolve)(typesDir, `${dictionary.key}.ts`);
+		await (0, node_fs_promises.writeFile)(outputPath, typeDefinition);
+		return outputPath;
+	})).filter(Boolean);
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createTypes,
-  generateTypeScriptType
-});
+
+//#endregion
+exports.createTypes = createTypes;
+exports.generateTypeScriptType = generateTypeScriptType;
 //# sourceMappingURL=createType.cjs.map

package/dist/cjs/createType/createType.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/createType/createType.ts"],"sourcesContent":["import {\n  ESMxCJSRequire,\n  getConfiguration,\n  IntlayerConfig,\n} from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/core';\nimport { mkdir, writeFile } from 'fs/promises';\nimport { resolve } from 'path';\nimport { parallelize } from '../utils/parallelize';\n\nconst requireUncached = (module: string) => {\n  delete ESMxCJSRequire.cache[ESMxCJSRequire.resolve(module)];\n  return ESMxCJSRequire(module);\n};\n\nexport const generateTypeScriptType = (dictionary: Dictionary) => {\n  const jsonString = JSON.stringify(dictionary, null, 2);\n\n  return `/* eslint-disable */\\nexport default ${jsonString} as const;\\n`;\n};\n/**\n * This function generates a TypeScript type definition from a JSON object\n */\nexport const createTypes = async (\n  dictionariesPaths: string[],\n  configuration: IntlayerConfig = getConfiguration()\n): Promise<string[]> => {\n  const { typesDir } = configuration.content;\n\n  // Create type folders if they don't exist\n  await mkdir(typesDir, { recursive: true });\n\n  const results = await parallelize(\n    dictionariesPaths,\n    async (dictionaryPath): Promise<string | undefined> => {\n      const dictionary: Dictionary = requireUncached(dictionaryPath);\n\n      if (!dictionary.key) {\n        return undefined;\n      }\n\n      const typeDefinition: string = generateTypeScriptType(dictionary);\n\n      const outputPath: string = resolve(typesDir, `${dictionary.key}.ts`);\n\n      await writeFile(outputPath, typeDefinition);\n\n      return outputPath;\n    }\n  );\n\n  return results.filter(Boolean) as string[];\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAIO;AAEP,sBAAiC;AACjC,kBAAwB;AACxB,yBAA4B;AAE5B,MAAM,kBAAkB,CAACA,YAAmB;AAC1C,SAAO,6BAAe,MAAM,6BAAe,QAAQA,OAAM,CAAC;AAC1D,aAAO,8BAAeA,OAAM;AAC9B;AAEO,MAAM,yBAAyB,CAAC,eAA2B;AAChE,QAAM,aAAa,KAAK,UAAU,YAAY,MAAM,CAAC;AAErD,SAAO;AAAA,iBAAwC,UAAU;AAAA;AAC3D;AAIO,MAAM,cAAc,OACzB,mBACA,oBAAgC,gCAAiB,MAC3B;AACtB,QAAM,EAAE,SAAS,IAAI,cAAc;AAGnC,YAAM,uBAAM,UAAU,EAAE,WAAW,KAAK,CAAC;AAEzC,QAAM,UAAU,UAAM;AAAA,IACpB;AAAA,IACA,OAAO,mBAAgD;AACrD,YAAM,aAAyB,gBAAgB,cAAc;AAE7D,UAAI,CAAC,WAAW,KAAK;AACnB,eAAO;AAAA,MACT;AAEA,YAAM,iBAAyB,uBAAuB,UAAU;AAEhE,YAAM,iBAAqB,qBAAQ,UAAU,GAAG,WAAW,GAAG,KAAK;AAEnE,gBAAM,2BAAU,YAAY,cAAc;AAE1C,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO,QAAQ,OAAO,OAAO;AAC/B;","names":["module"]}
+{"version":3,"file":"createType.cjs","names":["parallelize","dictionary: Dictionary","typeDefinition: string","outputPath: string"],"sources":["../../../src/createType/createType.ts"],"sourcesContent":["import { mkdir, writeFile } from 'node:fs/promises';\nimport { resolve } from 'node:path';\nimport type { Dictionary, IntlayerConfig } from '@intlayer/types';\nimport { parallelize } from '../utils/parallelize';\n\nexport const generateTypeScriptType = (dictionary: Dictionary) => {\n  const jsonString = JSON.stringify(dictionary, null, 2);\n\n  return `/* eslint-disable */\\nexport default ${jsonString} as const;\\n`;\n};\n/**\n * This function generates a TypeScript type definition from a JSON object\n */\nexport const createTypes = async (\n  dictionariesPaths: string[],\n  configuration: IntlayerConfig\n): Promise<string[]> => {\n  const { build, content } = configuration;\n  const { typesDir } = content;\n\n  // Create type folders if they don't exist\n  await mkdir(typesDir, { recursive: true });\n\n  const results = await parallelize(\n    dictionariesPaths,\n    async (dictionaryPath): Promise<string | undefined> => {\n      delete build.require.cache[build.require.resolve(dictionaryPath)];\n      const dictionary: Dictionary = build.require(dictionaryPath);\n\n      if (!dictionary.key) {\n        return undefined;\n      }\n\n      const typeDefinition: string = generateTypeScriptType(dictionary);\n\n      const outputPath: string = resolve(typesDir, `${dictionary.key}.ts`);\n\n      await writeFile(outputPath, typeDefinition);\n\n      return outputPath;\n    }\n  );\n\n  return results.filter(Boolean) as string[];\n};\n"],"mappings":";;;;;;;;AAKA,MAAa,0BAA0B,eAA2B;AAGhE,QAAO,wCAFY,KAAK,UAAU,YAAY,MAAM,EAAE,CAEI;;;;;AAK5D,MAAa,cAAc,OACzB,mBACA,kBACsB;CACtB,MAAM,EAAE,OAAO,YAAY;CAC3B,MAAM,EAAE,aAAa;AAGrB,mCAAY,UAAU,EAAE,WAAW,MAAM,CAAC;AAsB1C,SApBgB,MAAMA,sCACpB,mBACA,OAAO,mBAAgD;AACrD,SAAO,MAAM,QAAQ,MAAM,MAAM,QAAQ,QAAQ,eAAe;EAChE,MAAMC,aAAyB,MAAM,QAAQ,eAAe;AAE5D,MAAI,CAAC,WAAW,IACd;EAGF,MAAMC,iBAAyB,uBAAuB,WAAW;EAEjE,MAAMC,oCAA6B,UAAU,GAAG,WAAW,IAAI,KAAK;AAEpE,wCAAgB,YAAY,eAAe;AAE3C,SAAO;GAEV,EAEc,OAAO,QAAQ"}

package/dist/cjs/createType/index.cjs

@@ -1,25 +1,7 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var createType_exports = {};
-module.exports = __toCommonJS(createType_exports);
-__reExport(createType_exports, require('./createModuleAugmentation.cjs'), module.exports);
-__reExport(createType_exports, require('./createType.cjs'), module.exports);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ...require('./createModuleAugmentation.cjs'),
-  ...require('./createType.cjs')
-});
-//# sourceMappingURL=index.cjs.map
+const require_createType_createModuleAugmentation = require('./createModuleAugmentation.cjs');
+const require_createType_createType = require('./createType.cjs');
+
+exports.createModuleAugmentation = require_createType_createModuleAugmentation.createModuleAugmentation;
+exports.createTypes = require_createType_createType.createTypes;
+exports.generateTypeScriptType = require_createType_createType.generateTypeScriptType;
+exports.getTypeName = require_createType_createModuleAugmentation.getTypeName;

package/dist/cjs/fetchDistantDictionaries.cjs

@@ -1,80 +1,52 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var fetchDistantDictionaries_exports = {};
-__export(fetchDistantDictionaries_exports, {
-  fetchDistantDictionaries: () => fetchDistantDictionaries
-});
-module.exports = __toCommonJS(fetchDistantDictionaries_exports);
-var import_api = require("@intlayer/api");
-var import_config = require("@intlayer/config");
-var import_parallelize = require('./utils/parallelize.cjs');
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_utils_parallelize = require('./utils/parallelize.cjs');
+let __intlayer_config = require("@intlayer/config");
+__intlayer_config = require_rolldown_runtime.__toESM(__intlayer_config);
+let __intlayer_api = require("@intlayer/api");
+__intlayer_api = require_rolldown_runtime.__toESM(__intlayer_api);
+
+//#region src/fetchDistantDictionaries.ts
+/**
+* Fetch distant dictionaries and update the logger with their statuses.
+*/
 const fetchDistantDictionaries = async (options, onStatusUpdate) => {
-  const config = (0, import_config.getConfiguration)();
-  const appLogger = (0, import_config.getAppLogger)(config);
-  try {
-    const intlayerAPI = (0, import_api.getIntlayerAPIProxy)(void 0, config);
-    const distantDictionariesKeys = options.dictionaryKeys;
-    const processDictionary = async (dictionaryKey) => {
-      onStatusUpdate?.([
-        {
-          dictionaryKey,
-          type: "remote",
-          status: "fetching"
-        }
-      ]);
-      try {
-        const getDictionaryResult = await intlayerAPI.dictionary.getDictionary(dictionaryKey);
-        const distantDictionary = getDictionaryResult.data;
-        if (!distantDictionary) {
-          throw new Error(`Dictionary ${dictionaryKey} not found on remote`);
-        }
-        onStatusUpdate?.([
-          { dictionaryKey, type: "remote", status: "fetched" }
-        ]);
-        return distantDictionary;
-      } catch (error) {
-        onStatusUpdate?.([
-          {
-            dictionaryKey,
-            type: "remote",
-            status: "error",
-            error: `Error fetching dictionary ${dictionaryKey}: ${error}`
-          }
-        ]);
-        return void 0;
-      }
-    };
-    const result = await (0, import_parallelize.parallelize)(
-      distantDictionariesKeys,
-      async (dictionaryKey) => await processDictionary(dictionaryKey)
-    );
-    const filteredResult = result.filter(
-      (dict) => dict !== void 0
-    );
-    return filteredResult;
-  } catch (error) {
-    appLogger(`${import_config.x} Failed to fetch distant dictionaries`, { level: "error" });
-    return [];
-  }
+	const config = (0, __intlayer_config.getConfiguration)();
+	const appLogger = (0, __intlayer_config.getAppLogger)(config);
+	try {
+		const intlayerAPI = (0, __intlayer_api.getIntlayerAPIProxy)(void 0, config);
+		const distantDictionariesKeys = options.dictionaryKeys;
+		const processDictionary = async (dictionaryKey) => {
+			onStatusUpdate?.([{
+				dictionaryKey,
+				type: "remote",
+				status: "fetching"
+			}]);
+			try {
+				const distantDictionary = (await intlayerAPI.dictionary.getDictionary(dictionaryKey)).data;
+				if (!distantDictionary) throw new Error(`Dictionary ${dictionaryKey} not found on remote`);
+				onStatusUpdate?.([{
+					dictionaryKey,
+					type: "remote",
+					status: "fetched"
+				}]);
+				return distantDictionary;
+			} catch (error) {
+				onStatusUpdate?.([{
+					dictionaryKey,
+					type: "remote",
+					status: "error",
+					error: `Error fetching dictionary ${dictionaryKey}: ${error}`
+				}]);
+				return;
+			}
+		};
+		return (await require_utils_parallelize.parallelize(distantDictionariesKeys, async (dictionaryKey) => await processDictionary(dictionaryKey))).filter((dict) => dict !== void 0);
+	} catch (_error) {
+		appLogger(`${__intlayer_config.x} Failed to fetch distant dictionaries`, { level: "error" });
+		return [];
+	}
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  fetchDistantDictionaries
-});
+
+//#endregion
+exports.fetchDistantDictionaries = fetchDistantDictionaries;
 //# sourceMappingURL=fetchDistantDictionaries.cjs.map

package/dist/cjs/fetchDistantDictionaries.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/fetchDistantDictionaries.ts"],"sourcesContent":["import { getIntlayerAPIProxy } from '@intlayer/api';\n// @ts-ignore @intlayer/backend is not build yet\nimport type { DictionaryAPI } from '@intlayer/backend';\nimport { getAppLogger, getConfiguration, x } from '@intlayer/config';\nimport { DictionariesStatus } from './loadDictionaries';\nimport { parallelize } from './utils/parallelize';\n\ntype FetchDistantDictionariesOptions = {\n  dictionaryKeys: string[];\n  newDictionariesPath?: string;\n  logPrefix?: string;\n};\n\n/**\n * Fetch distant dictionaries and update the logger with their statuses.\n */\nexport const fetchDistantDictionaries = async (\n  options: FetchDistantDictionariesOptions,\n  onStatusUpdate?: (status: DictionariesStatus[]) => void\n): Promise<DictionaryAPI[]> => {\n  const config = getConfiguration();\n  const appLogger = getAppLogger(config);\n  try {\n    const intlayerAPI = getIntlayerAPIProxy(undefined, config);\n\n    const distantDictionariesKeys = options.dictionaryKeys;\n    // Process dictionaries in parallel with a concurrency limit\n    const processDictionary = async (\n      dictionaryKey: string\n    ): Promise<DictionaryAPI | undefined> => {\n      onStatusUpdate?.([\n        {\n          dictionaryKey,\n          type: 'remote',\n          status: 'fetching',\n        },\n      ]);\n\n      try {\n        // Fetch the dictionary\n        const getDictionaryResult =\n          await intlayerAPI.dictionary.getDictionary(dictionaryKey);\n\n        const distantDictionary = getDictionaryResult.data;\n\n        if (!distantDictionary) {\n          throw new Error(`Dictionary ${dictionaryKey} not found on remote`);\n        }\n\n        onStatusUpdate?.([\n          { dictionaryKey, type: 'remote', status: 'fetched' },\n        ]);\n\n        return distantDictionary;\n      } catch (error) {\n        onStatusUpdate?.([\n          {\n            dictionaryKey,\n            type: 'remote',\n            status: 'error',\n            error: `Error fetching dictionary ${dictionaryKey}: ${error}`,\n          },\n        ]);\n        return undefined;\n      }\n    };\n\n    const result = await parallelize(\n      distantDictionariesKeys,\n      async (dictionaryKey) => await processDictionary(dictionaryKey)\n    );\n\n    // Remove undefined values\n    const filteredResult = result.filter(\n      (dict: DictionaryAPI | undefined): dict is DictionaryAPI =>\n        dict !== undefined\n    );\n\n    return filteredResult;\n  } catch (error) {\n    appLogger(`${x} Failed to fetch distant dictionaries`, { level: 'error' });\n    return [];\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAAoC;AAGpC,oBAAkD;AAElD,yBAA4B;AAWrB,MAAM,2BAA2B,OACtC,SACA,mBAC6B;AAC7B,QAAM,aAAS,gCAAiB;AAChC,QAAM,gBAAY,4BAAa,MAAM;AACrC,MAAI;AACF,UAAM,kBAAc,gCAAoB,QAAW,MAAM;AAEzD,UAAM,0BAA0B,QAAQ;AAExC,UAAM,oBAAoB,OACxB,kBACuC;AACvC,uBAAiB;AAAA,QACf;AAAA,UACE;AAAA,UACA,MAAM;AAAA,UACN,QAAQ;AAAA,QACV;AAAA,MACF,CAAC;AAED,UAAI;AAEF,cAAM,sBACJ,MAAM,YAAY,WAAW,cAAc,aAAa;AAE1D,cAAM,oBAAoB,oBAAoB;AAE9C,YAAI,CAAC,mBAAmB;AACtB,gBAAM,IAAI,MAAM,cAAc,aAAa,sBAAsB;AAAA,QACnE;AAEA,yBAAiB;AAAA,UACf,EAAE,eAAe,MAAM,UAAU,QAAQ,UAAU;AAAA,QACrD,CAAC;AAED,eAAO;AAAA,MACT,SAAS,OAAO;AACd,yBAAiB;AAAA,UACf;AAAA,YACE;AAAA,YACA,MAAM;AAAA,YACN,QAAQ;AAAA,YACR,OAAO,6BAA6B,aAAa,KAAK,KAAK;AAAA,UAC7D;AAAA,QACF,CAAC;AACD,eAAO;AAAA,MACT;AAAA,IACF;AAEA,UAAM,SAAS,UAAM;AAAA,MACnB;AAAA,MACA,OAAO,kBAAkB,MAAM,kBAAkB,aAAa;AAAA,IAChE;AAGA,UAAM,iBAAiB,OAAO;AAAA,MAC5B,CAAC,SACC,SAAS;AAAA,IACb;AAEA,WAAO;AAAA,EACT,SAAS,OAAO;AACd,cAAU,GAAG,eAAC,yCAAyC,EAAE,OAAO,QAAQ,CAAC;AACzE,WAAO,CAAC;AAAA,EACV;AACF;","names":[]}
+{"version":3,"file":"fetchDistantDictionaries.cjs","names":["parallelize","x"],"sources":["../../src/fetchDistantDictionaries.ts"],"sourcesContent":["import { getIntlayerAPIProxy } from '@intlayer/api';\n// @ts-ignore @intlayer/backend is not build yet\nimport type { DictionaryAPI } from '@intlayer/backend';\nimport { getAppLogger, getConfiguration, x } from '@intlayer/config';\nimport type { DictionariesStatus } from './loadDictionaries';\nimport { parallelize } from './utils/parallelize';\n\ntype FetchDistantDictionariesOptions = {\n  dictionaryKeys: string[];\n  newDictionariesPath?: string;\n  logPrefix?: string;\n};\n\n/**\n * Fetch distant dictionaries and update the logger with their statuses.\n */\nexport const fetchDistantDictionaries = async (\n  options: FetchDistantDictionariesOptions,\n  onStatusUpdate?: (status: DictionariesStatus[]) => void\n): Promise<DictionaryAPI[]> => {\n  const config = getConfiguration();\n  const appLogger = getAppLogger(config);\n  try {\n    const intlayerAPI = getIntlayerAPIProxy(undefined, config);\n\n    const distantDictionariesKeys = options.dictionaryKeys;\n    // Process dictionaries in parallel with a concurrency limit\n    const processDictionary = async (\n      dictionaryKey: string\n    ): Promise<DictionaryAPI | undefined> => {\n      onStatusUpdate?.([\n        {\n          dictionaryKey,\n          type: 'remote',\n          status: 'fetching',\n        },\n      ]);\n\n      try {\n        // Fetch the dictionary\n        const getDictionaryResult =\n          await intlayerAPI.dictionary.getDictionary(dictionaryKey);\n\n        const distantDictionary = getDictionaryResult.data;\n\n        if (!distantDictionary) {\n          throw new Error(`Dictionary ${dictionaryKey} not found on remote`);\n        }\n\n        onStatusUpdate?.([\n          { dictionaryKey, type: 'remote', status: 'fetched' },\n        ]);\n\n        return distantDictionary;\n      } catch (error) {\n        onStatusUpdate?.([\n          {\n            dictionaryKey,\n            type: 'remote',\n            status: 'error',\n            error: `Error fetching dictionary ${dictionaryKey}: ${error}`,\n          },\n        ]);\n        return undefined;\n      }\n    };\n\n    const result = await parallelize(\n      distantDictionariesKeys,\n      async (dictionaryKey) => await processDictionary(dictionaryKey)\n    );\n\n    // Remove undefined values\n    const filteredResult = result.filter(\n      (dict: DictionaryAPI | undefined): dict is DictionaryAPI =>\n        dict !== undefined\n    );\n\n    return filteredResult;\n  } catch (_error) {\n    appLogger(`${x} Failed to fetch distant dictionaries`, { level: 'error' });\n    return [];\n  }\n};\n"],"mappings":";;;;;;;;;;;AAgBA,MAAa,2BAA2B,OACtC,SACA,mBAC6B;CAC7B,MAAM,kDAA2B;CACjC,MAAM,gDAAyB,OAAO;AACtC,KAAI;EACF,MAAM,sDAAkC,QAAW,OAAO;EAE1D,MAAM,0BAA0B,QAAQ;EAExC,MAAM,oBAAoB,OACxB,kBACuC;AACvC,oBAAiB,CACf;IACE;IACA,MAAM;IACN,QAAQ;IACT,CACF,CAAC;AAEF,OAAI;IAKF,MAAM,qBAFJ,MAAM,YAAY,WAAW,cAAc,cAAc,EAEb;AAE9C,QAAI,CAAC,kBACH,OAAM,IAAI,MAAM,cAAc,cAAc,sBAAsB;AAGpE,qBAAiB,CACf;KAAE;KAAe,MAAM;KAAU,QAAQ;KAAW,CACrD,CAAC;AAEF,WAAO;YACA,OAAO;AACd,qBAAiB,CACf;KACE;KACA,MAAM;KACN,QAAQ;KACR,OAAO,6BAA6B,cAAc,IAAI;KACvD,CACF,CAAC;AACF;;;AAeJ,UAXe,MAAMA,sCACnB,yBACA,OAAO,kBAAkB,MAAM,kBAAkB,cAAc,CAChE,EAG6B,QAC3B,SACC,SAAS,OACZ;UAGM,QAAQ;AACf,YAAU,GAAGC,oBAAE,wCAAwC,EAAE,OAAO,SAAS,CAAC;AAC1E,SAAO,EAAE"}

package/dist/cjs/filterInvalidDictionaries.cjs

@@ -1,62 +1,29 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var filterInvalidDictionaries_exports = {};
-__export(filterInvalidDictionaries_exports, {
-  filterInvalidDictionaries: () => filterInvalidDictionaries,
-  isInvalidDictionary: () => isInvalidDictionary
-});
-module.exports = __toCommonJS(filterInvalidDictionaries_exports);
-var import_client = require("@intlayer/config/client");
-var import_formatter = require('./utils/formatter.cjs');
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_utils_formatter = require('./utils/formatter.cjs');
+let __intlayer_config_client = require("@intlayer/config/client");
+__intlayer_config_client = require_rolldown_runtime.__toESM(__intlayer_config_client);
+
+//#region src/filterInvalidDictionaries.ts
 const isInvalidDictionary = (dictionary, configuration) => {
-  const appLogger = (0, import_client.getAppLogger)(configuration);
-  if (!dictionary) return false;
-  const isLocal = Boolean(dictionary.location === "locale");
-  const location = isLocal ? "Local" : "Remote";
-  const hasKey = Boolean(dictionary.key);
-  const hasContent = Boolean(dictionary.content);
-  if (!hasKey) {
-    appLogger(`${location} dictionary has no key`, {
-      level: "error"
-    });
-    appLogger(JSON.stringify(dictionary, null, 2), {
-      level: "error"
-    });
-    return false;
-  }
-  if (!hasContent) {
-    appLogger(
-      `${location} dictionary ${(0, import_client.colorizeKey)(dictionary.key)} has no content - ${dictionary.filePath ? (0, import_formatter.formatPath)(dictionary.filePath) : (0, import_client.colorizePath)("Remote")}`,
-      {
-        level: "error"
-      }
-    );
-    return false;
-  }
-  return true;
+	const appLogger = (0, __intlayer_config_client.getAppLogger)(configuration);
+	if (!dictionary) return false;
+	const location = Boolean(dictionary.location === "local") ? "Local" : "Remote";
+	const hasKey = Boolean(dictionary.key);
+	const hasContent = Boolean(dictionary.content);
+	if (!hasKey) {
+		appLogger(`${location} dictionary has no key`, { level: "error" });
+		appLogger(JSON.stringify(dictionary, null, 2), { level: "error" });
+		return false;
+	}
+	if (!hasContent) {
+		appLogger(`${location} dictionary ${(0, __intlayer_config_client.colorizeKey)(dictionary.key)} has no content - ${dictionary.filePath ? require_utils_formatter.formatPath(dictionary.filePath) : (0, __intlayer_config_client.colorizePath)("Remote")}`, { level: "error" });
+		return false;
+	}
+	return true;
 };
-const filterInvalidDictionaries = (dictionaries, configuration) => (dictionaries ?? [])?.filter(
-  (dictionary) => isInvalidDictionary(dictionary, configuration)
-);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  filterInvalidDictionaries,
-  isInvalidDictionary
-});
+const filterInvalidDictionaries = (dictionaries, configuration) => (dictionaries ?? [])?.filter((dictionary) => isInvalidDictionary(dictionary, configuration));
+
+//#endregion
+exports.filterInvalidDictionaries = filterInvalidDictionaries;
+exports.isInvalidDictionary = isInvalidDictionary;
 //# sourceMappingURL=filterInvalidDictionaries.cjs.map

package/dist/cjs/filterInvalidDictionaries.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/filterInvalidDictionaries.ts"],"sourcesContent":["import { type IntlayerConfig } from '@intlayer/config';\nimport {\n  colorizeKey,\n  colorizePath,\n  getAppLogger,\n} from '@intlayer/config/client';\nimport type { Dictionary } from '@intlayer/core';\nimport { formatPath } from './utils/formatter';\n\nexport const isInvalidDictionary = (\n  dictionary: Dictionary | undefined,\n  configuration?: IntlayerConfig\n): boolean => {\n  const appLogger = getAppLogger(configuration);\n\n  if (!dictionary) return false;\n\n  const isLocal = Boolean(dictionary.location === 'locale');\n  const location = isLocal ? 'Local' : 'Remote';\n  const hasKey = Boolean(dictionary.key);\n  const hasContent = Boolean(dictionary.content);\n\n  if (!hasKey) {\n    appLogger(`${location} dictionary has no key`, {\n      level: 'error',\n    });\n    appLogger(JSON.stringify(dictionary, null, 2), {\n      level: 'error',\n    });\n    return false;\n  }\n\n  if (!hasContent) {\n    appLogger(\n      `${location} dictionary ${colorizeKey(dictionary.key)} has no content - ${dictionary.filePath ? formatPath(dictionary.filePath) : colorizePath('Remote')}`,\n      {\n        level: 'error',\n      }\n    );\n    return false;\n  }\n\n  return true;\n};\n\nexport const filterInvalidDictionaries = (\n  dictionaries: (Dictionary | undefined)[] | undefined,\n  configuration?: IntlayerConfig\n): Dictionary[] =>\n  (dictionaries ?? [])?.filter((dictionary) =>\n    isInvalidDictionary(dictionary, configuration)\n  ) as Dictionary[];\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,oBAIO;AAEP,uBAA2B;AAEpB,MAAM,sBAAsB,CACjC,YACA,kBACY;AACZ,QAAM,gBAAY,4BAAa,aAAa;AAE5C,MAAI,CAAC,WAAY,QAAO;AAExB,QAAM,UAAU,QAAQ,WAAW,aAAa,QAAQ;AACxD,QAAM,WAAW,UAAU,UAAU;AACrC,QAAM,SAAS,QAAQ,WAAW,GAAG;AACrC,QAAM,aAAa,QAAQ,WAAW,OAAO;AAE7C,MAAI,CAAC,QAAQ;AACX,cAAU,GAAG,QAAQ,0BAA0B;AAAA,MAC7C,OAAO;AAAA,IACT,CAAC;AACD,cAAU,KAAK,UAAU,YAAY,MAAM,CAAC,GAAG;AAAA,MAC7C,OAAO;AAAA,IACT,CAAC;AACD,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,YAAY;AACf;AAAA,MACE,GAAG,QAAQ,mBAAe,2BAAY,WAAW,GAAG,CAAC,qBAAqB,WAAW,eAAW,6BAAW,WAAW,QAAQ,QAAI,4BAAa,QAAQ,CAAC;AAAA,MACxJ;AAAA,QACE,OAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAEO,MAAM,4BAA4B,CACvC,cACA,mBAEC,gBAAgB,CAAC,IAAI;AAAA,EAAO,CAAC,eAC5B,oBAAoB,YAAY,aAAa;AAC/C;","names":[]}
+{"version":3,"file":"filterInvalidDictionaries.cjs","names":["formatPath"],"sources":["../../src/filterInvalidDictionaries.ts"],"sourcesContent":["import {\n  colorizeKey,\n  colorizePath,\n  getAppLogger,\n} from '@intlayer/config/client';\nimport type { Dictionary, IntlayerConfig } from '@intlayer/types';\nimport { formatPath } from './utils/formatter';\n\nexport const isInvalidDictionary = (\n  dictionary: Dictionary | undefined,\n  configuration?: IntlayerConfig\n): boolean => {\n  const appLogger = getAppLogger(configuration);\n\n  if (!dictionary) return false;\n\n  const isLocal = Boolean(dictionary.location === 'local');\n  const location = isLocal ? 'Local' : 'Remote';\n  const hasKey = Boolean(dictionary.key);\n  const hasContent = Boolean(dictionary.content);\n\n  if (!hasKey) {\n    appLogger(`${location} dictionary has no key`, {\n      level: 'error',\n    });\n    appLogger(JSON.stringify(dictionary, null, 2), {\n      level: 'error',\n    });\n    return false;\n  }\n\n  if (!hasContent) {\n    appLogger(\n      `${location} dictionary ${colorizeKey(dictionary.key)} has no content - ${dictionary.filePath ? formatPath(dictionary.filePath) : colorizePath('Remote')}`,\n      {\n        level: 'error',\n      }\n    );\n    return false;\n  }\n\n  return true;\n};\n\nexport const filterInvalidDictionaries = (\n  dictionaries: (Dictionary | undefined)[] | undefined,\n  configuration: IntlayerConfig\n): Dictionary[] =>\n  (dictionaries ?? [])?.filter((dictionary) =>\n    isInvalidDictionary(dictionary, configuration)\n  ) as Dictionary[];\n"],"mappings":";;;;;;AAQA,MAAa,uBACX,YACA,kBACY;CACZ,MAAM,uDAAyB,cAAc;AAE7C,KAAI,CAAC,WAAY,QAAO;CAGxB,MAAM,WADU,QAAQ,WAAW,aAAa,QAAQ,GAC7B,UAAU;CACrC,MAAM,SAAS,QAAQ,WAAW,IAAI;CACtC,MAAM,aAAa,QAAQ,WAAW,QAAQ;AAE9C,KAAI,CAAC,QAAQ;AACX,YAAU,GAAG,SAAS,yBAAyB,EAC7C,OAAO,SACR,CAAC;AACF,YAAU,KAAK,UAAU,YAAY,MAAM,EAAE,EAAE,EAC7C,OAAO,SACR,CAAC;AACF,SAAO;;AAGT,KAAI,CAAC,YAAY;AACf,YACE,GAAG,SAAS,wDAA0B,WAAW,IAAI,CAAC,oBAAoB,WAAW,WAAWA,mCAAW,WAAW,SAAS,8CAAgB,SAAS,IACxJ,EACE,OAAO,SACR,CACF;AACD,SAAO;;AAGT,QAAO;;AAGT,MAAa,6BACX,cACA,mBAEC,gBAAgB,EAAE,GAAG,QAAQ,eAC5B,oBAAoB,YAAY,cAAc,CAC/C"}