element-book 26.12.0 → 26.12.1

package/{src/data/book-tree/book-tree-node.ts → dist/data/book-tree/book-tree-node.d.ts}

@@ -1,14 +1,12 @@
-import {type Values} from '@augment-vir/common';
-import {type AnyBookEntryType, type BookEntryType} from '../book-entry/book-entry-type.js';
-import {type BookEntry} from '../book-entry/book-entry.js';
-
+import { type Values } from '@augment-vir/common';
+import { type AnyBookEntryType, type BookEntryType } from '../book-entry/book-entry-type.js';
+import { type BookEntry } from '../book-entry/book-entry.js';
 /**
  * Property used to mark tree nodes.
  *
  * @category Internal
  */
-export const isBookTreeNodeMarker = '_isBookTreeNode';
-
+export declare const isBookTreeNodeMarker = "_isBookTreeNode";
 /**
  * The base tree node type for {@link BookTreeNode}.
  *
@@ -27,20 +25,16 @@ export type InternalBookTreeNodeType<Entry> = {
      */
     manuallyAdded: boolean;
 };
-
 /**
  * Any element-book tree node.
  *
  * @category Internal
  */
-export type BookTreeNode<EntryTypes extends BookEntryType = AnyBookEntryType> =
-    | Values<{
-          [EntryType in EntryTypes]: InternalBookTreeNodeType<
-              Extract<BookEntry, {entryType: EntryType}>
-          >;
-      }>
-    | (AnyBookEntryType extends EntryTypes ? InternalBookTreeNodeType<BookEntry> : never);
-
+export type BookTreeNode<EntryTypes extends BookEntryType = AnyBookEntryType> = Values<{
+    [EntryType in EntryTypes]: InternalBookTreeNodeType<Extract<BookEntry, {
+        entryType: EntryType;
+    }>>;
+}> | (AnyBookEntryType extends EntryTypes ? InternalBookTreeNodeType<BookEntry> : never);
 /**
  * The full element-book app tree for representing page structure.
  *

package/dist/data/book-tree/book-tree-node.js

@@ -0,0 +1,6 @@
+/**
+ * Property used to mark tree nodes.
+ *
+ * @category Internal
+ */
+export const isBookTreeNodeMarker = '_isBookTreeNode';

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

@@ -0,0 +1,13 @@
+import { BookEntryType } from '../book-entry/book-entry-type.js';
+import { type BookEntry } from '../book-entry/book-entry.js';
+import { type BookTree, type BookTreeNode } from './book-tree-node.js';
+export declare function doesNodeHaveEntryType<const EntryType extends BookEntryType>(node: unknown, entryType: EntryType): node is BookTreeNode<EntryType>;
+export declare function isBookTreeNode<const SpecificType extends BookEntryType>(input: unknown, entryType: SpecificType): input is BookTreeNode<SpecificType>;
+export declare function isAnyBookTreeNode(input: unknown): input is BookTreeNode<BookEntryType>;
+export declare function createEmptyBookTreeRoot(): BookTreeNode<BookEntryType.Root>;
+export declare function createBookTreeFromEntries({ entries, debug, }: {
+    entries: ReadonlyArray<BookEntry>;
+    debug: boolean;
+}): BookTree;
+export declare function traverseToImmediateParent(entryOrNode: Readonly<BookEntry> | BookTreeNode, currentTree: Readonly<BookTreeNode>): BookTreeNode | undefined;
+export declare function flattenTree(node: Readonly<BookTreeNode>): BookTreeNode[];

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

