generate.mjs

import { buildSideBarProps } from './utils/buildBarProps.mjs';
import buildContent from './utils/buildContent.mjs';
import { getSortedHeadNodes } from './utils/getSortedHeadNodes.mjs';
import { groupNodesByModule } from '../../utils/generators.mjs';
import { getRemarkRecma } from '../../utils/remark.mjs';
import { relative } from '../../utils/url.mjs';

const remarkRecma = getRemarkRecma();

/**
 * Process a chunk of items in a worker thread.
 * Transforms metadata entries into JSX AST nodes.
 *
 * Each item is a SlicedModuleInput containing the head node
 * and all entries for that module - no need to recompute grouping.
 *
 * @type {import('./types').Generator['processChunk']}
 */
export async function processChunk(
  slicedInput,
  itemIndices,
  { docPages, stabilityOverviewEntries }
) {
  const results = [];

  for (const idx of itemIndices) {
    const { head, entries } = slicedInput[idx];

    const sideBarProps = buildSideBarProps(
      head,
      docPages.map(([heading, path]) => [
        heading,
        head.path === path
          ? `${head.basename}.html`
          : `${relative(path, head.path)}.html`,
      ])
    );

    const content = await buildContent(
      entries,
      head,
      sideBarProps,
      remarkRecma,
      stabilityOverviewEntries
    );

    results.push(content);
  }

  return results;
}

/**
 * Generates a JSX AST
 *
 * @type {import('./types').Generator['generate']}
 */
export async function* generate(input, worker) {
  const groupedModules = groupNodesByModule(input);

  const headNodes = getSortedHeadNodes(input);

  const docPages = headNodes.map(node => [node.heading.data.name, node.path]);

  // Pre-compute stability overview data once — avoid serialising full AST nodes to workers
  const stabilityOverviewEntries = headNodes
    .filter(node => node.stability)
    .map(({ api, heading, stability }) => {
      return {
        api,
        name: heading.data.name,
        stabilityIndex: parseInt(stability.data.index, 10),
        stabilityDescription: stability.data.description.split('. ')[0],
      };
    });

  // Create sliced input: each item contains head + its module's entries
  // This avoids sending all 4700+ entries to every worker
  const entries = headNodes.map(head => ({
    head,
    entries: groupedModules.get(head.api),
  }));

  for await (const chunkResult of worker.stream(entries, {
    docPages,
    stabilityOverviewEntries,
  })) {
    yield chunkResult;
  }
}