@mui/internal-docs-infra 0.3.1-canary.3 → 0.3.1-canary.5

package/esm/useSearch/useSearch.js

@@ -1,10 +1,5 @@
 'use client';
 
-import _regenerator from "@babel/runtime/helpers/esm/regenerator";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import * as React from 'react';
 import { create, insertMultiple, search as oramaSearch } from '@orama/orama';
 import { pluginQPS } from '@orama/plugin-qps';
@@ -12,13 +7,11 @@ import { stemmer, language } from '@orama/stemmers/english';
 import { stopwords as englishStopwords } from '@orama/stopwords/english';
 // https://github.com/oramasearch/orama/blob/main/packages/stopwords/lib/en.js
 // Removed words that might be meaningful in a software documentation context
-var stopWords = englishStopwords.filter(function (word) {
-  return word !== 'about' && word !== 'but' &&
-  // start of button
-  word !== 'for' &&
-  // part of form
-  word !== 'between' && word !== 'before' && word !== 'after' && word !== 'above' && word !== 'below' && word !== 'once' && word !== 'then' && word !== 'where' && word !== 'to' && word !== 'from' && word !== 'up' && word !== 'down' && word !== 'in' && word !== 'out' && word !== 'on' && word !== 'off' && word !== 'over' && word !== 'under';
-});
+const stopWords = englishStopwords.filter(word => word !== 'about' && word !== 'but' &&
+// start of button
+word !== 'for' &&
+// part of form
+word !== 'between' && word !== 'before' && word !== 'after' && word !== 'above' && word !== 'below' && word !== 'once' && word !== 'then' && word !== 'where' && word !== 'to' && word !== 'from' && word !== 'up' && word !== 'down' && word !== 'in' && word !== 'out' && word !== 'on' && word !== 'off' && word !== 'over' && word !== 'under');
 
 /**
  * Type for our search document structure
@@ -27,7 +20,7 @@ var stopWords = englishStopwords.filter(function (word) {
 /**
  * Orama schema definition for our search document
  */