@@ -0,0 +1,136 @@
+import { check } from '@augment-vir/assert';
+import { BookEntryType } from '../book-entry/book-entry-type.js';
+import { isBookEntry } from '../book-entry/book-entry.js';
+import { listUrlBreadcrumbs, titleToUrlBreadcrumb } from '../book-entry/url-breadcrumbs.js';
+import { bookEntryVerifiers } from '../book-entry/verify-book-entry.js';
+import { isBookTreeNodeMarker } from './book-tree-node.js';
+import { addTreeToCache, getTreeFromCache } from './tree-cache.js';
+export function doesNodeHaveEntryType(node, entryType) {
+    return (check.hasKey(node, 'entry') &&
+        check.isObject(node.entry) &&
+        node.entry.entryType === entryType);
+}
+export function isBookTreeNode(input, entryType) {
+    return isAnyBookTreeNode(input) && input.entry.entryType === entryType;
+}
+export function isAnyBookTreeNode(input) {
+    return !!(check.hasKeys(input, [
+        isBookTreeNodeMarker,
+        'entry',
+    ]) && input[isBookTreeNodeMarker]);
+}
+export function createEmptyBookTreeRoot() {
+    const rootNode = {
+        [isBookTreeNodeMarker]: true,
+        entry: {
+            entryType: BookEntryType.Root,
+            title: '',
+            parent: undefined,
+            errors: [],
+            descriptionParagraphs: [],
+        },
+        urlBreadcrumb: '',
+        fullUrlBreadcrumbs: [],
+        children: {},
+        manuallyAdded: true,
+    };
+    return rootNode;
+}
+export function createBookTreeFromEntries({ entries, debug, }) {
+    const cachedTree = getTreeFromCache(entries);
+    if (cachedTree) {
+        return cachedTree;
+    }
+    const tree = createEmptyBookTreeRoot();
+    entries.forEach((newEntry) => addEntryToTree({ tree, newEntry, debug, manuallyAdded: true }));
+    const flattenedNodes = flattenTree(tree);
+    const bookTree = {
+        tree,
+        flattenedNodes,
+    };
+    addTreeToCache(entries, bookTree);
+    if (debug) {
+        console.info('element-book tree:', tree);
+    }
+    return bookTree;
+}
+function getOrAddImmediateParent(tree, entry, debug) {
+    if (!entry.parent) {
+        return tree;
+    }
+    const immediateParent = traverseToImmediateParent(entry, tree);
+    if (immediateParent) {
+        return immediateParent;
+    }
+    if (debug) {
+        console.info(`parent of ${entry.title} not found in tree; adding it now.`);
+    }
+    addEntryToTree({ tree, newEntry: entry.parent, debug, manuallyAdded: false });
+    const immediateParentAfterAdding = traverseToImmediateParent(entry, tree);
+    if (!immediateParentAfterAdding) {
+        throw new Error(`Failed to find node despite having just added it: ${listUrlBreadcrumbs(entry, false).join(' > ')}`);
+    }
+    return immediateParentAfterAdding;
+}
+function addEntryToTree({ tree, newEntry, debug, manuallyAdded, }) {
+    const errors = bookEntryVerifiers[newEntry.entryType](newEntry);
+    newEntry.errors.push(...errors);
+    const immediateParent = getOrAddImmediateParent(tree, newEntry, debug);
+    const newEntryUrlBreadcrumb = titleToUrlBreadcrumb(newEntry.title);
+    const existingChild = immediateParent.children[newEntryUrlBreadcrumb];
+    if (existingChild) {
+        // ignores multiple entries that have been added by following parent chains
+        if (manuallyAdded) {
+            if (existingChild.manuallyAdded) {
+                existingChild.entry.errors.push(new Error(`Cannot create duplicate '${newEntryUrlBreadcrumb}'${immediateParent.urlBreadcrumb
+                    ? ` in parent '${immediateParent.urlBreadcrumb}'.`
+                    : ''}`));
+                return;
+            }
+            existingChild.manuallyAdded = true;
+        }
+        return;
+    }
+    const newNode = {
+        [isBookTreeNodeMarker]: true,
+        children: {},
+        urlBreadcrumb: newEntryUrlBreadcrumb,
+        fullUrlBreadcrumbs: [
+            ...immediateParent.fullUrlBreadcrumbs,
+            newEntryUrlBreadcrumb,
+        ],
+        entry: newEntry,
+        manuallyAdded,
+    };
+    immediateParent.children[newEntryUrlBreadcrumb] = newNode;
+    if (isBookEntry(newEntry, BookEntryType.Page) &&
+        Object.values(newEntry.elementExamples).length) {
+        Object.values(newEntry.elementExamples).forEach((elementExample) => addEntryToTree({ tree, newEntry: elementExample, debug, manuallyAdded }));
+    }
+}
+export function traverseToImmediateParent(entryOrNode, currentTree) {
+    const breadcrumbs = isAnyBookTreeNode(entryOrNode)
+        ? entryOrNode.fullUrlBreadcrumbs.slice(0, -1)
+        : listUrlBreadcrumbs(entryOrNode, false);
+    if (!breadcrumbs.length) {
+        return undefined;
+    }
+    const immediateParentNode = breadcrumbs.reduce((currentAncestor, nextBreadcrumb) => {
+        if (!currentAncestor) {
+            return undefined;
+        }
+        return currentAncestor.children[nextBreadcrumb];
+    }, currentTree);
+    return immediateParentNode;
+}
+export function flattenTree(node) {
+    const hasErrors = !!node.entry.errors.length;
+    const childNodes = hasErrors
+        ? []
+        : Object.values(node.children).map((child) => flattenTree(child));
+    const entries = [
+        node,
+        ...childNodes,
+    ].flat();
+    return entries;
+}

