@intlayer/chokidar 5.8.1-canary.0 → 6.0.0-canary.0

package/dist/cjs/loadDictionaries/index.cjs

@@ -15,15 +15,15 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var loadDictionaries_exports = {};
 module.exports = __toCommonJS(loadDictionaries_exports);
+__reExport(loadDictionaries_exports, require('./loadContentDeclaration.cjs'), module.exports);
 __reExport(loadDictionaries_exports, require('./loadDictionaries.cjs'), module.exports);
-__reExport(loadDictionaries_exports, require('./loadDistantDictionaries.cjs'), module.exports);
 __reExport(loadDictionaries_exports, require('./loadLocalDictionaries.cjs'), module.exports);
-__reExport(loadDictionaries_exports, require('./loadContentDeclaration.cjs'), module.exports);
+__reExport(loadDictionaries_exports, require('./loadRemoteDictionaries.cjs'), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ...require('./loadContentDeclaration.cjs'),
   ...require('./loadDictionaries.cjs'),
-  ...require('./loadDistantDictionaries.cjs'),
   ...require('./loadLocalDictionaries.cjs'),
-  ...require('./loadContentDeclaration.cjs')
+  ...require('./loadRemoteDictionaries.cjs')
 });
 //# sourceMappingURL=index.cjs.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/loadDictionaries/index.ts"],"sourcesContent":["export * from './loadDictionaries';\nexport * from './loadDistantDictionaries';\nexport * from './loadLocalDictionaries';\nexport * from './loadContentDeclaration';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,qCAAc,+BAAd;AACA,qCAAc,sCADd;AAEA,qCAAc,oCAFd;AAGA,qCAAc,qCAHd;","names":[]}
