@messagevisor/catalog 0.5.0 → 0.7.0

package/src/node/index.ts

@@ -18,6 +18,123 @@ import type {
 
 import { attachFormatExamplePreviews } from "./formatExamplePreview";
 
+const CLI_FORMAT_GREEN = "\x1b[32m%s\x1b[0m";
+const CLI_FORMAT_DIM = "\x1b[2m%s\x1b[0m";
+const CLI_FORMAT_BOLD = "\x1b[1m%s\x1b[0m";
+
+function colorize(value: string, colorCode: number) {
+  return `\x1b[${colorCode}m${value}\x1b[0m`;
+}
+
+function prettyDuration(diffInMs: number) {
+  let diff = Math.abs(diffInMs);
+
+  if (diff === 0) {
+    return "0ms";
+  }
+
+  const ms = diff % 1000;
+  diff = (diff - ms) / 1000;
+  const secs = diff % 60;
+  diff = (diff - secs) / 60;
+  const mins = diff % 60;
+  const hrs = (diff - mins) / 60;
+
+  let result = "";
+
+  if (hrs) {
+    result += ` ${hrs}h`;
+  }
+
+  if (mins) {
+    result += ` ${mins}m`;
+  }
+
+  if (secs) {
+    result += ` ${secs}s`;
+  }
+
+  if (ms) {
+    result += ` ${ms}ms`;
+  }
+
+  return result.trim();
+}
+
+function pluralize(count: number, singular: string, plural = `${singular}s`) {
+  return `${count} ${count === 1 ? singular : plural}`;
+}
+
+function formatCatalogPath(rootDirectoryPath: string, filePath: string) {
+  const relativePath = path.relative(rootDirectoryPath, filePath);
+
+  if (relativePath && !relativePath.startsWith("..") && !path.isAbsolute(relativePath)) {
+    return relativePath;
+  }
+
+  return filePath;
+}
+
+class CatalogProgressReporter {
+  private readonly startedAt = Date.now();
+
+  constructor(
+    private readonly rootDirectoryPath: string,
+    private readonly outputDirectoryPath: string,
+  ) {}
+
+  start(options: { browserRouter: boolean; sets: boolean; features: string[] }) {
+    console.log("");
+    console.log(CLI_FORMAT_BOLD, "Generating Messagevisor catalog");
+    console.log(
+      `  ${colorize("Output", 36)}: ${formatCatalogPath(
+        this.rootDirectoryPath,
+        this.outputDirectoryPath,
+      )}`,
+    );
+    console.log(`  ${colorize("Router", 36)}: ${options.browserRouter ? "browser" : "hash"}`);
+    console.log(`  ${colorize("Sets", 36)}:   ${options.sets ? "enabled" : "none"}`);
+    console.log(`  ${colorize("Features", 36)}: ${options.features.join(", ") || "none"}`);
+    console.log("");
+  }
+
+  step(label: string, detail?: string) {
+    const suffix = detail ? `: ${colorize(detail, 2)}` : "";
+    console.log(`  ${colorize("•", 36)} ${label}${suffix}`);
+    return Date.now();
+  }
+
+  substep(label: string, detail?: string) {
+    const suffix = detail ? `: ${colorize(detail, 2)}` : "";
+    console.log(`    ${colorize("•", 36)} ${label}${suffix}`);
+    return Date.now();
+  }
+
+  done(startedAt: number, detail?: string) {
+    const suffix = detail ? ` ${detail}` : "";
+    console.log(CLI_FORMAT_DIM, `    done in ${prettyDuration(Date.now() - startedAt)}${suffix}`);
+  }
+
+  setStart(set: string | undefined) {
+    console.log("");
+    if (set) {
+      console.log(CLI_FORMAT_BOLD, `Set "${set}"`);
+    } else {
+      console.log(CLI_FORMAT_BOLD, "Root catalog");
+    }
+    return Date.now();
+  }
+
+  complete() {
+    console.log("");
+    console.log(
+      CLI_FORMAT_GREEN,
+      `Catalog exported to ${formatCatalogPath(this.rootDirectoryPath, this.outputDirectoryPath)}`,
+    );
+    console.log(CLI_FORMAT_BOLD, `Time: ${prettyDuration(Date.now() - this.startedAt)}`);
+  }
+}
+
 export interface CatalogPluginParsedOptions {
   _: string[];
   [key: string]: any;
@@ -223,6 +340,7 @@ export interface CatalogExportOptions {
   dev?: boolean;
   devEditors?: CatalogDevEditor[];
   withTranslationSearch?: boolean;
+  withDuplicates?: boolean;
 }
 
 export interface CatalogServeOptions {
@@ -240,6 +358,7 @@ export interface CatalogServerHandle {
 interface CatalogBuildContext {
   rootDirectoryPath: string;
   repositoryRootDirectoryPath: string;
+  repositorySourceRootDirectoryPath: string;
   outputDirectoryPath: string;
   dataDirectoryPath: string;
   historyIndex: CatalogHistoryIndex;
@@ -247,6 +366,9 @@ interface CatalogBuildContext {
   devEditors: CatalogDevEditor[];
   duplicateResultsBySet: Record<string, CatalogDuplicateTranslationsSetResult>;
   withTranslationSearch: boolean;
+  withDuplicates: boolean;
+  progress: CatalogProgressReporter;
+  writer: CatalogJsonWriter;
 }
 
 interface SourceFileInfo {
@@ -609,9 +731,41 @@ function toLocaleDuplicatesFile(
   };
 }
 
-async function writeJson(filePath: string, content: unknown) {
-  await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
-  await fs.promises.writeFile(filePath, JSON.stringify(content, null, 2));
+class CatalogJsonWriter {
+  private readonly directories = new Map<string, Promise<void>>();
+
+  private ensureDirectory(directoryPath: string) {
+    let promise = this.directories.get(directoryPath);
+
+    if (!promise) {
+      promise = fs.promises.mkdir(directoryPath, { recursive: true }).then(() => undefined);
+      this.directories.set(directoryPath, promise);
+    }
+
+    return promise;
+  }
+
+  async write(filePath: string, content: unknown) {
+    await this.ensureDirectory(path.dirname(filePath));
+    await fs.promises.writeFile(filePath, JSON.stringify(content, null, 2));
+  }
+}
+
+async function mapWithConcurrency<T>(
+  items: T[],
+  concurrency: number,
+  callback: (item: T, index: number) => Promise<void>,
+) {
+  let nextIndex = 0;
+  const workerCount = Math.min(concurrency, items.length);
+  const workers = Array.from({ length: workerCount }, async () => {
+    while (nextIndex < items.length) {
+      const index = nextIndex++;
+      await callback(items[index], index);
+    }
+  });
+
+  await Promise.all(workers);
 }
 
 function getEntityDirectoryPaths(config: any): Record<CatalogEntityType | "test", string> {
@@ -756,6 +910,18 @@ function addHistoryIndexEntry(
   target[key].push(entry);
 }
 
+function toEntityHistoryEntry(
+  entry: CatalogHistoryEntry,
+  entity: CatalogHistoryEntity,
+): CatalogHistoryEntry {
+  return {
+    commit: entry.commit,
+    author: entry.author,
+    timestamp: entry.timestamp,
+    entities: [entity],
+  };
+}
+
 function buildCatalogHistoryIndex(entries: CatalogHistoryEntry[]): CatalogHistoryIndex {
   const index = createEmptyHistoryIndex();
   index.entries = entries;
@@ -769,7 +935,7 @@ function buildCatalogHistoryIndex(entries: CatalogHistoryEntry[]): CatalogHistor
       }
 
       const entityKey = getHistoryEntityKey(entity.type, entity.key, entity.set);
-      addHistoryIndexEntry(index.byEntity, entityKey, entry);
+      addHistoryIndexEntry(index.byEntity, entityKey, toEntityHistoryEntry(entry, entity));
 
       if (!index.lastModifiedByEntity[entityKey]) {
         index.lastModifiedByEntity[entityKey] = toLastModified(entry);
@@ -1015,6 +1181,25 @@ function getRepositoryRootDirectoryPath(rootDirectoryPath: string) {
   }
 }
 
+function getRepositorySourceRootDirectoryPath(rootDirectoryPath: string) {
+  try {
+    const gitRootDirectoryPath =
+      runGit(rootDirectoryPath, ["rev-parse", "--show-toplevel"]).trim() || rootDirectoryPath;
+    const realRootDirectoryPath = getRealPath(rootDirectoryPath);
+
+    if (realRootDirectoryPath !== rootDirectoryPath) {
+      return path.resolve(
+        rootDirectoryPath,
+        path.relative(realRootDirectoryPath, gitRootDirectoryPath),
+      );
+    }
+
+    return gitRootDirectoryPath;
+  } catch (_error) {
+    return rootDirectoryPath;
+  }
+}
+
 function getOwnerAndRepoFromGitRemote(origin: string, host: string) {
   const escapedHost = host.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
   const match = origin.match(new RegExp(`${escapedHost}[:/]([^/]+)/(.+?)(?:\\.git)?$`));
@@ -1090,17 +1275,28 @@ function chunkHistory(history: CatalogHistoryEntry[], pageSize = CATALOG_HISTORY
   return pages.length > 0 ? pages : [[]];
 }
 
-async function writeHistoryPages(directoryPath: string, history: CatalogHistoryEntry[]) {
+async function writeHistoryPages(
+  writer: CatalogJsonWriter,
+  directoryPath: string,
+  history: CatalogHistoryEntry[],
+  options: { skipEmpty?: boolean } = {},
+) {
+  if (options.skipEmpty && history.length === 0) {
+    return 1;
+  }
+
   const pages = chunkHistory(history);
 
   for (let index = 0; index < pages.length; index++) {
-    await writeJson(path.join(directoryPath, `page-${index + 1}.json`), {
+    await writer.write(path.join(directoryPath, `page-${index + 1}.json`), {
       page: index + 1,
       pageSize: CATALOG_HISTORY_PAGE_SIZE,
       totalPages: pages.length,
       entries: pages[index],
     });
   }
+
+  return 0;
 }
 
 function getHistoryForEntity(
@@ -1113,11 +1309,12 @@ function getHistoryForEntity(
 }
 
 function getSourceFileInfo(
-  repositoryRootDirectoryPath: string,
+  repositorySourceRootDirectoryPath: string,
   rootDirectoryPath: string,
   projectConfig: any,
   type: CatalogEntityType,
   key: string,
+  options: { resolveAbsolutePath?: boolean } = {},
 ): SourceFileInfo {
   const directoryByType: Record<CatalogEntityType, string> = {
     locale: projectConfig.localesDirectoryPath,
@@ -1134,10 +1331,10 @@ function getSourceFileInfo(
       ...key.split(projectConfig.namespaceCharacter),
     ) + extension,
   );
-  const absolutePath = getRealPath(filePath);
+  const absolutePath = options.resolveAbsolutePath ? getRealPath(filePath) : filePath;
 
   return {
-    sourcePath: toPosixPath(path.relative(repositoryRootDirectoryPath, absolutePath)),
+    sourcePath: toPosixPath(path.relative(repositorySourceRootDirectoryPath, filePath)),
     absolutePath,
   };
 }
@@ -1168,13 +1365,15 @@ async function buildSetCatalog(
   outputRelativeDirectory: string,
 ) {
   const outputDirectoryPath = path.join(context.dataDirectoryPath, outputRelativeDirectory);
-  const [localeKeys, messageKeys, attributeKeys, segmentKeys, targetKeys] = await Promise.all([
+  const setStartedAt = context.progress.setStart(set);
+  const entitiesStartedAt = context.progress.step("Processing entities");
+  const [localeKeys, messageKeys, attributeKeys, segmentKeys, targetKeys] = (await Promise.all([
     datasource.listLocales(),
     datasource.listMessages(),
     datasource.listAttributes(),
     datasource.listSegments(),
     datasource.listTargets(),
-  ]);
+  ])) as [string[], string[], string[], string[], string[]];
   const [locales, messages, attributes, segments, targets] = await Promise.all([
     readAll<Locale>(localeKeys, (key) => datasource.readLocale(key)),
     readAll<Message>(messageKeys, (key) => datasource.readMessage(key)),
@@ -1182,6 +1381,18 @@ async function buildSetCatalog(
     readAll<Segment>(segmentKeys, (key) => datasource.readSegment(key)),
     readAll<Target>(targetKeys, (key) => datasource.readTarget(key)),
   ]);
+  context.progress.done(
+    entitiesStartedAt,
+    `(${[
+      pluralize(localeKeys.length, "locale"),
+      pluralize(messageKeys.length, "message"),
+      pluralize(attributeKeys.length, "attribute"),
+      pluralize(segmentKeys.length, "segment"),
+      pluralize(targetKeys.length, "target"),
+    ].join(", ")})`,
+  );
+
+  const relationshipsStartedAt = context.progress.step("Mapping relationships");
   const messageTargets: Record<string, string[]> = {};
   const targetMessages: Record<string, string[]> = {};
   const localeTargets: Record<string, Set<string>> = {};
@@ -1282,6 +1493,7 @@ async function buildSetCatalog(
       }
     }
   }
+  context.progress.done(relationshipsStartedAt);
 
   const history = set ? context.historyIndex.bySet[set] || [] : context.historyIndex.entries;
   const localeDirections = getLocaleDirections(locales);
@@ -1310,8 +1522,11 @@ async function buildSetCatalog(
     },
   };
 
-  await writeHistoryPages(path.join(outputDirectoryPath, "history"), history);
+  const historyStartedAt = context.progress.step("Writing history pages");
+  await writeHistoryPages(context.writer, path.join(outputDirectoryPath, "history"), history);
+  context.progress.done(historyStartedAt, `(${pluralize(history.length, "entry", "entries")})`);
 
+  const examplesStartedAt = context.progress.step("Evaluating examples");
   const evaluatedMessageExamplesByKey = (
     await context.runtime.resolveExamples(projectConfig, datasource, {
       onlyMessages: true,
@@ -1345,15 +1560,31 @@ async function buildSetCatalog(
     });
     return accumulator;
   }, {});
+  context.progress.done(
+    examplesStartedAt,
+    `(${pluralize(
+      Object.values(evaluatedMessageExamplesByKey).reduce(
+        (total, items) => total + items.length,
+        0,
+      ),
+      "message example",
+    )}, ${pluralize(
+      Object.values(evaluatedLocaleExamplesByKey).reduce((total, items) => total + items.length, 0),
+      "locale example",
+    )})`,
+  );
 
-  for (const localeKey of localeKeys) {
+  const localesStartedAt = context.progress.step("Writing locales");
+  let skippedEmptyHistoryCount = 0;
+  await mapWithConcurrency(localeKeys, 32, async (localeKey) => {
     const locale = locales[localeKey];
     const sourceFileInfo = getSourceFileInfo(
-      context.repositoryRootDirectoryPath,
+      context.repositorySourceRootDirectoryPath,
       context.rootDirectoryPath,
       projectConfig,
       "locale",
       localeKey,
+      { resolveAbsolutePath: context.devEditors.length > 0 },
     );
     const detail = {
       type: "locale",
@@ -1379,18 +1610,30 @@ async function buildSetCatalog(
         targets: sortStrings(Array.from(localeTargets[localeKey] || [])),
       }),
     );
-    await writeJson(
+    await context.writer.write(
       path.join(outputDirectoryPath, "entities", "locale", `${encodeKey(localeKey)}.json`),
       detail,
     );
-    await writeJson(
-      path.join(outputDirectoryPath, "duplicates", "locales", `${encodeKey(localeKey)}.json`),
-      toLocaleDuplicatesFile(localeKey, duplicatesByLocale),
-    );
-    await writeHistoryPages(
+    skippedEmptyHistoryCount += await writeHistoryPages(
+      context.writer,
       path.join(outputDirectoryPath, "history", "locale", encodeKey(localeKey)),
       getHistoryForEntity(context.historyIndex, "locale", localeKey, set || undefined),
+      { skipEmpty: true },
     );
+  });
+  context.progress.done(localesStartedAt, `(${pluralize(localeKeys.length, "locale")})`);
+
+  if (context.withDuplicates) {
+    const duplicatesStartedAt = context.progress.step("Writing duplicate reports");
+
+    await mapWithConcurrency(localeKeys, 32, async (localeKey) => {
+      await context.writer.write(
+        path.join(outputDirectoryPath, "duplicates", "locales", `${encodeKey(localeKey)}.json`),
+        toLocaleDuplicatesFile(localeKey, duplicatesByLocale),
+      );
+    });
+
+    context.progress.done(duplicatesStartedAt, `(${pluralize(localeKeys.length, "locale")})`);
   }
 
   // translationShards[3charPrefix][messageKey] = Set<lowercased value>
@@ -1411,7 +1654,10 @@ async function buildSetCatalog(
     }
   }
 
-  for (const messageKey of messageKeys) {
+  const messagesStartedAt = context.progress.step("Writing messages");
+  const messageDetailsStartedAt = context.progress.substep("Writing message details");
+  let skippedEmptyMessageHistoryCount = 0;
+  await mapWithConcurrency(messageKeys, 32, async (messageKey) => {
     const message = messages[messageKey];
     const overrides = (message.overrides || []).map((override: Override) => {
       const attributes = new Set<string>();
@@ -1426,11 +1672,12 @@ async function buildSetCatalog(
       };
     });
     const sourceFileInfo = getSourceFileInfo(
-      context.repositoryRootDirectoryPath,
+      context.repositorySourceRootDirectoryPath,
       context.rootDirectoryPath,
       projectConfig,
       "message",
       messageKey,
+      { resolveAbsolutePath: context.devEditors.length > 0 },
     );
     const detail = {
       type: "message",
@@ -1465,22 +1712,6 @@ async function buildSetCatalog(
     }
     const overrideLocalesList = sortStrings(Array.from(overrideLocalesSet));
 
-    if (context.withTranslationSearch) {
-      // Build translation shards (direct + inherited + override, all locales combined)
-      for (const localeKey of localeKeys) {
-        const row = resolveTranslationRow(message.translations, localeKey, locales);
-        if (row.source !== "missing" && row.value) {
-          addToTranslationShard(messageKey, row.value);
-        }
-        for (const override of overrides) {
-          const overrideRow = resolveTranslationRow(override.translations, localeKey, locales);
-          if (overrideRow.source !== "missing" && overrideRow.value) {
-            addToTranslationShard(messageKey, overrideRow.value);
-          }
-        }
-      }
-    }
-
     index.entities.message.push(
       getEntitySummary(message, "message", messageKey, context.historyIndex, set || undefined, {
         targets: sortStrings(messageTargets[messageKey] || []),
@@ -1488,34 +1719,88 @@ async function buildSetCatalog(
         ...(overrideLocalesList.length > 0 ? { overrideLocales: overrideLocalesList } : {}),
       }),
     );
-    await writeJson(
+    await context.writer.write(
       path.join(outputDirectoryPath, "entities", "message", `${encodeKey(messageKey)}.json`),
       detail,
     );
-    await writeHistoryPages(
+  });
+  context.progress.done(messageDetailsStartedAt, `(${pluralize(messageKeys.length, "message")})`);
+
+  const messageHistoryStartedAt = context.progress.substep("Writing message history pages");
+  await mapWithConcurrency(messageKeys, 32, async (messageKey) => {
+    const skippedHistory = await writeHistoryPages(
+      context.writer,
       path.join(outputDirectoryPath, "history", "message", encodeKey(messageKey)),
       getHistoryForEntity(context.historyIndex, "message", messageKey, set || undefined),
+      { skipEmpty: true },
     );
-  }
+    skippedEmptyMessageHistoryCount += skippedHistory;
+    skippedEmptyHistoryCount += skippedHistory;
+  });
+  context.progress.done(
+    messageHistoryStartedAt,
+    `(${pluralize(messageKeys.length, "message")}, ${pluralize(
+      skippedEmptyMessageHistoryCount,
+      "empty history",
+      "empty histories",
+    )} skipped)`,
+  );
+  context.progress.done(
+    messagesStartedAt,
+    `(${pluralize(messageKeys.length, "message")}, ${pluralize(
+      skippedEmptyMessageHistoryCount,
+      "empty history",
+      "empty histories",
+    )} skipped)`,
+  );
 
   if (context.withTranslationSearch) {
+    const translationSearchStartedAt = context.progress.step("Building translation search shards");
+
+    for (const messageKey of messageKeys) {
+      const message = messages[messageKey];
+
+      for (const localeKey of localeKeys) {
+        const row = resolveTranslationRow(message.translations, localeKey, locales);
+        if (row.source !== "missing" && row.value) {
+          addToTranslationShard(messageKey, row.value);
+        }
+
+        for (const override of message.overrides || []) {
+          const overrideRow = resolveTranslationRow(override.translations, localeKey, locales);
+          if (overrideRow.source !== "missing" && overrideRow.value) {
+            addToTranslationShard(messageKey, overrideRow.value);
+          }
+        }
+      }
+    }
+
     for (const [prefix, messageMap] of Object.entries(translationShards)) {
       const shardData: Record<string, string[]> = {};
       for (const [msgKey, valueSet] of Object.entries(messageMap)) {
         shardData[msgKey] = Array.from(valueSet);
       }
-      await writeJson(path.join(outputDirectoryPath, "translations", `${prefix}.json`), shardData);
+      await context.writer.write(
+        path.join(outputDirectoryPath, "translations", `${prefix}.json`),
+        shardData,
+      );
     }
+    context.progress.done(
+      translationSearchStartedAt,
+      `(${pluralize(Object.keys(translationShards).length, "shard")})`,
+    );
   }
 
-  for (const attributeKey of attributeKeys) {
+  const attributesStartedAt = context.progress.step("Writing attributes");
+  await mapWithConcurrency(attributeKeys, 32, async (attributeKey) => {
     const attribute = attributes[attributeKey];
     const sourceFileInfo = getSourceFileInfo(
-      context.repositoryRootDirectoryPath,
+      context.repositorySourceRootDirectoryPath,
       context.rootDirectoryPath,
       projectConfig,
       "attribute",
       attributeKey,
+      { resolveAbsolutePath: context.devEditors.length > 0 },
     );
     const detail = {
       type: "attribute",
@@ -1547,26 +1832,31 @@ async function buildSetCatalog(
         },
       ),
     );
-    await writeJson(
+    await context.writer.write(
       path.join(outputDirectoryPath, "entities", "attribute", `${encodeKey(attributeKey)}.json`),
       detail,
     );
-    await writeHistoryPages(
+    skippedEmptyHistoryCount += await writeHistoryPages(
+      context.writer,
       path.join(outputDirectoryPath, "history", "attribute", encodeKey(attributeKey)),
       getHistoryForEntity(context.historyIndex, "attribute", attributeKey, set || undefined),
+      { skipEmpty: true },
     );
-  }
+  });
+  context.progress.done(attributesStartedAt, `(${pluralize(attributeKeys.length, "attribute")})`);
 
-  for (const segmentKey of segmentKeys) {
+  const segmentsStartedAt = context.progress.step("Writing segments");
+  await mapWithConcurrency(segmentKeys, 32, async (segmentKey) => {
     const segment = segments[segmentKey];
     const usedAttributes = new Set<string>();
     collectAttributeKeysFromConditions(segment.conditions, usedAttributes);
     const sourceFileInfo = getSourceFileInfo(
-      context.repositoryRootDirectoryPath,
+      context.repositorySourceRootDirectoryPath,
       context.rootDirectoryPath,
       projectConfig,
       "segment",
       segmentKey,
+      { resolveAbsolutePath: context.devEditors.length > 0 },
     );
     const detail = {
       type: "segment",
@@ -1586,17 +1876,21 @@ async function buildSetCatalog(
         targets: sortStrings(Array.from(segmentTargets[segmentKey] || [])),
       }),
     );
-    await writeJson(
+    await context.writer.write(
       path.join(outputDirectoryPath, "entities", "segment", `${encodeKey(segmentKey)}.json`),
       detail,
     );
-    await writeHistoryPages(
+    skippedEmptyHistoryCount += await writeHistoryPages(
+      context.writer,
       path.join(outputDirectoryPath, "history", "segment", encodeKey(segmentKey)),
       getHistoryForEntity(context.historyIndex, "segment", segmentKey, set || undefined),
+      { skipEmpty: true },
     );
-  }
+  });
+  context.progress.done(segmentsStartedAt, `(${pluralize(segmentKeys.length, "segment")})`);
 
-  for (const targetKey of targetKeys) {
+  const targetsStartedAt = context.progress.step("Writing targets");
+  await mapWithConcurrency(targetKeys, 32, async (targetKey) => {
     const target = targets[targetKey];
     const targetLocaleKeys = target.locales?.length ? target.locales : localeKeys;
     const formatsByLocale: Record<string, FormatPresets | undefined> = {};
@@ -1608,11 +1902,12 @@ async function buildSetCatalog(
     }
 
     const sourceFileInfo = getSourceFileInfo(
-      context.repositoryRootDirectoryPath,
+      context.repositorySourceRootDirectoryPath,
       context.rootDirectoryPath,
       projectConfig,
       "target",
       targetKey,
+      { resolveAbsolutePath: context.devEditors.length > 0 },
     );
     const detail = {
       type: "target",
@@ -1632,21 +1927,30 @@ async function buildSetCatalog(
         messageCount: targetMessages[targetKey].length,
       }),
     );
-    await writeJson(
+    await context.writer.write(
       path.join(outputDirectoryPath, "entities", "target", `${encodeKey(targetKey)}.json`),
       detail,
     );
-    await writeHistoryPages(
+    skippedEmptyHistoryCount += await writeHistoryPages(
+      context.writer,
       path.join(outputDirectoryPath, "history", "target", encodeKey(targetKey)),
       getHistoryForEntity(context.historyIndex, "target", targetKey, set || undefined),
+      { skipEmpty: true },
     );
-  }
+  });
+  context.progress.done(targetsStartedAt, `(${pluralize(targetKeys.length, "target")})`);
 
+  const indexStartedAt = context.progress.step("Writing catalog index");
   for (const type of Object.keys(index.entities) as CatalogEntityType[]) {
     index.entities[type].sort((a, b) => a.key.localeCompare(b.key));
   }
 
-  await writeJson(path.join(outputDirectoryPath, "index.json"), index);
+  await context.writer.write(path.join(outputDirectoryPath, "index.json"), index);
+  context.progress.done(indexStartedAt);
+  context.progress.done(
+    setStartedAt,
+    `total (${pluralize(skippedEmptyHistoryCount, "empty history", "empty histories")} skipped)`,
+  );
 
   return index;
 }
@@ -1685,23 +1989,69 @@ export async function exportCatalog(
     : projectConfig.catalogDirectoryPath;
   const dataDirectoryPath = path.join(outputDirectoryPath, "data");
   const withTranslationSearch = options.withTranslationSearch === true;
+  const withDuplicates = options.withDuplicates === true;
+  const progress = new CatalogProgressReporter(rootDirectoryPath, outputDirectoryPath);
+  const writer = new CatalogJsonWriter();
+
+  progress.start({
+    browserRouter: options.browserRouter !== false,
+    sets: projectConfig.sets === true,
+    features: [
+      ...(withTranslationSearch ? ["translation search"] : []),
+      ...(withDuplicates ? ["duplicates"] : []),
+    ],
+  });
 
+  let stepStartedAt = progress.step("Preparing output directory");
   await fs.promises.rm(outputDirectoryPath, { recursive: true, force: true });
   await fs.promises.mkdir(dataDirectoryPath, { recursive: true });
+  progress.done(stepStartedAt);
 
   if (options.copyAssets !== false) {
+    stepStartedAt = progress.step("Copying Catalog UI assets");
     await copyCatalogAssets(outputDirectoryPath);
+    progress.done(stepStartedAt);
   }
 
   const devEditors = options.dev ? options.devEditors || detectDevEditors() : [];
+  stepStartedAt = progress.step("Reading Git history");
   const historyIndex = await getGitHistoryIndex(rootDirectoryPath, projectConfig);
-  const duplicateTranslations = await runtime.findDuplicateTranslations(projectConfig, datasource);
-  const duplicateResultsBySet = Object.fromEntries(
-    duplicateTranslations.results.map((result) => [getDuplicateSetKey(result.set), result]),
-  );
+  progress.done(stepStartedAt, `(${pluralize(historyIndex.entries.length, "commit")})`);
+
+  stepStartedAt = progress.step("Resolving repository links");
+  const links = getRepoLinks(rootDirectoryPath);
+  progress.done(stepStartedAt);
+
+  let duplicateResultsBySet: Record<string, CatalogDuplicateTranslationsSetResult> = {};
+  if (withDuplicates) {
+    stepStartedAt = progress.step("Scanning duplicate translations");
+    duplicateResultsBySet = Object.fromEntries(
+      (await runtime.findDuplicateTranslations(projectConfig, datasource)).results.map((result) => [
+        getDuplicateSetKey(result.set),
+        result,
+      ]),
+    );
+    progress.done(
+      stepStartedAt,
+      `(${pluralize(
+        Object.values(duplicateResultsBySet).reduce(
+          (total, result) =>
+            total +
+            result.locales.reduce(
+              (localeTotal, localeResult) => localeTotal + localeResult.duplicateValues.length,
+              0,
+            ),
+          0,
+        ),
+        "duplicate value",
+      )})`,
+    );
+  }
+
   const context: CatalogBuildContext = {
     rootDirectoryPath,
     repositoryRootDirectoryPath: getRepositoryRootDirectoryPath(rootDirectoryPath),
+    repositorySourceRootDirectoryPath: getRepositorySourceRootDirectoryPath(rootDirectoryPath),
     outputDirectoryPath,
     dataDirectoryPath,
     historyIndex,
@@ -1709,11 +2059,27 @@ export async function exportCatalog(
     devEditors,
     duplicateResultsBySet,
     withTranslationSearch,
+    withDuplicates,
+    progress,
+    writer,
   };
+  stepStartedAt = progress.step("Discovering project sets");
   const executions = await runtime.getProjectSetExecutions(projectConfig, datasource);
+  progress.done(
+    stepStartedAt,
+    projectConfig.sets
+      ? `(${executions.map((execution) => execution.set).join(", ") || "none"})`
+      : "(root)",
+  );
   const setIndexes: Record<string, CatalogSetIndex> = {};
 
-  await writeHistoryPages(path.join(dataDirectoryPath, "project", "history"), historyIndex.entries);
+  stepStartedAt = progress.step("Writing project history");
+  await writeHistoryPages(
+    writer,
+    path.join(dataDirectoryPath, "project", "history"),
+    historyIndex.entries,
+  );
+  progress.done(stepStartedAt, `(${pluralize(historyIndex.entries.length, "entry", "entries")})`);
 
   for (const execution of executions) {
     const outputRelativeDirectory = projectConfig.sets ? path.join("sets", execution.set) : "root";
@@ -1726,6 +2092,7 @@ export async function exportCatalog(
     );
   }
 
+  stepStartedAt = progress.step("Writing manifest");
   const manifest = {
     schemaVersion: CATALOG_SCHEMA_VERSION,
     generatedAt: new Date().toISOString(),
@@ -1735,8 +2102,9 @@ export async function exportCatalog(
     dev: options.dev ? { editors: devEditors } : undefined,
     features: {
       translationSearch: withTranslationSearch,
+      duplicates: withDuplicates,
     },
-    links: getRepoLinks(rootDirectoryPath),
+    links,
     paths: {
       projectHistory: "data/project/history/page-1.json",
       root: projectConfig.sets ? undefined : "data/root/index.json",
@@ -1752,9 +2120,10 @@ export async function exportCatalog(
     counts: Object.fromEntries(Object.keys(setIndexes).map((key) => [key, setIndexes[key].counts])),
   };
 
-  await writeJson(path.join(dataDirectoryPath, "manifest.json"), manifest);
+  await writer.write(path.join(dataDirectoryPath, "manifest.json"), manifest);
+  progress.done(stepStartedAt);
 
-  console.log(`Catalog exported to ${outputDirectoryPath}`);
+  progress.complete();
 
   return {
     outputDirectoryPath,
@@ -2032,6 +2401,10 @@ function isWithTranslationSearchEnabled(parsed: CatalogPluginParsedOptions) {
   return parsed.withTranslationSearch === true || parsed["with-translation-search"] === true;
 }
 
+function isWithDuplicatesEnabled(parsed: CatalogPluginParsedOptions) {
+  return parsed.withDuplicates === true || parsed["with-duplicates"] === true;
+}
+
 export function createCatalogPlugin(
   runtime: CatalogRuntime,
   api: ReturnType<typeof createCatalogApi> = createCatalogApi(runtime),
@@ -2042,6 +2415,7 @@ export function createCatalogPlugin(
       const allowedSubcommands = ["export", "serve"];
       const browserRouter = !(parsed.hashRouter || parsed["hash-router"]);
       const withTranslationSearch = isWithTranslationSearchEnabled(parsed);
+      const withDuplicates = isWithDuplicatesEnabled(parsed);
 
       if (!parsed.subcommand) {
         await api.exportCatalog(rootDirectoryPath, projectConfig, datasource, {
@@ -2050,6 +2424,7 @@ export function createCatalogPlugin(
           browserRouter,
           dev: true,
           withTranslationSearch,
+          withDuplicates,
         });
         const server = await api.serveCatalog(rootDirectoryPath, projectConfig, datasource, {
           outDir: parsed.outDir,
@@ -2093,6 +2468,7 @@ export function createCatalogPlugin(
               browserRouter,
               dev: true,
               withTranslationSearch,
+              withDuplicates,
             });
             server.triggerReload();
           } catch (error) {
@@ -2141,6 +2517,7 @@ export function createCatalogPlugin(
           copyAssets: !parsed.noAssets,
           browserRouter,
           withTranslationSearch,
+          withDuplicates,
         });
       }