Function alignPatternToSource

packages/cli/src/cli/utils/buckets.ts:322–390

(
  pattern: string[],
  source: string[],
  locale: string,
  options?: { forbid?: { patternIndex: number; sourceIndex: number } },
)

// patternIndex to a given sourceIndex, which lets us probe for alternative
// [locale] placements.
function alignPatternToSource(
  pattern: string[],
  source: string[],
  locale: string,
  options?: { forbid?: { patternIndex: number; sourceIndex: number } },
): { patToSrc: number[] } | null {
  const patternLength = pattern.length;
  const sourceLength = source.length;
  const memo = new Map<string, boolean>();
  const parent = new Map<string, { i2: number; j2: number }>();
  const isDoubleStar = (segment: string) => segment === "**";
  const segmentMatches = (patternSegment: string, sourceSegment: string) => {
    const concrete = patternSegment.replaceAll("[locale]", locale);
    return minimatch(sourceSegment, concrete, { dot: true, nocase: true });
  };
  const forbid = options?.forbid;
  const key = (i: number, j: number) => `${i}|${j}`;
  const dfs = (i: number, j: number): boolean => {
    const memoKey = key(i, j);
    if (memo.has(memoKey)) {
      return memo.get(memoKey)!;
    }
    if (i === patternLength) {
      const done = j === sourceLength;
      memo.set(memoKey, done);
      return done;
    }
    let matched = false;
    if (isDoubleStar(pattern[i])) {
      for (let k = j; k <= sourceLength; k += 1) {
        if (dfs(i + 1, k)) {
          parent.set(memoKey, { i2: i + 1, j2: k });
          matched = true;
          break;
        }
      }
    } else if (j < sourceLength && segmentMatches(pattern[i], source[j])) {
      const blocked =
        forbid && forbid.patternIndex === i && forbid.sourceIndex === j;
      if (!blocked && dfs(i + 1, j + 1)) {
        parent.set(memoKey, { i2: i + 1, j2: j + 1 });
        matched = true;
      }
    }
    memo.set(memoKey, matched);
    return matched;
  };

  if (!dfs(0, 0)) {
    return null;
  }

  const patToSrc = Array(patternLength).fill(-1) as number[];
  let i = 0;
  let j = 0;
  while (i < patternLength) {
    const step = parent.get(key(i, j));
    if (!step) {