element-book 26.12.0 → 26.12.1

package/{src/data/book-entry/base-book-entry.ts → dist/data/book-entry/base-book-entry.d.ts}

@@ -1,6 +1,5 @@
-import {type HTMLTemplateResult} from 'element-vir';
-import {type BookEntryType} from './book-entry-type.js';
-
+import { type HTMLTemplateResult } from 'element-vir';
+import { type BookEntryType } from './book-entry-type.js';
 /**
  * Base properties for all book entry types.
  *

package/dist/data/book-entry/base-book-entry.js

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

package/{src/data/book-entry/book-entry-type.ts → dist/data/book-entry/book-entry-type.d.ts}

@@ -3,21 +3,17 @@
  *
  * @category Internal
  */
-export enum BookEntryType {
+export declare enum BookEntryType {
     /** A single element example. */
-    ElementExample = 'element-example',
+    ElementExample = "element-example",
     /** An individual book page with element examples and/or sub-pages. */
-    Page = 'page',
+    Page = "page",
     /** Tree root. Not for external use. */
-    Root = 'root',
+    Root = "root"
 }
-
 /**
  * A union of all possible element-book entry types.
  *
  * @category Internal
  */
-export type AnyBookEntryType =
-    | BookEntryType.ElementExample
-    | BookEntryType.Page
-    | BookEntryType.Root;
+export type AnyBookEntryType = BookEntryType.ElementExample | BookEntryType.Page | BookEntryType.Root;

package/dist/data/book-entry/book-entry-type.js

@@ -0,0 +1,14 @@
+/**
+ * All possible types for element-book entries.
+ *
+ * @category Internal
+ */
+export var BookEntryType;
+(function (BookEntryType) {
+    /** A single element example. */
+    BookEntryType["ElementExample"] = "element-example";
+    /** An individual book page with element examples and/or sub-pages. */
+    BookEntryType["Page"] = "page";
+    /** Tree root. Not for external use. */
+    BookEntryType["Root"] = "root";
+})(BookEntryType || (BookEntryType = {}));

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

@@ -0,0 +1,17 @@
+import { type BookEntryType } from './book-entry-type.js';
+import { type BookElementExample, type BookPage } from './book-page/book-page.js';
+import { type BookRoot } from './book-root.js';
+/**
+ * All possible book entries.
+ *
+ * @category Internal
+ */
+export type BookEntry = BookPage | BookRoot | BookElementExample;
+/**
+ * Check if the input is a book entry of the given type.
+ *
+ * @internal
+ */
+export declare function isBookEntry<const SpecificType extends BookEntryType>(entry: unknown, entryType: SpecificType): entry is Extract<BookEntry, {
+    entryType: SpecificType;
+}>;

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

@@ -0,0 +1,9 @@
+import { check } from '@augment-vir/assert';
+/**
+ * Check if the input is a book entry of the given type.
+ *
+ * @internal
+ */
+export function isBookEntry(entry, entryType) {
+    return check.hasKey(entry, 'entryType') && entry.entryType === entryType;
+}

package/dist/data/book-entry/book-page/book-page-controls.d.ts

@@ -0,0 +1,92 @@
+import { type EmptyObject } from 'type-fest';
+/**
+ * Adds a control to an element-book page.
+ *
+ * @category Internal
+ */
+export type BookPageControl<ControlType extends BookPageControlType = BookPageControlType> = {
+    controlType: ControlType;
+    initValue: BookPageControlValueType[ControlType];
+    /** The name and label for the control. */
+    controlName: string;
+} & (ControlType extends BookPageControlType.Dropdown ? {
+    options: string[];
+} : EmptyObject);
+/**
+ * Initialization options for an element-book page control.
+ *
+ * @category Internal
+ */
+export type BookPageControlInit<ControlType extends BookPageControlType> = Omit<BookPageControl<ControlType>, 'controlName'>;
+/**
+ * Checks and type guards that the input page control init is of the given type.
+ *
+ * @internal
+ */
+export declare function isControlInitType<const SpecificControlType extends BookPageControlType>(controlInit: BookPageControlInit<any>, specificType: SpecificControlType): controlInit is BookPageControlInit<SpecificControlType>;
+/**
+ * Define a page control. This doesn't do anything fancy (in fact it only returns the input) but it
+ * helps immensely with type inference.
+ *
+ * @category Main
+ */
+export declare function definePageControl<const ControlType extends BookPageControlType>(controlInit: BookPageControlInit<ControlType>): BookPageControlInit<ControlType>;
+/**
+ * Maps an object of user-defined controls to their initial values.
+ *
+ * @category Internal
+ */
+export type ControlsToValues<ControlsInit extends BookPageControlsInitBase> = {
+    [ControlName in keyof ControlsInit]: ControlsInit[ControlName]['initValue'];
+};
+/**
+ * Base type for a arbitrary, user-defined object of page controls.
+ *
+ * @category Internal
+ */
+export type BookPageControlsInitBase = Record<string, BookPageControlInit<BookPageControlType>>;
+/**
+ * Base type for a arbitrary, user-defined object of page control values.
+ *
+ * @category Internal
+ */
+export type BookPageControlsValues = ControlsToValues<BookPageControlsInitBase>;
+/**
+ * All the supported page control types. One of these must be chosen when defining a page control.
+ *
+ * @category Main
+ */
+export declare enum BookPageControlType {
+    Checkbox = "checkbox",
+    Color = "color",
+    Dropdown = "dropdown",
+    /** Hidden controls allow any values but they aren't displayed to the user for editing. */
+    Hidden = "hidden",
+    Number = "number",
+    Text = "text"
+}
+/**
+ * Specifies the default value for each page control type, as well as its type.
+ *
+ * @category Internal
+ */
+export declare const controlValueTypes: {
+    checkbox: boolean;
+    color: string;
+    dropdown: string;
+    hidden: any;
+    number: number;
+    text: string;
+};
+/**
+ * Each page control type mapped to the type of their value.
+ *
+ * @category Internal
+ */
+export type BookPageControlValueType = typeof controlValueTypes;
+/**
+ * Checks that the given control init object is valid.
+ *
+ * @internal
+ */
+export declare function checkControls(controlsInit: BookPageControlsInitBase | undefined, pageName: string): Error[];

package/dist/data/book-entry/book-page/book-page-controls.js

@@ -0,0 +1,70 @@
+/**
+ * Checks and type guards that the input page control init is of the given type.
+ *
+ * @internal
+ */
+export function isControlInitType(controlInit, specificType) {
+    return controlInit.controlType === specificType;
+}
+/**
+ * Define a page control. This doesn't do anything fancy (in fact it only returns the input) but it
+ * helps immensely with type inference.
+ *
+ * @category Main
+ */
+export function definePageControl(controlInit) {
+    return controlInit;
+}
+/**
+ * All the supported page control types. One of these must be chosen when defining a page control.
+ *
+ * @category Main
+ */
+export var BookPageControlType;
+(function (BookPageControlType) {
+    BookPageControlType["Checkbox"] = "checkbox";
+    BookPageControlType["Color"] = "color";
+    BookPageControlType["Dropdown"] = "dropdown";
+    /** Hidden controls allow any values but they aren't displayed to the user for editing. */
+    BookPageControlType["Hidden"] = "hidden";
+    BookPageControlType["Number"] = "number";
+    BookPageControlType["Text"] = "text";
+})(BookPageControlType || (BookPageControlType = {}));
+const anySymbol = Symbol('any-type');
+/**
+ * Specifies the default value for each page control type, as well as its type.
+ *
+ * @category Internal
+ */
+export const controlValueTypes = {
+    [BookPageControlType.Checkbox]: false,
+    [BookPageControlType.Color]: '',
+    [BookPageControlType.Dropdown]: '',
+    [BookPageControlType.Hidden]: anySymbol,
+    [BookPageControlType.Number]: 0,
+    [BookPageControlType.Text]: '',
+};
+/**
+ * Checks that the given control init object is valid.
+ *
+ * @internal
+ */
+export function checkControls(controlsInit, pageName) {
+    if (!controlsInit) {
+        return [];
+    }
+    const errors = [];
+    Object.entries(controlsInit).forEach(([controlName, controlEntry,]) => {
+        const expectedInitDefault = controlValueTypes[controlEntry.controlType];
+        if (expectedInitDefault === anySymbol) {
+            return;
+        }
+        if (typeof expectedInitDefault !== typeof controlEntry.initValue) {
+            errors.push(new Error(`Control '${controlName}' in page '${pageName}' has invalid initValue '${controlEntry.initValue}': expected initValue of type ${typeof expectedInitDefault} because the control is of type ${controlEntry.controlType}.`));
+        }
+        if (!controlName) {
+            errors.push(new Error(`'${pageName}' cannot have an empty control name.`));
+        }
+    });
+    return errors;
+}

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

@@ -0,0 +1,63 @@
+import { type Overwrite, type PartialWithUndefined, type SetOptionalAndNullable } from '@augment-vir/common';
+import { type CSSResult, type HtmlInterpolation, type PropertyInitMapBase, type RenderParams, type TypedEvent } from 'element-vir';
+import { type GlobalValues } from '../../../ui/elements/element-book-app/global-values.js';
+import { type BaseBookEntry } from '../base-book-entry.js';
+import { type BookEntryType } from '../book-entry-type.js';
+import { type BookPageControlsInitBase, type ControlsToValues } from './book-page-controls.js';
+/**
+ * An individual element-book page.
+ *
+ * @category Type
+ */
+export type BookPage<GlobalValuesType extends GlobalValues = {}, ParentPage extends BookPage | undefined = any, ControlsInit extends BookPageControlsInitBase = BookPageControlsInitBase> = Overwrite<BaseBookEntry, {
+    /**
+     * The parent page of this page. If this page is meant to be at the top-level, set this to
+     * `undefined`.
+     */
+    parent: ParentPage;
+    entryType: BookEntryType.Page;
+}> & {
+    controls: ControlsInit;
+    elementExamples: Record<string, BookElementExample>;
+    useVerticalExamples: boolean;
+};
+/**
+ * All parameters required for rendering an element-book page.
+ *
+ * @category Internal
+ */
+export type BookPageExampleRenderParams<GlobalValuesType extends GlobalValues, ControlsInit extends BookPageControlsInitBase, State extends PropertyInitMapBase> = Pick<RenderParams<any, any, State, any, any, any, any, any>, 'state' | 'updateState'> & {
+    controls: ControlsToValues<ControlsInit> & GlobalValuesType;
+};
+/**
+ * An individual element example for an element-book page.
+ *
+ * @category Internal
+ */
+export type BookElementExample<GlobalValuesType extends GlobalValues = {}, ControlsInit extends BookPageControlsInitBase = {}, State extends PropertyInitMapBase = {}> = Overwrite<BaseBookEntry, {
+    parent: BookPage | undefined;
+    entryType: BookEntryType.ElementExample;
+    isVertical: boolean;
+    /** Render the example. */
+    render: (renderParams: BookPageExampleRenderParams<GlobalValuesType, ControlsInit, State>) => HtmlInterpolation;
+} & PartialWithUndefined<{
+    /**
+     * Initialize the state for this example. This is only called once, before the first render
+     * of the example.
+     */
+    state: () => State;
+    /** Specify which events this example should intercept (so the user can see them). */
+    showEvents: ReadonlyArray<string | TypedEvent>;
+    /**
+     * Style the element example. You can even use the :host selector to style this specific
+     * example's wrapper element!
+     */
+    styles: CSSResult;
+}>>;
+/**
+ * The properties that are necessary to initialize an element example. Missing properties will be
+ * filled in by the parent.
+ *
+ * @category Internal
+ */
+export type BookElementExampleInit<GlobalValuesType extends GlobalValues, Controls extends BookPageControlsInitBase, State extends PropertyInitMapBase> = SetOptionalAndNullable<Omit<BookElementExample<GlobalValuesType, Controls, State>, 'entryType' | 'parent' | 'errors' | 'isVertical'>, 'descriptionParagraphs'>;

package/dist/data/book-entry/book-page/book-page.js

@@ -0,0 +1,2 @@
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+export {};

package/dist/data/book-entry/book-page/controls-wrapper.d.ts

@@ -0,0 +1,32 @@
+import { type PartialWithUndefined } from '@augment-vir/common';
+import { type BookTreeNode } from '../../book-tree/book-tree-node.js';
+import { type BookPageControlsValues } from './book-page-controls.js';
+/**
+ * Nested page controls.
+ *
+ * @category Internal
+ */
+export type ControlsWrapper = {
+    children: {
+        [Breadcrumb: string]: ControlsWrapper;
+    };
+    controls: BookPageControlsValues;
+};
+/**
+ * Find the controls at the given breadcrumbs.
+ *
+ * @category Internal
+ */
+export declare function traverseControls(controlsWrapper: ControlsWrapper, fullUrlBreadcrumbs: ReadonlyArray<string>): BookPageControlsValues;
+/**
+ * Add new controls at the given breadcrumbs.
+ *
+ * @category Internal
+ */
+export declare function createNewControls(controlsWrapper: Readonly<ControlsWrapper>, breadcrumbsForNewValue: ReadonlyArray<string>, newValues: BookPageControlsValues): ControlsWrapper;
+/**
+ * Add new controls from the given tree node.
+ *
+ * @category Internal
+ */
+export declare function updateTreeControls(node: BookTreeNode, existingControls: PartialWithUndefined<ControlsWrapper> | undefined): ControlsWrapper;

package/dist/data/book-entry/book-page/controls-wrapper.js

@@ -0,0 +1,65 @@
+import { mapObjectValues } from '@augment-vir/common';
+import { isBookTreeNode } from '../../book-tree/book-tree.js';
+import { BookEntryType } from '../book-entry-type.js';
+/**
+ * Find the controls at the given breadcrumbs.
+ *
+ * @category Internal
+ */
+export function traverseControls(controlsWrapper, fullUrlBreadcrumbs) {
+    return traverseAndInsertNewControls(controlsWrapper, [
+        /** Empty string represents the breadcrumb for the root node */
+        '',
+        ...fullUrlBreadcrumbs,
+    ], undefined);
+}
+function traverseAndInsertNewControls(controlsWrapper, urlBreadcrumbs, newValues) {
+    const nextBreadcrumbs = urlBreadcrumbs.slice(1);
+    const nextBreadcrumb = nextBreadcrumbs[0];
+    /** If we're at the end of the breadcrumbs, then it's time to insert the new controls. */
+    if (!nextBreadcrumb && newValues) {
+        controlsWrapper.controls = newValues;
+    }
+    const childControlsWrapper = controlsWrapper.children[nextBreadcrumb || ''];
+    const childrenControls = childControlsWrapper &&
+        traverseAndInsertNewControls(childControlsWrapper, nextBreadcrumbs, newValues);
+    const allControls = {
+        ...controlsWrapper.controls,
+        ...childrenControls,
+    };
+    return allControls;
+}
+/**
+ * Add new controls at the given breadcrumbs.
+ *
+ * @category Internal
+ */
+export function createNewControls(controlsWrapper, breadcrumbsForNewValue, newValues) {
+    const newControls = { ...controlsWrapper };
+    traverseAndInsertNewControls(newControls, [
+        /** Empty string represents the breadcrumb for the root node */
+        '',
+        ...breadcrumbsForNewValue,
+    ], newValues);
+    return newControls;
+}
+/**
+ * Add new controls from the given tree node.
+ *
+ * @category Internal
+ */
+export function updateTreeControls(node, existingControls) {
+    const controls = existingControls?.controls ||
+        (isBookTreeNode(node, BookEntryType.Page)
+            ? mapObjectValues(node.entry.controls, (name, setup) => {
+                return setup.initValue;
+            })
+            : {});
+    const controlsWrapper = {
+        children: mapObjectValues(node.children, (childName, childTreeNode) => {
+            return updateTreeControls(childTreeNode, existingControls?.children?.[childTreeNode.urlBreadcrumb]);
+        }),
+        controls,
+    };
+    return controlsWrapper;
+}

package/dist/data/book-entry/book-page/define-book-page.d.ts

@@ -0,0 +1,58 @@
+import { type SetOptionalAndNullable } from '@augment-vir/common';
+import { type PropertyInitMapBase } from 'element-vir';
+import { type EmptyObject } from 'type-fest';
+import { type GlobalValues } from '../../../ui/elements/element-book-app/global-values.js';
+import { type InfiniteRecursionLimiter } from '../../../util/type.js';
+import { type BookPageControlsInitBase } from './book-page-controls.js';
+import { type BookElementExampleInit, type BookPage } from './book-page.js';
+/**
+ * The callback type for a book page definition's `defineExample` callback.
+ *
+ * @category Internal
+ */
+export type DefineExampleCallback<GlobalValuesType extends GlobalValues = {}, ControlsInit extends BookPageControlsInitBase = BookPageControlsInitBase> = <State extends PropertyInitMapBase>(exampleInit: BookElementExampleInit<GlobalValuesType, ControlsInit, State>) => void;
+/**
+ * Used for `defineExamples` in a book page's init.
+ *
+ * @category Internal
+ */
+export type ElementExamplesDefiner<GlobalValuesType extends GlobalValues = {}, ControlsInit extends BookPageControlsInitBase = BookPageControlsInitBase> = (params: {
+    defineExample: DefineExampleCallback<GlobalValuesType, ControlsInit>;
+}) => void;
+/**
+ * Collapses all element-book control inits into a single flag object.
+ *
+ * @category Internal
+ */
+export type CollapseControlsInit<ParentPage extends BookPage | undefined, CurrentControlsInit extends BookPageControlsInitBase, 
+/** Prevent infinite recursion TypeScript errors. */
+RecursionDepth = InfiniteRecursionLimiter> = CurrentControlsInit & (RecursionDepth extends [any, ...infer RemainingDepth] ? ParentPage extends BookPage<infer GlobalValuesType, infer GrandParentPage, infer ParentControls> ? CollapseControlsInit<GrandParentPage, ParentControls, RemainingDepth> : EmptyObject : EmptyObject);
+/**
+ * Collapses all element-book global values into a single flag object.
+ *
+ * @category Internal
+ */
+export type CollapseGlobalValuesType<ParentPage extends BookPage | undefined, GlobalValuesType extends GlobalValues, 
+/** Prevent infinite recursion TypeScript errors. */
+RecursionDepth = InfiniteRecursionLimiter> = GlobalValuesType & (RecursionDepth extends [any, ...infer RemainingDepth] ? ParentPage extends BookPage<infer GlobalValuesType, infer GrandParentPage, infer ParentControls> ? CollapseGlobalValuesType<GrandParentPage, GlobalValuesType, RemainingDepth> : EmptyObject : EmptyObject);
+/**
+ * The parameters for initializing a new element-book page.
+ *
+ * @category Type
+ */
+export type BookPageInit<GlobalValuesType extends GlobalValues, ParentPage extends BookPage | undefined, CurrentControlsInit extends BookPageControlsInitBase> = SetOptionalAndNullable<Omit<BookPage<any, ParentPage, CurrentControlsInit>, 'entryType' | 'elementExamples' | 'errors'>, 'controls' | 'descriptionParagraphs' | 'useVerticalExamples'> & {
+    defineExamples?: ElementExamplesDefiner<CollapseGlobalValuesType<ParentPage, GlobalValuesType>, CollapseControlsInit<ParentPage, CurrentControlsInit>> | undefined;
+};
+/**
+ * A variant of {@link defineBookPage} that allows you specify what the expected global element-book
+ * values are for the page that you are defining.
+ *
+ * @category Main
+ */
+export declare function defineBookPageWithGlobals<const GlobalValuesType extends GlobalValues = {}>(): <const ParentPage extends BookPage | undefined = undefined, const ControlsInit extends BookPageControlsInitBase = {}>(pageInit: BookPageInit<GlobalValuesType, ParentPage, ControlsInit>) => BookPage<GlobalValuesType, ParentPage, ControlsInit>;
+/**
+ * Define an element-book page. This is how you create new entries for your element-book instance.
+ *
+ * @category Main
+ */
+export declare function defineBookPage<const GlobalValuesType extends GlobalValues = {}, const ParentPage extends BookPage | undefined = undefined, const ControlsInit extends BookPageControlsInitBase = {}>(pageInit: BookPageInit<GlobalValuesType, ParentPage, ControlsInit>): BookPage<GlobalValuesType, ParentPage, ControlsInit>;

package/dist/data/book-entry/book-page/define-book-page.js

@@ -0,0 +1,52 @@
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+import { check } from '@augment-vir/assert';
+import { BookEntryType } from '../book-entry-type.js';
+import { titleToUrlBreadcrumb } from '../url-breadcrumbs.js';
+/**
+ * A variant of {@link defineBookPage} that allows you specify what the expected global element-book
+ * values are for the page that you are defining.
+ *
+ * @category Main
+ */
+export function defineBookPageWithGlobals() {
+    return (pageInit) => {
+        return defineBookPage(pageInit);
+    };
+}
+/**
+ * Define an element-book page. This is how you create new entries for your element-book instance.
+ *
+ * @category Main
+ */
+export function defineBookPage(pageInit) {
+    const page = {
+        ...pageInit,
+        entryType: BookEntryType.Page,
+        useVerticalExamples: !!pageInit.useVerticalExamples,
+        elementExamples: {},
+        descriptionParagraphs: pageInit.descriptionParagraphs ?? [],
+        controls: pageInit.controls ?? {},
+        errors: [],
+    };
+    const alreadyTakenElementExampleNames = new Set();
+    if (pageInit.defineExamples) {
+        pageInit.defineExamples({
+            defineExample(elementExampleInit) {
+                const newExample = {
+                    ...elementExampleInit,
+                    isVertical: page.useVerticalExamples,
+                    entryType: BookEntryType.ElementExample,
+                    parent: page,
+                    descriptionParagraphs: elementExampleInit.descriptionParagraphs ?? [],
+                    errors: [
+                        alreadyTakenElementExampleNames.has(elementExampleInit.title) &&
+                            new Error(`Example title '${elementExampleInit.title}' in page '${pageInit.title}' is already taken.`),
+                    ].filter(check.isTruthy),
+                };
+                alreadyTakenElementExampleNames.add(elementExampleInit.title);
+                page.elementExamples[titleToUrlBreadcrumb(newExample.title)] = newExample;
+            },
+        });
+    }
+    return page;
+}

package/dist/data/book-entry/book-root.d.ts

@@ -0,0 +1,12 @@
+import { type Overwrite } from '@augment-vir/common';
+import { type BaseBookEntry } from './base-book-entry.js';
+import { type BookEntryType } from './book-entry-type.js';
+/**
+ * The root of a book tree.
+ *
+ * @category Internal
+ */
+export type BookRoot = Overwrite<BaseBookEntry, {
+    entryType: BookEntryType.Root;
+    parent: undefined;
+}>;

package/dist/data/book-entry/book-root.js

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

package/dist/data/book-entry/url-breadcrumbs.d.ts

@@ -0,0 +1,23 @@
+import { type BookEntry } from './book-entry.js';
+/**
+ * Create a list of URL breadcrumbs for the given element-book entry.
+ *
+ * @internal
+ */
+export declare function listUrlBreadcrumbs(entry: BookEntry, includeSelf: boolean): string[];
+/**
+ * Convert an element-book entry's title to a URL-safe breadcrumb title.
+ *
+ * @internal
+ */
+export declare function titleToUrlBreadcrumb(title: string): string;
+/**
+ * Check if a full list of URL breadcrumbs (`searchIn`) starts with the subset list of URL
+ * breadcrumbs (`searchFor`).
+ *
+ * @internal
+ */
+export declare function doBreadcrumbsStartWith({ searchFor, searchIn, }: {
+    searchIn: ReadonlyArray<string>;
+    searchFor: ReadonlyArray<string>;
+}): boolean;

package/{src/data/book-entry/url-breadcrumbs.ts → dist/data/book-entry/url-breadcrumbs.js}

@@ -1,48 +1,39 @@
-import {collapseWhiteSpace} from '@augment-vir/common';
-import {type BookEntry} from './book-entry.js';
-
+import { collapseWhiteSpace } from '@augment-vir/common';
 /**
  * Create a list of URL breadcrumbs for the given element-book entry.
  *
  * @internal
  */
-export function listUrlBreadcrumbs(entry: BookEntry, includeSelf: boolean): string[] {
+export function listUrlBreadcrumbs(entry, includeSelf) {
     const entryBreadcrumb = titleToUrlBreadcrumb(entry.title);
-
     if (entry.parent) {
         return [
             ...listUrlBreadcrumbs(entry.parent, false),
             titleToUrlBreadcrumb(entry.parent.title),
         ].concat(includeSelf ? [entryBreadcrumb] : []);
-    } else if (includeSelf) {
+    }
+    else if (includeSelf) {
         return [entryBreadcrumb];
-    } else {
+    }
+    else {
         return [];
     }
 }
-
 /**
  * Convert an element-book entry's title to a URL-safe breadcrumb title.
  *
  * @internal
  */
-export function titleToUrlBreadcrumb(title: string): string {
+export function titleToUrlBreadcrumb(title) {
     return collapseWhiteSpace(title).toLowerCase().replaceAll(/\s/g, '-');
 }
-
 /**
  * Check if a full list of URL breadcrumbs (`searchIn`) starts with the subset list of URL
  * breadcrumbs (`searchFor`).
  *
  * @internal
  */
-export function doBreadcrumbsStartWith({
-    searchFor,
-    searchIn,
-}: {
-    searchIn: ReadonlyArray<string>;
-    searchFor: ReadonlyArray<string>;
-}): boolean {
+export function doBreadcrumbsStartWith({ searchFor, searchIn, }) {
     return searchFor.every((breadcrumb, index) => {
         return searchIn[index] === breadcrumb;
     });

package/dist/data/book-entry/verify-book-entry.d.ts

@@ -0,0 +1,3 @@
+import { BookEntryType } from './book-entry-type.js';
+import { type BookEntry } from './book-entry.js';
+export declare const bookEntryVerifiers: { [EntryType in BookEntryType]: (entry: BookEntry) => Error[]; };

package/{src/data/book-entry/verify-book-entry.ts → dist/data/book-entry/verify-book-entry.js}

@@ -1,8 +1,6 @@
-import {check} from '@augment-vir/assert';
-import {BookEntryType} from './book-entry-type.js';
-import {type BookEntry} from './book-entry.js';
-import {checkControls} from './book-page/book-page-controls.js';
-
+import { check } from '@augment-vir/assert';
+import { BookEntryType } from './book-entry-type.js';
+import { checkControls } from './book-page/book-page-controls.js';
 export const bookEntryVerifiers = {
     [BookEntryType.ElementExample]: () => {
         // currently all element example checking happens on page definition
@@ -17,8 +15,4 @@ export const bookEntryVerifiers = {
     [BookEntryType.Root]: () => {
         return [];
     },
-} satisfies {
-    [EntryType in BookEntryType]: (entry: Extract<BookEntry, {entryType: EntryType}>) => Error[];
-} as {
-    [EntryType in BookEntryType]: (entry: BookEntry) => Error[];
 };