package/dist/data/book-tree/search-nodes.d.ts

@@ -0,0 +1,5 @@
+import { type BookTreeNode } from './book-tree-node.js';
+export declare function searchFlattenedNodes({ flattenedNodes, searchQuery, }: {
+    flattenedNodes: ReadonlyArray<BookTreeNode>;
+    searchQuery: string;
+}): ReadonlyArray<BookTreeNode>;

package/dist/data/book-tree/search-nodes.js

@@ -0,0 +1,74 @@
+import { check } from '@augment-vir/assert';
+import { randomString } from '@augment-vir/common';
+import { convertTemplateToString } from 'element-vir';
+import { fuzzySearch } from '../../util/fuzzy-search.js';
+const searchJoin = randomString(32);
+function createBreadcrumbsSearchKey(breadcrumbs) {
+    return breadcrumbs.join(searchJoin);
+}
+function getFullTreeKeysToInclude(breadcrumbs) {
+    if (!breadcrumbs.length) {
+        return [];
+    }
+    const currentKey = createBreadcrumbsSearchKey(breadcrumbs);
+    const ancestorKeys = getFullTreeKeysToInclude(breadcrumbs.slice(0, -1));
+    return [
+        currentKey,
+        ...ancestorKeys,
+    ];
+}
+const errorQueries = [
+    'error',
+    'errors',
+];
+function isSearchingForErrors(searchQuery) {
+    return errorQueries.includes(searchQuery);
+}
+export function searchFlattenedNodes({ flattenedNodes, searchQuery, }) {
+    const includeInSearchResults = {};
+    function addChildren(treeNode) {
+        const childrenKeys = Object.values(treeNode.children).map((child) => {
+            addChildren(child);
+            return createBreadcrumbsSearchKey(child.fullUrlBreadcrumbs);
+        });
+        childrenKeys.forEach((keyToInclude) => (includeInSearchResults[keyToInclude] = true));
+    }
+    flattenedNodes.forEach((treeNode) => {
+        const matchesErrors = treeNode.entry.errors.length && isSearchingForErrors(searchQuery);
+        const currentNodeSearchKey = createBreadcrumbsSearchKey(treeNode.fullUrlBreadcrumbs);
+        const shouldInclude = fuzzySearch({
+            searchIn: [
+                treeNode.entry.title,
+                ...treeNode.entry.descriptionParagraphs.map((paragraph) => {
+                    if (check.isString(paragraph)) {
+                        return paragraph;
+                    }
+                    else {
+                        return convertTemplateToString(paragraph);
+                    }
+                }),
+            ]
+                .join(' ')
+                .toLowerCase(),
+            searchQuery: searchQuery.toLowerCase(),
+        }) ||
+            matchesErrors ||
+            includeInSearchResults[currentNodeSearchKey];
+        if (shouldInclude) {
+            const keysToInclude = getFullTreeKeysToInclude(treeNode.fullUrlBreadcrumbs);
+            addChildren(treeNode);
+            keysToInclude.forEach((keyToInclude) => (includeInSearchResults[keyToInclude] = true));
+        }
+        else {
+            includeInSearchResults[currentNodeSearchKey] = false;
+        }
+    });
+    return flattenedNodes.filter((treeNode) => {
+        const inSearchResultsKey = createBreadcrumbsSearchKey(treeNode.fullUrlBreadcrumbs);
+        const shouldInclude = includeInSearchResults[inSearchResultsKey];
+        if (!check.isBoolean(shouldInclude)) {
+            throw new TypeError(`Failed to find '${treeNode.fullUrlBreadcrumbs.join(' > ')}' in includeInSearchResults.`);
+        }
+        return shouldInclude;
+    });
+}

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

@@ -0,0 +1,4 @@
+import { type BookEntry } from '../book-entry/book-entry.js';
+import { type BookTree } from './book-tree-node.js';
+export declare function getTreeFromCache(entries: ReadonlyArray<BookEntry>): BookTree | undefined;
+export declare function addTreeToCache(entries: ReadonlyArray<BookEntry>, tree: BookTree): void;

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

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

package/dist/data/unset.d.ts

@@ -0,0 +1 @@
+export declare const unsetInternalState: unique symbol;

