element-book 2.0.0 → 3.0.0

package/dist/data/element-book-entry/element-book-page/element-book-page-example.d.ts

@@ -20,8 +20,6 @@ export type ElementBookPageExampleInit<ParentPage extends ElementBookPage<any>,
      * wrapper element!
      */
     styles?: CSSResult;
-    /** Set to true to hide the example controls (example title and buttons). */
-    hideExampleControls?: boolean | undefined;
     /** Render the example. */
     renderCallback: RequireNonVoid<RenderOutput, (renderParams: ElementBookPageExampleRenderParams<ParentPage, StateInit>) => RenderOutput, 'renderCallback is missing a return statement'>;
 };

package/dist/data/element-book-entry/entry-tree/entry-tree-search.d.ts

@@ -0,0 +1,8 @@
+import { ElementBookEntry } from '../element-book-entry';
+import { ElementBookEntryTypeEnum } from '../element-book-entry-type';
+import { EntryTreeNode } from './entry-tree';
+export declare function createSearchedTree({ entries, startTree, searchQuery, }: {
+    entries: ReadonlyArray<ElementBookEntry>;
+    startTree: Readonly<EntryTreeNode<ElementBookEntryTypeEnum.Root>>;
+    searchQuery: string;
+}): EntryTreeNode;

package/dist/data/element-book-entry/entry-tree/entry-tree-search.js

