16433921444

Committed 22 Jul 2025 03:34AM UTC coverage: 60.246%. First build

Build # 16433921444

Build Type

Pull #530

github

Committed by

web-flow

Commit Message

Merge 3d2ac4e49 into 13de464a1

Pull Request Pull Request #530: Fix non-deterministic search-index.json generation

Run Details

421 of 714 branches covered (58.96%)

Branch coverage included in aggregate %.

26 of 28 new or added lines in 3 files covered. (92.86%)

658 of 1077 relevant lines covered (61.1%)

7.98 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/docusaurus-search-local/src/server/utils/postBuildFactory.ts

import fs from "fs";
import path from "path";
import util from "util";
import {
  ProcessedPluginOptions,
  PostBuildData,
  SearchDocument,
} from "../../shared/interfaces";
import { buildIndex } from "./buildIndex";
import { debugInfo } from "./debug";
import { processDocInfos } from "./processDocInfos";
import { scanDocuments } from "./scanDocuments";

const writeFileAsync = util.promisify(fs.writeFile);

export function postBuildFactory(
  config: ProcessedPluginOptions,
  searchIndexFilename: string
) {
  return async function postBuild(buildData: PostBuildData): Promise<void> {
    debugInfo("gathering documents");

    const data = processDocInfos(buildData, config);

    debugInfo("parsing documents");

    for (const versionData of data) {
      // Give every index entry a unique id so that the index does not need to store long URLs.
      const allDocuments = await scanDocuments(versionData.paths, config);

      debugInfo("building index");

      const docsByDirMap = new Map<string, SearchDocument[][]>();
      const {
        searchContextByPaths,
        hideSearchBarWithNoSearchContext,
        useAllContextsWithNoSearchContext,
      } = config;
      if (searchContextByPaths) {
        const { baseUrl } = buildData;
        const rootAllDocs: SearchDocument[][] = [];
        if (!hideSearchBarWithNoSearchContext) {
          docsByDirMap.set("", rootAllDocs);
        }
        let docIndex = 0;
        for (const documents of allDocuments) {
          rootAllDocs[docIndex] = [];
          for (const doc of documents) {
            if (doc.u.startsWith(baseUrl)) {
              const uri = doc.u.substring(baseUrl.length);
              const matchedPaths: string[] = [];
              for (const _path of searchContextByPaths) {
                const path = typeof _path === "string" ? _path : _path.path;
                if (uri === path || uri.startsWith(`${path}/`)) {
                  matchedPaths.push(path);
                }
              }
              for (const matchedPath of matchedPaths) {
                let dirAllDocs = docsByDirMap.get(matchedPath);
                if (!dirAllDocs) {
                  dirAllDocs = new Array(allDocuments.length);
                  docsByDirMap.set(matchedPath, dirAllDocs);
                }
                let dirDocs = dirAllDocs[docIndex];
                if (!dirDocs) {
                  dirAllDocs[docIndex] = dirDocs = [];
                }
                dirDocs.push(doc);
              }
              if (
                matchedPaths.length > 0 &&
                !useAllContextsWithNoSearchContext
              ) {
                continue;
              }
            }
            rootAllDocs[docIndex].push(doc);
          }
          docIndex++;
        }
      } else {
        docsByDirMap.set("", allDocuments);
      }

      for (const [k, allDocs] of Array.from(docsByDirMap.entries()).sort(([a], [b]) => a.localeCompare(b))) {
        const searchIndex = buildIndex(allDocs, config);

        debugInfo(`writing index (/${k}) to disk`);

        await writeFileAsync(
          path.join(
            versionData.outDir,
            searchIndexFilename.replace(
              "{dir}",
              k === "" ? "" : `-${k.replace(/\//g, "-")}`
            )
          ),
          JSON.stringify(searchIndex),
          { encoding: "utf8" }
        );

        debugInfo(`index (/${k}) written to disk successfully!`);
      }
    }
  };
}