package/dist/index.js

@@ -0,0 +1,18 @@
+export * from './data/book-entry/base-book-entry.js';
+export * from './data/book-entry/book-entry-type.js';
+export * from './data/book-entry/book-entry.js';
+export * from './data/book-entry/book-page/book-page-controls.js';
+export * from './data/book-entry/book-page/book-page.js';
+export * from './data/book-entry/book-page/controls-wrapper.js';
+export * from './data/book-entry/book-page/define-book-page.js';
+export * from './data/book-entry/book-root.js';
+export * from './data/book-entry/url-breadcrumbs.js';
+export * from './data/book-tree/book-tree-node.js';
+export * from './routing/book-routing.js';
+export * from './ui/color-theme/color-theme.js';
+export * from './ui/color-theme/create-color-theme.js';
+export * from './ui/elements/element-book-app/element-book-app-slots.js';
+export * from './ui/elements/element-book-app/element-book-app.element.js';
+export * from './ui/elements/element-book-app/element-book-config.js';
+export * from './ui/elements/element-book-app/global-values.js';
+export * from './util/type.js';

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

@@ -0,0 +1,4 @@
+import { SpaRouter } from 'spa-router-vir';
+import { type ValidBookPaths } from './book-routing.js';
+export declare function createBookRouter(basePath: string | undefined): SpaRouter<ValidBookPaths, undefined, undefined>;
+export type BookRouter = ReturnType<typeof createBookRouter>;

package/{src/routing/book-router.ts → dist/routing/book-router.js}