@@ -0,0 +1,66 @@
+import { filterObject, isTruthy } from '@augment-vir/common';
+import { fuzzySearch } from '../../../utilities/search';
+import { ElementBookEntryTypeEnum } from '../element-book-entry-type';
+import { createEmptyEntryTreeRoot } from './entry-tree';
+import { addTreeToCache, getTreeFromCache } from './tree-cache';
+export function createSearchedTree({ entries, startTree, searchQuery, }) {
+    const cachedSearchTree = getTreeFromCache(entries, searchQuery);
+    if (cachedSearchTree) {
+        return cachedSearchTree;
+    }
+    const newTree = createEmptyEntryTreeRoot('Search Results');
+    recursivelySearchTree(startTree, newTree, searchQuery);
+    addTreeToCache(entries, searchQuery, newTree);
+    return newTree;
+}
+function recursivelySearchTree(oldTreeNode, newNode, searchQuery) {
+    if (oldTreeNode.entry.entryType !== ElementBookEntryTypeEnum.Root &&
+        fuzzySearch({
+            searchIn: oldTreeNode.entry.title,
+            searchQuery: searchQuery,
+        })) {
+        newNode.children = oldTreeNode.children;
+        return true;
+    }
+    if ('examples' in oldTreeNode.entry) {
+        const filteredExamples = filterObject(oldTreeNode.entry.examples, (exampleName) => fuzzySearch({
+            searchIn: exampleName,
+            searchQuery,
+        }));
+        const newEntry = {
+            ...oldTreeNode.entry,
+            examples: filteredExamples,
+        };
+        newNode.entry = newEntry;
+        if (Object.values(newEntry.examples).length) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    const searchedChildEntries = Object.entries(oldTreeNode.children)
+        .map(([childName, childNode,]) => {
+        const newChildNode = {
+            ...childNode,
+            children: {},
+        };
+        if (recursivelySearchTree(childNode, newChildNode, searchQuery)) {
+            return [
+                childName,
+                newChildNode,
+            ];
+        }
+        else {
+            return undefined;
+        }
+    })
+        .filter(isTruthy);
+    if (searchedChildEntries.length) {
+        newNode.children = Object.fromEntries(searchedChildEntries);
+        return true;
+    }
+    else {
+        return false;
+    }
+}

package/dist/data/element-book-entry/entry-tree/entry-tree.d.ts

@@ -2,18 +2,19 @@ import { ElementBookEntry } from '../element-book-entry';
 import { ElementBookEntryTypeEnum } from '../element-book-entry-type';
 export declare function doesNodeHaveEntryType<EntryType extends ElementBookEntryTypeEnum>(node: EntryTreeNode<any>, entryType: EntryType): node is EntryTreeNode<EntryType>;
 declare const markerKeyName = "isElementBookEntryTreeNode";
-export type EntryTreeNode<EntryType extends ElementBookEntryTypeEnum = ElementBookEntryTypeEnum> = {
+export type EntryTreeNode<EntryType extends ElementBookEntryTypeEnum = any> = {
     [markerKeyName]: true;
     entry: Extract<ElementBookEntry, {
         entryType: EntryType;
     }>;
+    /** Breadcrumb is different from entry.title because it's modified to support URLs. */
     breadcrumb: string;
     children: Record<string, EntryTreeNode>;
 };
 export declare function isEntryNode<SpecificType extends ElementBookEntryTypeEnum>(input: unknown, entryType: SpecificType): input is EntryTreeNode<SpecificType>;
-export declare function createEmptyEntryTreeRoot(title: string | undefined): EntryTreeNode;
+export declare function createEmptyEntryTreeRoot(title: string | undefined): EntryTreeNode<ElementBookEntryTypeEnum.Root>;
 export declare function titleToBreadcrumb(title: string): string;
-export declare function entriesToTree(entries: ReadonlyArray<ElementBookEntry>, everythingTitle: string | undefined): EntryTreeNode<ElementBookEntryTypeEnum>;
+export declare function entriesToTree(entries: ReadonlyArray<ElementBookEntry>, everythingTitle: string | undefined): EntryTreeNode<ElementBookEntryTypeEnum.Root>;
 export declare function listBreadcrumbs(entry: ElementBookEntry, includeSelf?: boolean): string[];
 export declare function findEntryByBreadcrumbs(breadcrumbs: ReadonlyArray<string>, tree: Readonly<EntryTreeNode>): Readonly<EntryTreeNode> | undefined;
 export {};

package/dist/data/element-book-entry/entry-tree/entry-tree.js

@@ -1,5 +1,6 @@
 import { collapseWhiteSpace, isLengthAtLeast, typedHasProperties } from '@augment-vir/common';
 import { ElementBookEntryTypeEnum } from '../element-book-entry-type';
+import { addTreeToCache, getTreeFromCache } from './tree-cache';
 export function doesNodeHaveEntryType(node, entryType) {
     return node.entry.entryType === entryType;
 }
@@ -29,6 +30,14 @@ export function titleToBreadcrumb(title) {
     return collapseWhiteSpace(title).toLowerCase().replaceAll(/\s/g, '-');
 }
 export function entriesToTree(entries, everythingTitle) {
+    const baseTree = createBaseTree(entries, everythingTitle);
+    return baseTree;
+}
+function createBaseTree(entries, everythingTitle) {
+    const cachedTree = getTreeFromCache(entries, '');
+    if (cachedTree) {
+        return cachedTree;
+    }
     const tree = createEmptyEntryTreeRoot(everythingTitle);
     entries.forEach((newEntry) => {
         /**
@@ -51,6 +60,7 @@ export function entriesToTree(entries, everythingTitle) {
         };
         immediateParent.children[breadcrumb] = newNode;
     });
+    addTreeToCache(entries, '', tree);
     return tree;
 }
 function traverseToImmediateParent(entry, currentTree) {

package/dist/data/element-book-entry/entry-tree/tree-cache.d.ts

@@ -0,0 +1,5 @@
+import { ElementBookEntry } from '../element-book-entry';
+import { ElementBookEntryTypeEnum } from '../element-book-entry-type';
+import { EntryTreeNode } from './entry-tree';
+export declare function getTreeFromCache(entries: ReadonlyArray<ElementBookEntry>, searchString: string): EntryTreeNode<ElementBookEntryTypeEnum.Root> | undefined;
+export declare function addTreeToCache(entries: ReadonlyArray<ElementBookEntry>, searchString: string, tree: EntryTreeNode<ElementBookEntryTypeEnum.Root>): void;

package/dist/data/element-book-entry/entry-tree/tree-cache.js

@@ -0,0 +1,8 @@
+import { getOrSetFromMap } from '@augment-vir/common';
+const treeCache = new Map();
+export function getTreeFromCache(entries, searchString) {
+    return treeCache.get(entries)?.get(searchString);
+}
+export function addTreeToCache(entries, searchString, tree) {
+    getOrSetFromMap(treeCache, entries, () => new Map()).set(searchString, tree);
+}

package/dist/routing/create-element-book-router.js

@@ -26,9 +26,15 @@ function sanitizePaths(paths) {
         ];
     }
     else if (firstPath === ElementBookMainRoute.Search) {
+        if (!paths[1]) {
+            return [
+                ElementBookMainRoute.Book,
+                ...paths.slice(1),
+            ];
+        }
         return [
             firstPath,
-            paths[1] ?? '',
+            paths[1],
         ];
     }
     else {

package/dist/routing/element-book-routing.d.ts

@@ -5,5 +5,6 @@ export declare enum ElementBookMainRoute {
 }
 export type ValidElementBookPaths = [ElementBookMainRoute.Search, string] | [ElementBookMainRoute.Book, ...string[]];
 export type ElementBookFullRoute = Required<Readonly<FullRoute<ValidElementBookPaths, undefined | Record<string, string>, undefined>>>;
+export declare function extractSearchQuery(paths: Readonly<ValidElementBookPaths>): string;
 export declare const defaultElementBookFullRoute: Readonly<ElementBookFullRoute>;
 export type ElementBookRouter = ElementBookFullRoute extends FullRoute<infer Paths, infer Search, infer Hash> ? Readonly<SpaRouter<Paths, Search, Hash>> : never;

package/dist/routing/element-book-routing.js

@@ -3,6 +3,14 @@ export var ElementBookMainRoute;
     ElementBookMainRoute["Search"] = "search";
     ElementBookMainRoute["Book"] = "book";
 })(ElementBookMainRoute || (ElementBookMainRoute = {}));
+export function extractSearchQuery(paths) {
+    if (paths[0] === ElementBookMainRoute.Book) {
+        return '';
+    }
+    else {
+        return decodeURIComponent(paths[1]);
+    }
+}
 export const defaultElementBookFullRoute = {
     hash: undefined,
     paths: [ElementBookMainRoute.Book],

package/dist/ui/elements/element-book-app/element-book-app.element.js

@@ -1,14 +1,15 @@
-import { areJsonEqual, extractErrorMessage, getOrSetFromMap } from '@augment-vir/common';
+import { areJsonEqual, extractErrorMessage } from '@augment-vir/common';
 import { assign, css, defineElement, defineElementEvent, html, listen } from 'element-vir';
-import { entriesToTree, findEntryByBreadcrumbs, } from '../../../data/element-book-entry/entry-tree/entry-tree';
+import { entriesToTree } from '../../../data/element-book-entry/entry-tree/entry-tree';
+import { createSearchedTree } from '../../../data/element-book-entry/entry-tree/entry-tree-search';
 import { createElementBookRouter } from '../../../routing/create-element-book-router';
-import { ElementBookMainRoute, defaultElementBookFullRoute, } from '../../../routing/element-book-routing';
+import { defaultElementBookFullRoute, extractSearchQuery, } from '../../../routing/element-book-routing';
 import { colorThemeCssVars, setThemeCssVars } from '../../color-theme/color-theme';
 import { createTheme } from '../../color-theme/create-color-theme';
 import { ChangeRouteEvent } from '../../events/change-route.event';
 import { ElementBookNav } from '../element-book-nav.element';
 import { ElementBookEntryDisplay } from '../entry-display/element-book-entry-display.element';
-const treeCache = new Map();
+import { getCurrentTreeEntry } from './get-current-entry';
 export const ElementBookApp = defineElement()({
     tagName: 'element-book-app',
     events: {
@@ -113,21 +114,16 @@ export const ElementBookApp = defineElement()({
                 });
                 setThemeCssVars(host, newTheme);
             }
-            const entriesTree = getOrSetFromMap(treeCache, inputs.entries, () => entriesToTree(inputs.entries, inputs.everythingTitle));
-            const entryTreeNodeByInitialPath = findEntryByBreadcrumbs(state.currentRoute.paths.slice(1), entriesTree);
-            if (!entryTreeNodeByInitialPath) {
-                const newRoute = {
-                    paths: [
-                        ElementBookMainRoute.Book,
-                    ],
-                };
-                updateRoutes(newRoute);
-            }
-            const currentEntryTreeNode = findEntryByBreadcrumbs(state.currentRoute.paths.slice(1), entriesTree);
-            if (!currentEntryTreeNode) {
-                throw new Error(`Tried to self-correct for invalid path ${state.currentRoute.paths.join('/')}
-                        but failed to do so.`);
-            }
+            const originalTree = entriesToTree(inputs.entries, inputs.everythingTitle);
+            const searchQuery = extractSearchQuery(state.currentRoute.paths);
+            const searchedTree = searchQuery
+                ? createSearchedTree({
+                    entries: inputs.entries,
+                    searchQuery,
+                    startTree: originalTree,
+                })
+                : originalTree;
+            const currentEntryTreeNode = getCurrentTreeEntry(searchedTree, state.currentRoute.paths, updateRoutes);
             return html `
                 <div
                     class="root"
@@ -144,7 +140,7 @@ export const ElementBookApp = defineElement()({
                 >
                     <${ElementBookNav}
                         ${assign(ElementBookNav, {
-                tree: entriesTree,
+                tree: originalTree,
                 router: state.router,
                 selectedPath: state.currentRoute.paths,
             })}

package/dist/ui/elements/element-book-app/get-current-entry.d.ts

@@ -0,0 +1,4 @@
+import { ElementBookEntryTypeEnum } from '../../../data/element-book-entry/element-book-entry-type';
+import { EntryTreeNode } from '../../../data/element-book-entry/entry-tree/entry-tree';
+import { ElementBookFullRoute, ValidElementBookPaths } from '../../../routing/element-book-routing';
+export declare function getCurrentTreeEntry(entriesTree: EntryTreeNode<ElementBookEntryTypeEnum.Root>, paths: Readonly<ValidElementBookPaths>, updateRoutes: (newRoute: Partial<ElementBookFullRoute>) => void): EntryTreeNode;

package/dist/ui/elements/element-book-app/get-current-entry.js

@@ -0,0 +1,17 @@
+import { findEntryByBreadcrumbs, } from '../../../data/element-book-entry/entry-tree/entry-tree';
+import { ElementBookMainRoute, defaultElementBookFullRoute, } from '../../../routing/element-book-routing';
+export function getCurrentTreeEntry(entriesTree, paths, updateRoutes) {
+    if (paths[0] === ElementBookMainRoute.Search) {
+        return entriesTree;
+    }
+    const entryTreeNodeByInitialPath = findEntryByBreadcrumbs(paths.slice(1), entriesTree);
+    if (!entryTreeNodeByInitialPath) {
+        updateRoutes(defaultElementBookFullRoute);
+    }
+    const currentEntryTreeNode = findEntryByBreadcrumbs(paths.slice(1), entriesTree);
+    if (!currentEntryTreeNode) {
+        throw new Error(`Tried to self-correct for invalid path ${paths.join('/')}
+                        but failed to do so.`);
+    }
+    return currentEntryTreeNode;
+}

package/dist/ui/elements/entry-display/element-book-entry-display.element.js

@@ -1,10 +1,12 @@
+import { wait } from '@augment-vir/common';
 import { VirIcon } from '@electrovir/icon-element';
-import { assign, css, html } from 'element-vir';
+import { assign, css, html, listen, renderIf } from 'element-vir';
 import { isElementBookEntry } from '../../../data/element-book-entry/element-book-entry';
 import { ElementBookEntryTypeEnum } from '../../../data/element-book-entry/element-book-entry-type';
 import { isEntryNode, listBreadcrumbs, } from '../../../data/element-book-entry/entry-tree/entry-tree';
-import { ElementBookMainRoute, } from '../../../routing/element-book-routing';
+import { ElementBookMainRoute, extractSearchQuery, } from '../../../routing/element-book-routing';
 import { colorThemeCssVars } from '../../color-theme/color-theme';
+import { ChangeRouteEvent } from '../../events/change-route.event';
 import { Element24Icon } from '../../icons/element-24.icon';
 import { ElementBookRouteLink } from '../common/element-book-route-link.element';
 import { defineElementBookElement } from '../define-book-element';
@@ -26,6 +28,9 @@ export const ElementBookEntryDisplay = defineElementBookElement()({
             padding: 4px 8px;
             background-color: ${colorThemeCssVars['element-book-page-background-color'].value};
             z-index: 9999999999;
+            display: flex;
+            gap: 16px;
+            justify-content: space-between;
         }
 
         .all-examples-wrapper {
@@ -88,29 +93,64 @@ export const ElementBookEntryDisplay = defineElementBookElement()({
             margin-top: 8px;
         }
     `,
-    renderCallback: ({ inputs }) => {
+    renderCallback: ({ inputs, dispatch }) => {
         const nestedPages = extractNestedPages(inputs.currentNode);
+        const currentSearch = extractSearchQuery(inputs.currentRoute.paths);
         const entryBreadcrumbs = listBreadcrumbs(inputs.currentNode.entry, false).reverse();
         const exampleTemplates = createNestedPagesTemplates({
             nestedPages,
             parentBreadcrumbs: entryBreadcrumbs,
             isTopLevel: true,
             router: inputs.router,
+            isSearching: !!currentSearch,
         });
         return html `
             <div class="title-bar">
-                <${ElementBookBreadcrumbs}
-                    ${assign(ElementBookBreadcrumbs, {
+                ${renderIf(!!currentSearch, html `
+                        &nbsp;
+                    `, html `
+                        <${ElementBookBreadcrumbs}
+                            ${assign(ElementBookBreadcrumbs, {
             currentRoute: inputs.currentRoute,
             router: inputs.router,
         })}
-                ></${ElementBookBreadcrumbs}>
+                        ></${ElementBookBreadcrumbs}>
+                    `)}
+                <input
+                    placeholder="search"
+                    .value=${currentSearch}
+                    ${listen('input', async (event) => {
+            const inputElement = event.currentTarget;
+            if (!(inputElement instanceof HTMLInputElement)) {
+                throw new Error('Failed to find input element for search.');
+            }
+            const preThrottleValue = inputElement.value;
+            // throttle it a bit
+            await wait(500);
+            if (inputElement.value !== preThrottleValue) {
+                return;
+            }
+            dispatch(new ChangeRouteEvent({
+                paths: [
+                    ElementBookMainRoute.Search,
+                    encodeURIComponent(inputElement.value),
+                ],
+            }));
+        })}
+                />
             </div>
             <div class="all-examples-wrapper">${exampleTemplates}</div>
         `;
     },
 });
-function createNestedPagesTemplates({ nestedPages, parentBreadcrumbs, isTopLevel, router, }) {
+function createNestedPagesTemplates({ nestedPages, parentBreadcrumbs, isTopLevel, router, isSearching, }) {
+    if (!nestedPages.length && isSearching) {
+        return [
+            html `
+                No results
+            `,
+        ];
+    }
     return nestedPages
         .map((nestingNode) => {
         if (isEntryNode(nestingNode, ElementBookEntryTypeEnum.Page)) {
@@ -196,6 +236,7 @@ function createNestedPagesTemplates({ nestedPages, parentBreadcrumbs, isTopLevel
                         : parentBreadcrumbs,
                     isTopLevel: false,
                     router,
+                    isSearching,
                 })}
                         `;
             });

package/dist/ui/elements/entry-display/element-book-example-controls.element.js

@@ -16,10 +16,9 @@ export const ElementBookExampleControls = defineElementBookElement()({
         }
     `,
     renderCallback({ inputs }) {
-        const title = inputs.example.hideExampleControls ? '' : inputs.example.title;
         return html `
             <span>
-                ${title || defaultTitle}
+                ${inputs.example.title}
                 <span></span>
             </span>
         `;

package/dist/ui/elements/entry-display/element-book-page-examples.element.js

@@ -1,5 +1,5 @@
 import { mapObjectValues } from '@augment-vir/common';
-import { assign, classMap, css, html, listen, renderIf, repeat } from 'element-vir';
+import { assign, css, html, listen, repeat } from 'element-vir';
 import { unsetInternalState } from '../../../data/unset';
 import { colorThemeCssVars } from '../../color-theme/color-theme';
 import { defineElementBookElement } from '../define-book-element';
@@ -36,11 +36,6 @@ export const ElementBookPageExamples = defineElementBookElement()({
         .individual-example-wrapper:hover ${ElementBookExampleControls} {
             color: ${colorThemeCssVars['element-book-accent-icon-color'].value};
         }
-
-        .hidden-controls {
-            pointer-events: none;
-            visibility: hidden;
-        }
     `,
     stateInit: {
         unset: unsetInternalState,
@@ -56,7 +51,6 @@ export const ElementBookPageExamples = defineElementBookElement()({
             });
         }
         const examples = inputs.page.examples;
-        const allControlsHidden = Object.values(examples).every((example) => 'hideExampleControls' in example && example.hideExampleControls);
         /**
          * Use the repeat directive here, instead of just a map, so that lit doesn't accidentally
          * keep state cached between element book pages.
@@ -72,21 +66,11 @@ export const ElementBookPageExamples = defineElementBookElement()({
             const exampleBreadcrumbs = inputs.parentBreadcrumbs.concat(example.title);
             return html `
                     <div class="individual-example-wrapper">
-                        ${renderIf(!allControlsHidden, html `
-                                <${ElementBookExampleControls}
-                                    class=${classMap({
-                /**
-                 * If not all controls are hidden, we still want to render
-                 * every control so that they take up space, but just hide
-                 * them.
-                 */
-                'hidden-controls': !!example.hideExampleControls,
-            })}
-                                    ${assign(ElementBookExampleControls, {
+                        <${ElementBookExampleControls}
+                            ${assign(ElementBookExampleControls, {
                 example,
             })}
-                                ></${ElementBookExampleControls}>
-                            `)}
+                        ></${ElementBookExampleControls}>
                         <${ElementBookExampleViewer}
                             ${assign(ElementBookExampleViewer, {
                 example,

package/dist/utilities/search.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Code adapted from
+ * https://github.com/bevacqua/fuzzysearch/blob/9873ea0546a47f5d96e037ff02b78b871c809d62/index.js
+ *
+ * That code has the following license:
+ */
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright © 2015 Nicolas Bevacqua
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+ * associated documentation files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish, distribute,
+ * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+ * NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+export declare function fuzzySearch({ 
+/** What you want to search for; the user search input. */
+searchQuery, 
+/** What we're searching in. See if the searchQuery is found within this. */
+searchIn, }: {
+    searchQuery: string;
+    searchIn: string;
+}): boolean;

package/dist/utilities/search.js

@@ -0,0 +1,54 @@
+// cspell:disable
+/**
+ * Code adapted from
+ * https://github.com/bevacqua/fuzzysearch/blob/9873ea0546a47f5d96e037ff02b78b871c809d62/index.js
+ *
+ * That code has the following license:
+ */
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright © 2015 Nicolas Bevacqua
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+ * associated documentation files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish, distribute,
+ * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+ * NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+// cspell:enable
+export function fuzzySearch({ 
+/** What you want to search for; the user search input. */
+searchQuery, 
+/** What we're searching in. See if the searchQuery is found within this. */
+searchIn, }) {
+    const searchInLength = searchIn.length;
+    const searchQueryLength = searchQuery.length;
+    if (searchQueryLength > searchInLength) {
+        return false;
+    }
+    if (searchQueryLength === searchInLength) {
+        return searchQuery === searchIn;
+    }
+    const lowercaseSearchIn = searchIn.toLowerCase();
+    const lowercaseSearchQuery = searchQuery.toLowerCase();
+    outer: for (let i = 0, j = 0; i < searchQueryLength; i++) {
+        const charCode = lowercaseSearchQuery.charCodeAt(i);
+        while (j < searchInLength) {
+            if (lowercaseSearchIn.charCodeAt(j++) === charCode) {
+                continue outer;
+            }
+        }
+        return false;
+    }
+    return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "element-book",
-    "version": "2.0.0",
+    "version": "3.0.0",
     "keywords": [
         "book",
         "design system",