typesense-nextra-adapter 0.0.1

package/dist/client/Search.css

@@ -0,0 +1,184 @@
+:root {
+  --docsearch-primary-color: hsl(var(--nextra-primary-hue, 212) 100% 50%);
+  --docsearch-text-color: #111827;
+  --docsearch-muted-color: #4b5563;
+  --docsearch-container-background: #1818184d;
+  --docsearch-search-button-background: #0000000d;
+  --docsearch-search-button-hover-background: transparent;
+  --docsearch-search-button-text-color: #111827;
+  --docsearch-modal-background: #fff;
+  --docsearch-modal-shadow: 0 20px 25px -5px #0000001a, 0 10px 10px -5px #0000000a;
+  --docsearch-modal-width: 640px;
+  --docsearch-searchbox-background: #0000000d;
+  --docsearch-searchbox-focus-background: transparent;
+  --docsearch-searchbox-shadow: inset 0 0 0 2px var(--docsearch-primary-color);
+  --docsearch-hit-color: #1f2937;
+  --docsearch-hit-active-color: var(--docsearch-primary-color);
+  --docsearch-hit-background: #fafafa;
+  --docsearch-hit-shadow: none;
+  --docsearch-key-gradient: none;
+  --docsearch-key-shadow: none;
+  --docsearch-key-background: var(--nextra-bg, #fff);
+  --docsearch-key-color: #4b5563;
+  --docsearch-spacing: 12px;
+  --docsearch-footer-background: transparent;
+  --docsearch-footer-shadow: none;
+}
+
+html.dark {
+  --docsearch-text-color: #dadee4;
+  --docsearch-muted-color: #8f96a1;
+  --docsearch-search-button-background: #f9fafb1a;
+  --docsearch-search-button-text-color: #d1d5db;
+  --docsearch-modal-background: #111;
+  --docsearch-modal-shadow: 0 20px 25px -5px #00000080;
+  --docsearch-searchbox-background: #f9fafb1a;
+  --docsearch-hit-color: #d1d5db;
+  --docsearch-hit-background: #181818;
+  --docsearch-key-background: var(--nextra-bg, #111);
+  --docsearch-key-color: #9ca3af;
+  --docsearch-logo-color: #d1d5db;
+}
+
+.DocSearch-Container {
+  -webkit-backdrop-filter: blur(4px);
+  backdrop-filter: blur(4px);
+}
+
+#docsearch-list {
+  flex-direction: column;
+  gap: .25rem;
+  display: flex;
+}
+
+.DocSearch-Modal {
+  -webkit-backdrop-filter: blur(12px);
+  backdrop-filter: blur(12px);
+  border: 1px solid #e5e7eb;
+}
+
+html.dark .DocSearch-Modal {
+  border-color: #262626;
+}
+
+.DocSearch-Button {
+  border: 1px solid #0000;
+  border-radius: .5rem;
+  width: 100%;
+  margin: 0;
+  padding: .5rem .75rem;
+  transition: all .2s;
+}
+
+@media (min-width: 768px) {
+  .DocSearch-Button {
+    width: 16rem;
+  }
+}
+
+.DocSearch-Button:hover, .DocSearch-Button:focus {
+  border-color: var(--docsearch-primary-color);
+  box-shadow: 0 0 0 1px var(--docsearch-primary-color);
+  background: none;
+}
+
+.DocSearch-Button-Placeholder {
+  color: #4b5563;
+  font-size: 1rem;
+  line-height: 1.25;
+}
+
+html.dark .DocSearch-Button-Placeholder {
+  color: #9ca3af;
+}
+
+@media (min-width: 768px) {
+  .DocSearch-Button-Placeholder {
+    font-size: .875rem;
+  }
+}
+
+.DocSearch-Button-Keys {
+  gap: .25rem;
+  min-width: auto;
+}
+
+.DocSearch-Button-Key {
+  height: 1.25rem;
+  font-size: 11px;
+  font-family: var(--font-mono, monospace);
+  box-shadow: none;
+  border: 1px solid #0000001a;
+  border-radius: .25rem;
+  align-items: center;
+  margin: 0;
+  padding: 0 .375rem;
+  font-weight: 500;
+  display: flex;
+}
+
+html.dark .DocSearch-Button-Key {
+  border-color: #fff3;
+}
+
+.DocSearch-Hit-source {
+  color: var(--docsearch-muted-color);
+  padding: .5rem .625rem 0;
+  font-weight: 600;
+}
+
+.DocSearch-Hit {
+  padding-bottom: 0;
+}
+
+.DocSearch-Hit a {
+  box-shadow: none;
+  border: 1px solid #0000;
+  border-radius: .375rem;
+  transition: all .2s;
+}
+
+.DocSearch-Hit-title, .DocSearch-Hit[aria-selected="true"] .DocSearch-Hit-title {
+  margin-bottom: 2px;
+  color: var(--docsearch-hit-color) !important;
+}
+
+.DocSearch-Hit[aria-selected="true"] .DocSearch-Hit-path {
+  color: var(--docsearch-muted-color) !important;
+}
+
+.DocSearch-Hit[aria-selected="true"] a {
+  background-color: hsla(var(--nextra-primary-hue, 212),
+    100%,
+    50%,
+    .1);
+  color: var(--docsearch-primary-color);
+}
+
+.DocSearch-Hit mark, .DocSearch-Hit[aria-selected="true"] mark {
+  border-radius: 2px;
+  text-decoration: none;
+  background: hsla(var(--nextra-primary-hue, 212), 100%, 50%, .8) !important;
+  color: #fff !important;
+}
+
+.DocSearch-Screen-Icon svg {
+  margin: auto;
+}
+
+.DocSearch-Footer {
+  border-top: 1px solid #0000001a;
+}
+
+html.dark .DocSearch-Footer {
+  border-color: #ffffff1a;
+}
+
+.DocSearch-Commands-Key {
+  background-color: #e6e9eb;
+}
+
+html.dark .DocSearch-Commands-Key {
+  background-color: #22262d;
+}
+

package/dist/client/Search.d.ts

@@ -0,0 +1,22 @@
+import type { Locales } from './locales.js';
+import type { DocSearchProps } from 'typesense-docsearch-react';
+import 'typesense-docsearch-css';
+import './Search.css';
+export type TypesenseDocSearchProps = Omit<DocSearchProps, 'translations' | 'typesenseCollectionName' | 'typesenseSearchParameters'> & {
+    typesenseSearchParameters?: DocSearchProps['typesenseSearchParameters'];
+};
+export type SearchProps = {
+    docSearchProps: TypesenseDocSearchProps;
+    locales?: Locales;
+    /**
+     * The base collection name (e.g. 'my_docs').
+     * The component will auto-append the locale (e.g., 'my_docs_en').
+     */
+    collectionName: string;
+    /**
+     * Explicitly set the language.
+     * If omitted, it will attempt to detect it from Next.js route params ([lang] or [locale]).
+     */
+    lang?: string;
+};
+export declare function Search({ lang, ...props }: SearchProps): import("react/jsx-runtime").JSX.Element;

package/dist/client/Search.js

@@ -0,0 +1,134 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Suspense, lazy, useCallback, useEffect, useRef, useState } from "react";
+import { useParams } from "next/navigation";
+import "typesense-docsearch-css";
+import "./Search.css";
+const RealSearch = /*#__PURE__*/ lazy(()=>import("./RealSearch.js"));
+function Search({ lang, ...props }) {
+    const [isLoaded, setIsLoaded] = useState(false);
+    const isLoadedRef = useRef(false);
+    const triggerRef = useRef(null);
+    const params = useParams();
+    const detectedLang = lang || params?.lang || params?.locale || 'en';
+    const placeholder = props.locales?.[detectedLang]?.placeholder || 'Search';
+    const loadSearch = useCallback((trigger)=>{
+        if (!triggerRef.current) triggerRef.current = trigger;
+        if (!isLoadedRef.current) {
+            isLoadedRef.current = true;
+            setIsLoaded(true);
+        }
+    }, []);
+    useEffect(()=>{
+        let idleHandle;
+        idleHandle = 'requestIdleCallback' in window ? window.requestIdleCallback(()=>loadSearch('idle')) : setTimeout(()=>loadSearch('idle'), 2000);
+        const handleKeyDown = (event)=>{
+            const target = event.target;
+            if ('INPUT' === target.tagName || 'TEXTAREA' === target.tagName || target.isContentEditable) return;
+            const isCmdK = (event.metaKey || event.ctrlKey) && 'k' === event.key.toLowerCase();
+            const isSlash = '/' === event.key;
+            if (isCmdK || isSlash) {
+                if (!isLoadedRef.current) {
+                    event.preventDefault();
+                    loadSearch('keyboard');
+                }
+            }
+        };
+        window.addEventListener('keydown', handleKeyDown);
+        return ()=>{
+            if ('requestIdleCallback' in window) window.cancelIdleCallback(idleHandle);
+            else clearTimeout(idleHandle);
+            window.removeEventListener('keydown', handleKeyDown);
+        };
+    }, [
+        loadSearch
+    ]);
+    useEffect(()=>{
+        if (isLoaded && 'keyboard' === triggerRef.current) {
+            const interval = setInterval(()=>{
+                const button = document.querySelector('.DocSearch-Button:not(.DocSearch-Fake-Button)');
+                if (button) {
+                    button.click();
+                    clearInterval(interval);
+                    triggerRef.current = null;
+                }
+            }, 50);
+            const timeout = setTimeout(()=>clearInterval(interval), 5000);
+            return ()=>{
+                clearInterval(interval);
+                clearTimeout(timeout);
+            };
+        }
+    }, [
+        isLoaded
+    ]);
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: isLoaded ? /*#__PURE__*/ jsx(Suspense, {
+            fallback: /*#__PURE__*/ jsx(FakeSearchButton, {
+                placeholder: placeholder,
+                onMouseEnter: ()=>loadSearch('hover')
+            }),
+            children: /*#__PURE__*/ jsx(RealSearch, {
+                lang: detectedLang,
+                ...props
+            })
+        }) : /*#__PURE__*/ jsx(FakeSearchButton, {
+            placeholder: placeholder,
+            onClick: ()=>loadSearch('hover'),
+            onMouseEnter: ()=>loadSearch('hover')
+        })
+    });
+}
+function FakeSearchButton({ onClick, onMouseEnter, placeholder = 'Search' }) {
+    const [modifierKey, setModifierKey] = useState(null);
+    useEffect(()=>{
+        const isMac = /(Mac|iPhone|iPod|iPad)/i.test("u" > typeof navigator ? navigator.platform : '');
+        setModifierKey(isMac ? '⌘' : 'Ctrl');
+    }, []);
+    return /*#__PURE__*/ jsxs("button", {
+        type: "button",
+        className: "DocSearch DocSearch-Button DocSearch-Fake-Button",
+        "aria-label": "Search",
+        onClick: onClick,
+        onMouseEnter: onMouseEnter,
+        children: [
+            /*#__PURE__*/ jsxs("span", {
+                className: "DocSearch-Button-Container",
+                children: [
+                    /*#__PURE__*/ jsx("svg", {
+                        width: "20",
+                        height: "20",
+                        className: "DocSearch-Search-Icon",
+                        viewBox: "0 0 20 20",
+                        children: /*#__PURE__*/ jsx("path", {
+                            d: "M14.386 14.386l4.0877 4.0877-4.0877-4.0877c-2.9418 2.9419-7.7115 2.9419-10.6533 0-2.9419-2.9418-2.9419-7.7115 0-10.6533 2.9418-2.9419 7.7115-2.9419 10.6533 0 2.9419 2.9418 2.9419 7.7115 0 10.6533z",
+                            stroke: "currentColor",
+                            fill: "none",
+                            fillRule: "evenodd",
+                            strokeLinecap: "round",
+                            strokeLinejoin: "round"
+                        })
+                    }),
+                    /*#__PURE__*/ jsx("span", {
+                        className: "DocSearch-Button-Placeholder",
+                        children: placeholder
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsxs("span", {
+                className: "DocSearch-Button-Keys",
+                children: [
+                    /*#__PURE__*/ jsx("kbd", {
+                        className: "DocSearch-Button-Key",
+                        children: modifierKey
+                    }),
+                    /*#__PURE__*/ jsx("kbd", {
+                        className: "DocSearch-Button-Key",
+                        children: "K"
+                    })
+                ]
+            })
+        ]
+    });
+}
+export { Search };

package/dist/client/index.d.ts

@@ -0,0 +1,3 @@
+export { type Locales, RU_LOCALES, ZH_LOCALES, VN_LOCALES } from './locales.js';
+export { Search, type SearchProps } from './Search.js';
+export type { TypesenseDocSearchProps } from './Search.js';

package/dist/client/index.js

@@ -0,0 +1,2 @@
+export { RU_LOCALES, VN_LOCALES, ZH_LOCALES } from "./locales.js";
+export { Search } from "./Search.js";

package/dist/client/locales.d.ts

@@ -0,0 +1,8 @@
+import type { DocSearchProps } from 'typesense-docsearch-react';
+export type Locales = Record<string, {
+    translations: DocSearchProps['translations'];
+    placeholder: string;
+}>;
+export declare const ZH_LOCALES: Locales;
+export declare const RU_LOCALES: Locales;
+export declare const VN_LOCALES: Locales;

package/dist/client/locales.js

@@ -0,0 +1,130 @@
+const ZH_LOCALES = {
+    zh: {
+        placeholder: '搜索文档',
+        translations: {
+            button: {
+                buttonText: '搜索',
+                buttonAriaLabel: '搜索'
+            },
+            modal: {
+                searchBox: {
+                    resetButtonTitle: '清除查询条件',
+                    resetButtonAriaLabel: '清除查询条件',
+                    cancelButtonText: '取消',
+                    cancelButtonAriaLabel: '取消'
+                },
+                startScreen: {
+                    recentSearchesTitle: '搜索历史',
+                    noRecentSearchesText: '没有搜索历史',
+                    saveRecentSearchButtonTitle: '保存至搜索历史',
+                    removeRecentSearchButtonTitle: '从搜索历史中移除',
+                    favoriteSearchesTitle: '收藏',
+                    removeFavoriteSearchButtonTitle: '从收藏中移除'
+                },
+                errorScreen: {
+                    titleText: '无法获取结果',
+                    helpText: '你可能需要检查你的网络连接'
+                },
+                footer: {
+                    selectText: '选择',
+                    navigateText: '切换',
+                    closeText: '关闭',
+                    searchByText: '搜索提供者'
+                },
+                noResultsScreen: {
+                    noResultsText: '无法找到相关结果',
+                    suggestedQueryText: '你可以尝试查询',
+                    reportMissingResultsText: '你认为该查询应该有结果？',
+                    reportMissingResultsLinkText: '点击反馈'
+                }
+            }
+        }
+    }
+};
+const RU_LOCALES = {
+    ru: {
+        placeholder: 'Поиск в документации',
+        translations: {
+            button: {
+                buttonText: 'Поиск',
+                buttonAriaLabel: 'Поиск'
+            },
+            modal: {
+                searchBox: {
+                    resetButtonTitle: 'Очистить поиск',
+                    resetButtonAriaLabel: 'Очистить поиск',
+                    cancelButtonText: 'Закрыть',
+                    cancelButtonAriaLabel: 'Закрыть'
+                },
+                startScreen: {
+                    recentSearchesTitle: 'История поиска',
+                    noRecentSearchesText: 'Нет истории поиска',
+                    saveRecentSearchButtonTitle: 'Сохранить в истории поиска',
+                    removeRecentSearchButtonTitle: 'Удалить из истории поиска',
+                    favoriteSearchesTitle: 'Избранное',
+                    removeFavoriteSearchButtonTitle: 'Удалить из избранного'
+                },
+                errorScreen: {
+                    titleText: 'Невозможно получить результаты',
+                    helpText: 'Проверьте подключение к Интернету'
+                },
+                footer: {
+                    selectText: 'выбрать',
+                    navigateText: 'перейти',
+                    closeText: 'закрыть',
+                    searchByText: 'поиск от'
+                },
+                noResultsScreen: {
+                    noResultsText: 'Ничего не найдено',
+                    suggestedQueryText: 'Попробуйте изменить запрос',
+                    reportMissingResultsText: 'Считаете, что результаты должны быть?',
+                    reportMissingResultsLinkText: 'Сообщите об этом'
+                }
+            }
+        }
+    }
+};
+const VN_LOCALES = {
+    vn: {
+        placeholder: 'Tìm kiếm tài liệu',
+        translations: {
+            button: {
+                buttonText: 'Tìm kiếm',
+                buttonAriaLabel: 'Tìm kiếm'
+            },
+            modal: {
+                searchBox: {
+                    resetButtonTitle: 'Xóa truy vấn',
+                    resetButtonAriaLabel: 'Xóa truy vấn',
+                    cancelButtonText: 'Hủy',
+                    cancelButtonAriaLabel: 'Hủy'
+                },
+                startScreen: {
+                    recentSearchesTitle: 'Gần đây',
+                    noRecentSearchesText: 'Chưa có tìm kiếm gần đây',
+                    saveRecentSearchButtonTitle: 'Lưu tìm kiếm này',
+                    removeRecentSearchButtonTitle: 'Xóa tìm kiếm này khỏi lịch sử',
+                    favoriteSearchesTitle: 'Yêu thích',
+                    removeFavoriteSearchButtonTitle: 'Xóa tìm kiếm này khỏi mục yêu thích'
+                },
+                errorScreen: {
+                    titleText: 'Không thể tải kết quả',
+                    helpText: 'Hãy kiểm tra lại kết nối mạng của bạn.'
+                },
+                footer: {
+                    selectText: 'để chọn',
+                    navigateText: 'để di chuyển',
+                    closeText: 'để đóng',
+                    searchByText: 'Vận hành bởi'
+                },
+                noResultsScreen: {
+                    noResultsText: 'Không có kết quả cho',
+                    suggestedQueryText: 'Hãy thử tìm với từ khóa',
+                    reportMissingResultsText: 'Bạn nghĩ truy vấn này nên có kết quả?',
+                    reportMissingResultsLinkText: 'Hãy cho chúng tôi biết.'
+                }
+            }
+        }
+    }
+};
+export { RU_LOCALES, VN_LOCALES, ZH_LOCALES };

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+import type { ConfigurationOptions } from 'typesense/lib/Typesense/Configuration';
+import type { CustomCollectionSettingsConfig, DocSearchRecord } from './types.js';
+import { getDefaultCollectionFields } from './typesenseHelper.js';
+export type { CustomCollectionSettings, CustomCollectionSettingsConfig, DocSearchRecord, } from './types.js';
+export { getDefaultCollectionFields };
+export interface NextraTypesenseOptions {
+    /** Typesense server connection options. */
+    serverConfig: ConfigurationOptions;
+    /** The base name of the Typesense collection. */
+    collectionName: string;
+    /** Optional schema overrides. Can be a global settings object or a map keyed by language. */
+    customCollectionSettings?: CustomCollectionSettingsConfig;
+    /** Whether to index code blocks into Typesense. Defaults to `false`. */
+    indexCodeBlocks?: boolean;
+    /** Whether a failed indexing attempt should crash the process. Defaults to `true`. */
+    failOnIndexError?: boolean;
+    /** Hook to mutate or enrich the record before it gets indexed. */
+    transformRecord?: (record: DocSearchRecord, route: {
+        routePath: string;
+        filePath: string;
+    }) => DocSearchRecord;
+    /** The output directory to scan for HTML files. Defaults to '.next/server/app' */
+    outDir?: string;
+    /** Default language if the <html lang="..."> attribute is missing. Defaults to 'en' */
+    defaultLang?: string;
+    /**
+     * Maximum number of files to read and parse concurrently.
+     * Prevents "Too many open files" OS errors.
+     * @default 10
+     */
+    concurrencyLimit?: number;
+    /**
+     * Maximum number of records to accumulate before sending a batch request to Typesense.
+     * Lower this if your payloads are extremely large and hitting Typesense payload limits.
+     * @default 200
+     */
+    batchSize?: number;
+}
+export declare function indexNextraToTypesense(options: NextraTypesenseOptions): Promise<void>;

package/dist/index.js

@@ -0,0 +1,137 @@
+import path from "path";
+import { promises } from "fs";
+import { TypesenseHelper, getDefaultCollectionFields } from "./typesenseHelper.js";
+import { IndexFromHtml } from "./indexFromHtml.js";
+async function getHtmlFiles(dir) {
+    let results = [];
+    try {
+        const list = await promises.readdir(dir, {
+            withFileTypes: true
+        });
+        for (const dirent of list){
+            const filePath = path.resolve(dir, dirent.name);
+            if (dirent.isDirectory()) results = results.concat(await getHtmlFiles(filePath));
+            else if (filePath.endsWith('.html')) results.push(filePath);
+        }
+    } catch (err) {}
+    return results;
+}
+async function asyncPool(poolLimit, array, iteratorFn) {
+    const executing = new Set();
+    for (const item of array){
+        const p = Promise.resolve().then(()=>iteratorFn(item));
+        executing.add(p);
+        const clean = ()=>executing.delete(p);
+        p.then(clean).catch(clean);
+        if (executing.size >= poolLimit) await Promise.race(executing);
+    }
+    await Promise.all(executing);
+}
+async function indexNextraToTypesense(options) {
+    const outDir = options.outDir || path.join(process.cwd(), '.next/server/app');
+    const defaultLang = options.defaultLang || 'en';
+    const concurrencyLimit = options.concurrencyLimit || 10;
+    const batchSize = options.batchSize || 200;
+    console.log(`\n\x1b[36m[TypesensePlugin]\x1b[0m Scanning Next.js build directory: ${outDir}`);
+    const htmlFiles = await getHtmlFiles(outDir);
+    if (0 === htmlFiles.length) return void console.warn(`\n\x1b[33m⚠ [TypesensePlugin] No HTML files found in ${outDir}.\x1b[0m \x1b[90mSkipping indexing.\x1b[0m\n`);
+    const routeGroups = {};
+    console.log(`\n\x1b[90mExtracting languages for ${htmlFiles.length} files...\x1b[0m`);
+    await asyncPool(50, htmlFiles, async (filePath)=>{
+        const relativePath = path.relative(outDir, filePath);
+        if ([
+            '404.html',
+            '500.html',
+            '_not-found.html',
+            '_global-error.html'
+        ].includes(relativePath)) return;
+        let routePath = '/' + relativePath.replace(/\\/g, '/').replace(/\.html$/, '');
+        if ('/index' === routePath) routePath = '/';
+        else if (routePath.endsWith('/index')) routePath = routePath.replace(/\/index$/, '');
+        const fd = await promises.open(filePath, 'r');
+        const buffer = Buffer.alloc(2000);
+        await fd.read(buffer, 0, 2000, 0);
+        await fd.close();
+        const contentChunk = buffer.toString('utf-8');
+        const langMatch = contentChunk.match(/<html[^>]*\slang=(['"])(.*?)\1/i);
+        const locale = langMatch?.[2] || defaultLang;
+        if (!routeGroups[locale]) routeGroups[locale] = {
+            locale,
+            files: []
+        };
+        routeGroups[locale].files.push({
+            routePath,
+            filePath
+        });
+    });
+    if (0 === Object.keys(routeGroups).length) return void console.warn(`\n\x1b[33m⚠ [TypesensePlugin] No valid routes found for indexing.\x1b[0m`);
+    const extractor = new IndexFromHtml({
+        indexCodeBlocks: options.indexCodeBlocks ?? false
+    });
+    for(const groupKey in routeGroups){
+        const { locale, files } = routeGroups[groupKey];
+        const aliasName = `${options.collectionName}_${locale}`;
+        const collectionNameTmp = `${aliasName}_${Date.now()}`;
+        const maxRouteLength = files.reduce((max, f)=>Math.max(max, f.routePath.length), 0);
+        const padLength = Math.max(maxRouteLength + 4, 30);
+        console.log(`\n\x1b[1m\x1b[36m[TypesensePlugin]\x1b[0m \x1b[1mProcessing group:\x1b[0m \x1b[35m${aliasName}\x1b[0m \x1b[90m(${files.length} routes)\x1b[0m`);
+        const helper = new TypesenseHelper({
+            config: options.serverConfig,
+            aliasName,
+            collectionNameTmp,
+            customSettings: resolveCustomSettings(options.customCollectionSettings, locale),
+            locale,
+            isVersioned: false,
+            batchSize
+        });
+        try {
+            await helper.init();
+            await helper.createTmpCollection();
+        } catch (error) {
+            console.error(`\n\x1b[31m✖ Failed to create collection:\x1b[0m \x1b[37m${collectionNameTmp}\x1b[0m`);
+            if (false !== options.failOnIndexError) throw error;
+            continue;
+        }
+        let totalRecords = 0;
+        let criticalError = null;
+        await asyncPool(concurrencyLimit, files, async (file)=>{
+            if (criticalError) return;
+            try {
+                const content = await promises.readFile(file.filePath, 'utf-8');
+                let records = extractor.getRecords(content, file.routePath, locale);
+                if (options.transformRecord) records = records.map((record)=>options.transformRecord(record, {
+                        routePath: file.routePath,
+                        filePath: file.filePath
+                    }));
+                if (records.length > 0) {
+                    const added = await helper.addRecords(records, file.routePath, padLength);
+                    totalRecords += added;
+                }
+            } catch (error) {
+                if ('TYPESENSE_BATCH_ERROR' === error.message) {
+                    if (false !== options.failOnIndexError) criticalError = error;
+                } else {
+                    console.error(`  \x1b[31m✖\x1b[0m \x1b[37m${file.routePath}\x1b[0m \x1b[31mfailed to parse\x1b[0m`);
+                    if (false !== options.failOnIndexError) criticalError = error;
+                }
+            }
+        });
+        if (criticalError) throw criticalError;
+        try {
+            await helper.flushBatch();
+            await helper.commitTmpCollection();
+            console.log(`\x1b[32m✔ Indexing complete for\x1b[0m \x1b[35m${aliasName}\x1b[0m \x1b[90m—\x1b[0m \x1b[33m${totalRecords}\x1b[0m \x1b[90mtotal records!\x1b[0m`);
+        } catch (error) {
+            console.error(`\n\x1b[31m✖ Failed to flush remaining batch or commit collection.\x1b[0m`);
+            if (false !== options.failOnIndexError) throw error;
+        }
+    }
+}
+function resolveCustomSettings(settings, locale) {
+    if (!settings) return null;
+    const isGlobalConfig = 'token_separators' in settings || 'symbols_to_index' in settings || 'fields' in settings || 'enable_nested_fields' in settings;
+    if (isGlobalConfig) return settings;
+    const perLangSettings = settings;
+    return perLangSettings[locale] || null;
+}
+export { getDefaultCollectionFields, indexNextraToTypesense };

package/dist/indexFromHtml.d.ts

@@ -0,0 +1,19 @@
+import type { DocSearchRecord } from './types.js';
+export declare class IndexFromHtml {
+    private levels;
+    private selectors;
+    constructor(options?: {
+        indexCodeBlocks?: boolean;
+    });
+    getRecords(html: string, url: string, lang?: string): DocSearchRecord[];
+    private getLevelFromTag;
+    private generateEmptyHierarchy;
+    private getHierarchyRadio;
+    private getAnchor;
+    private getClosestAnchor;
+    private getObjectID;
+    /**
+     * Removes anchor links and invisible characters
+     */
+    private cleanText;
+}