-var searchSchema = {
+const searchSchema = {
   type: 'string',
   group: 'string',
   title: 'string',
@@ -42,7 +35,7 @@ var searchSchema = {
   sections: 'string',
   subsections: 'string',
   part: 'string',
-  "export": 'string',
+  export: 'string',
   props: 'string',
   dataAttributes: 'string',
   cssVariables: 'string',
@@ -58,39 +51,33 @@ var searchSchema = {
  * Default function to flatten a sitemap page into search results
  */
 function defaultFlattenPage(page, sectionData, includeCategoryInGroup, excludeSections, generateSlug) {
-  var _page$keywords;
-  var results = [];
+  const results = [];
 
   // Extract top-level sections and all subsections with their slugs
   // Re-slugify from titles using the provided slugify function to match actual page IDs
-  var sections = [];
-  var subsections = [];
+  const sections = [];
+  const subsections = [];
   if (page.sections) {
-    var _loop = function _loop() {
-      var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-        originalSlug = _Object$entries$_i[0],
-        sectionInfo = _Object$entries$_i[1];
+    // Top-level sections are the direct children
+    for (const [originalSlug, sectionInfo] of Object.entries(page.sections)) {
       // Use generateSlug if provided, otherwise use the original slug from sitemap
-      var slug = generateSlug ? generateSlug(sectionInfo.title, []) : originalSlug;
+      const slug = generateSlug ? generateSlug(sectionInfo.title, []) : originalSlug;
       sections.push({
         title: sectionInfo.title,
-        slug: slug
+        slug
       });
 
       // Subsections are all nested children (recursively)
       if (sectionInfo.children && Object.keys(sectionInfo.children).length > 0) {
-        var _extractWithSlugs = function extractWithSlugs(hierarchy, parentSlugs, parentTitles) {
-          var items = [];
-          for (var _i2 = 0, _Object$entries2 = Object.entries(hierarchy); _i2 < _Object$entries2.length; _i2++) {
-            var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
-              childOriginalSlug = _Object$entries2$_i[0],
-              childData = _Object$entries2$_i[1];
+        const extractWithSlugs = (hierarchy, parentSlugs, parentTitles) => {
+          const items = [];
+          for (const [childOriginalSlug, childData] of Object.entries(hierarchy)) {
             // Use generateSlug if provided, otherwise use the original slug from sitemap
             // When generateSlug is provided, pass parent titles for context
             // (e.g., for Releases pages: v1.0.0-rc.0-autocomplete)
-            var childSlug = generateSlug ? generateSlug(childData.title, parentTitles) : childOriginalSlug;
-            var currentSlugs = [].concat(_toConsumableArray(parentSlugs), [childSlug]);
-            var currentTitles = [].concat(_toConsumableArray(parentTitles), [childData.title]);
+            const childSlug = generateSlug ? generateSlug(childData.title, parentTitles) : childOriginalSlug;
+            const currentSlugs = [...parentSlugs, childSlug];
+            const currentTitles = [...parentTitles, childData.title];
             items.push({
               title: childData.title,
               slug: childSlug,
@@ -98,66 +85,57 @@ function defaultFlattenPage(page, sectionData, includeCategoryInGroup, excludeSe
               parentTitles: currentTitles
             });
             if (childData.children && Object.keys(childData.children).length > 0) {
-              items.push.apply(items, _toConsumableArray(_extractWithSlugs(childData.children, currentSlugs, currentTitles)));
+              items.push(...extractWithSlugs(childData.children, currentSlugs, currentTitles));
             }
           }
           return items;
         };
-        subsections.push.apply(subsections, _toConsumableArray(_extractWithSlugs(sectionInfo.children, [slug], [sectionInfo.title])));
+        subsections.push(...extractWithSlugs(sectionInfo.children, [slug], [sectionInfo.title]));
       }
-    };
-    // Top-level sections are the direct children
-    for (var _i = 0, _Object$entries = Object.entries(page.sections); _i < _Object$entries.length; _i++) {
-      _loop();
     }
   }
-  var flattened = {};
-  if ((_page$keywords = page.keywords) != null && _page$keywords.length) {
+  const flattened = {};
+  if (page.keywords?.length) {
     flattened.keywords = page.keywords.join(' ');
   }
   if (sections.length > 0) {
-    flattened.sections = sections.map(function (s) {
-      return s.title;
-    }).join(' ');
+    flattened.sections = sections.map(s => s.title).join(' ');
   }
   if (subsections.length > 0) {
-    flattened.subsections = subsections.map(function (s) {
-      return s.title;
-    }).join(' ');
+    flattened.subsections = subsections.map(s => s.title).join(' ');
   }
 
   // Add base page result
-  results.push(_extends(_extends({
+  results.push({
     type: 'page',
-    group: includeCategoryInGroup ? "".concat(sectionData.title, " Pages") : 'Pages',
+    group: includeCategoryInGroup ? `${sectionData.title} Pages` : 'Pages',
     page: page.title,
     title: page.title,
     slug: page.slug,
     path: page.path,
     description: page.description,
     sectionTitle: sectionData.title,
-    prefix: sectionData.prefix
-  }, flattened.keywords ? {
-    keywords: flattened.keywords
-  } : {}), excludeSections ? {} : {
-    sections: flattened.sections,
-    subsections: flattened.subsections
-  }));
+    prefix: sectionData.prefix,
+    ...(flattened.keywords ? {
+      keywords: flattened.keywords
+    } : {}),
+    ...(excludeSections ? {} : {
+      sections: flattened.sections,
+      subsections: flattened.subsections
+    })
+  });
 
   // Add entries for each part
   if (page.parts && Object.keys(page.parts).length > 0) {
-    for (var _i3 = 0, _Object$entries3 = Object.entries(page.parts); _i3 < _Object$entries3.length; _i3++) {
-      var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i3], 2),
-        partName = _Object$entries3$_i[0],
-        partData = _Object$entries3$_i[1];
+    for (const [partName, partData] of Object.entries(page.parts)) {
       results.push({
         type: 'part',
         group: 'API Reference',
         part: partName,
-        "export": "".concat(page.slug, ".").concat(partName),
+        export: `${page.slug}.${partName}`,
         slug: partName.toLowerCase(),
         path: page.path,
-        title: page.title ? "".concat(page.title, " \u2023 ").concat(partName) : partName,
+        title: page.title ? `${page.title} ‣ ${partName}` : partName,
         description: page.description,
         sectionTitle: sectionData.title,
         prefix: sectionData.prefix,
@@ -171,16 +149,13 @@ function defaultFlattenPage(page, sectionData, includeCategoryInGroup, excludeSe
 
   // Add entries for each export
   if (page.exports && Object.keys(page.exports).length > 0) {
-    for (var _i4 = 0, _Object$entries4 = Object.entries(page.exports); _i4 < _Object$entries4.length; _i4++) {
-      var _Object$entries4$_i = _slicedToArray(_Object$entries4[_i4], 2),
-        exportName = _Object$entries4$_i[0],
-        exportData = _Object$entries4$_i[1];
+    for (const [exportName, exportData] of Object.entries(page.exports)) {
       // If export name matches page slug (case-insensitive), use #api-reference
-      var exportSlug = exportName.toLowerCase() === page.slug.toLowerCase() ? 'api-reference' : exportName.toLowerCase();
+      const exportSlug = exportName.toLowerCase() === page.slug.toLowerCase() ? 'api-reference' : exportName.toLowerCase();
       results.push({
         type: 'export',
         group: 'API Reference',
-        "export": exportSlug,
+        export: exportSlug,
         slug: page.slug,
         path: page.path,
         title: exportName,
@@ -196,15 +171,14 @@ function defaultFlattenPage(page, sectionData, includeCategoryInGroup, excludeSe
   }
 
   // Add entries for each section
-  for (var _i5 = 0, _sections = sections; _i5 < _sections.length; _i5++) {
-    var sectionItem = _sections[_i5];
+  for (const sectionItem of sections) {
     results.push({
       type: 'section',
       group: 'Sections',
       section: sectionItem.title,
-      slug: "".concat(page.slug, "#").concat(sectionItem.slug),
+      slug: `${page.slug}#${sectionItem.slug}`,
       path: page.path,
-      title: page.title ? "".concat(page.title, " \u2023 ").concat(sectionItem.title) : sectionItem.title,
+      title: page.title ? `${page.title} ‣ ${sectionItem.title}` : sectionItem.title,
       description: page.description,
       sectionTitle: sectionData.title,
       prefix: sectionData.prefix,
@@ -213,16 +187,15 @@ function defaultFlattenPage(page, sectionData, includeCategoryInGroup, excludeSe
   }
 
   // Add entries for each subsection
-  for (var _i6 = 0, _subsections = subsections; _i6 < _subsections.length; _i6++) {
-    var subsectionItem = _subsections[_i6];
-    var fullTitle = subsectionItem.parentTitles.join(' ‣ ');
+  for (const subsectionItem of subsections) {
+    const fullTitle = subsectionItem.parentTitles.join(' ‣ ');
     results.push({
       type: 'subsection',
       group: 'Sections',
       subsection: fullTitle,
-      slug: "".concat(page.slug, "#").concat(subsectionItem.slug.toLowerCase()),
+      slug: `${page.slug}#${subsectionItem.slug.toLowerCase()}`,
       path: page.path,
-      title: page.title ? "".concat(page.title, " \u2023 ").concat(fullTitle) : fullTitle,
+      title: page.title ? `${page.title} ‣ ${fullTitle}` : fullTitle,
       description: page.description,
       sectionTitle: sectionData.title,
       prefix: sectionData.prefix,
@@ -236,7 +209,7 @@ function defaultFlattenPage(page, sectionData, includeCategoryInGroup, excludeSe
  * Default function to format search results
  */
 function defaultFormatResult(hit) {
-  var base = {
+  const base = {
     id: hit.id,
     title: hit.document.title,
     description: hit.document.description,
@@ -247,50 +220,57 @@ function defaultFormatResult(hit) {
     score: hit.score,
     keywords: hit.document.keywords
   };
-  var type = hit.document.type;
+  const type = hit.document.type;
   if (type === 'part') {
-    return _extends(_extends({}, base), {}, {
+    return {
+      ...base,
       type: 'part',
       part: hit.document.part,
-      "export": hit.document["export"],
+      export: hit.document.export,
       props: hit.document.props,
       dataAttributes: hit.document.dataAttributes,
       cssVariables: hit.document.cssVariables
-    });
+    };
   }
   if (type === 'export') {
-    return _extends(_extends({}, base), {}, {
+    return {
+      ...base,
       type: 'export',
-      "export": hit.document["export"],
+      export: hit.document.export,
       props: hit.document.props,
       dataAttributes: hit.document.dataAttributes,
       cssVariables: hit.document.cssVariables
-    });
+    };
   }
   if (type === 'section') {
-    return _extends(_extends({}, base), {}, {
+    return {
+      ...base,
       type: 'section',
       section: hit.document.section
-    });
+    };
   }
   if (type === 'subsection') {
-    return _extends(_extends({}, base), {}, {
+    return {
+      ...base,
       type: 'subsection',
       subsection: hit.document.subsection
-    });
+    };
   }
 
   // Default to page type
-  return _extends(_extends(_extends({}, base), {}, {
+  return {
+    ...base,
     type: 'page',
-    page: hit.document.title
-  }, hit.document.sections ? {
-    sections: hit.document.sections
-  } : {}), hit.document.subsections ? {
-    subsections: hit.document.subsections
-  } : {});
+    page: hit.document.title,
+    ...(hit.document.sections ? {
+      sections: hit.document.sections
+    } : {}),
+    ...(hit.document.subsections ? {
+      subsections: hit.document.subsections
+    } : {})
+  };
 }
-export var defaultSearchBoost = {
+export const defaultSearchBoost = {
   type: 100,
   group: 100,
   slug: 2,
@@ -300,7 +280,7 @@ export var defaultSearchBoost = {
   pageKeywords: 15,
   description: 1.5,
   part: 1.5,
-  "export": 1.3,
+  export: 1.3,
   sectionTitle: 50,
   section: 3,
   subsection: 2.5,
@@ -319,329 +299,252 @@ export var defaultSearchBoost = {
  * @returns Search state and functions
  */
 export function useSearch(options) {
-  var sitemapImport = options.sitemap,
-    maxDefaultResults = options.maxDefaultResults,
-    _options$tolerance = options.tolerance,
-    tolerance = _options$tolerance === void 0 ? 1 : _options$tolerance,
-    _options$limit = options.limit,
-    defaultLimit = _options$limit === void 0 ? 20 : _options$limit,
-    _options$boost = options.boost,
-    boost = _options$boost === void 0 ? defaultSearchBoost : _options$boost,
-    _options$enableStemmi = options.enableStemming,
-    enableStemming = _options$enableStemmi === void 0 ? true : _options$enableStemmi,
-    generateSlug = options.generateSlug,
-    _options$flattenPage = options.flattenPage,
-    flattenPage = _options$flattenPage === void 0 ? defaultFlattenPage : _options$flattenPage,
-    _options$formatResult = options.formatResult,
-    formatResult = _options$formatResult === void 0 ? defaultFormatResult : _options$formatResult;
-  var _React$useState = React.useState(null),
-    _React$useState2 = _slicedToArray(_React$useState, 2),
-    index = _React$useState2[0],
-    setIndex = _React$useState2[1];
-  var _React$useState3 = React.useState({
-      results: [],
-      count: 0,
-      elapsed: {
-        raw: 0,
-        formatted: '0ms'
-      }
-    }),
-    _React$useState4 = _slicedToArray(_React$useState3, 2),
-    defaultResults = _React$useState4[0],
-    setDefaultResults = _React$useState4[1];
-  var _React$useState5 = React.useState({
-      results: [],
-      count: 0,
-      elapsed: {
-        raw: 0,
-        formatted: '0ms'
+  const {
+    sitemap: sitemapImport,
+    maxDefaultResults,
+    tolerance = 1,
+    limit: defaultLimit = 20,
+    boost = defaultSearchBoost,
+    enableStemming = true,
+    generateSlug,
+    flattenPage = defaultFlattenPage,
+    formatResult = defaultFormatResult
+  } = options;
+  const [index, setIndex] = React.useState(null);
+  const [defaultResults, setDefaultResults] = React.useState({
+    results: [],
+    count: 0,
+    elapsed: {
+      raw: 0,
+      formatted: '0ms'
+    }
+  });
+  const [results, setResults] = React.useState({
+    results: [],
+    count: 0,
+    elapsed: {
+      raw: 0,
+      formatted: '0ms'
+    }
+  });
+  React.useEffect(() => {
+    (async () => {
+      const {
+        sitemap
+      } = await sitemapImport();
+      if (!sitemap) {
+        console.error('Sitemap is undefined');
+        return;
       }
-    }),
-    _React$useState6 = _slicedToArray(_React$useState5, 2),
-    results = _React$useState6[0],
-    setResults = _React$useState6[1];
-  React.useEffect(function () {
-    _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
-      var _yield$sitemapImport, sitemap, searchIndex, pages, pageResultsByGroup, pageResultsCount, dummyDoc, pageResultsGrouped, defaultResultsValue;
-      return _regenerator().w(function (_context) {
-        while (1) switch (_context.n) {
-          case 0:
-            _context.n = 1;
-            return sitemapImport();
-          case 1:
-            _yield$sitemapImport = _context.v;
-            sitemap = _yield$sitemapImport.sitemap;
-            if (sitemap) {
-              _context.n = 2;
-              break;
-            }
-            console.error('Sitemap is undefined');
-            return _context.a(2);
-          case 2:
-            _context.n = 3;
-            return create({
-              schema: searchSchema,
-              components: enableStemming ? {
-                tokenizer: {
-                  stemming: true,
-                  language: language,
-                  stemmer: stemmer,
-                  stemmerSkipProperties: ['type', 'group', 'slug', 'sectionTitle', 'page', 'part', 'export', 'dataAttributes', 'cssVariables', 'props'],
-                  stopWords: stopWords
-                }
-              } : undefined,
-              plugins: [pluginQPS()]
-            });
-          case 3:
-            searchIndex = _context.v;
-            // Flatten the sitemap data structure to a single array of pages
-            pages = [];
-            pageResultsByGroup = {};
-            pageResultsCount = 0;
-            Object.entries(sitemap.data).forEach(function (_ref2) {
-              var _ref3 = _slicedToArray(_ref2, 2),
-                _sectionKey = _ref3[0],
-                sectionData = _ref3[1];
-              (sectionData.pages || []).forEach(function (page) {
-                var flattened = flattenPage(page, sectionData, options.includeCategoryInGroup || false, options.excludeSections, generateSlug);
-                pages.push.apply(pages, _toConsumableArray(flattened));
+      const searchIndex = await create({
+        schema: searchSchema,
+        components: enableStemming ? {
+          tokenizer: {
+            stemming: true,
+            language,
+            stemmer,
+            stemmerSkipProperties: ['type', 'group', 'slug', 'sectionTitle', 'page', 'part', 'export', 'dataAttributes', 'cssVariables', 'props'],
+            stopWords
+          }
+        } : undefined,
+        plugins: [pluginQPS()]
+      });
 
-                // Add the first result (page type) to default results, grouped by their group
-                if ((maxDefaultResults === undefined || pageResultsCount < maxDefaultResults) && flattened.length > 0) {
-                  var pageResult = flattened[0];
-                  var group = pageResult.group || 'Pages';
-                  if (!pageResultsByGroup[group]) {
-                    pageResultsByGroup[group] = [];
-                  }
-                  pageResultsByGroup[group].push(pageResult);
-                  pageResultsCount += 1;
-                }
-              });
-            });
+      // Flatten the sitemap data structure to a single array of pages
+      const pages = [];
+      const pageResultsByGroup = {};
+      let pageResultsCount = 0;
+      Object.entries(sitemap.data).forEach(([_sectionKey, sectionData]) => {
+        (sectionData.pages || []).forEach(page => {
+          const flattened = flattenPage(page, sectionData, options.includeCategoryInGroup || false, options.excludeSections, generateSlug);
+          pages.push(...flattened);
 
-            // Insert a dummy document with all fields to ensure QPS plugin initializes stats for all properties.
-            // This is needed because QPS only creates stats for properties that have data inserted.
-            // Using empty strings ensures no false matches while still initializing the stats.
-            dummyDoc = {
-              type: '',
-              group: '',
-              title: '',
-              description: '',
-              slug: '',
-              sectionTitle: '',
-              prefix: '',
-              path: '',
-              keywords: '',
-              page: '',
-              pageKeywords: '',
-              sections: '',
-              subsections: '',
-              part: '',
-              "export": '',
-              props: '',
-              dataAttributes: '',
-              cssVariables: '',
-              section: '',
-              subsection: ''
-            };
-            _context.n = 4;
-            return insertMultiple(searchIndex, [dummyDoc].concat(pages));
-          case 4:
-            pageResultsGrouped = Object.entries(pageResultsByGroup).map(function (_ref4) {
-              var _ref5 = _slicedToArray(_ref4, 2),
-                group = _ref5[0],
-                items = _ref5[1];
-              return {
-                group: group,
-                items: items
-              };
-            });
-            defaultResultsValue = {
-              results: pageResultsGrouped,
-              count: pageResultsCount,
-              elapsed: {
-                raw: 0,
-                formatted: '0ms'
-              }
-            };
-            setIndex(searchIndex);
-            setDefaultResults(defaultResultsValue);
-            setResults(defaultResultsValue);
-          case 5:
-            return _context.a(2);
+          // Add the first result (page type) to default results, grouped by their group
+          if ((maxDefaultResults === undefined || pageResultsCount < maxDefaultResults) && flattened.length > 0) {
+            const pageResult = flattened[0];
+            const group = pageResult.group || 'Pages';
+            if (!pageResultsByGroup[group]) {
+              pageResultsByGroup[group] = [];
+            }
+            pageResultsByGroup[group].push(pageResult);
+            pageResultsCount += 1;
+          }
+        });
+      });
+
+      // Insert a dummy document with all fields to ensure QPS plugin initializes stats for all properties.
+      // This is needed because QPS only creates stats for properties that have data inserted.
+      // Using empty strings ensures no false matches while still initializing the stats.
+      const dummyDoc = {
+        type: '',
+        group: '',
+        title: '',
+        description: '',
+        slug: '',
+        sectionTitle: '',
+        prefix: '',
+        path: '',
+        keywords: '',
+        page: '',
+        pageKeywords: '',
+        sections: '',
+        subsections: '',
+        part: '',
+        export: '',
+        props: '',
+        dataAttributes: '',
+        cssVariables: '',
+        section: '',
+        subsection: ''
+      };
+      await insertMultiple(searchIndex, [dummyDoc, ...pages]);
+      const pageResultsGrouped = Object.entries(pageResultsByGroup).map(([group, items]) => ({
+        group,
+        items
+      }));
+      const defaultResultsValue = {
+        results: pageResultsGrouped,
+        count: pageResultsCount,
+        elapsed: {
+          raw: 0,
+          formatted: '0ms'
         }
-      }, _callee);
-    }))();
+      };
+      setIndex(searchIndex);
+      setDefaultResults(defaultResultsValue);
+      setResults(defaultResultsValue);
+    })();
   }, [sitemapImport, maxDefaultResults, flattenPage, generateSlug, enableStemming, options.includeCategoryInGroup, options.excludeSections]);
-  var search = React.useCallback(/*#__PURE__*/function () {
-    var _ref6 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(value) {
-      var _ref7,
-        facets,
-        groupBy,
-        _ref7$limit,
-        limit,
-        where,
-        valueLower,
-        valueNormalized,
-        useCustomSort,
-        cache,
-        getDocProps,
-        searchResults,
-        count,
-        elapsed,
-        groupedResults,
-        formattedResults,
-        _args2 = arguments;
-      return _regenerator().w(function (_context2) {
-        while (1) switch (_context2.n) {
-          case 0:
-            _ref7 = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : {}, facets = _ref7.facets, groupBy = _ref7.groupBy, _ref7$limit = _ref7.limit, limit = _ref7$limit === void 0 ? defaultLimit : _ref7$limit, where = _ref7.where;
-            if (!(!index || !value.trim())) {
-              _context2.n = 1;
-              break;
-            }
-            setResults(defaultResults);
-            return _context2.a(2);
-          case 1:
-            valueLower = value.toLowerCase(); // Normalize for comparison: convert spaces/hyphens to a common format
-            valueNormalized = valueLower.replace(/[-\s]+/g, ' ').trim(); // For longer search terms, skip custom sorting and rely on Orama's scoring
-            // The overhead of checking exact/startsWith/contains isn't worth it
-            useCustomSort = valueLower.length <= 20; // Cache for computed document properties to avoid repeated string operations
-            cache = new Map();
-            getDocProps = function getDocProps(doc) {
-              var key = doc.slug; // Use slug as cache key since it's unique per document
-              var props = cache.get(key);
-              if (!props) {
-                var titleLower = doc.title.toLowerCase();
-                var slugLower = doc.slug.toLowerCase();
-                props = {
-                  titleLower: titleLower,
-                  slugLower: slugLower,
-                  slugNormalized: slugLower.replace(/-/g, ' ')
-                };
-                cache.set(key, props);
-              }
-              return props;
-            };
-            _context2.n = 2;
-            return oramaSearch(index, {
-              term: value,
-              facets: facets,
-              groupBy: groupBy,
-              where: where,
-              limit: limit,
-              tolerance: tolerance,
-              boost: boost,
-              sortBy: useCustomSort ? function (_ref8, _ref9) {
-                var _ref0 = _slicedToArray(_ref8, 3),
-                  _ = _ref0[0],
-                  aScore = _ref0[1],
-                  aDocument = _ref0[2];
-                var _ref1 = _slicedToArray(_ref9, 3),
-                  __ = _ref1[0],
-                  bScore = _ref1[1],
-                  bDocument = _ref1[2];
-                var a = getDocProps(aDocument);
-                var b = getDocProps(bDocument);
+  const search = React.useCallback(async (value, {
+    facets,
+    groupBy,
+    limit = defaultLimit,
+    where
+  } = {}) => {
+    if (!index || !value.trim()) {
+      setResults(defaultResults);
+      return;
+    }
+    const valueLower = value.toLowerCase();
+    // Normalize for comparison: convert spaces/hyphens to a common format
+    const valueNormalized = valueLower.replace(/[-\s]+/g, ' ').trim();
 
-                // Prioritize exact matches (short-circuit on first match)
-                var aExact = a.titleLower === valueLower || a.slugLower === valueLower || a.slugNormalized === valueNormalized;
-                var bExact = b.titleLower === valueLower || b.slugLower === valueLower || b.slugNormalized === valueNormalized;
-                if (aExact !== bExact) {
-                  return aExact ? -1 : 1;
-                }
+    // For longer search terms, skip custom sorting and rely on Orama's scoring
+    // The overhead of checking exact/startsWith/contains isn't worth it
+    const useCustomSort = valueLower.length <= 20;
 
-                // Then prioritize startsWith matches
-                var aStartsWith = a.titleLower.startsWith(valueLower) || a.slugNormalized.startsWith(valueNormalized);
-                var bStartsWith = b.titleLower.startsWith(valueLower) || b.slugNormalized.startsWith(valueNormalized);
-                if (aStartsWith !== bStartsWith) {
-                  return aStartsWith ? -1 : 1;
-                }
+    // Cache for computed document properties to avoid repeated string operations
+    const cache = new Map();
+    const getDocProps = doc => {
+      const key = doc.slug; // Use slug as cache key since it's unique per document
+      let props = cache.get(key);
+      if (!props) {
+        const titleLower = doc.title.toLowerCase();
+        const slugLower = doc.slug.toLowerCase();
+        props = {
+          titleLower,
+          slugLower,
+          slugNormalized: slugLower.replace(/-/g, ' ')
+        };
+        cache.set(key, props);
+      }
+      return props;
+    };
+    const searchResults = await oramaSearch(index, {
+      term: value,
+      facets,
+      groupBy,
+      where,
+      limit,
+      tolerance,
+      boost,
+      sortBy: useCustomSort ? ([_, aScore, aDocument], [__, bScore, bDocument]) => {
+        const a = getDocProps(aDocument);
+        const b = getDocProps(bDocument);
 
-                // Then prioritize contains matches
-                var aContains = a.titleLower.includes(valueLower) || a.slugNormalized.includes(valueNormalized);
-                var bContains = b.titleLower.includes(valueLower) || b.slugNormalized.includes(valueNormalized);
-                if (aContains !== bContains) {
-                  return aContains ? -1 : 1;
-                }
+        // Prioritize exact matches (short-circuit on first match)
+        const aExact = a.titleLower === valueLower || a.slugLower === valueLower || a.slugNormalized === valueNormalized;
+        const bExact = b.titleLower === valueLower || b.slugLower === valueLower || b.slugNormalized === valueNormalized;
+        if (aExact !== bExact) {
+          return aExact ? -1 : 1;
+        }
 
-                // Then sort by score descending
-                return bScore - aScore;
-              } : undefined
-            });
-          case 2:
-            searchResults = _context2.v;
-            count = searchResults.count;
-            elapsed = searchResults.elapsed;
-            if (!searchResults.groups) {
-              _context2.n = 3;
-              break;
-            }
-            groupedResults = searchResults.groups.map(function (group) {
-              return {
-                group: group.values.join(' '),
-                items: group.result.map(formatResult)
-              };
-            });
-            setResults({
-              results: groupedResults,
-              count: count,
-              elapsed: elapsed
-            });
-            return _context2.a(2);
-          case 3:
-            formattedResults = searchResults.hits.map(formatResult);
-            setResults({
-              results: [{
-                group: 'Default',
-                items: formattedResults
-              }],
-              count: count,
-              elapsed: elapsed
-            });
-          case 4:
-            return _context2.a(2);
+        // Then prioritize startsWith matches
+        const aStartsWith = a.titleLower.startsWith(valueLower) || a.slugNormalized.startsWith(valueNormalized);
+        const bStartsWith = b.titleLower.startsWith(valueLower) || b.slugNormalized.startsWith(valueNormalized);
+        if (aStartsWith !== bStartsWith) {
+          return aStartsWith ? -1 : 1;
         }
-      }, _callee2);
-    }));
-    return function (_x) {
-      return _ref6.apply(this, arguments);
-    };
-  }(), [index, defaultLimit, defaultResults, tolerance, boost, formatResult]);
+
+        // Then prioritize contains matches
+        const aContains = a.titleLower.includes(valueLower) || a.slugNormalized.includes(valueNormalized);
+        const bContains = b.titleLower.includes(valueLower) || b.slugNormalized.includes(valueNormalized);
+        if (aContains !== bContains) {
+          return aContains ? -1 : 1;
+        }
+
+        // Then sort by score descending
+        return bScore - aScore;
+      } : undefined
+    });
+    const count = searchResults.count;
+    const elapsed = searchResults.elapsed;
+    if (searchResults.groups) {
+      const groupedResults = searchResults.groups.map(group => ({
+        group: group.values.join(' '),
+        items: group.result.map(formatResult)
+      }));
+      setResults({
+        results: groupedResults,
+        count,
+        elapsed
+      });
+      return;
+    }
+    const formattedResults = searchResults.hits.map(formatResult);
+    setResults({
+      results: [{
+        group: 'Default',
+        items: formattedResults
+      }],
+      count,
+      elapsed
+    });
+  }, [index, defaultLimit, defaultResults, tolerance, boost, formatResult]);
 
   /**
    * Build a URL from a search result
    * Handles path normalization and hash fragments for different result types
    */
-  var buildResultUrl = React.useCallback(function (result) {
-    var url = result.path.startsWith('./') ? "".concat(result.prefix).concat(result.path.replace(/^\.\//, '').replace(/\/page\.mdx$/, '')) : result.path;
+  const buildResultUrl = React.useCallback(result => {
+    let url = result.path.startsWith('./') ? `${result.prefix}${result.path.replace(/^\.\//, '').replace(/\/page\.mdx$/, '')}` : result.path;
 
     // Add hash for non-page types
     if ('type' in result && result.type !== 'page') {
-      var hash;
+      let hash;
       if (result.type === 'section' || result.type === 'subsection') {
         // For sections and subsections, extract hash from the slug field
         // which already contains the page slug + hash (e.g., "button#api-reference")
-        var hashIndex = result.slug.indexOf('#');
+        const hashIndex = result.slug.indexOf('#');
         hash = hashIndex !== -1 ? result.slug.substring(hashIndex + 1) : '';
       } else if (result.type === 'part') {
         hash = result.part.toLowerCase();
       } else if (result.type === 'export') {
-        hash = result["export"]; // already lowercase or api-reference
+        hash = result.export; // already lowercase or api-reference
       } else {
         hash = '';
       }
       if (hash) {
-        url += "#".concat(hash);
+        url += `#${hash}`;
       }
     }
     return url;
   }, []);
   return {
-    results: results,
+    results,
     isReady: index !== null,
-    search: search,
-    defaultResults: defaultResults,
-    buildResultUrl: buildResultUrl
+    search,
+    defaultResults,
+    buildResultUrl
   };
 }