Function execute

packages/cli/src/cli/cmd/run/execute.ts:14–113

(input: CmdRunContext)

const WARN_CONCURRENCY_COUNT = 30;

export default async function execute(input: CmdRunContext) {
  const effectiveConcurrency = Math.min(
    input.flags.concurrency,
    input.tasks.length,
  );

  if (effectiveConcurrency >= WARN_CONCURRENCY_COUNT) {
    console.warn(
      chalk.yellow(
        `⚠️ High concurrency (${effectiveConcurrency}) may cause failures in some environments.`,
      ),
    );
  }

  console.log(chalk.hex(colors.orange)(`[Localization]`));

  return new Listr<CmdRunContext>(
    [
      {
        title: "Initializing localization engine",
        task: async (ctx, task) => {
          task.title = `Localization engine ${chalk.hex(colors.green)("ready")} (${ctx.localizer!.id})`;
        },
      },
      {
        title: `Processing localization tasks ${chalk.dim(
          `(tasks: ${input.tasks.length}, concurrency: ${effectiveConcurrency})`,
        )}`,
        task: async (ctx, task) => {
          if (input.tasks.length < 1) {
            task.title = `Skipping, nothing to localize.`;
            task.skip();
            return;
          }

          // Preload checksums for all unique bucket path patterns before starting any workers
          const initialChecksumsMap = new Map<string, Record<string, string>>();
          const uniqueBucketPatterns = _.uniq(
            ctx.tasks.map((t) => t.bucketPathPattern),
          );
          for (const bucketPathPattern of uniqueBucketPatterns) {
            const deltaProcessor = createDeltaProcessor(bucketPathPattern);
            const checksums = await deltaProcessor.loadChecksums();
            initialChecksumsMap.set(bucketPathPattern, checksums);
          }

          const i18nLimiter = pLimit(effectiveConcurrency);
          const ioLimiter = pLimit(1);

          const perFileIoLimiters = new Map<string, LimitFunction>();
          const getFileIoLimiter = (
            bucketPathPattern: string,
          ): LimitFunction => {
            const lockKey = bucketPathPattern;

            if (!perFileIoLimiters.has(lockKey)) {
              perFileIoLimiters.set(lockKey, pLimit(1));
            }