1	import fs from "fs";
2	import path from "path";
3	import util from "util";
4	import {
5	ProcessedPluginOptions,
6	PostBuildData,
7	SearchDocument,
8	} from "../../shared/interfaces";
9	import { buildIndex } from "./buildIndex";
10	import { debugInfo } from "./debug";
11	import { processDocInfos } from "./processDocInfos";
12	import { scanDocuments } from "./scanDocuments";
13
14	const writeFileAsync = util.promisify(fs.writeFile);	×
15
16	export function postBuildFactory(
17	config: ProcessedPluginOptions,
18	searchIndexFilename: string
19	) {
20	return async function postBuild(buildData: PostBuildData): Promise<void> {	×
21	debugInfo("gathering documents");	×
22
23	const data = processDocInfos(buildData, config);	×
24
25	debugInfo("parsing documents");	×
26
27	for (const versionData of data) {	×
28	// Give every index entry a unique id so that the index does not need to store long URLs.
29	const allDocuments = await scanDocuments(versionData.paths, config);	×
30
31	debugInfo("building index");	×
32
33	const docsByDirMap = new Map<string, SearchDocument[][]>();	×
34	const {
35	searchContextByPaths,
36	hideSearchBarWithNoSearchContext,
37	useAllContextsWithNoSearchContext,
38	} = config;	×
39	if (searchContextByPaths) {	×
40	const { baseUrl } = buildData;	×
41	const rootAllDocs: SearchDocument[][] = [];	×
42	if (!hideSearchBarWithNoSearchContext) {	×
43	docsByDirMap.set("", rootAllDocs);	×
44	}
45	let docIndex = 0;	×
46	for (const documents of allDocuments) {	×
47	rootAllDocs[docIndex] = [];	×
48	for (const doc of documents) {	×
49	if (doc.u.startsWith(baseUrl)) {	×
50	const uri = doc.u.substring(baseUrl.length);	×
51	const matchedPaths: string[] = [];	×
52	for (const _path of searchContextByPaths) {	×
53	const path = typeof _path === "string" ? _path : _path.path;	×
54	if (uri === path \|\| uri.startsWith(`${path}/`)) {	×
55	matchedPaths.push(path);	×
56	}
57	}
58	for (const matchedPath of matchedPaths) {	×
59	let dirAllDocs = docsByDirMap.get(matchedPath);	×
60	if (!dirAllDocs) {	×
61	dirAllDocs = new Array(allDocuments.length);	×
62	docsByDirMap.set(matchedPath, dirAllDocs);	×
63	}
64	let dirDocs = dirAllDocs[docIndex];	×
65	if (!dirDocs) {	×
66	dirAllDocs[docIndex] = dirDocs = [];	×
67	}
68	dirDocs.push(doc);	×
69	}
70	if (	×
71	matchedPaths.length > 0 &&	×
72	!useAllContextsWithNoSearchContext
73	) {
74	continue;	×
75	}
76	}
77	rootAllDocs[docIndex].push(doc);	×
78	}
79	docIndex++;	×
80	}
81	} else {
82	docsByDirMap.set("", allDocuments);	×
83	}
84
NEW 85	for (const [k, allDocs] of Array.from(docsByDirMap.entries()).sort(([a], [b]) => a.localeCompare(b))) {	×
86	const searchIndex = buildIndex(allDocs, config);	×
87
88	debugInfo(`writing index (/${k}) to disk`);	×
89
90	await writeFileAsync(	×
91	path.join(
92	versionData.outDir,
93	searchIndexFilename.replace(
94	"{dir}",
95	k === "" ? "" : `-${k.replace(/\//g, "-")}`	×
96	)
97	),
98	JSON.stringify(searchIndex),
99	{ encoding: "utf8" }
100	);
101
102	debugInfo(`index (/${k}) written to disk successfully!`);	×
103	}
104	}
105	};
106	}

easyops-cn / docusaurus-search-local / 16433921444

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous