element-book 26.12.0 → 26.12.1

package/dist/ui/elements/entry-display/book-page/book-page-wrapper.element.d.ts

@@ -0,0 +1,10 @@
+import { type BookEntryType } from '../../../../data/book-entry/book-entry-type.js';
+import { type ControlsWrapper } from '../../../../data/book-entry/book-page/controls-wrapper.js';
+import { type BookTreeNode } from '../../../../data/book-tree/book-tree-node.js';
+import { type BookRouter } from '../../../../routing/book-router.js';
+export declare const BookPageWrapper: import("element-vir").DeclarativeElementDefinition<"book-page-wrapper", {
+    isTopLevel: boolean;
+    pageNode: BookTreeNode<BookEntryType.Page>;
+    router: BookRouter | undefined;
+    controls: ControlsWrapper;
+}, {}, {}, "book-page-wrapper-", "book-page-wrapper-", readonly [], readonly []>;

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

@@ -0,0 +1,86 @@
+import { combineErrors } from '@augment-vir/common';
+import { css, html } from 'element-vir';
+import { traverseControls, } from '../../../../data/book-entry/book-page/controls-wrapper.js';
+import { BookMainRoute } from '../../../../routing/book-routing.js';
+import { BookError } from '../../common/book-error.element.js';
+import { BookRouteLink } from '../../common/book-route-link.element.js';
+import { defineBookElement } from '../../define-book-element.js';
+import { BookEntryDescription } from '../book-entry-description.element.js';
+import { BookPageControls } from './book-page-controls.element.js';
+export const BookPageWrapper = defineBookElement()({
+    tagName: 'book-page-wrapper',
+    styles: css `
+        :host {
+            display: block;
+        }
+
+        h2,
+        h3 {
+            margin: 0;
+            padding: 0;
+            font-size: 1.5em;
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+
+        .page-header .title-group {
+            align-items: flex-start;
+            display: flex;
+            flex-direction: column;
+        }
+
+        ${BookRouteLink} {
+            display: inline-block;
+        }
+    `,
+    render({ inputs }) {
+        const titleTemplate = inputs.isTopLevel
+            ? html `
+                  <h2 class="header-with-icon">${inputs.pageNode.entry.title}</h2>
+              `
+            : html `
+                  <h3 class="header-with-icon">${inputs.pageNode.entry.title}</h3>
+              `;
+        const linkPaths = [
+            BookMainRoute.Book,
+            ...inputs.pageNode.fullUrlBreadcrumbs,
+        ];
+        const error = inputs.pageNode.entry.errors.length
+            ? combineErrors(inputs.pageNode.entry.errors)
+            : undefined;
+        if (error) {
+            console.error(error);
+        }
+        return html `
+            <div class="page-header block-entry">
+                <div class="title-group">
+                    <${BookRouteLink.assign({
+            route: {
+                paths: linkPaths,
+                hash: undefined,
+                search: undefined,
+            },
+            router: inputs.router,
+        })}>
+                        ${titleTemplate}
+                    </${BookRouteLink}>
+                    ${error
+            ? html `
+                              <${BookError.assign({ message: error.message })}></${BookError}>
+                          `
+            : html `
+                              <${BookEntryDescription.assign({
+                descriptionParagraphs: inputs.pageNode.entry.descriptionParagraphs,
+            })}></${BookEntryDescription}>
+                              <${BookPageControls.assign({
+                config: inputs.pageNode.entry.controls,
+                currentValues: traverseControls(inputs.controls, inputs.pageNode.fullUrlBreadcrumbs),
+                fullUrlBreadcrumbs: inputs.pageNode.fullUrlBreadcrumbs,
+            })}></${BookPageControls}>
+                          `}
+                </div>
+            </div>
+        `;
+    },
+});

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

@@ -0,0 +1,7 @@
+import { type BookEntryType } from '../../../../data/book-entry/book-entry-type.js';
+import { type BookTreeNode } from '../../../../data/book-tree/book-tree-node.js';
+import { type BookRouter } from '../../../../routing/book-router.js';
+export declare const BookElementExampleControls: import("element-vir").DeclarativeElementDefinition<"book-element-example-controls", {
+    elementExampleNode: BookTreeNode<BookEntryType.ElementExample>;
+    router: BookRouter | undefined;
+}, {}, {}, "book-element-example-controls-", "book-element-example-controls-", readonly [], readonly []>;

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

@@ -0,0 +1,34 @@
+import { css, html } from 'element-vir';
+import { BookMainRoute } from '../../../../routing/book-routing.js';
+import { colorThemeCssVars } from '../../../color-theme/color-theme.js';
+import { BookRouteLink } from '../../common/book-route-link.element.js';
+import { defineBookElement } from '../../define-book-element.js';
+export const BookElementExampleControls = defineBookElement()({
+    tagName: 'book-element-example-controls',
+    styles: css `
+        :host {
+            display: flex;
+            color: ${colorThemeCssVars['element-book-page-foreground-faint-level-1-color'].value};
+            border-bottom: 1px solid currentColor;
+            padding: 0 8px 4px;
+        }
+    `,
+    render({ inputs }) {
+        const linkPaths = [
+            BookMainRoute.Book,
+            ...inputs.elementExampleNode.fullUrlBreadcrumbs,
+        ];
+        return html `
+            <${BookRouteLink.assign({
+            route: {
+                paths: linkPaths,
+                hash: undefined,
+                search: undefined,
+            },
+            router: inputs.router,
+        })}>
+                ${inputs.elementExampleNode.entry.title}
+            </${BookRouteLink}>
+        `;
+    },
+});

package/dist/ui/elements/entry-display/element-example/book-element-example-viewer.element.d.ts

@@ -0,0 +1,7 @@
+import { type BookEntryType } from '../../../../data/book-entry/book-entry-type.js';
+import { type BookPageControlsValues } from '../../../../data/book-entry/book-page/book-page-controls.js';
+import { type BookTreeNode } from '../../../../data/book-tree/book-tree-node.js';
+export declare const BookElementExampleViewer: import("element-vir").DeclarativeElementDefinition<"book-element-example-viewer", {
+    elementExampleNode: BookTreeNode<BookEntryType.ElementExample>;
+    currentPageControls: BookPageControlsValues;
+}, any, {}, "book-element-example-viewer-", "book-element-example-viewer-", readonly [], readonly []>;

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

@@ -0,0 +1,61 @@
+import { combineErrors, extractErrorMessage } from '@augment-vir/common';
+import { html, renderIf } from 'element-vir';
+import { unsetInternalState } from '../../../../data/unset.js';
+import { BookError } from '../../common/book-error.element.js';
+import { defineBookElement } from '../../define-book-element.js';
+export const BookElementExampleViewer = defineBookElement()({
+    tagName: 'book-element-example-viewer',
+    state() {
+        return {
+            isUnset: unsetInternalState,
+        };
+    },
+    render({ state, inputs, updateState }) {
+        try {
+            if (inputs.elementExampleNode.entry.errors.length) {
+                throw combineErrors(inputs.elementExampleNode.entry.errors);
+            }
+            if (
+            /** This is a check to make sure the input entry _does_ match the expected type. */
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            !inputs.elementExampleNode.entry.render ||
+                typeof inputs.elementExampleNode.entry.render === 'string') {
+                throw new Error(`Failed to render example '${inputs.elementExampleNode.entry.title}': render is not a function`);
+            }
+            if (state.isUnset === unsetInternalState) {
+                updateState({
+                    isUnset: undefined,
+                    ...inputs.elementExampleNode.entry.state?.(),
+                });
+            }
+            const output = inputs.elementExampleNode.entry.render({
+                state,
+                updateState,
+                controls: inputs.currentPageControls,
+            });
+            if (output instanceof Promise) {
+                throw new TypeError('render output cannot be a promise');
+            }
+            return html `
+                ${renderIf(!!inputs.elementExampleNode.entry.styles, html `
+                        <style>
+                            ${inputs.elementExampleNode.entry.styles}
+                        </style>
+                    `)}
+                ${output}
+            `;
+        }
+        catch (error) {
+            console.error('ERROR HERE', extractErrorMessage(error));
+            console.error(error);
+            return html `
+                <${BookError.assign({
+                message: `${inputs.elementExampleNode.entry.title} failed: ${extractErrorMessage(error)}`,
+            })}></${BookError}>
+            `;
+        }
+    },
+    options: {
+        allowPolymorphicState: true,
+    },
+});

package/dist/ui/elements/entry-display/element-example/book-element-example-wrapper.element.d.ts

@@ -0,0 +1,9 @@
+import { type BookEntryType } from '../../../../data/book-entry/book-entry-type.js';
+import { type BookPageControlsValues } from '../../../../data/book-entry/book-page/book-page-controls.js';
+import { type BookTreeNode } from '../../../../data/book-tree/book-tree-node.js';
+import { type BookRouter } from '../../../../routing/book-router.js';
+export declare const BookElementExampleWrapper: import("element-vir").DeclarativeElementDefinition<"book-element-example-wrapper", {
+    elementExampleNode: BookTreeNode<BookEntryType.ElementExample>;
+    currentPageControls: BookPageControlsValues;
+    router: BookRouter | undefined;
+}, {}, {}, "book-element-example-wrapper-", "book-element-example-wrapper-", readonly [], readonly []>;

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

@@ -0,0 +1,50 @@
+import { omitObjectKeys } from '@augment-vir/common';
+import { css, html } from 'element-vir';
+import { colorThemeCssVars } from '../../../color-theme/color-theme.js';
+import { defineBookElement } from '../../define-book-element.js';
+import { BookElementExampleControls } from './book-element-example-controls.element.js';
+import { BookElementExampleViewer } from './book-element-example-viewer.element.js';
+export const BookElementExampleWrapper = defineBookElement()({
+    tagName: 'book-element-example-wrapper',
+    styles: css `
+        :host {
+            display: inline-block;
+            max-width: 100%;
+        }
+
+        .examples-wrapper {
+            display: flex;
+            gap: 32px;
+            flex-wrap: wrap;
+        }
+
+        .error {
+            color: red;
+            font-weight: bold;
+        }
+
+        .individual-example-wrapper {
+            display: flex;
+            flex-direction: column;
+            gap: 24px;
+            max-width: 100%;
+            align-items: flex-start;
+        }
+
+        ${BookElementExampleControls} {
+            color: ${colorThemeCssVars['element-book-page-foreground-faint-level-1-color'].value};
+        }
+
+        :host(:hover) ${BookElementExampleControls} {
+            color: ${colorThemeCssVars['element-book-accent-icon-color'].value};
+        }
+    `,
+    render({ inputs }) {
+        return html `
+            <div class="individual-example-wrapper">
+                <${BookElementExampleControls.assign(omitObjectKeys(inputs, ['currentPageControls']))}></${BookElementExampleControls}>
+                <${BookElementExampleViewer.assign(inputs)}></${BookElementExampleViewer}>
+            </div>
+        `;
+    },
+});

package/dist/ui/elements/entry-display/entry-display/book-entry-display.element.d.ts

@@ -0,0 +1,18 @@
+import { type BookEntryType } from '../../../../data/book-entry/book-entry-type.js';
+import { type ControlsWrapper } from '../../../../data/book-entry/book-page/controls-wrapper.js';
+import { type BookTreeNode } from '../../../../data/book-tree/book-tree-node.js';
+import { type BookRouter } from '../../../../routing/book-router.js';
+import { type BookFullRoute } from '../../../../routing/book-routing.js';
+export declare const BookEntryDisplay: import("element-vir").DeclarativeElementDefinition<"book-entry-display", {
+    controls: ControlsWrapper;
+    currentNodes: ReadonlyArray<BookTreeNode>;
+    currentRoute: Readonly<BookFullRoute>;
+    debug: boolean;
+    originalTree: Readonly<BookTreeNode<BookEntryType.Root>>;
+    router: BookRouter | undefined;
+    showLoading: boolean;
+}, {
+    lastElement: undefined | Element;
+}, {
+    loadingRender: import("element-vir").DefineEvent<boolean>;
+}, "book-entry-display-", "book-entry-display-", readonly [], readonly []>;

package/{src/ui/elements/entry-display/entry-display/book-entry-display.element.ts → dist/ui/elements/entry-display/entry-display/book-entry-display.element.js}

@@ -1,31 +1,18 @@
-import {css, defineElementEvent, html, onDomCreated, renderIf} from 'element-vir';
-import {LoaderAnimated24Icon, ViraIcon, viraAnimationDurations} from 'vira';
-import {type BookEntryType} from '../../../../data/book-entry/book-entry-type.js';
-import {type ControlsWrapper} from '../../../../data/book-entry/book-page/controls-wrapper.js';
-import {type BookTreeNode} from '../../../../data/book-tree/book-tree-node.js';
-import {type BookRouter} from '../../../../routing/book-router.js';
-import {type BookFullRoute, extractSearchQuery} from '../../../../routing/book-routing.js';
-import {defineBookElement} from '../../define-book-element.js';
-import {ElementBookSlotName} from '../../element-book-app/element-book-app-slots.js';
-import {BookBreadcrumbsBar} from '../book-breadcrumbs-bar.element.js';
-import {createNodeTemplates} from './create-node-templates.js';
-
-export const BookEntryDisplay = defineBookElement<{
-    controls: ControlsWrapper;
-    currentNodes: ReadonlyArray<BookTreeNode>;
-    currentRoute: Readonly<BookFullRoute>;
-    debug: boolean;
-    originalTree: Readonly<BookTreeNode<BookEntryType.Root>>;
-    router: BookRouter | undefined;
-    showLoading: boolean;
-}>()({
+import { css, defineElementEvent, html, onDomCreated, renderIf } from 'element-vir';
+import { LoaderAnimated24Icon, ViraIcon, viraAnimationDurations } from 'vira';
+import { extractSearchQuery } from '../../../../routing/book-routing.js';
+import { defineBookElement } from '../../define-book-element.js';
+import { ElementBookSlotName } from '../../element-book-app/element-book-app-slots.js';
+import { BookBreadcrumbsBar } from '../book-breadcrumbs-bar.element.js';
+import { createNodeTemplates } from './create-node-templates.js';
+export const BookEntryDisplay = defineBookElement()({
     tagName: 'book-entry-display',
     state() {
         return {
-            lastElement: undefined as undefined | Element,
+            lastElement: undefined,
         };
     },
-    styles: css`
+    styles: css `
         :host {
             display: flex;
             flex-direction: column;
@@ -86,11 +73,10 @@ export const BookEntryDisplay = defineBookElement<{
         }
     `,
     events: {
-        loadingRender: defineElementEvent<boolean>(),
+        loadingRender: defineElementEvent(),
     },
-    render: ({inputs, dispatch, events, state, updateState}) => {
+    render: ({ inputs, dispatch, events, state, updateState }) => {
         const currentSearch = extractSearchQuery(inputs.currentRoute.paths);
-
         const entryTemplates = createNodeTemplates({
             currentNodes: inputs.currentNodes,
             isTopLevel: true,
@@ -99,45 +85,37 @@ export const BookEntryDisplay = defineBookElement<{
             controls: inputs.controls,
             originalTree: inputs.originalTree,
         });
-
-        return html`
+        return html `
             <${BookBreadcrumbsBar.assign({
-                currentSearch,
-                currentRoute: inputs.currentRoute,
-                router: inputs.router,
-            })}></${BookBreadcrumbsBar}>
+            currentSearch,
+            currentRoute: inputs.currentRoute,
+            router: inputs.router,
+        })}></${BookBreadcrumbsBar}>
 
-            ${renderIf(
-                inputs.showLoading,
-                html`
+            ${renderIf(inputs.showLoading, html `
                     <div
                         ${onDomCreated(() => {
-                            dispatch(new events.loadingRender(true));
-                        })}
+            dispatch(new events.loadingRender(true));
+        })}
                         class="loading"
                     >
-                        <${ViraIcon.assign({icon: LoaderAnimated24Icon})}></${ViraIcon}>
+                        <${ViraIcon.assign({ icon: LoaderAnimated24Icon })}></${ViraIcon}>
                     </div>
-                    ${renderIf(
-                        !!state.lastElement,
-                        html`
+                    ${renderIf(!!state.lastElement, html `
                             ${state.lastElement}
                             <slot name=${ElementBookSlotName.Footer}></slot>
-                        `,
-                    )}
-                `,
-                html`
+                        `)}
+                `, html `
                     <div
                         ${onDomCreated((element) => {
-                            updateState({lastElement: element});
-                        })}
+            updateState({ lastElement: element });
+        })}
                         class="all-book-entries-wrapper"
                     >
                         ${entryTemplates}
                     </div>
                     <slot name=${ElementBookSlotName.Footer}></slot>
-                `,
-            )}
+                `)}
         `;
     },
 });

package/dist/ui/elements/entry-display/entry-display/create-node-templates.d.ts

@@ -0,0 +1,13 @@
+import { type HtmlInterpolation } from 'element-vir';
+import { BookEntryType } from '../../../../data/book-entry/book-entry-type.js';
+import { type ControlsWrapper } from '../../../../data/book-entry/book-page/controls-wrapper.js';
+import { type BookTreeNode } from '../../../../data/book-tree/book-tree-node.js';
+import { type BookRouter } from '../../../../routing/book-router.js';
+export declare function createNodeTemplates({ currentNodes, isTopLevel, router, isSearching, controls, originalTree, }: {
+    currentNodes: ReadonlyArray<BookTreeNode>;
+    isTopLevel: boolean;
+    router: BookRouter | undefined;
+    isSearching: boolean;
+    controls: ControlsWrapper;
+    originalTree: Readonly<BookTreeNode<BookEntryType.Root>>;
+}): HtmlInterpolation[];

package/dist/ui/elements/entry-display/entry-display/create-node-templates.js

@@ -0,0 +1,113 @@
+import { check } from '@augment-vir/assert';
+import { mapObjectValues } from '@augment-vir/common';
+import { classMap, html, nothing, repeat, } from 'element-vir';
+import { BookEntryType } from '../../../../data/book-entry/book-entry-type.js';
+import { traverseControls, } from '../../../../data/book-entry/book-page/controls-wrapper.js';
+import { isBookTreeNode, traverseToImmediateParent } from '../../../../data/book-tree/book-tree.js';
+import { BookError } from '../../common/book-error.element.js';
+import { BookPageControls } from '../book-page/book-page-controls.element.js';
+import { BookPageWrapper } from '../book-page/book-page-wrapper.element.js';
+import { BookElementExampleWrapper } from '../element-example/book-element-example-wrapper.element.js';
+function getFlattenedControlsFromHiddenParents(currentNodes, currentControls, currentNode, originalTree) {
+    const parent = traverseToImmediateParent(currentNode, originalTree);
+    const allControls = [];
+    if (parent) {
+        const parentControls = getFlattenedControlsFromHiddenParents(currentNodes, currentControls, parent, originalTree);
+        if (parentControls) {
+            allControls.push(parentControls);
+        }
+    }
+    if (isBookTreeNode(currentNode, BookEntryType.Page) && !currentNodes.includes(currentNode)) {
+        const currentEntryControls = traverseControls(currentControls, currentNode.fullUrlBreadcrumbs);
+        allControls.push({
+            config: currentNode.entry.controls,
+            current: currentEntryControls,
+            breadcrumbs: mapObjectValues(currentEntryControls, () => {
+                return currentNode.fullUrlBreadcrumbs;
+            }),
+        });
+    }
+    return allControls.reduce((accum, currentControls) => {
+        return {
+            config: {
+                ...accum.config,
+                ...currentControls.config,
+            },
+            current: {
+                ...accum.current,
+                ...currentControls.current,
+            },
+            breadcrumbs: {
+                ...accum.breadcrumbs,
+                ...currentControls.breadcrumbs,
+            },
+        };
+    }, { config: {}, current: {}, breadcrumbs: {} });
+}
+export function createNodeTemplates({ currentNodes, isTopLevel, router, isSearching, controls, originalTree, }) {
+    if (!currentNodes.length && isSearching) {
+        return [
+            html `
+                No results
+            `,
+        ];
+    }
+    const hiddenAncestorControls = check.isLengthAtLeast(currentNodes, 1)
+        ? getFlattenedControlsFromHiddenParents(currentNodes, controls, currentNodes[0], originalTree)
+        : undefined;
+    const hiddenAncestorControlsTemplate = hiddenAncestorControls &&
+        Object.values(hiddenAncestorControls.config).length &&
+        check.isLengthAtLeast(currentNodes, 1)
+        ? html `
+                  <${BookPageControls.assign({
+            config: hiddenAncestorControls.config,
+            currentValues: hiddenAncestorControls.current,
+            fullUrlBreadcrumbs: hiddenAncestorControls.breadcrumbs,
+        })}></${BookPageControls}>
+              `
+        : nothing;
+    const templates = repeat(currentNodes, (node) => node.fullUrlBreadcrumbs.join('>'), (currentNode) => {
+        if (isBookTreeNode(currentNode, BookEntryType.Page)) {
+            return html `
+                    <${BookPageWrapper.assign({
+                isTopLevel,
+                pageNode: currentNode,
+                controls,
+                router,
+            })}
+                        class="block-entry"
+                    ></${BookPageWrapper}>
+                `;
+        }
+        else if (isBookTreeNode(currentNode, BookEntryType.ElementExample)) {
+            const controlsForElementExample = traverseControls(controls, currentNode.fullUrlBreadcrumbs.slice(0, -1));
+            return html `
+                    <${BookElementExampleWrapper.assign({
+                elementExampleNode: currentNode,
+                currentPageControls: controlsForElementExample,
+                router,
+            })}
+                        class="inline-entry ${classMap({
+                'block-entry': currentNode.entry.isVertical,
+            })}"
+                    ></${BookElementExampleWrapper}>
+                `;
+        }
+        else if (isBookTreeNode(currentNode, BookEntryType.Root)) {
+            return nothing;
+        }
+        else {
+            return html `
+                    <${BookError.assign({
+                message: `Unknown entry type for rendering: '${currentNode.entry.entryType}'`,
+            })}
+                        class="block-entry"
+                    ></${BookError}>
+                `;
+        }
+    });
+    return [
+        hiddenAncestorControlsTemplate,
+        templates,
+    ];
+}

package/dist/ui/events/change-route.event.d.ts

@@ -0,0 +1 @@
+export declare const ChangeRouteEvent: import("element-vir").DefinedTypedEvent<"element-book-change-route", Partial<Readonly<Required<import("spa-router-vir").SpaRoute<import("../../routing/book-routing.js").ValidBookPaths, undefined, undefined>>>>>;

package/dist/ui/events/change-route.event.js

@@ -0,0 +1,2 @@
+import { defineTypedEvent } from 'element-vir';
+export const ChangeRouteEvent = defineTypedEvent()('element-book-change-route');

package/dist/util/fuzzy-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/{src/util/fuzzy-search.ts → dist/util/fuzzy-search.js}

@@ -5,7 +5,6 @@
  *
  * That code has the following license:
  */
-
 /**
  * The MIT License (MIT)
  *
@@ -27,16 +26,11 @@
  * 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,
-}: {
-    searchQuery: string;
-    searchIn: string;
-}): boolean {
+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) {
@@ -45,10 +39,8 @@ export function fuzzySearch({
     if (searchQueryLength === searchInLength) {
         return searchQuery === searchIn;
     }
-
     const lowercaseSearchIn = searchIn.toLowerCase();
     const lowercaseSearchQuery = searchQuery.toLowerCase();
-
     // eslint-disable-next-line sonarjs/no-labels
     outer: for (let i = 0, j = 0; i < searchQueryLength; i++) {
         const charCode = lowercaseSearchQuery.codePointAt(i);

package/{src/util/type.ts → dist/util/type.d.ts}

@@ -3,8 +3,9 @@
  *
  * @category Internal
  */
-export type NestedType<SubType> = {[prop: PropertyKey]: SubType | NestedType<SubType>};
-
+export type NestedType<SubType> = {
+    [prop: PropertyKey]: SubType | NestedType<SubType>;
+};
 /**
  * The TypeScript compiler is hard-coded to prevent recursion deeper than 50, so this helps us make
  * sure we stay below that limit.
@@ -42,5 +43,5 @@ export type InfiniteRecursionLimiter = [
     3,
     2,
     1,
-    0,
+    0
 ];

package/dist/util/type.js

@@ -0,0 +1 @@
+export {};