#自定义搜索

// rspress.config.ts
import { defineConfig } from 'rspress/config';

export default defineConfig({
  themeConfig: {
    search: {
      // 启用搜索
      enabled: true,
      // 搜索占位符
      placeholder: '搜索文档...',
    },
  },
});

export default defineConfig({
  themeConfig: {
    search: {
      enabled: true,
      // 搜索字段
      searchFields: ['title', 'content', 'headers'],
      // 最大结果数
      maxResults: 10,
      // 最小搜索长度
      minSearchLength: 2,
      // 搜索快捷键
      hotkey: {
        key: 'k',
        meta: true, // Cmd/Ctrl + K
      },
    },
  },
});

import { defineConfig } from 'rspress/config';
import pluginSearch from '@rspress/plugin-search';

export default defineConfig({
  plugins: [
    pluginSearch({
      // 搜索模式
      mode: 'local',

      // 索引选项
      indexOptions: {
        // 要索引的字段
        fields: ['title', 'content', 'headers'],

        // 权重
        fieldWeights: {
          title: 10,
          headers: 5,
          content: 1,
        },

        // 最小词长度
        minWordLength: 2,

        // 停止词
        stopWords: ['the', 'a', 'an', 'and', 'or', 'but'],
      },

      // 搜索选项
      searchOptions: {
        // 最大结果数
        maxResults: 20,

        // 模糊匹配
        fuzzy: 0.2,

        // 前缀搜索
        prefix: true,

        // 高亮匹配
        highlight: true,
      },

      // UI 选项
      uiOptions: {
        placeholder: '搜索文档...',
        emptyText: '未找到结果',
        hotkey: 'k',
      },
    }),
  ],
});

pluginSearch({
  mode: 'local',

  // 自定义索引函数
  indexing: async (pages) => {
    const index = [];

    for (const page of pages) {
      // 提取和处理内容
      const sections = extractSections(page.content);

      for (const section of sections) {
        index.push({
          id: `${page.id}-${section.id}`,
          title: page.title,
          header: section.header,
          content: section.content,
          url: `${page.url}#${section.anchor}`,
          weight: calculateWeight(section),
        });
      }
    }

    return index;
  },
});

function extractSections(content: string) {
  // 按标题拆分内容
  const sections = [];
  const lines = content.split('\n');
  let currentSection = null;

  for (const line of lines) {
    if (line.startsWith('#')) {
      if (currentSection) {
        sections.push(currentSection);
      }
      currentSection = {
        id: generateId(),
        header: line.replace(/^#+\s*/, ''),
        content: '',
        anchor: generateAnchor(line),
      };
    } else if (currentSection) {
      currentSection.content += line + '\n';
    }
  }

  if (currentSection) {
    sections.push(currentSection);
  }

  return sections;
}

function calculateWeight(section) {
  // 根据内容计算权重
  const headerLevel = section.header.match(/^#+/)?.[0].length || 1;
  const contentLength = section.content.length;

  return (7 - headerLevel) * 2 + Math.min(contentLength / 100, 5);
}

import { defineConfig } from 'rspress/config';

export default defineConfig({
  themeConfig: {
    search: {
      provider: 'algolia',
      algolia: {
        // Algolia 配置
        appId: 'YOUR_APP_ID',
        apiKey: 'YOUR_SEARCH_API_KEY',
        indexName: 'YOUR_INDEX_NAME',

        // 搜索参数
        searchParameters: {
          facetFilters: ['language:zh-CN'],
          hitsPerPage: 10,
        },

        // UI 选项
        placeholder: '搜索文档...',
        translations: {
          button: {
            buttonText: '搜索',
            buttonAriaLabel: '搜索文档',
          },
          modal: {
            searchBox: {
              resetButtonTitle: '清除查询',
              resetButtonAriaLabel: '清除查询',
              cancelButtonText: '取消',
              cancelButtonAriaLabel: '取消',
            },
            footer: {
              selectText: '选择',
              navigateText: '导航',
              closeText: '关闭',
            },
          },
        },
      },
    },
  },
});

pluginSearch({
  mode: 'local',

  // 排除路径
  exclude: [
    '/admin/**',
    '/internal/**',
    '**/_*.md', // 排除私有文件
  ],

  // 包含路径
  include: [
    '/docs/**',
    '/guide/**',
    '/api/**',
  ],

  // 自定义分词
  tokenizer: (text) => {
    // 中文分词
    return text
      .split(/[\s\u3000]+/)
      .filter(word => word.length >= 2);
  },

  // 自定义评分
  scoring: {
    title: 10,
    heading: 5,
    content: 1,
    // 最新内容提升
    recency: (date) => {
      const days = (Date.now() - date.getTime()) / (1000 * 60 * 60 * 24);
      return Math.max(0, 1 - days / 365);
    },
  },
});

// 使用 Web Worker 进行搜索
// workers/search.worker.ts
import { buildIndex, search } from './search-engine';

let searchIndex;

self.addEventListener('message', async (event) => {
  const { type, data } = event.data;

  switch (type) {
    case 'build-index':
      searchIndex = await buildIndex(data);
      self.postMessage({ type: 'index-ready' });
      break;

    case 'search':
      const results = search(searchIndex, data.query);
      self.postMessage({ type: 'results', results });
      break;
  }
});

// utils/search-cache.ts
class SearchCache {
  private cache = new Map<string, any>();
  private maxSize = 100;

  get(query: string) {
    return this.cache.get(query);
  }

  set(query: string, results: any) {
    // LRU 缓存
    if (this.cache.size >= this.maxSize) {
      const firstKey = this.cache.keys().next().value;
      this.cache.delete(firstKey);
    }
    this.cache.set(query, results);
  }

  clear() {
    this.cache.clear();
  }
}

export const searchCache = new SearchCache();

async function performSearch(query: string) {
  // 检查缓存
  const cached = searchCache.get(query);
  if (cached) {
    return cached;
  }

  // 执行搜索
  const results = await search(query);

  // 缓存结果
  searchCache.set(query, results);

  return results;
}

// utils/search-analytics.ts
export function trackSearch(query: string, resultsCount: number) {
  // Google Analytics
  if (window.gtag) {
    window.gtag('event', 'search', {
      search_term: query,
      results_count: resultsCount,
    });
  }

  // 自定义分析
  fetch('/api/analytics/search', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      query,
      resultsCount,
      timestamp: Date.now(),
    }),
  });
}

// 跟踪流行查询
export class SearchInsights {
  private queries = new Map<string, number>();

  trackQuery(query: string) {
    const count = this.queries.get(query) || 0;
    this.queries.set(query, count + 1);
  }

  getPopularQueries(limit = 10) {
    return Array.from(this.queries.entries())
      .sort((a, b) => b[1] - a[1])
      .slice(0, limit)
      .map(([query, count]) => ({ query, count }));
  }

  trackNoResults(query: string) {
    // 记录没有结果的查询
    console.log('No results for:', query);
  }
}

const debouncedSearch = debounce(search, 300);

const throttledSearch = throttle(search, 500);