+{"version":3,"sources":["../../../src/loadDictionaries/index.ts"],"sourcesContent":["export * from './loadContentDeclaration';\nexport * from './loadDictionaries';\nexport * from './loadLocalDictionaries';\nexport * from './loadRemoteDictionaries';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,qCAAc,qCAAd;AACA,qCAAc,+BADd;AAEA,qCAAc,oCAFd;AAGA,qCAAc,qCAHd;","names":[]}

package/dist/cjs/loadDictionaries/loadContentDeclaration.cjs

@@ -18,33 +18,73 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var loadContentDeclaration_exports = {};
 __export(loadContentDeclaration_exports, {
+  formatLocalDictionaries: () => formatLocalDictionaries,
   loadContentDeclarations: () => loadContentDeclarations
 });
 module.exports = __toCommonJS(loadContentDeclaration_exports);
 var import_config = require("@intlayer/config");
+var import_path = require("path");
+var import_filterInvalidDictionaries = require('../filterInvalidDictionaries.cjs');
 var import_processContentDeclaration = require('../transpiler/declaration_file_to_dictionary/intlayer_dictionary/processContentDeclaration.cjs');
-const loadContentDeclarations = async (contentDeclarationFilePath, projectRequire = import_config.ESMxCJSRequire) => {
-  const contentDeclarations = contentDeclarationFilePath.map((path) => ({
-    ...(0, import_config.loadExternalFile)(path, void 0, projectRequire),
-    filePath: path
+var import_parallelize = require('../utils/parallelize.cjs');
+const formatLocalDictionaries = (dictionariesRecord) => Object.entries(dictionariesRecord).map(([relativePath, dict]) => ({
+  ...dict,
+  localId: `${dict.key}::local::${relativePath}`,
+  location: "locale",
+  filePath: relativePath
+}));
+const loadContentDeclarations = async (contentDeclarationFilePath, configuration = (0, import_config.getConfiguration)(), projectRequire = import_config.ESMxCJSRequire, onStatusUpdate) => {
+  const dictionariesRecord = contentDeclarationFilePath.reduce(
+    (acc, path) => {
+      const relativePath = (0, import_path.relative)(configuration.content.baseDir, path);
+      return {
+        ...acc,
+        [relativePath]: (0, import_config.loadExternalFile)(path, void 0, projectRequire)
+      };
+    },
+    {}
+  );
+  const contentDeclarations = formatLocalDictionaries(dictionariesRecord);
+  const listFoundDictionaries = contentDeclarations.map((declaration) => ({
+    dictionaryKey: declaration.key,
+    type: "local",
+    status: "found"
   }));
-  const resultDictionariesPaths = [];
-  for await (const contentDeclaration of contentDeclarations) {
-    if (!contentDeclaration) {
-      continue;
+  onStatusUpdate?.(listFoundDictionaries);
+  const processedDictionaries = await (0, import_parallelize.parallelize)(
+    contentDeclarations,
+    async (contentDeclaration) => {
+      if (!contentDeclaration) {
+        return void 0;
+      }
+      onStatusUpdate?.([
+        {
+          dictionaryKey: contentDeclaration.key,
+          type: "local",
+          status: "building"
+        }
+      ]);
+      const processedContentDeclaration = await (0, import_processContentDeclaration.processContentDeclaration)(
+        contentDeclaration
+      );
+      if (!processedContentDeclaration) {
+        return void 0;
+      }
+      onStatusUpdate?.([
+        {
+          dictionaryKey: processedContentDeclaration.key,
+          type: "local",
+          status: "built"
+        }
+      ]);
+      return processedContentDeclaration;
     }
-    const processedContentDeclaration = await (0, import_processContentDeclaration.processContentDeclaration)(
-      contentDeclaration
-    );
-    if (!processedContentDeclaration) {
-      continue;
-    }
-    resultDictionariesPaths.push(processedContentDeclaration);
-  }
-  return resultDictionariesPaths;
+  );
+  return (0, import_filterInvalidDictionaries.filterInvalidDictionaries)(processedDictionaries);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  formatLocalDictionaries,
   loadContentDeclarations
 });
 //# sourceMappingURL=loadContentDeclaration.cjs.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/loadDictionaries/loadContentDeclaration.ts"],"sourcesContent":["import { ESMxCJSRequire, loadExternalFile } from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/core';\nimport { processContentDeclaration } from '../transpiler/declaration_file_to_dictionary/intlayer_dictionary/processContentDeclaration';\n\nexport const loadContentDeclarations = async (\n  contentDeclarationFilePath: string[],\n  projectRequire = ESMxCJSRequire\n): Promise<Dictionary[]> => {\n  const contentDeclarations = contentDeclarationFilePath.map((path) => ({\n    ...loadExternalFile(path, undefined, projectRequire),\n    filePath: path,\n  }));\n  const resultDictionariesPaths: Dictionary[] = [];\n\n  for await (const contentDeclaration of contentDeclarations) {\n    if (!contentDeclaration) {\n      continue;\n    }\n\n    const processedContentDeclaration = await processContentDeclaration(\n      contentDeclaration as Dictionary\n    );\n\n    if (!processedContentDeclaration) {\n      continue;\n    }\n\n    resultDictionariesPaths.push(processedContentDeclaration);\n  }\n\n  return resultDictionariesPaths;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAiD;AAEjD,uCAA0C;AAEnC,MAAM,0BAA0B,OACrC,4BACA,iBAAiB,iCACS;AAC1B,QAAM,sBAAsB,2BAA2B,IAAI,CAAC,UAAU;AAAA,IACpE,OAAG,gCAAiB,MAAM,QAAW,cAAc;AAAA,IACnD,UAAU;AAAA,EACZ,EAAE;AACF,QAAM,0BAAwC,CAAC;AAE/C,mBAAiB,sBAAsB,qBAAqB;AAC1D,QAAI,CAAC,oBAAoB;AACvB;AAAA,IACF;AAEA,UAAM,8BAA8B,UAAM;AAAA,MACxC;AAAA,IACF;AAEA,QAAI,CAAC,6BAA6B;AAChC;AAAA,IACF;AAEA,4BAAwB,KAAK,2BAA2B;AAAA,EAC1D;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../../src/loadDictionaries/loadContentDeclaration.ts"],"sourcesContent":["import {\n  ESMxCJSRequire,\n  getConfiguration,\n  IntlayerConfig,\n  loadExternalFile,\n} from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/core';\nimport { relative } from 'path';\nimport { filterInvalidDictionaries } from '../filterInvalidDictionaries';\nimport { processContentDeclaration } from '../transpiler/declaration_file_to_dictionary/intlayer_dictionary/processContentDeclaration';\nimport { parallelize } from '../utils/parallelize';\nimport { DictionariesStatus } from './loadDictionaries';\n\nexport const formatLocalDictionaries = (\n  dictionariesRecord: Record<string, Dictionary>\n): Dictionary[] =>\n  Object.entries(dictionariesRecord).map(([relativePath, dict]) => ({\n    ...dict,\n    localId: `${dict.key}::local::${relativePath}`,\n    location: 'locale' as const,\n    filePath: relativePath,\n  }));\n\nexport const loadContentDeclarations = async (\n  contentDeclarationFilePath: string[],\n  configuration: IntlayerConfig = getConfiguration(),\n  projectRequire = ESMxCJSRequire,\n  onStatusUpdate?: (status: DictionariesStatus[]) => void\n): Promise<Dictionary[]> => {\n  const dictionariesRecord = contentDeclarationFilePath.reduce(\n    (acc, path) => {\n      const relativePath = relative(configuration.content.baseDir, path);\n      return {\n        ...acc,\n        [relativePath]: loadExternalFile(path, undefined, projectRequire),\n      };\n    },\n    {} as Record<string, Dictionary>\n  );\n  const contentDeclarations: Dictionary[] =\n    formatLocalDictionaries(dictionariesRecord);\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      );\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);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAKO;AAEP,kBAAyB;AACzB,uCAA0C;AAC1C,uCAA0C;AAC1C,yBAA4B;AAGrB,MAAM,0BAA0B,CACrC,uBAEA,OAAO,QAAQ,kBAAkB,EAAE,IAAI,CAAC,CAAC,cAAc,IAAI,OAAO;AAAA,EAChE,GAAG;AAAA,EACH,SAAS,GAAG,KAAK,GAAG,YAAY,YAAY;AAAA,EAC5C,UAAU;AAAA,EACV,UAAU;AACZ,EAAE;AAEG,MAAM,0BAA0B,OACrC,4BACA,oBAAgC,gCAAiB,GACjD,iBAAiB,8BACjB,mBAC0B;AAC1B,QAAM,qBAAqB,2BAA2B;AAAA,IACpD,CAAC,KAAK,SAAS;AACb,YAAM,mBAAe,sBAAS,cAAc,QAAQ,SAAS,IAAI;AACjE,aAAO;AAAA,QACL,GAAG;AAAA,QACH,CAAC,YAAY,OAAG,gCAAiB,MAAM,QAAW,cAAc;AAAA,MAClE;AAAA,IACF;AAAA,IACA,CAAC;AAAA,EACH;AACA,QAAM,sBACJ,wBAAwB,kBAAkB;AAE5C,QAAM,wBAAwB,oBAAoB,IAAI,CAAC,iBAAiB;AAAA,IACtE,eAAe,YAAY;AAAA,IAC3B,MAAM;AAAA,IACN,QAAQ;AAAA,EACV,EAAE;AAEF,mBAAiB,qBAAqB;AAEtC,QAAM,wBAAwB,UAAM;AAAA,IAClC;AAAA,IACA,OAAO,uBAAwD;AAC7D,UAAI,CAAC,oBAAoB;AACvB,eAAO;AAAA,MACT;AAEA,uBAAiB;AAAA,QACf;AAAA,UACE,eAAe,mBAAmB;AAAA,UAClC,MAAM;AAAA,UACN,QAAQ;AAAA,QACV;AAAA,MACF,CAAC;AAED,YAAM,8BAA8B,UAAM;AAAA,QACxC;AAAA,MACF;AAEA,UAAI,CAAC,6BAA6B;AAChC,eAAO;AAAA,MACT;AAEA,uBAAiB;AAAA,QACf;AAAA,UACE,eAAe,4BAA4B;AAAA,UAC3C,MAAM;AAAA,UACN,QAAQ;AAAA,QACV;AAAA,MACF,CAAC;AAED,aAAO;AAAA,IACT;AAAA,EACF;AAEA,aAAO,4DAA0B,qBAAqB;AACxD;","names":[]}

package/dist/cjs/loadDictionaries/loadDictionaries.cjs

@@ -23,65 +23,140 @@ __export(loadDictionaries_exports, {
 module.exports = __toCommonJS(loadDictionaries_exports);
 var import_config = require("@intlayer/config");
 var import_node_path = require("node:path");
-var import_fetchDistantDictionaryKeys = require('../fetchDistantDictionaryKeys.cjs');
-var import_log = require('../log.cjs');
-var import_sortAlphabetically = require('../utils/sortAlphabetically.cjs');
 var import_loadContentDeclaration = require('./loadContentDeclaration.cjs');
-var import_loadDistantDictionaries = require('./loadDistantDictionaries.cjs');
-const loadDictionaries = async (contentDeclarationsPaths, configuration = (0, import_config.getConfiguration)(), projectRequire = import_config.ESMxCJSRequire) => {
-  try {
-    const appLogger = (0, import_config.getAppLogger)(configuration);
-    const { editor } = configuration;
-    appLogger("Dictionaries:", { isVerbose: true });
-    const files = Array.isArray(contentDeclarationsPaths) ? contentDeclarationsPaths : [contentDeclarationsPaths];
-    const localDictionaries = await (0, import_loadContentDeclaration.loadContentDeclarations)(
-      files,
-      projectRequire
+var import_loadRemoteDictionaries = require('./loadRemoteDictionaries.cjs');
+var import_log = require('./log.cjs');
+let loadDictionariesStatus = [];
+const logger = new import_log.DictionariesLogger();
+const setLoadDictionariesStatus = (statuses) => {
+  let updated = [...loadDictionariesStatus];
+  for (const incoming of statuses) {
+    const idx = updated.findIndex(
+      (s) => s.dictionaryKey === incoming.dictionaryKey && s.type === incoming.type
     );
-    const filteredLocalDictionaries = localDictionaries.filter((dict) => {
-      const hasKey = Boolean(dict.key);
-      const hasContent = Boolean(dict.content);
-      if (!hasContent) {
-        console.error(
+    if (idx >= 0) {
+      updated[idx] = incoming;
+    } else {
+      updated.push(incoming);
+    }
+  }
+  loadDictionariesStatus = updated;
+  logger.update(statuses);
+  return updated;
+};
+const iconFor = (status) => {
+  switch (status) {
+    case "built":
+    case "imported":
+    case "fetched":
+      return "\u2714";
+    case "error":
+      return "\u2716";
+    default:
+      return "\u23F2";
+  }
+};
+const colorFor = (status) => {
+  switch (status) {
+    case "built":
+    case "imported":
+    case "fetched":
+      return import_config.ANSIColors.GREEN;
+    case "error":
+      return import_config.ANSIColors.RED;
+    default:
+      return import_config.ANSIColors.BLUE;
+  }
+};
+const printSummary = (configuration = (0, import_config.getConfiguration)()) => {
+  if (configuration.log.mode !== "verbose") return;
+  const appLogger = (0, import_config.getAppLogger)(configuration);
+  const byKey = /* @__PURE__ */ new Map();
+  for (const s of loadDictionariesStatus) {
+    const rec = byKey.get(s.dictionaryKey) ?? {};
+    if (s.type === "local") rec.local = s.status;
+    if (s.type === "remote") rec.remote = s.status;
+    byKey.set(s.dictionaryKey, rec);
+  }
+  const keys = Array.from(byKey.keys()).sort((a, b) => a.localeCompare(b));
+  for (const key of keys) {
+    const rec = byKey.get(key);
+    const labels = [];
+    if (rec.local) {
+      const inner = (0, import_config.colorize)(
+        `${iconFor(rec.local)} ${rec.local}`,
+        colorFor(rec.local)
+      );
+      labels.push(
+        `${import_config.ANSIColors.GREY}[` + (0, import_config.colorize)("local: ", import_config.ANSIColors.GREY) + inner + `${import_config.ANSIColors.GREY}]${import_config.ANSIColors.RESET}`
+      );
+    }
+    if (rec.remote) {
+      const inner = (0, import_config.colorize)(
+        `${iconFor(rec.remote)} ${rec.remote}`,
+        colorFor(rec.remote)
+      );
+      labels.push(
+        `${import_config.ANSIColors.GREY}[` + (0, import_config.colorize)("distant: ", import_config.ANSIColors.GREY) + inner + `${import_config.ANSIColors.GREY}]${import_config.ANSIColors.RESET}`
+      );
+    }
+    appLogger(
+      ` - ${(0, import_config.colon)((0, import_config.colorizeKey)(key), { colSize: keys })} ${labels.join(" ")}`
+    );
+  }
+};
+const loadDictionaries = async (contentDeclarationsPaths, configuration = (0, import_config.getConfiguration)(), projectRequire = import_config.ESMxCJSRequire) => {
+  const appLogger = (0, import_config.getAppLogger)(configuration);
+  appLogger("Dictionaries:", { isVerbose: true });
+  const files = Array.isArray(contentDeclarationsPaths) ? contentDeclarationsPaths : [contentDeclarationsPaths];
+  const localDictionaries = await (0, import_loadContentDeclaration.loadContentDeclarations)(
+    files,
+    configuration,
+    projectRequire,
+    setLoadDictionariesStatus
+  );
+  const filteredLocalDictionaries = localDictionaries.filter((dict) => {
+    const hasKey = Boolean(dict.key);
+    const hasContent = Boolean(dict.content);
+    if (!hasContent) {
+      appLogger(
+        [
           "Content declaration has no exported content",
           dict.filePath ? (0, import_node_path.relative)(configuration.content.baseDir, dict.filePath) : ""
-        );
-      } else if (!hasKey) {
-        console.error("Content declaration has no key", dict.filePath);
-      }
-      return hasKey && hasContent;
-    });
-    const localDictionaryKeys = filteredLocalDictionaries.map((dict) => dict.key).filter(Boolean);
-    import_log.logger.init(localDictionaryKeys, []);
-    import_log.logger.updateStatus(
-      filteredLocalDictionaries.map((dict) => ({
-        dictionaryKey: dict.key,
-        type: "local",
-        status: { status: "built" }
-      }))
-    );
-    let distantDictionaries = [];
-    let distantDictionaryKeys = [];
-    if (editor.clientId && editor.clientSecret) {
-      try {
-        distantDictionaryKeys = await (0, import_fetchDistantDictionaryKeys.fetchDistantDictionaryKeys)();
-        const orderedDistantDictionaryKeys = distantDictionaryKeys.sort(import_sortAlphabetically.sortAlphabetically);
-        import_log.logger.addDictionaryKeys("distant", orderedDistantDictionaryKeys);
-        distantDictionaries = await (0, import_loadDistantDictionaries.loadDistantDictionaries)({
-          dictionaryKeys: orderedDistantDictionaryKeys
-        });
-      } catch (_error) {
-        appLogger("Error during fetching distant dictionaries", {
-          level: "error"
-        });
-      }
+        ],
+        { level: "error" }
+      );
+    } else if (!hasKey) {
+      appLogger(["Content declaration has no key", dict.filePath], {
+        level: "error"
+      });
     }
-    import_log.logger.stop();
-    return [...filteredLocalDictionaries, ...distantDictionaries];
-  } catch (error) {
-    import_log.logger.stop();
-    throw error;
+    return hasKey && hasContent;
+  });
+  const localDictionariesStatus = filteredLocalDictionaries.map(
+    (dict) => ({
+      dictionaryKey: dict.key,
+      type: "local",
+      status: "built"
+    })
+  );
+  setLoadDictionariesStatus(localDictionariesStatus);
+  const hasRemoteDictionaries = Boolean(
+    configuration.editor.clientId && configuration.editor.clientSecret
+  );
+  let remoteDictionaries = [];
+  if (hasRemoteDictionaries) {
+    remoteDictionaries = await (0, import_loadRemoteDictionaries.loadRemoteDictionaries)(
+      configuration,
+      setLoadDictionariesStatus
+    );
   }
+  logger.finish();
+  printSummary(configuration);
+  return {
+    localDictionaries: filteredLocalDictionaries,
+    remoteDictionaries
+  };
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/loadDictionaries/loadDictionaries.ts"],"sourcesContent":["// @ts-ignore @intlayer/backend is not build yet\nimport type { DictionaryAPI } from '@intlayer/backend';\nimport {\n  ESMxCJSRequire,\n  getAppLogger,\n  getConfiguration,\n} from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/core';\nimport { relative } from 'node:path';\nimport { fetchDistantDictionaryKeys } from '../fetchDistantDictionaryKeys';\nimport { logger } from '../log';\nimport { sortAlphabetically } from '../utils/sortAlphabetically';\nimport { loadContentDeclarations } from './loadContentDeclaration';\nimport { loadDistantDictionaries } from './loadDistantDictionaries';\n\nexport const loadDictionaries = async (\n  contentDeclarationsPaths: string[] | string,\n  configuration = getConfiguration(),\n  projectRequire = ESMxCJSRequire\n): Promise<Dictionary[]> => {\n  try {\n    const appLogger = getAppLogger(configuration);\n    const { editor } = configuration;\n\n    appLogger('Dictionaries:', { isVerbose: true });\n\n    const files = Array.isArray(contentDeclarationsPaths)\n      ? contentDeclarationsPaths\n      : [contentDeclarationsPaths];\n\n    const localDictionaries: Dictionary[] = await loadContentDeclarations(\n      files,\n      projectRequire\n    );\n\n    const filteredLocalDictionaries = localDictionaries.filter((dict) => {\n      const hasKey = Boolean(dict.key);\n      const hasContent = Boolean(dict.content);\n\n      if (!hasContent) {\n        console.error(\n          'Content declaration has no exported content',\n          dict.filePath\n            ? relative(configuration.content.baseDir, dict.filePath)\n            : ''\n        );\n      } else if (!hasKey) {\n        console.error('Content declaration has no key', dict.filePath);\n      }\n\n      return hasKey && hasContent;\n    });\n\n    const localDictionaryKeys = filteredLocalDictionaries\n      .map((dict) => dict.key)\n      .filter(Boolean); // Remove empty or undefined keys\n\n    // Initialize the logger with both local and distant dictionaries\n    logger.init(localDictionaryKeys, []);\n\n    // Update logger statuses for local dictionaries\n    logger.updateStatus(\n      filteredLocalDictionaries.map((dict) => ({\n        dictionaryKey: dict.key,\n        type: 'local',\n        status: { status: 'built' },\n      }))\n    );\n\n    let distantDictionaries: DictionaryAPI[] = [];\n    let distantDictionaryKeys: string[] = [];\n\n    if (editor.clientId && editor.clientSecret) {\n      try {\n        // Fetch distant dictionary keys\n        distantDictionaryKeys = await fetchDistantDictionaryKeys();\n\n        const orderedDistantDictionaryKeys =\n          distantDictionaryKeys.sort(sortAlphabetically);\n\n        // Add distant dictionaries to the logger\n        logger.addDictionaryKeys('distant', orderedDistantDictionaryKeys);\n\n        // Fetch distant dictionaries\n        distantDictionaries = await loadDistantDictionaries({\n          dictionaryKeys: orderedDistantDictionaryKeys,\n        });\n      } catch (_error) {\n        appLogger('Error during fetching distant dictionaries', {\n          level: 'error',\n        });\n      }\n    }\n\n    // Ensure the logger is stopped\n    logger.stop();\n\n    return [...filteredLocalDictionaries, ...distantDictionaries];\n  } catch (error) {\n    // Ensure the logger is stopped\n    logger.stop();\n\n    throw error; // Re-throw the error after logging\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,oBAIO;AAEP,uBAAyB;AACzB,wCAA2C;AAC3C,iBAAuB;AACvB,gCAAmC;AACnC,oCAAwC;AACxC,qCAAwC;AAEjC,MAAM,mBAAmB,OAC9B,0BACA,oBAAgB,gCAAiB,GACjC,iBAAiB,iCACS;AAC1B,MAAI;AACF,UAAM,gBAAY,4BAAa,aAAa;AAC5C,UAAM,EAAE,OAAO,IAAI;AAEnB,cAAU,iBAAiB,EAAE,WAAW,KAAK,CAAC;AAE9C,UAAM,QAAQ,MAAM,QAAQ,wBAAwB,IAChD,2BACA,CAAC,wBAAwB;AAE7B,UAAM,oBAAkC,UAAM;AAAA,MAC5C;AAAA,MACA;AAAA,IACF;AAEA,UAAM,4BAA4B,kBAAkB,OAAO,CAAC,SAAS;AACnE,YAAM,SAAS,QAAQ,KAAK,GAAG;AAC/B,YAAM,aAAa,QAAQ,KAAK,OAAO;AAEvC,UAAI,CAAC,YAAY;AACf,gBAAQ;AAAA,UACN;AAAA,UACA,KAAK,eACD,2BAAS,cAAc,QAAQ,SAAS,KAAK,QAAQ,IACrD;AAAA,QACN;AAAA,MACF,WAAW,CAAC,QAAQ;AAClB,gBAAQ,MAAM,kCAAkC,KAAK,QAAQ;AAAA,MAC/D;AAEA,aAAO,UAAU;AAAA,IACnB,CAAC;AAED,UAAM,sBAAsB,0BACzB,IAAI,CAAC,SAAS,KAAK,GAAG,EACtB,OAAO,OAAO;AAGjB,sBAAO,KAAK,qBAAqB,CAAC,CAAC;AAGnC,sBAAO;AAAA,MACL,0BAA0B,IAAI,CAAC,UAAU;AAAA,QACvC,eAAe,KAAK;AAAA,QACpB,MAAM;AAAA,QACN,QAAQ,EAAE,QAAQ,QAAQ;AAAA,MAC5B,EAAE;AAAA,IACJ;AAEA,QAAI,sBAAuC,CAAC;AAC5C,QAAI,wBAAkC,CAAC;AAEvC,QAAI,OAAO,YAAY,OAAO,cAAc;AAC1C,UAAI;AAEF,gCAAwB,UAAM,8DAA2B;AAEzD,cAAM,+BACJ,sBAAsB,KAAK,4CAAkB;AAG/C,0BAAO,kBAAkB,WAAW,4BAA4B;AAGhE,8BAAsB,UAAM,wDAAwB;AAAA,UAClD,gBAAgB;AAAA,QAClB,CAAC;AAAA,MACH,SAAS,QAAQ;AACf,kBAAU,8CAA8C;AAAA,UACtD,OAAO;AAAA,QACT,CAAC;AAAA,MACH;AAAA,IACF;AAGA,sBAAO,KAAK;AAEZ,WAAO,CAAC,GAAG,2BAA2B,GAAG,mBAAmB;AAAA,EAC9D,SAAS,OAAO;AAEd,sBAAO,KAAK;AAEZ,UAAM;AAAA,EACR;AACF;","names":[]}
+{"version":3,"sources":["../../../src/loadDictionaries/loadDictionaries.ts"],"sourcesContent":["// @ts-ignore @intlayer/backend is not build yet\nimport {\n  ANSIColors,\n  colon,\n  colorize,\n  colorizeKey,\n  ESMxCJSRequire,\n  getAppLogger,\n  getConfiguration,\n  type IntlayerConfig,\n} from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/core';\nimport { relative } from 'node:path';\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  let updated: DictionariesStatus[] = [...loadDictionariesStatus];\n\n  for (const incoming of statuses) {\n    const idx = updated.findIndex(\n      (s) =>\n        s.dictionaryKey === incoming.dictionaryKey && s.type === incoming.type\n    );\n    if (idx >= 0) {\n      updated[idx] = 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 = getConfiguration()) => {\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 s of loadDictionariesStatus) {\n    const rec = byKey.get(s.dictionaryKey) ?? {};\n    if (s.type === 'local') rec.local = s.status;\n    if (s.type === 'remote') rec.remote = s.status;\n    byKey.set(s.dictionaryKey, rec);\n  }\n\n  const keys = Array.from(byKey.keys()).sort((a, b) => a.localeCompare(b));\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      labels.push(\n        `${ANSIColors.GREY}[` +\n          colorize('local: ', ANSIColors.GREY) +\n          inner +\n          `${ANSIColors.GREY}]${ANSIColors.RESET}`\n      );\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 = getConfiguration(),\n  projectRequire = ESMxCJSRequire\n): Promise<{\n  localDictionaries: Dictionary[];\n  remoteDictionaries: Dictionary[];\n}> => {\n  const appLogger = getAppLogger(configuration);\n\n  appLogger('Dictionaries:', { isVerbose: true });\n\n  const files = Array.isArray(contentDeclarationsPaths)\n    ? contentDeclarationsPaths\n    : [contentDeclarationsPaths];\n\n  const localDictionaries: Dictionary[] = await loadContentDeclarations(\n    files,\n    configuration,\n    projectRequire,\n    setLoadDictionariesStatus\n  );\n\n  const filteredLocalDictionaries = localDictionaries.filter((dict) => {\n    const hasKey = Boolean(dict.key);\n    const hasContent = Boolean(dict.content);\n\n    if (!hasContent) {\n      appLogger(\n        [\n          'Content declaration has no exported content',\n          dict.filePath\n            ? relative(configuration.content.baseDir, dict.filePath)\n            : '',\n        ],\n        { level: 'error' }\n      );\n    } else if (!hasKey) {\n      appLogger(['Content declaration has no key', dict.filePath], {\n        level: 'error',\n      });\n    }\n\n    return hasKey && hasContent;\n  });\n\n  const localDictionariesStatus = filteredLocalDictionaries.map(\n    (dict) =>\n      ({\n        dictionaryKey: dict.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  let remoteDictionaries: Dictionary[] = [];\n  if (hasRemoteDictionaries) {\n    remoteDictionaries = await loadRemoteDictionaries(\n      configuration,\n      setLoadDictionariesStatus\n    );\n  }\n\n  // Stop spinner and show final progress line(s)\n  logger.finish();\n\n  printSummary(configuration);\n\n  return {\n    localDictionaries: filteredLocalDictionaries,\n    remoteDictionaries,\n  };\n};\n"],"mappings":"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","names":[]}

package/dist/cjs/loadDictionaries/loadRemoteDictionaries.cjs

@@ -0,0 +1,101 @@
+"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 loadRemoteDictionaries_exports = {};
+__export(loadRemoteDictionaries_exports, {
+  formatDistantDictionaries: () => formatDistantDictionaries,
+  loadRemoteDictionaries: () => loadRemoteDictionaries
+});
+module.exports = __toCommonJS(loadRemoteDictionaries_exports);
+var import_config = require("@intlayer/config");
+var import_remote_dictionaries_entry = __toESM(require("@intlayer/remote-dictionaries-entry"));
+var import_fetchDistantDictionaries = require('../fetchDistantDictionaries.cjs');
+var import_fetchDistantDictionaryKeysAndUpdateTimestamp = require('../fetchDistantDictionaryKeysAndUpdateTimestamp.cjs');
+var import_sortAlphabetically = require('../utils/sortAlphabetically.cjs');
+const formatDistantDictionaries = (dictionaries) => dictionaries.map((dict) => ({
+  ...dict,
+  localId: `${dict.key}::remote::${dict.id}`,
+  location: "distant"
+}));
+const loadRemoteDictionaries = async (configuration = (0, import_config.getConfiguration)(), onStatusUpdate) => {
+  const appLogger = (0, import_config.getAppLogger)(configuration);
+  const { editor } = configuration;
+  const hasRemoteDictionaries = Boolean(editor.clientId && editor.clientSecret);
+  if (!hasRemoteDictionaries) return [];
+  try {
+    const distantDictionaryUpdateTimeStamp = await (0, import_fetchDistantDictionaryKeysAndUpdateTimestamp.fetchDistantDictionaryKeysAndUpdateTimestamp)(configuration);
+    const dictionariesKeysToFetch = Object.entries(
+      distantDictionaryUpdateTimeStamp
+    ).filter(([dictionaryKey, updatedAt]) => {
+      if (!updatedAt) return true;
+      if (!import_remote_dictionaries_entry.default[dictionaryKey]) return true;
+      return import_remote_dictionaries_entry.default[dictionaryKey] > updatedAt;
+    }).map(([dictionaryKey]) => dictionaryKey);
+    const cachedDictionaries = Object.values(import_remote_dictionaries_entry.default).filter(
+      (dictionary) => dictionary?.updatedAt && !dictionariesKeysToFetch.includes(dictionary.key)
+    );
+    if (cachedDictionaries.length > 0) {
+      onStatusUpdate?.(
+        cachedDictionaries.map((d) => ({
+          dictionaryKey: d.key,
+          type: "remote",
+          status: "imported"
+        }))
+      );
+    }
+    const orderedDistantDictionaryKeys = dictionariesKeysToFetch.sort(import_sortAlphabetically.sortAlphabetically);
+    if (orderedDistantDictionaryKeys.length > 0) {
+      onStatusUpdate?.(
+        orderedDistantDictionaryKeys.map((key) => ({
+          dictionaryKey: key,
+          type: "remote",
+          status: "pending"
+        }))
+      );
+    }
+    const distantDictionariesData = await (0, import_fetchDistantDictionaries.fetchDistantDictionaries)(
+      {
+        dictionaryKeys: orderedDistantDictionaryKeys
+      },
+      onStatusUpdate
+    );
+    const distantDictionaries = formatDistantDictionaries(
+      distantDictionariesData
+    );
+    return [...cachedDictionaries, ...distantDictionaries];
+  } catch (error) {
+    appLogger(`${import_config.x} Failed to fetch distant dictionaries`, { level: "error" });
+    return [];
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatDistantDictionaries,
+  loadRemoteDictionaries
+});
+//# sourceMappingURL=loadRemoteDictionaries.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/loadDictionaries/loadRemoteDictionaries.ts"],"sourcesContent":["// @ts-ignore @intlayer/backend is not build yet\nimport type { DictionaryAPI } from '@intlayer/backend';\nimport { getAppLogger, getConfiguration, x } from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/core';\nimport remoteDictionariesRecord from '@intlayer/remote-dictionaries-entry';\nimport { fetchDistantDictionaries } from '../fetchDistantDictionaries';\nimport { fetchDistantDictionaryKeysAndUpdateTimestamp } from '../fetchDistantDictionaryKeysAndUpdateTimestamp';\nimport { DictionariesStatus } from '../loadDictionaries/loadDictionaries';\nimport { sortAlphabetically } from '../utils/sortAlphabetically';\n\nexport const formatDistantDictionaries = (\n  dictionaries: DictionaryAPI[]\n): Dictionary[] =>\n  dictionaries.map((dict) => ({\n    ...dict,\n    localId: `${dict.key}::remote::${dict.id}`,\n    location: 'distant' as const,\n  }));\n\nexport const loadRemoteDictionaries = async (\n  configuration = getConfiguration(),\n  onStatusUpdate?: (status: DictionariesStatus[]) => void\n): Promise<DictionaryAPI[]> => {\n  const appLogger = getAppLogger(configuration);\n  const { editor } = configuration;\n\n  const hasRemoteDictionaries = Boolean(editor.clientId && editor.clientSecret);\n\n  if (!hasRemoteDictionaries) return [];\n\n  try {\n    const distantDictionaryUpdateTimeStamp: Record<string, number> =\n      await fetchDistantDictionaryKeysAndUpdateTimestamp(configuration);\n\n    const dictionariesKeysToFetch = Object.entries(\n      distantDictionaryUpdateTimeStamp\n    )\n      .filter(([dictionaryKey, updatedAt]) => {\n        // If dictionary doesn't have updatedAt, always fetch it\n        if (!updatedAt) return true;\n\n        // If remote timestamp doesn't exist, fetch it\n        if (!remoteDictionariesRecord[dictionaryKey]) return true;\n\n        // If remote timestamp is newer than local, fetch it\n        return remoteDictionariesRecord[dictionaryKey] > updatedAt;\n      })\n      .map(([dictionaryKey]) => dictionaryKey);\n\n    const cachedDictionaries = Object.values(remoteDictionariesRecord).filter(\n      (dictionary) =>\n        dictionary?.updatedAt &&\n        !dictionariesKeysToFetch.includes(dictionary.key)\n    );\n\n    // Report cached as already imported\n    if (cachedDictionaries.length > 0) {\n      onStatusUpdate?.(\n        cachedDictionaries.map((d) => ({\n          dictionaryKey: d.key,\n          type: 'remote',\n          status: 'imported',\n        }))\n      );\n    }\n\n    const orderedDistantDictionaryKeys =\n      dictionariesKeysToFetch.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: DictionaryAPI[] = formatDistantDictionaries(\n      distantDictionariesData\n    );\n\n    return [...cachedDictionaries, ...distantDictionaries];\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;AAEA,oBAAkD;AAElD,uCAAqC;AACrC,sCAAyC;AACzC,0DAA6D;AAE7D,gCAAmC;AAE5B,MAAM,4BAA4B,CACvC,iBAEA,aAAa,IAAI,CAAC,UAAU;AAAA,EAC1B,GAAG;AAAA,EACH,SAAS,GAAG,KAAK,GAAG,aAAa,KAAK,EAAE;AAAA,EACxC,UAAU;AACZ,EAAE;AAEG,MAAM,yBAAyB,OACpC,oBAAgB,gCAAiB,GACjC,mBAC6B;AAC7B,QAAM,gBAAY,4BAAa,aAAa;AAC5C,QAAM,EAAE,OAAO,IAAI;AAEnB,QAAM,wBAAwB,QAAQ,OAAO,YAAY,OAAO,YAAY;AAE5E,MAAI,CAAC,sBAAuB,QAAO,CAAC;AAEpC,MAAI;AACF,UAAM,mCACJ,UAAM,kGAA6C,aAAa;AAElE,UAAM,0BAA0B,OAAO;AAAA,MACrC;AAAA,IACF,EACG,OAAO,CAAC,CAAC,eAAe,SAAS,MAAM;AAEtC,UAAI,CAAC,UAAW,QAAO;AAGvB,UAAI,CAAC,iCAAAA,QAAyB,aAAa,EAAG,QAAO;AAGrD,aAAO,iCAAAA,QAAyB,aAAa,IAAI;AAAA,IACnD,CAAC,EACA,IAAI,CAAC,CAAC,aAAa,MAAM,aAAa;AAEzC,UAAM,qBAAqB,OAAO,OAAO,iCAAAA,OAAwB,EAAE;AAAA,MACjE,CAAC,eACC,YAAY,aACZ,CAAC,wBAAwB,SAAS,WAAW,GAAG;AAAA,IACpD;AAGA,QAAI,mBAAmB,SAAS,GAAG;AACjC;AAAA,QACE,mBAAmB,IAAI,CAAC,OAAO;AAAA,UAC7B,eAAe,EAAE;AAAA,UACjB,MAAM;AAAA,UACN,QAAQ;AAAA,QACV,EAAE;AAAA,MACJ;AAAA,IACF;AAEA,UAAM,+BACJ,wBAAwB,KAAK,4CAAkB;AAGjD,QAAI,6BAA6B,SAAS,GAAG;AAC3C;AAAA,QACE,6BAA6B,IAAI,CAAC,SAAS;AAAA,UACzC,eAAe;AAAA,UACf,MAAM;AAAA,UACN,QAAQ;AAAA,QACV,EAAE;AAAA,MACJ;AAAA,IACF;AAEA,UAAM,0BAA0B,UAAM;AAAA,MACpC;AAAA,QACE,gBAAgB;AAAA,MAClB;AAAA,MACA;AAAA,IACF;AAEA,UAAM,sBAAuC;AAAA,MAC3C;AAAA,IACF;AAEA,WAAO,CAAC,GAAG,oBAAoB,GAAG,mBAAmB;AAAA,EACvD,SAAS,OAAO;AACd,cAAU,GAAG,eAAC,yCAAyC,EAAE,OAAO,QAAQ,CAAC;AACzE,WAAO,CAAC;AAAA,EACV;AACF;","names":["remoteDictionariesRecord"]}

package/dist/cjs/loadDictionaries/log.cjs

@@ -0,0 +1,144 @@
+"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 log_exports = {};
+__export(log_exports, {
+  DictionariesLogger: () => DictionariesLogger
+});
+module.exports = __toCommonJS(log_exports);
+var import_config = require("@intlayer/config");
+class DictionariesLogger {
+  statuses = [];
+  spinnerTimer = null;
+  spinnerIndex = 0;
+  renderedLines = 0;
+  spinnerFrames = import_config.spinnerFrames;
+  isFinished = false;
+  prefix;
+  lastRenderedState = "";
+  constructor() {
+    const configuration = (0, import_config.getConfiguration)();
+    this.prefix = configuration.log.prefix;
+  }
+  update(newStatuses) {
+    if (this.isFinished) return;
+    for (const status of newStatuses) {
+      const index = this.statuses.findIndex(
+        (s) => s.dictionaryKey === status.dictionaryKey && s.type === status.type
+      );
+      if (index >= 0) {
+        this.statuses[index] = status;
+      } else {
+        this.statuses.push(status);
+      }
+    }
+    this.startSpinner();
+    this.render();
+  }
+  finish() {
+    this.isFinished = true;
+    this.stopSpinner();
+    this.render();
+  }
+  startSpinner() {
+    if (this.spinnerTimer || this.isFinished) return;
+    this.spinnerTimer = setInterval(() => {
+      this.spinnerIndex = (this.spinnerIndex + 1) % this.spinnerFrames.length;
+      this.render();
+    }, 100);
+  }
+  stopSpinner() {
+    if (!this.spinnerTimer) return;
+    clearInterval(this.spinnerTimer);
+    this.spinnerTimer = null;
+  }
+  render() {
+    const { localTotal, localDone, remoteTotal, remoteDone } = this.computeProgress();
+    const frame = this.spinnerFrames[this.spinnerIndex];
+    const lines = [];
+    const isLocalDone = localDone === localTotal;
+    const isRemoteDone = remoteDone === remoteTotal;
+    if (isLocalDone) {
+      lines.push(
+        `${this.prefix} ${(0, import_config.colorize)("\u2714", import_config.ANSIColors.GREEN)} local dictionaries: ${localDone}/${localTotal}`
+      );
+    } else {
+      lines.push(
+        `${this.prefix} ${(0, import_config.colorize)(frame, import_config.ANSIColors.BLUE)} local dictionaries: ${localDone}/${localTotal}`
+      );
+    }
+    if (remoteTotal > 0) {
+      if (isRemoteDone) {
+        lines.push(
+          `${this.prefix} ${(0, import_config.colorize)("\u2714", import_config.ANSIColors.GREEN)} remote dictionaries: ${remoteDone}/${remoteTotal}`
+        );
+      } else {
+        lines.push(
+          `${this.prefix} ${(0, import_config.colorize)(frame, import_config.ANSIColors.BLUE)} remote dictionaries: ${remoteDone}/${remoteTotal}`
+        );
+      }
+    }
+    const currentState = lines.join("\n");
+    if (currentState === this.lastRenderedState) {
+      return;
+    }
+    this.lastRenderedState = currentState;
+    if (this.renderedLines > 0) {
+      process.stdout.write(`\x1B[${this.renderedLines}F`);
+    }
+    const totalLinesToClear = Math.max(this.renderedLines, lines.length);
+    for (let i = 0; i < totalLinesToClear; i++) {
+      process.stdout.write("\x1B[2K");
+      const line = lines[i];
+      if (line !== void 0) {
+        process.stdout.write(line);
+      }
+      process.stdout.write("\n");
+    }
+    this.renderedLines = lines.length;
+  }
+  computeProgress() {
+    const localKeys = new Set(
+      this.statuses.filter((s) => s.type === "local").map((s) => s.dictionaryKey)
+    );
+    const localDoneKeys = new Set(
+      this.statuses.filter(
+        (s) => s.type === "local" && (s.status === "built" || s.status === "error")
+      ).map((s) => s.dictionaryKey)
+    );
+    const remoteKeys = new Set(
+      this.statuses.filter((s) => s.type === "remote").map((s) => s.dictionaryKey)
+    );
+    const remoteDoneKeys = new Set(
+      this.statuses.filter(
+        (s) => s.type === "remote" && (s.status === "fetched" || s.status === "imported" || s.status === "error")
+      ).map((s) => s.dictionaryKey)
+    );
+    return {
+      localTotal: localKeys.size,
+      localDone: localDoneKeys.size,
+      remoteTotal: remoteKeys.size,
+      remoteDone: remoteDoneKeys.size
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DictionariesLogger
+});
+//# sourceMappingURL=log.cjs.map