@@ -1,13 +1,11 @@
-import {check} from '@augment-vir/assert';
-import {SpaRouter} from 'spa-router-vir';
-import {BookMainRoute, defaultBookFullRoute, type ValidBookPaths} from './book-routing.js';
-
-export function createBookRouter(basePath: string | undefined) {
-    return new SpaRouter<ValidBookPaths, undefined, undefined>({
+import { check } from '@augment-vir/assert';
+import { SpaRouter } from 'spa-router-vir';
+import { BookMainRoute, defaultBookFullRoute } from './book-routing.js';
+export function createBookRouter(basePath) {
+    return new SpaRouter({
         basePath,
         sanitizeRoute(rawRoute) {
             const sanitizedPaths = sanitizePaths(rawRoute.paths);
-
             return {
                 paths: sanitizedPaths,
                 hash: undefined,
@@ -16,32 +14,30 @@ export function createBookRouter(basePath: string | undefined) {
         },
     });
 }
-
-export type BookRouter = ReturnType<typeof createBookRouter>;
-
-function sanitizePaths(paths: ReadonlyArray<string>): ValidBookPaths {
+function sanitizePaths(paths) {
     const firstPath = paths[0];
-
     if (!check.isEnumValue(firstPath, BookMainRoute)) {
         return defaultBookFullRoute.paths;
-    } else if (firstPath === BookMainRoute.Book) {
+    }
+    else if (firstPath === BookMainRoute.Book) {
         return [
             BookMainRoute.Book,
             ...paths.slice(1),
         ];
-    } else if ((firstPath as BookMainRoute) === BookMainRoute.Search) {
+    }
+    else if (firstPath === BookMainRoute.Search) {
         if (!paths[1]) {
             return [
                 BookMainRoute.Book,
                 ...paths.slice(1),
             ];
         }
-
         return [
             firstPath,
             paths[1],
         ];
-    } else {
+    }
+    else {
         throw new Error(`Route path not handled for sanitization: ${paths.join('/')}`);
     }
 }

package/{src/routing/book-routing.ts → dist/routing/book-routing.d.ts}

@@ -1,49 +1,34 @@
-import {type FullSpaRoute} from 'spa-router-vir';
-
+import { type FullSpaRoute } from 'spa-router-vir';
 /**
  * Top level routes supported by the element-book app.
  *
  * @category Internal
  */
-export enum BookMainRoute {
-    Search = 'search',
-    Book = 'book',
+export declare enum BookMainRoute {
+    Search = "search",
+    Book = "book"
 }
-
 /**
  * Valid route paths for the element-book app.
  *
  * @category Internal
  */
 export type ValidBookPaths = [BookMainRoute.Search, string] | [BookMainRoute.Book, ...string[]];
-
 /**
  * A full element-book app route. Only paths are supported.
  *
  * @category Internal
  */
 export type BookFullRoute = Readonly<FullSpaRoute<ValidBookPaths, undefined, undefined>>;
-
 /**
  * Extract the current search query from the current route paths.
  *
  * @category Internal
  */
-export function extractSearchQuery(paths: Readonly<ValidBookPaths>) {
-    if (paths[0] === BookMainRoute.Book) {
-        return '';
-    } else {
-        return paths[1] ? decodeURIComponent(paths[1]) : '';
-    }
-}
-
+export declare function extractSearchQuery(paths: Readonly<ValidBookPaths>): string;
 /**
  * The default element-book app route.
  *
  * @category Internal
  */
-export const defaultBookFullRoute: Readonly<BookFullRoute> = {
-    hash: undefined,
-    paths: [BookMainRoute.Book],
-    search: undefined,
-} as const;
+export declare const defaultBookFullRoute: Readonly<BookFullRoute>;

package/dist/routing/book-routing.js

@@ -0,0 +1,33 @@
+/**
+ * Top level routes supported by the element-book app.
+ *
+ * @category Internal
+ */
+export var BookMainRoute;
+(function (BookMainRoute) {
+    BookMainRoute["Search"] = "search";
+    BookMainRoute["Book"] = "book";
+})(BookMainRoute || (BookMainRoute = {}));
+/**
+ * Extract the current search query from the current route paths.
+ *
+ * @category Internal
+ */
+export function extractSearchQuery(paths) {
+    if (paths[0] === BookMainRoute.Book) {
+        return '';
+    }
+    else {
+        return paths[1] ? decodeURIComponent(paths[1]) : '';
+    }
+}
+/**
+ * The default element-book app route.
+ *
+ * @category Internal
+ */
+export const defaultBookFullRoute = {
+    hash: undefined,
+    paths: [BookMainRoute.Book],
+    search: undefined,
+};

package/dist/ui/color-theme/color-theme.d.ts

@@ -0,0 +1,57 @@
+import { type CSSResult } from 'element-vir';
+/**
+ * A single background and foreground color pairing.
+ *
+ * @category Internal
+ */
+export type ColorPair = {
+    background: CSSResult;
+    foreground: CSSResult;
+};
+/**
+ * Color pairs for everything used by the element-book app.
+ *
+ * @category Internal
+ */
+export type ColorTheme = {
+    nav: {
+        hover: ColorPair;
+        active: ColorPair;
+        selected: ColorPair;
+    };
+    accent: {
+        icon: CSSResult;
+    };
+    page: ColorPair & {
+        backgroundFaint1: CSSResult;
+        backgroundFaint2: CSSResult;
+        foregroundFaint1: CSSResult;
+        foregroundFaint2: CSSResult;
+    };
+};
+/**
+ * All color theme CSS vars for the element-book app.
+ *
+ * @category Internal
+ */
+export declare const colorThemeCssVars: import("lit-css-vars").CssVarDefinitions<{
+    readonly 'element-book-nav-hover-background-color': "magenta";
+    readonly 'element-book-nav-hover-foreground-color': "magenta";
+    readonly 'element-book-nav-active-background-color': "magenta";
+    readonly 'element-book-nav-active-foreground-color': "magenta";
+    readonly 'element-book-nav-selected-background-color': "magenta";
+    readonly 'element-book-nav-selected-foreground-color': "magenta";
+    readonly 'element-book-accent-icon-color': "magenta";
+    readonly 'element-book-page-background-color': "magenta";
+    readonly 'element-book-page-background-faint-level-1-color': "magenta";
+    readonly 'element-book-page-background-faint-level-2-color': "magenta";
+    readonly 'element-book-page-foreground-color': "magenta";
+    readonly 'element-book-page-foreground-faint-level-1-color': "magenta";
+    readonly 'element-book-page-foreground-faint-level-2-color': "magenta";
+}>;
+/**
+ * Sets a new color theme's CSS vars on the given HTML element for the element-book app.
+ *
+ * @category Internal
+ */
+export declare function setThemeCssVars(element: HTMLElement, theme: ColorTheme): void;

package/dist/ui/color-theme/color-theme.js

@@ -0,0 +1,94 @@
+import { check } from '@augment-vir/assert';
+import { defineCssVars, setCssVarValue } from 'lit-css-vars';
+/**
+ * All color theme CSS vars for the element-book app.
+ *
+ * @category Internal
+ */
+export const colorThemeCssVars = defineCssVars({
+    'element-book-nav-hover-background-color': 'magenta',
+    'element-book-nav-hover-foreground-color': 'magenta',
+    'element-book-nav-active-background-color': 'magenta',
+    'element-book-nav-active-foreground-color': 'magenta',
+    'element-book-nav-selected-background-color': 'magenta',
+    'element-book-nav-selected-foreground-color': 'magenta',
+    'element-book-accent-icon-color': 'magenta',
+    'element-book-page-background-color': 'magenta',
+    'element-book-page-background-faint-level-1-color': 'magenta',
+    'element-book-page-background-faint-level-2-color': 'magenta',
+    'element-book-page-foreground-color': 'magenta',
+    'element-book-page-foreground-faint-level-1-color': 'magenta',
+    'element-book-page-foreground-faint-level-2-color': 'magenta',
+});
+const colorThemeCssVarMapping = {
+    nav: {
+        hover: {
+            background: colorThemeCssVars['element-book-nav-hover-background-color'],
+            foreground: colorThemeCssVars['element-book-nav-hover-foreground-color'],
+        },
+        active: {
+            background: colorThemeCssVars['element-book-nav-active-background-color'],
+            foreground: colorThemeCssVars['element-book-nav-active-foreground-color'],
+        },
+        selected: {
+            background: colorThemeCssVars['element-book-nav-selected-background-color'],
+            foreground: colorThemeCssVars['element-book-nav-selected-foreground-color'],
+        },
+    },
+    accent: {
+        icon: colorThemeCssVars['element-book-accent-icon-color'],
+    },
+    page: {
+        background: colorThemeCssVars['element-book-page-background-color'],
+        backgroundFaint1: colorThemeCssVars['element-book-page-background-faint-level-1-color'],
+        backgroundFaint2: colorThemeCssVars['element-book-page-background-faint-level-2-color'],
+        foreground: colorThemeCssVars['element-book-page-foreground-color'],
+        foregroundFaint1: colorThemeCssVars['element-book-page-foreground-faint-level-1-color'],
+        foregroundFaint2: colorThemeCssVars['element-book-page-foreground-faint-level-2-color'],
+    },
+};
+/**
+ * Sets a new color theme's CSS vars on the given HTML element for the element-book app.
+ *
+ * @category Internal
+ */
+export function setThemeCssVars(element, theme) {
+    recursiveSetThemeCssVars(element, theme, colorThemeCssVarMapping);
+}
+function isCssResult(input) {
+    return check.hasKey(input, '_$cssResult$');
+}
+function isCssVarDefinition(input) {
+    return (check.hasKeys(input, [
+        'name',
+        'value',
+        'default',
+    ]) &&
+        check.isString(input.default) &&
+        isCssResult(input.name) &&
+        isCssResult(input.value));
+}
+function recursiveSetThemeCssVars(element, nestedCssResult, nestedCssVars) {
+    Object.entries(nestedCssResult).forEach(([key, value,]) => {
+        const nestedCssVar = nestedCssVars[key];
+        if (!nestedCssVar) {
+            throw new Error(`no nestedCssVar at key '${key}'`);
+        }
+        if (isCssResult(value)) {
+            if (!isCssVarDefinition(nestedCssVar)) {
+                throw new Error(`got a CSS result at '${key}' but no CSS var`);
+            }
+            setCssVarValue({
+                forCssVar: nestedCssVar,
+                onElement: element,
+                toValue: String(value),
+            });
+        }
+        else {
+            if (isCssVarDefinition(nestedCssVar)) {
+                throw new Error(`got no CSS result at '${key}' but did find a CSS var`);
+            }
+            recursiveSetThemeCssVars(element, value, nestedCssVar);
+        }
+    });
+}

package/dist/ui/color-theme/create-color-theme.d.ts

@@ -0,0 +1,32 @@
+import { type PartialWithUndefined } from '@augment-vir/common';
+import { type ColorTheme } from './color-theme.js';
+/**
+ * The default theme color.
+ *
+ * @category Internal
+ */
+export declare const defaultThemeStartColor = "dodgerblue";
+/**
+ * Theme style options for the element-book app.
+ *
+ * @category Internal
+ */
+export declare enum ThemeStyle {
+    Dark = "dark",
+    Light = "light"
+}
+/**
+ * Theme configuration options for the element-book app.
+ *
+ * @category Internal
+ */
+export type ThemeConfig = PartialWithUndefined<{
+    themeColor: string;
+    themeStyle: ThemeStyle;
+}>;
+/**
+ * Creates a theme from the given theme configuration.
+ *
+ * @category Internal
+ */
+export declare function createTheme({ themeColor: inputThemeColor, themeStyle, }?: ThemeConfig): ColorTheme;