rspress-plugin-typesense 0.0.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Typesense
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,25 @@
+# Rspress Plugin Typesense 🦀🔎⚡️
+
+A plugin that brings lightning-fast, typo-tolerant search powered by Typesense to your Rspress site.
+
+## Getting started
+
+Install dependencies:
+
+```bash
+npm install rspress-plugin-typesense
+```
+
+## About Typesense & Rspress
+
+[**Typesense**](https://typesense.org/) is an open-source, lightning-fast search engine that delivers instant, typo-tolerant results with minimal setup. It's an open source alternative to Algolia and an easier-to-use alternative to ElasticSearch.
+
+[**Rspress**](https://rspress.rs/) is a high-performance static site generator for documentation websites. Built with Rust, it offers a modern development experience and produces blazing-fast static sites.
+
+Together, **Typesense** and **Rspress** provide a seamless way to add powerful, blazingly-fast search to modern documentation websites.
+
+## License
+
+Licensed under the Apache 2.0 License, Copyright © Typesense.
+
+See [LICENSE](../../LICENSE) for more information.

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import type { RspressPlugin } from '@rspress/core';
+import type { ConfigurationOptions } from 'typesense/lib/Typesense/Configuration';
+import type { CustomCollectionSettingsConfig } from './types.js';
+import { getDefaultCollectionFields } from './typesenseHelper.js';
+export type { CustomCollectionSettings, CustomCollectionSettingsConfig, } from './types.js';
+export { getDefaultCollectionFields };
+export interface TypesensePluginOptions {
+    typesenseOptions: ConfigurationOptions;
+    collectionName: string;
+    customCollectionSettings?: CustomCollectionSettingsConfig;
+}
+export declare function pluginTypesense(options: TypesensePluginOptions): RspressPlugin;

package/dist/index.js

@@ -0,0 +1,110 @@
+import path from "path";
+import fs from "fs";
+import { TypesenseHelper, getDefaultCollectionFields } from "./typesenseHelper.js";
+import { IndexFromHtml } from "./indexFromHtml.js";
+function pluginTypesense(options) {
+    let generatedRoutes = [];
+    return {
+        name: 'rspress-plugin-typesense',
+        config (config) {
+            return config;
+        },
+        async routeGenerated (routes) {
+            generatedRoutes = routes;
+        },
+        async afterBuild (config, isProd) {
+            if (!isProd) return;
+            const outDir = config.outDir || 'doc_build';
+            const defaultLang = config.lang || 'en';
+            const isVersioned = config.search?.versioned ?? true;
+            const defaultVersion = config.multiVersion?.default || '';
+            if (0 === generatedRoutes.length) return void console.warn(`\n\x1b[33m⚠ [TypesensePlugin] No routes generated.\x1b[0m \x1b[90mSkipping indexing.\x1b[0m\n`);
+            const routeGroups = {};
+            for (const route of generatedRoutes){
+                const possibleHomePages = [
+                    'index',
+                    route.lang ? `${route.lang}_index` : '',
+                    route.version ? `${route.version}_index` : '',
+                    route.version && route.lang ? `${route.version}_${route.lang}_index` : ''
+                ];
+                if (possibleHomePages.includes(route.pageName)) continue;
+                const locale = route.lang || defaultLang;
+                const groupKey = locale;
+                if (!routeGroups[groupKey]) routeGroups[groupKey] = {
+                    locale,
+                    routes: []
+                };
+                routeGroups[groupKey].routes.push(route);
+            }
+            if (0 === Object.keys(routeGroups).length) return void console.warn(`\n\x1b[33m⚠ [TypesensePlugin] No routes found for indexing.\x1b[0m \x1b[90mSkipping indexing process.\x1b[0m\n`);
+            const extractor = new IndexFromHtml();
+            for(const groupKey in routeGroups){
+                const { locale, routes } = routeGroups[groupKey];
+                const aliasName = `${options.collectionName}_${locale}`;
+                const collectionNameTmp = `${aliasName}_${Date.now()}`;
+                const maxRouteLength = routes.reduce((max, r)=>Math.max(max, r.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(${routes.length} routes)\x1b[0m`);
+                const localizedCustomSettings = resolveCustomSettings(options.customCollectionSettings, locale);
+                const helper = new TypesenseHelper({
+                    config: options.typesenseOptions,
+                    aliasName,
+                    collectionNameTmp,
+                    customSettings: localizedCustomSettings,
+                    locale,
+                    isVersioned
+                });
+                await helper.init();
+                await helper.createTmpCollection();
+                let totalRecords = 0;
+                for (const route of routes){
+                    const version = route.version || defaultVersion;
+                    let normalizedRoute = route.routePath.replace(/^\//, '');
+                    if (defaultVersion && normalizedRoute.startsWith(`${defaultVersion}/`)) normalizedRoute = normalizedRoute.substring(defaultVersion.length + 1);
+                    if (defaultLang && normalizedRoute.startsWith(`${defaultLang}/`)) normalizedRoute = normalizedRoute.substring(defaultLang.length + 1);
+                    let htmlPath = path.join(outDir, normalizedRoute);
+                    let fileFound = false;
+                    if (fs.existsSync(htmlPath + '.html')) {
+                        htmlPath += '.html';
+                        fileFound = true;
+                    } else if (fs.existsSync(path.join(htmlPath, 'index.html'))) {
+                        htmlPath = path.join(htmlPath, 'index.html');
+                        fileFound = true;
+                    }
+                    if (!fileFound) {
+                        const fillerLength = Math.max(2, padLength - route.routePath.length);
+                        const filler = '\x1b[90m' + '.'.repeat(fillerLength) + '\x1b[0m';
+                        console.warn(`  \x1b[33m⚠\x1b[0m \x1b[37m${route.routePath}\x1b[0m ${filler} \x1b[33mskipped\x1b[0m \x1b[90m(HTML not found)\x1b[0m`);
+                        continue;
+                    }
+                    try {
+                        const htmlContent = fs.readFileSync(htmlPath, 'utf-8');
+                        const records = extractor.getRecords(htmlContent, route.routePath, locale);
+                        if (isVersioned && version) records.forEach((r)=>r.version = version);
+                        if (records.length > 0) totalRecords += await helper.addRecords(records, route.routePath, false, padLength);
+                    } catch (error) {
+                        const fillerLength = Math.max(2, padLength - route.routePath.length);
+                        const filler = '\x1b[90m' + '.'.repeat(fillerLength) + '\x1b[0m';
+                        console.error(`  \x1b[31m✖\x1b[0m \x1b[37m${route.routePath}\x1b[0m ${filler} \x1b[31m failed\x1b[0m \x1b[90m(Processing error)\x1b[0m`);
+                        console.error(`    \x1b[31m↳ ${error instanceof Error ? error.message : error}\x1b[0m`);
+                    }
+                }
+                try {
+                    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(`[TypesensePlugin] Failed to commit collection ${aliasName}:`, error);
+                    throw error;
+                }
+            }
+        }
+    };
+}
+function resolveCustomSettings(settings, locale) {
+    if (!settings) return null;
+    const isGlobalConfig = 'token_separators' in settings || 'symbols_to_index' in settings || 'field_definitions' in settings || 'enable_nested_fields' in settings;
+    if (isGlobalConfig) return settings;
+    const perLangSettings = settings;
+    return perLangSettings[locale] || null;
+}
+export { getDefaultCollectionFields, pluginTypesense };

package/dist/indexFromHtml.d.ts

@@ -0,0 +1,16 @@
+import type { DocSearchRecord } from './types.js';
+export declare class IndexFromHtml {
+    private levels;
+    private selectors;
+    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;
+}

package/dist/indexFromHtml.js

@@ -0,0 +1,196 @@
+import crypto_0 from "crypto";
+import * as __rspack_external_cheerio from "cheerio";
+class IndexFromHtml {
+    levels = [
+        'lvl0',
+        'lvl1',
+        'lvl2',
+        'lvl3',
+        'lvl4',
+        'lvl5',
+        'lvl6'
+    ];
+    selectors = {
+        lvl0: {
+            selector: '.rp-nav-menu__item--active',
+            global: true
+        },
+        lvl1: {
+            selector: '.rp-doc h1',
+            global: false
+        },
+        lvl2: {
+            selector: '.rp-doc h2',
+            global: false
+        },
+        lvl3: {
+            selector: '.rp-doc h3',
+            global: false
+        },
+        lvl4: {
+            selector: '.rp-doc h4',
+            global: false
+        },
+        lvl5: {
+            selector: '.rp-doc h5',
+            global: false
+        },
+        lvl6: {
+            selector: '.rp-doc h6',
+            global: false
+        },
+        content: {
+            selector: '.rp-doc p, .rp-doc li, .rp-doc table, .rp-doc .rp-callout, .rp-doc .rp-codeblock__content .rp-codeblock__content__scroll-container',
+            global: false
+        }
+    };
+    getRecords(html, url, lang) {
+        const $ = __rspack_external_cheerio.load(html);
+        const records = [];
+        const getGlobalText = (selector)=>{
+            const el = $(selector).first();
+            return el.length ? this.cleanText(el) : null;
+        };
+        const globalHierarchy = {
+            lvl0: getGlobalText(this.selectors.lvl0.selector) || getGlobalText(this.selectors.lvl1.selector) || getGlobalText('.rp-sidebar-item--active .rp-sidebar-item__left') || $('title').text().trim() || 'Documentation'
+        };
+        const selectorString = Object.values(this.selectors).filter((s)=>!s.global).map((s)=>s.selector).join(', ');
+        const nodes = $(selectorString);
+        let previousHierarchy = this.generateEmptyHierarchy();
+        previousHierarchy.lvl0 = globalHierarchy.lvl0 || null;
+        const anchors = this.generateEmptyHierarchy();
+        nodes.each((index, element)=>{
+            const el = $(element);
+            const isNestedMatch = el.parents(selectorString).length > 0;
+            if (isNestedMatch) return;
+            const tagName = element.tagName.toLowerCase();
+            const currentLevel = this.getLevelFromTag(tagName);
+            const hierarchy = {
+                ...previousHierarchy
+            };
+            const currentLevelInt = this.levels.indexOf(currentLevel);
+            if ('content' !== currentLevel) {
+                const text = this.cleanText(el);
+                hierarchy[currentLevel] = text;
+                anchors[currentLevel] = this.getAnchor(el);
+                for(let i = currentLevelInt + 1; i < 7; i++){
+                    const lvlKey = `lvl${i}`;
+                    hierarchy[lvlKey] = null;
+                    anchors[lvlKey] = null;
+                }
+                previousHierarchy = {
+                    ...hierarchy
+                };
+            }
+            let content = null;
+            if ('content' === currentLevel) {
+                content = this.cleanText(el);
+                if (!content) return;
+            }
+            if (currentLevel.startsWith('lvl') && !hierarchy[currentLevel]) return;
+            const resolvedAnchor = this.getClosestAnchor(anchors);
+            let levelWeight;
+            if ('content' !== currentLevel) levelWeight = 100 - 10 * currentLevelInt;
+            else {
+                const isCodeBlock = el.hasClass('rp-codeblock__content__scroll-container') || el.parents('.rp-codeblock, pre').length > 0;
+                levelWeight = isCodeBlock ? 0 : 10;
+            }
+            const weight = {
+                page_rank: 0,
+                level: levelWeight,
+                position: index,
+                position_descending: nodes.length - index
+            };
+            const record = {
+                objectID: '',
+                url_without_anchor: url,
+                url: resolvedAnchor ? `${url}#${resolvedAnchor}` : url,
+                anchor: resolvedAnchor,
+                content: content,
+                hierarchy: hierarchy,
+                hierarchy_radio: this.getHierarchyRadio(hierarchy, currentLevel),
+                type: currentLevel,
+                weight: weight,
+                language: lang
+            };
+            record.objectID = this.getObjectID(record);
+            records.push(record);
+        });
+        return records;
+    }
+    getLevelFromTag(tagName) {
+        if ([
+            'h1',
+            'h2',
+            'h3',
+            'h4',
+            'h5',
+            'h6'
+        ].includes(tagName)) return `lvl${tagName.replace('h', '')}`;
+        return 'content';
+    }
+    generateEmptyHierarchy() {
+        return {
+            lvl0: null,
+            lvl1: null,
+            lvl2: null,
+            lvl3: null,
+            lvl4: null,
+            lvl5: null,
+            lvl6: null
+        };
+    }
+    getHierarchyRadio(hierarchy, currentLevel) {
+        const radio = this.generateEmptyHierarchy();
+        let isFound = false;
+        for(let i = 6; i >= 0; i--){
+            const level = `lvl${i}`;
+            const value = hierarchy[level];
+            if (!isFound && null !== value) {
+                if ('content' === currentLevel || level === currentLevel) {
+                    radio[level] = value;
+                    isFound = true;
+                    continue;
+                }
+            }
+            radio[level] = null;
+        }
+        return radio;
+    }
+    getAnchor(el) {
+        const id = el.attr('id');
+        return id || null;
+    }
+    getClosestAnchor(anchors) {
+        for(let i = 6; i >= 0; i--){
+            const val = anchors[`lvl${i}`];
+            if (val) return val;
+        }
+        return null;
+    }
+    getObjectID(record) {
+        const hierarchyToHash = {};
+        Object.keys(record.hierarchy).forEach((k)=>{
+            const val = record.hierarchy[k];
+            if (val) hierarchyToHash[k] = val;
+        });
+        const payload = {
+            hierarchy: hierarchyToHash,
+            url: record.url_without_anchor,
+            position: record.weight.position
+        };
+        const jsonStr = JSON.stringify(payload, Object.keys(payload).sort());
+        return crypto_0.createHash('sha1').update(jsonStr).digest('hex');
+    }
+    cleanText(el) {
+        const clone = el.clone();
+        clone.find('.rp-header-anchor').remove();
+        clone.find('br').replaceWith(' ');
+        clone.find('li, p, div, tr').append(' ');
+        let text = clone.text();
+        text = text.replace(/\u00A0/g, ' ').replace(/[\u200B-\u200D\uFEFF]/g, '').replace(/\s+/g, ' ').trim();
+        if (text.length > 10000) text = text.slice(0, 10000) + '...';
+        return text;
+    }
+}
+export { IndexFromHtml };

package/dist/runtime/RealSearch.d.ts

@@ -0,0 +1,10 @@
+import type { DocSearchProps } from 'typesense-docsearch-react';
+import type { Locales } from './locales.js';
+type SearchProps = {
+    docSearchProps: Omit<DocSearchProps, 'translations'>;
+    locales?: Locales;
+    versionedSearch?: boolean;
+};
+declare function Search({ locales, versionedSearch, docSearchProps: { typesenseCollectionName, transformItems, typesenseSearchParameters, ...docSearchProps }, }: SearchProps): import("react/jsx-runtime").JSX.Element;
+export type { SearchProps };
+export default Search;

package/dist/runtime/RealSearch.js

@@ -0,0 +1,55 @@
+import { Fragment, jsx } from "react/jsx-runtime";
+import { DocSearch } from "typesense-docsearch-react";
+import { useLang, useNavigate, useVersion } from "@rspress/core/runtime";
+import { Link } from "@theme";
+const Hit = ({ hit, children })=>/*#__PURE__*/ jsx(Link, {
+        href: hit.url,
+        children: children
+    });
+const safeEscapeHighlights = (str)=>{
+    if (!str) return str;
+    return str.replace(/<(?!mark>|\/mark>)/gi, '&lt;').replace(/(?<!<mark|<\/mark)>/gi, '&gt;');
+};
+function Search({ locales = {}, versionedSearch = true, docSearchProps: { typesenseCollectionName, transformItems, typesenseSearchParameters, ...docSearchProps } }) {
+    const navigate = useNavigate();
+    const version = useVersion();
+    const lang = useLang() || 'en';
+    const { translations, placeholder } = locales?.[lang] ?? {};
+    const resolvedCollectionName = `${typesenseCollectionName}_${lang}`;
+    const searchParams = {
+        ...typesenseSearchParameters || {}
+    };
+    const filters = [];
+    if (searchParams.filter_by) filters.push(`(${searchParams.filter_by})`);
+    if (versionedSearch && version) filters.push(`version:=\`${version}\``);
+    if (filters.length > 0) searchParams.filter_by = filters.join(' && ');
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: /*#__PURE__*/ jsx(DocSearch, {
+            typesenseCollectionName: resolvedCollectionName,
+            typesenseSearchParameters: searchParams,
+            placeholder: placeholder,
+            translations: translations,
+            transformItems: (items)=>{
+                const transformedItems = items.map((item)=>{
+                    const transformed = structuredClone(item);
+                    if (transformed._snippetResult?.content?.value) transformed._snippetResult.content.value = safeEscapeHighlights(transformed._snippetResult.content.value);
+                    if (transformed._highlightResult?.hierarchy) Object.values(transformed._highlightResult.hierarchy).forEach((level)=>{
+                        if (level?.value) level.value = safeEscapeHighlights(level.value);
+                    });
+                    return transformed;
+                });
+                if (transformItems) return transformItems(transformedItems);
+                return transformedItems;
+            },
+            navigator: {
+                navigate ({ itemUrl }) {
+                    navigate(itemUrl);
+                }
+            },
+            hitComponent: Hit,
+            ...docSearchProps
+        })
+    });
+}
+const RealSearch = Search;
+export default RealSearch;

package/dist/runtime/Search.css

@@ -0,0 +1,76 @@
+[class*="DocSearch"] {
+  --docsearch-searchbox-shadow: inset 0 0 0 2px var(--rp-c-brand);
+  --docsearch-primary-color: var(--rp-c-brand);
+  --docsearch-text-color: var(--rp-c-text-1);
+  --docsearch-secondary-text-color: var(--rp-c-text-2);
+  --docsearch-muted-color: var(--rp-c-text-2);
+  --docsearch-subtle-color: var(--rp-c-divider-light);
+  --docsearch-container-background: #3c3c3c66;
+  --docsearch-modal-background: var(--rp-c-bg);
+  --docsearch-search-button-background: color-mix(in srgb,
+    var(--rp-c-bg) 30%,
+    transparent);
+  --docsearch-search-button-text-color: var(--rp-c-text-2);
+  --docsearch-searchbox-background: color-mix(in srgb,
+    var(--rp-c-bg) 30%,
+    transparent);
+  --docsearch-searchbox-focus-background: color-mix(in srgb,
+    var(--rp-c-bg) 30%,
+    transparent);
+  --docsearch-hit-highlight-color: var(--rp-c-brand-tint);
+  --docsearch-hit-color: var(--rp-c-text-1);
+  --docsearch-hit-background: var(--rp-c-bg-soft);
+  --docsearch-hit-shadow: var(--rp-shadow-2);
+  --docsearch-footer-background: var(--rp-c-bg);
+  --docsearch-key-background: var(--rp-c-bg-mute);
+  --docsearch-key-color: var(--rp-c-text-2);
+  --docsearch-highlight-color: var(--rp-c-brand);
+  --docsearch-icon-color: var(--rp-c-text-1);
+  --docsearch-background-color: var(--rp-c-bg-mute);
+  --docsearch-focus-color: var(--rp-c-brand);
+  --docsearch-dropdown-menu-background: var(--rp-c-bg-soft);
+  --docsearch-dropdown-menu-item-hover-background: var(--rp-c-bg);
+}
+
+html.dark {
+  --docsearch-text-color: #f5f6f7;
+  --docsearch-container-background: #090a11cc;
+  --docsearch-modal-background: #15172a;
+  --docsearch-modal-shadow: inset 1px 1px 0 0 #2c2e40, 0 3px 8px 0 #000309;
+  --docsearch-searchbox-background: #090a11;
+  --docsearch-searchbox-focus-background: #000;
+  --docsearch-hit-color: #bec3c9;
+  --docsearch-hit-shadow: none;
+  --docsearch-hit-background: #090a11;
+  --docsearch-key-gradient: linear-gradient(-26.5deg,
+    #565872 0%,
+    #31355b 100%);
+  --docsearch-key-shadow: inset 0 -2px 0 0 #282d55, inset 0 0 1px 1px #51577d,
+    0 2px 2px 0 #0304094d;
+  --docsearch-footer-background: #1e2136;
+  --docsearch-footer-shadow: inset 0 1px 0 0 #494c6a80, 0 -4px 8px 0 #0003;
+  --docsearch-logo-color: #fff;
+  --docsearch-muted-color: #7f8497;
+}
+
+.DocSearch {
+  border-radius: var(--rp-radius-small);
+}
+
+.DocSearch-Button-Container > .DocSearch-Button-Placeholder {
+  font-size: .825rem;
+}
+
+.DocSearch-Button {
+  border: 1px solid var(--docsearch-subtle-color);
+}
+
+.DocSearch-Button:hover {
+  box-shadow: none;
+  color: var(--docsearch-search-button-text-color);
+}
+
+.DocSearch-Screen-Icon svg {
+  margin: auto;
+}
+

package/dist/runtime/Search.d.ts

@@ -0,0 +1,5 @@
+import type { SearchProps } from './RealSearch.js';
+import 'typesense-docsearch-css';
+import './Search.css';
+export declare function Search(props: SearchProps): import("react/jsx-runtime").JSX.Element;
+export type { SearchProps };

package/dist/runtime/Search.js

@@ -0,0 +1,131 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Suspense, lazy, useCallback, useEffect, useRef, useState } from "react";
+import "typesense-docsearch-css";
+import "./Search.css";
+import { useLang } from "@rspress/core/runtime";
+const RealSearch = /*#__PURE__*/ lazy(()=>import("./RealSearch.js"));
+function Search(props) {
+    const [isLoaded, setIsLoaded] = useState(false);
+    const isLoadedRef = useRef(false);
+    const triggerRef = useRef(null);
+    const lang = useLang() || 'en';
+    const placeholder = props.locales?.[lang]?.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, {
+                ...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/runtime/index.d.ts

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

package/dist/runtime/index.js

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

package/dist/runtime/locales.d.ts

@@ -0,0 +1,7 @@
+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;

package/dist/runtime/locales.js

@@ -0,0 +1,87 @@
+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: 'Сообщите об этом'
+                }
+            }
+        }
+    }
+};
+export { RU_LOCALES, ZH_LOCALES };

package/dist/types.d.ts

@@ -0,0 +1,42 @@
+import type { CollectionCreateSchema } from 'typesense/lib/Typesense/Collections';
+export interface Hierarchy {
+    [key: string]: string | null | undefined;
+    lvl0: string | null;
+    lvl1: string | null;
+    lvl2: string | null;
+    lvl3: string | null;
+    lvl4: string | null;
+    lvl5: string | null;
+    lvl6: string | null;
+}
+export interface RecordWeight {
+    page_rank: number;
+    level: number;
+    position: number;
+    position_descending: number;
+}
+export interface DocSearchRecord {
+    objectID: string;
+    url: string;
+    url_without_anchor: string;
+    anchor: string | null;
+    content: string | null;
+    hierarchy: Hierarchy;
+    hierarchy_radio: Hierarchy;
+    type: string;
+    weight: RecordWeight;
+    version?: string;
+    language?: string;
+    [key: string]: any;
+}
+export interface FieldsParams {
+    locale: string;
+    isVersioned: boolean;
+}
+export interface CustomCollectionSettings {
+    token_separators?: CollectionCreateSchema['token_separators'];
+    symbols_to_index?: CollectionCreateSchema['symbols_to_index'];
+    fields?: (params: FieldsParams) => CollectionCreateSchema['fields'];
+    enable_nested_fields?: CollectionCreateSchema['enable_nested_fields'];
+}
+export type CustomCollectionSettingsConfig = CustomCollectionSettings | Record<string, CustomCollectionSettings>;

package/dist/typesenseHelper.d.ts

@@ -0,0 +1,50 @@
+import type { CollectionCreateSchema } from 'typesense/lib/Typesense/Collections';
+import type { ConfigurationOptions } from 'typesense/lib/Typesense/Configuration';
+import type { DocSearchRecord, CustomCollectionSettings, FieldsParams } from './types.js';
+export interface TypesenseHelperOptions {
+    config: ConfigurationOptions;
+    aliasName: string;
+    collectionNameTmp: string;
+    customSettings: CustomCollectionSettings | null;
+    locale: string;
+    isVersioned: boolean;
+}
+export declare class TypesenseHelper {
+    private typesenseClient;
+    private aliasName;
+    private collectionNameTmp;
+    private collectionLocale;
+    private customSettings;
+    private isVersioned;
+    private typesenseVersion;
+    constructor(options: TypesenseHelperOptions);
+    init(): Promise<void>;
+    createTmpCollection(): Promise<void>;
+    addRecords(records: DocSearchRecord[], fileName: string, fromSitemap: boolean, padLength?: number): Promise<number>;
+    commitTmpCollection(): Promise<void>;
+    static transformRecord(record: DocSearchRecord, isVersioned: boolean): any;
+    private getOldCollectionName;
+    private transferSynonyms;
+    private transferOverrides;
+}
+/**
+ * Returns the default collection fields used when creating a Typesense collection.
+ *
+ * Use this when you need to customize specific fields without redefining the entire schema.
+ * The `version` field is automatically included when `isVersioned` is `true`.
+ *
+ * @param locale - The locale used for text fields (e.g. `'en'`, `'zh'`).
+ * @param isVersioned - When `true`, appends the `version` field to the returned fields.
+ *
+ * @example
+ * // Adding a custom field while keeping defaults:
+ * customLocaleCollectionSettings: {
+ *   en: {
+ *     fields: (params) => [
+ *       ...getDefaultCollectionFields(params),
+ *       { name: 'my_custom_field', type: 'string', locale },
+ *     ],
+ *   },
+ * }
+ */
+export declare function getDefaultCollectionFields({ locale, isVersioned, }: FieldsParams): CollectionCreateSchema['fields'];

package/dist/typesenseHelper.js

@@ -0,0 +1,204 @@
+import { Client } from "typesense";
+class TypesenseHelper {
+    typesenseClient;
+    aliasName;
+    collectionNameTmp;
+    collectionLocale;
+    customSettings;
+    isVersioned;
+    typesenseVersion = 0;
+    constructor(options){
+        const clientConfig = {
+            ...options.config
+        };
+        clientConfig.connectionTimeoutSeconds = clientConfig.connectionTimeoutSeconds || 1800;
+        clientConfig.retryIntervalSeconds = clientConfig.retryIntervalSeconds || 1;
+        clientConfig.numRetries = clientConfig.numRetries || 3;
+        clientConfig.healthcheckIntervalSeconds = clientConfig.healthcheckIntervalSeconds || 60;
+        clientConfig.logLevel = clientConfig.logLevel || 'error';
+        this.typesenseClient = new Client(clientConfig);
+        this.aliasName = options.aliasName;
+        this.collectionNameTmp = options.collectionNameTmp;
+        this.collectionLocale = options.locale || process.env.TYPESENSE_COLLECTION_LOCALE || 'en';
+        this.customSettings = options.customSettings;
+        this.isVersioned = options.isVersioned;
+    }
+    async init() {
+        const debugInfo = await this.typesenseClient.debug.retrieve();
+        const version = debugInfo.version;
+        if ('nightly' === version) this.typesenseVersion = 30;
+        else this.typesenseVersion = parseInt(version.split('.')[0], 10);
+    }
+    async createTmpCollection() {
+        if (0 === this.typesenseVersion) await this.init();
+        try {
+            await this.typesenseClient.collections(this.collectionNameTmp).delete();
+        } catch (error) {
+            if (error?.httpStatus !== 404) {
+                console.error('[TypesensePlugin] Error:');
+                throw error;
+            }
+        }
+        const schema = {
+            name: this.collectionNameTmp,
+            fields: getDefaultCollectionFields({
+                locale: this.collectionLocale,
+                isVersioned: this.isVersioned
+            }),
+            default_sorting_field: 'item_priority',
+            token_separators: [
+                '_',
+                '-'
+            ]
+        };
+        if (this.customSettings) {
+            if (this.customSettings.token_separators) schema.token_separators = this.customSettings.token_separators;
+            if (this.customSettings.fields) schema.fields = this.customSettings.fields({
+                locale: this.collectionLocale,
+                isVersioned: this.isVersioned
+            });
+            if (this.customSettings.symbols_to_index) schema.symbols_to_index = this.customSettings.symbols_to_index;
+            if (void 0 !== this.customSettings.enable_nested_fields) schema.enable_nested_fields = this.customSettings.enable_nested_fields;
+        }
+        await this.typesenseClient.collections().create(schema);
+    }
+    async addRecords(records, fileName, fromSitemap, padLength = 40) {
+        const transformedRecords = records.map((r)=>TypesenseHelper.transformRecord(r, this.isVersioned));
+        const recordCount = transformedRecords.length;
+        const results = await this.typesenseClient.collections(this.collectionNameTmp).documents().import(transformedRecords, {
+            action: 'create'
+        });
+        const failedItems = results.filter((r)=>false === r.success);
+        if (failedItems.length > 0) {
+            console.error('Typesense Import Failed:', JSON.stringify(failedItems, null, 2));
+            throw new Error('Failed to import some records');
+        }
+        const iconColor = fromSitemap ? '\x1b[36m' : '\x1b[32m';
+        const fillerLength = Math.max(2, padLength - fileName.length);
+        const filler = '\x1b[90m' + '.'.repeat(fillerLength) + '\x1b[0m';
+        const paddedCount = recordCount.toString().padStart(4, ' ');
+        console.log(`  ${iconColor}✔\x1b[0m \x1b[37m${fileName}\x1b[0m ${filler} \x1b[33m${paddedCount}\x1b[0m \x1b[90mrecords\x1b[0m`);
+        return recordCount;
+    }
+    async commitTmpCollection() {
+        const oldCollectionName = await this.getOldCollectionName();
+        if (oldCollectionName) {
+            await this.transferSynonyms(oldCollectionName);
+            await this.transferOverrides(oldCollectionName);
+        }
+        await this.typesenseClient.aliases().upsert(this.aliasName, {
+            collection_name: this.collectionNameTmp
+        });
+        if (oldCollectionName) await this.typesenseClient.collections(oldCollectionName).delete();
+    }
+    static transformRecord(record, isVersioned) {
+        const transformedRecord = {};
+        const excludeKeys = [
+            'weight',
+            'language',
+            'tags',
+            '.*_tag'
+        ];
+        for(const key in record)if (null !== record[key] && void 0 !== record[key] && !excludeKeys.includes(key)) transformedRecord[key] = record[key];
+        if (record.weight) transformedRecord['item_priority'] = 1000000000 * record.weight.page_rank + 1000 * record.weight.level + record.weight.position_descending;
+        else transformedRecord['item_priority'] = 0;
+        for(let x = 0; x < 7; x++){
+            const lvlKey = `lvl${x}`;
+            if (record.hierarchy && null != record.hierarchy[lvlKey]) transformedRecord[`hierarchy.lvl${x}`] = record.hierarchy[lvlKey];
+            if (record.hierarchy_radio && null != record.hierarchy_radio[lvlKey]) transformedRecord[`hierarchy_radio.lvl${x}`] = record.hierarchy_radio[lvlKey];
+        }
+        if (isVersioned && record.version && 'string' == typeof record.version) transformedRecord['version'] = record.version.split(',');
+        else if (!isVersioned) delete transformedRecord['version'];
+        return transformedRecord;
+    }
+    async getOldCollectionName() {
+        try {
+            const alias = await this.typesenseClient.aliases(this.aliasName).retrieve();
+            return alias.collection_name;
+        } catch (error) {
+            if (error?.httpStatus === 404) return null;
+            throw error;
+        }
+    }
+    async transferSynonyms(oldCollectionName) {
+        if (this.typesenseVersion >= 30) {
+            const oldCollection = await this.typesenseClient.collections(oldCollectionName).retrieve();
+            const synonyms = oldCollection.synonym_sets || [];
+            for (const syn of synonyms)await this.typesenseClient.collections(this.collectionNameTmp).synonyms().upsert(syn.id, syn);
+            return;
+        }
+        const result = await this.typesenseClient.collections(oldCollectionName).synonyms().retrieve();
+        const synonyms = result.synonyms || [];
+        for (const synonym of synonyms){
+            const { id, ...synonymKeys } = synonym;
+            await this.typesenseClient.collections(this.collectionNameTmp).synonyms().upsert(synonym.id, synonymKeys);
+        }
+    }
+    async transferOverrides(oldCollectionName) {
+        if (this.typesenseVersion >= 30) {
+            const oldCollection = await this.typesenseClient.collections(oldCollectionName).retrieve();
+            const curations = oldCollection.curation_sets || [];
+            for (const cur of curations)await this.typesenseClient.collections(this.collectionNameTmp).overrides().upsert(cur.id, cur);
+            return;
+        }
+        const result = await this.typesenseClient.collections(oldCollectionName).overrides().retrieve();
+        const overrides = result.overrides || [];
+        for (const override of overrides){
+            const { id, ...overrideKeys } = override;
+            await this.typesenseClient.collections(this.collectionNameTmp).overrides().upsert(override.id, overrideKeys);
+        }
+    }
+}
+function getDefaultCollectionFields({ locale, isVersioned }) {
+    const baseFields = [
+        {
+            name: 'anchor',
+            type: 'string',
+            optional: true
+        },
+        {
+            name: 'content',
+            type: 'string',
+            locale,
+            optional: true
+        },
+        {
+            name: 'url',
+            type: 'string',
+            facet: true
+        },
+        {
+            name: 'url_without_anchor',
+            type: 'string',
+            facet: true,
+            optional: true
+        },
+        ...Array.from({
+            length: 7
+        }).map((_, i)=>({
+                name: `hierarchy.lvl${i}`,
+                type: 'string',
+                facet: true,
+                locale,
+                optional: true
+            })),
+        {
+            name: 'type',
+            type: 'string',
+            facet: true,
+            optional: true
+        },
+        {
+            name: 'item_priority',
+            type: 'int64'
+        }
+    ];
+    if (isVersioned) baseFields.push({
+        name: 'version',
+        type: 'string',
+        facet: true,
+        optional: true
+    });
+    return baseFields;
+}
+export { TypesenseHelper, getDefaultCollectionFields };

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "rspress-plugin-typesense",
+  "description": "A plugin to add Typesense-powered search to your Rspress site",
+  "version": "0.0.1",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime/index.d.ts",
+      "default": "./dist/runtime/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rslib build",
+    "dev": "rslib build --watch"
+  },
+  "devDependencies": {
+    "@rslib/core": "^0.20.1",
+    "@types/node": "^24.12.0",
+    "rsbuild-plugin-publint": "^0.3.4",
+    "typescript": "^6.0.2"
+  },
+  "peerDependencies": {
+    "@rspress/core": "^2.0.8"
+  },
+  "dependencies": {
+    "cheerio": "^1.2.0",
+    "typesense-docsearch-css": "^0.4.1",
+    "typesense-docsearch-react": "^3.4.1"
+  },
+  "keywords": [
+    "typesense",
+    "documentation-search",
+    "search",
+    "rspress-plugin",
+    "rspress",
+    "plugin"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/typesense/rspress-plugin-typesense.git"
+  },
+  "bugs": "https://github.com/typesense/rspress-plugin-typesense/issues",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  }
+}