element-book 6.0.3 → 7.0.1

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

@@ -1,13 +0,0 @@
-import { ElementBookPageControlTypeEnum, ElementBookPageControlValueType } from './element-book-page-control-type';
-export type ElementBookPageControl<ControlType extends ElementBookPageControlTypeEnum> = {
-    controlType: ControlType;
-    initValue: ElementBookPageControlValueType[ControlType];
-    controlName: string;
-};
-export type ElementBookPageControlInit<ControlType extends ElementBookPageControlTypeEnum> = Omit<ElementBookPageControl<ControlType>, 'controlName'>;
-/** Define a page control. This doesn't do anything fancy but it helps immensely with type inference. */
-export declare function definePageControl<ControlType extends ElementBookPageControlTypeEnum>(controlInit: ElementBookPageControlInit<ControlType>): ElementBookPageControlInit<ControlType>;
-export type ElementBookPageControlMap = Record<string, ElementBookPageControlInit<ElementBookPageControlTypeEnum>>;
-export type PageControlsToValues<Controls extends ElementBookPageControlMap> = {
-    [ControlName in keyof Controls]: Controls[ControlName]['initValue'];
-};

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

@@ -1,4 +0,0 @@
-/** Define a page control. This doesn't do anything fancy but it helps immensely with type inference. */
-export function definePageControl(controlInit) {
-    return controlInit;
-}

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

@@ -1,22 +0,0 @@
-import { RequireNonVoid } from '@augment-vir/common';
-import { PropertyInitMapBase, RenderParams, TypedEvent } from 'element-vir';
-import { CSSResult } from 'lit';
-import { ElementBookPageControlMap, PageControlsToValues } from './element-book-page-controls/element-book-page-control';
-export type ElementBookPageExampleRenderParams<ParentControls extends ElementBookPageControlMap, StateInit extends PropertyInitMapBase> = Pick<RenderParams<any, any, StateInit, any, any, any>, 'state' | 'updateState'> & {
-    controls: PageControlsToValues<ParentControls>;
-};
-export type ElementBookPageExampleInit<ParentControls extends ElementBookPageControlMap, StateInit extends PropertyInitMapBase, RenderOutput> = {
-    /** This example's title. Each title in a page must be unique. */
-    title: string;
-    /** Initialize the state for this example. */
-    stateInitStatic?: StateInit;
-    /** Specify which events this example should intercept (so the user can see them). */
-    capturedEvents?: ReadonlyArray<string | TypedEvent>;
-    /**
-     * Style the example. You can even use the :host selector to style this specific example's
-     * wrapper element!
-     */
-    styles?: CSSResult;
-    /** Render the example. */
-    renderCallback: RequireNonVoid<RenderOutput, (renderParams: ElementBookPageExampleRenderParams<ParentControls, StateInit>) => RenderOutput, 'renderCallback is missing a return statement'>;
-};

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

@@ -1,23 +0,0 @@
-import { Overwrite } from '@augment-vir/common';
-import { PropertyInitMapBase } from 'element-vir';
-import { SetOptional } from 'type-fest';
-import { BaseElementBookEntry } from '../element-book-chapter/element-book-chapter';
-import { ElementBookEntryTypeEnum } from '../element-book-entry-type';
-import { ElementBookPageControlMap } from './element-book-page-controls/element-book-page-control';
-import { ElementBookPageExampleInit } from './element-book-page-example';
-export type ElementBookPage<Controls extends ElementBookPageControlMap = ElementBookPageControlMap> = Overwrite<BaseElementBookEntry, {
-    entryType: ElementBookEntryTypeEnum.Page;
-}> & {
-    controls: Controls;
-    examples: Record<string, ElementBookPageExampleInit<any, any, any> | Error>;
-    pageBreadcrumbs: ReadonlyArray<string>;
-};
-export type PageControlsFromPage<Page extends ElementBookPage<any>> = Page extends ElementBookPage<infer Controls> ? Controls : never;
-export type DefinePageExamplesCallback<ParentPageControls extends ElementBookPageControlMap> = (params: {
-    defineExample: DefineExampleCallback<ParentPageControls>;
-}) => void;
-export type DefineExampleCallback<ParentPageControls extends ElementBookPageControlMap> = <StateInit extends PropertyInitMapBase = {}, RenderOutput = any>(exampleInit: ElementBookPageExampleInit<ParentPageControls, StateInit, RenderOutput>) => void;
-export type ElementBookPageInit<Controls extends ElementBookPageControlMap> = Overwrite<SetOptional<Omit<ElementBookPage<Controls>, 'entryType' | 'allExampleTitles' | 'pageBreadcrumbs' | 'examples'>, 'controls'>, {
-    defineExamplesCallback?: DefinePageExamplesCallback<Controls>;
-}>;
-export declare function defineElementBookPage<Controls extends ElementBookPageControlMap = {}>(pageSetup: ElementBookPageInit<Controls>): ElementBookPage<Controls>;

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

@@ -1,41 +0,0 @@
-import { combineErrors } from '@augment-vir/common';
-import { listBreadcrumbs } from '../element-book-entry';
-import { ElementBookEntryTypeEnum } from '../element-book-entry-type';
-function insertElementExample(parentExamples, parentBreadcrumbs, exampleInit) {
-    const errors = [];
-    const failureMessage = `Failed to define example '${parentBreadcrumbs
-        .concat(exampleInit.title)
-        .join(' > ')}'`;
-    if (parentExamples.hasOwnProperty(exampleInit.title)) {
-        errors.push(new Error(`${failureMessage}: title '${exampleInit.title}' is already being used.`));
-    }
-    else if (!exampleInit.title) {
-        errors.push(new Error(`${failureMessage}: example title is missing or empty.`));
-    }
-    if (errors.length) {
-        parentExamples[exampleInit.title] = combineErrors(errors);
-    }
-    else {
-        parentExamples[exampleInit.title] = exampleInit;
-    }
-}
-export function defineElementBookPage(pageSetup) {
-    if (!pageSetup.title) {
-        throw new Error(`Cannot have an element-book page with an empty title.`);
-    }
-    const allExamples = {};
-    const page = {
-        entryType: ElementBookEntryTypeEnum.Page,
-        ...pageSetup,
-        examples: allExamples,
-        controls: pageSetup.controls ?? {},
-        pageBreadcrumbs: [],
-    };
-    page.pageBreadcrumbs = listBreadcrumbs(page);
-    if (pageSetup.defineExamplesCallback) {
-        pageSetup.defineExamplesCallback({
-            defineExample: (exampleInit) => insertElementExample(allExamples, page.pageBreadcrumbs, exampleInit),
-        });
-    }
-    return page;
-}

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

@@ -1,8 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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 = 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<ElementBookEntryTypeEnum.Root>;
-export declare function entriesToTree(entries: ReadonlyArray<ElementBookEntry>, everythingTitle: string | undefined): EntryTreeNode<ElementBookEntryTypeEnum.Root>;
-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,87 +0,0 @@
-import { isLengthAtLeast, typedHasProperties } from '@augment-vir/common';
-import { listBreadcrumbs, titleToBreadcrumb } from '../element-book-entry';
-import { ElementBookEntryTypeEnum } from '../element-book-entry-type';
-import { addTreeToCache, getTreeFromCache } from './tree-cache';
-export function doesNodeHaveEntryType(node, entryType) {
-    return node.entry.entryType === entryType;
-}
-const markerKeyName = 'isElementBookEntryTreeNode';
-export function isEntryNode(input, entryType) {
-    return !!(typedHasProperties(input, [
-        markerKeyName,
-        'entry',
-    ]) &&
-        input[markerKeyName] &&
-        input.entry.entryType === entryType);
-}
-export function createEmptyEntryTreeRoot(title) {
-    const rootNode = {
-        [markerKeyName]: true,
-        entry: {
-            entryType: ElementBookEntryTypeEnum.Root,
-            title: title || 'Everything',
-            parent: undefined,
-        },
-        breadcrumb: '',
-        children: {},
-    };
-    return rootNode;
-}
-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) => {
-        /**
-         * The type for newEntry does not include Error but if errors occur during entry definition
-         * they will be replaced with errors.
-         */
-        if (newEntry instanceof Error) {
-            throw newEntry;
-        }
-        const immediateParent = traverseToImmediateParent(newEntry, tree);
-        const breadcrumb = titleToBreadcrumb(newEntry.title);
-        if (breadcrumb in immediateParent.children) {
-            throw new Error(`Cannot create duplicate entry '${breadcrumb}'${immediateParent.breadcrumb ? ` in parent '${immediateParent.breadcrumb}'.` : ''}`);
-        }
-        const newNode = {
-            [markerKeyName]: true,
-            children: {},
-            breadcrumb,
-            entry: newEntry,
-        };
-        immediateParent.children[breadcrumb] = newNode;
-    });
-    addTreeToCache(entries, '', tree);
-    return tree;
-}
-function traverseToImmediateParent(entry, currentTree) {
-    const topDownAncestryChain = listBreadcrumbs(entry)
-        // reverse so we get the top most ancestor first in the list
-        .reverse();
-    const immediateParentNode = topDownAncestryChain.reduce((currentAncestor, nextBreadcrumb) => {
-        const nextAncestor = currentAncestor.children[nextBreadcrumb];
-        if (!nextAncestor) {
-            throw new Error(`Failed to find parent ElementBookEntry by name of '${nextBreadcrumb}' in entry '${currentAncestor.entry.title}'`);
-        }
-        return nextAncestor;
-    }, currentTree);
-    return immediateParentNode;
-}
-export function findEntryByBreadcrumbs(breadcrumbs, tree) {
-    if (!isLengthAtLeast(breadcrumbs, 1)) {
-        return tree;
-    }
-    const nextBreadcrumb = breadcrumbs[0];
-    const nextTree = tree.children[nextBreadcrumb];
-    if (!nextTree) {
-        return undefined;
-    }
-    return findEntryByBreadcrumbs(breadcrumbs.slice(1), nextTree);
-}

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

@@ -1,5 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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/data/element-book-entry/entry-tree/walk-entry-tree.d.ts

@@ -1,8 +0,0 @@
-import { MaybePromise } from '@augment-vir/common';
-import { EntryTreeNode } from './entry-tree';
-/**
- * Walk the whole given tree, calling callback on each node. If callback returns the boolean false
- * exactly, then all walking will abort. If callback returns a promise, this function will return a
- * promise. Otherwise, it will not return a promise.
- */
-export declare function walkEntryTree<CallbackReturn extends MaybePromise<void | boolean>>(startNode: Readonly<EntryTreeNode>, callback: (node: Readonly<EntryTreeNode>) => CallbackReturn): CallbackReturn;

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

@@ -1,85 +0,0 @@
-/**
- * Walk the whole given tree, calling callback on each node. If callback returns the boolean false
- * exactly, then all walking will abort. If callback returns a promise, this function will return a
- * promise. Otherwise, it will not return a promise.
- */
-export function walkEntryTree(startNode, callback) {
-    // this inner function is for easier typing purposes
-    function innerWalk() {
-        const outerResult = callback(startNode);
-        if (outerResult === false) {
-            return false;
-        }
-        let abort = false;
-        if (outerResult instanceof Promise) {
-            return new Promise(async (resolve, reject) => {
-                try {
-                    const outerResolvedResult = await outerResult;
-                    if (outerResolvedResult === false) {
-                        return;
-                    }
-                    await Promise.all(Object.values(startNode.children).map(async (child) => {
-                        if (abort) {
-                            return false;
-                        }
-                        const result = await walkEntryTree(child, callback);
-                        if (result === false) {
-                            abort = true;
-                            return false;
-                        }
-                        return result;
-                    }));
-                    if (abort) {
-                        return resolve(false);
-                    }
-                    else {
-                        return resolve();
-                    }
-                }
-                catch (error) {
-                    return reject(error);
-                }
-            });
-        }
-        else {
-            let gotPromise = false;
-            const childResults = Object.values(startNode.children).map((child) => {
-                if (abort) {
-                    return false;
-                }
-                const result = walkEntryTree(child, callback);
-                if (result === false) {
-                    abort = true;
-                }
-                else if (result instanceof Promise) {
-                    gotPromise = true;
-                }
-                return result;
-            });
-            if (gotPromise) {
-                return new Promise(async (resolve, reject) => {
-                    try {
-                        if (abort) {
-                            return resolve(false);
-                        }
-                        const results = await Promise.all(childResults);
-                        if (results.some((result) => result === false)) {
-                            return resolve(false);
-                        }
-                        else {
-                            return resolve();
-                        }
-                    }
-                    catch (error) {
-                        return reject(error);
-                    }
-                });
-            }
-            else if (abort) {
-                return false;
-            }
-            return;
-        }
-    }
-    return innerWalk();
-}

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

@@ -1,2 +0,0 @@
-import { ElementBookRouter } from './element-book-routing';
-export declare function createElementBookRouter(baseRoute: string | undefined): ElementBookRouter;

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

@@ -1,10 +0,0 @@
-import { FullRoute, SpaRouter } from 'spa-router-vir';
-export declare enum ElementBookMainRoute {
-    Search = "search",
-    Book = "book"
-}
-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

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

package/dist/ui/elements/common/element-book-route-link.element.d.ts

@@ -1,5 +0,0 @@
-import { ElementBookFullRoute, ElementBookRouter } from '../../../routing/element-book-routing';
-export declare const ElementBookRouteLink: import("element-vir").DeclarativeElementDefinition<"element-book-route-link", {
-    route: Partial<ElementBookFullRoute>;
-    router: ElementBookRouter | undefined;
-}, {}, {}, `element-book-route-link-${string}`, "element-book-route-link-anchor-padding", import("lit-html").HTMLTemplateResult>;

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

@@ -1,4 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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/element-book-breadcrumbs.element.d.ts

@@ -1,5 +0,0 @@
-import { ElementBookFullRoute, ElementBookRouter } from '../../routing/element-book-routing';
-export declare const ElementBookBreadcrumbs: import("element-vir").DeclarativeElementDefinition<"element-book-breadcrumbs", {
-    currentRoute: Readonly<ElementBookFullRoute>;
-    router: ElementBookRouter;
-}, {}, {}, `element-book-breadcrumbs-${string}`, `element-book-breadcrumbs-${string}`, import("lit-html").HTMLTemplateResult | import("lit-html").HTMLTemplateResult[]>;

package/dist/ui/elements/element-book-nav.element.d.ts

@@ -1,7 +0,0 @@
-import { EntryTreeNode } from '../../data/element-book-entry/entry-tree/entry-tree';
-import { ElementBookRouter } from '../../routing/element-book-routing';
-export declare const ElementBookNav: import("element-vir").DeclarativeElementDefinition<"element-book-nav", {
-    tree: EntryTreeNode;
-    selectedPath: ReadonlyArray<string>;
-    router: ElementBookRouter | undefined;
-}, {}, {}, `element-book-nav-${string}`, `element-book-nav-${string}`, import("lit-html").HTMLTemplateResult>;

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

@@ -1,129 +0,0 @@
-import { areJsonEqual } from '@augment-vir/common';
-import { VirIcon } from '@electrovir/icon-element';
-import { assign, classMap, css, html, renderIf } from 'element-vir';
-import { ElementBookEntryTypeEnum } from '../../data/element-book-entry/element-book-entry-type';
-import { ElementBookMainRoute } from '../../routing/element-book-routing';
-import { colorThemeCssVars } from '../color-theme/color-theme';
-import { Element16Icon } from '../icons/element-16.icon';
-import { ElementBookRouteLink } from './common/element-book-route-link.element';
-import { defineElementBookElement } from './define-book-element';
-import { ElementBookSlotName } from './element-book-app/element-book-app-slots';
-export const ElementBookNav = defineElementBookElement()({
-    tagName: 'element-book-nav',
-    styles: css `
-        :host {
-            display: flex;
-            flex-direction: column;
-            padding: 16px 0;
-            background-color: ${colorThemeCssVars['element-book-page-background-faint-level-2-color'].value};
-        }
-
-        .title-row:hover {
-            background-color: ${colorThemeCssVars['element-book-nav-hover-background-color'].value};
-            color: ${colorThemeCssVars['element-book-nav-hover-foreground-color'].value};
-        }
-
-        .title-row:active {
-            background-color: ${colorThemeCssVars['element-book-nav-active-background-color']
-        .value};
-            color: ${colorThemeCssVars['element-book-nav-active-foreground-color'].value};
-        }
-
-        .title-row {
-            display: block;
-            ${ElementBookRouteLink.cssVars['element-book-route-link-anchor-padding']
-        .name}: 1px 24px 1px calc(calc(16px * var(--indent, 0)) + 8px);
-        }
-
-        ${ElementBookRouteLink} {
-            font-size: 20px;
-        }
-
-        ul {
-            list-style: none;
-            padding: 0;
-            margin: 0;
-        }
-
-        .selected,
-        .selected:hover {
-            background-color: ${colorThemeCssVars['element-book-nav-selected-background-color']
-        .value};
-            color: ${colorThemeCssVars['element-book-nav-selected-foreground-color'].value};
-            pointer-events: none;
-        }
-
-        .title-text {
-            white-space: nowrap;
-            text-overflow: ellipsis;
-            display: inline-flex;
-            gap: 8px;
-            align-items: center;
-            font-size: 0.75em;
-        }
-
-        ${VirIcon} {
-            display: inline-flex;
-            color: ${colorThemeCssVars['element-book-accent-icon-color'].value};
-        }
-    `,
-    renderCallback({ inputs }) {
-        const navTree = createNavigationTree({
-            indent: 0,
-            entryTreeNode: inputs.tree,
-            rootPath: [],
-            router: inputs.router,
-            selectedPath: inputs.selectedPath.slice(1),
-        });
-        return html `
-            <ul>
-                ${navTree}
-            </ul>
-        `;
-    },
-});
-function createNavigationTree({ indent, entryTreeNode, rootPath, selectedPath, router, }) {
-    const entryPath = entryTreeNode.breadcrumb
-        ? rootPath.concat(entryTreeNode.breadcrumb)
-        : rootPath;
-    const isPage = entryTreeNode.entry.entryType === ElementBookEntryTypeEnum.Page;
-    const childTemplates = Object.values(entryTreeNode.children).map((child) => {
-        return createNavigationTree({
-            indent: indent + 1,
-            entryTreeNode: child,
-            rootPath: entryPath,
-            selectedPath,
-            router,
-        });
-    });
-    return html `
-        <div class="nav-tree-entry" style="--indent: ${indent};">
-            <slot name=${ElementBookSlotName.NavHeader}></slot>
-            <li class=${entryTreeNode.entry.entryType}>
-                <${ElementBookRouteLink}
-                    ${assign(ElementBookRouteLink, {
-        router: router,
-        route: {
-            paths: [
-                ElementBookMainRoute.Book,
-                ...entryPath,
-            ],
-        },
-    })}
-                    class=${classMap({
-        'title-row': true,
-        selected: areJsonEqual(selectedPath, entryPath),
-    })}
-                >
-                    <div class="title-text">
-                        ${renderIf(isPage, html `
-                                <${VirIcon} ${assign(VirIcon, { icon: Element16Icon })}></${VirIcon}>
-                            `)}
-                        ${entryTreeNode.entry.title}
-                    </div>
-                </${ElementBookRouteLink}>
-            </li>
-            ${childTemplates}
-        </div>
-    `;
-}

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

@@ -1,7 +0,0 @@
-import { EntryTreeNode } from '../../../data/element-book-entry/entry-tree/entry-tree';
-import { ElementBookFullRoute, ElementBookRouter } from '../../../routing/element-book-routing';
-export declare const ElementBookEntryDisplay: import("element-vir").DeclarativeElementDefinition<"element-book-entry-display", {
-    currentRoute: Readonly<ElementBookFullRoute>;
-    currentNode: Readonly<EntryTreeNode>;
-    router: ElementBookRouter;
-}, {}, {}, `element-book-entry-display-${string}`, `element-book-entry-display-${string}`, import("lit-html").HTMLTemplateResult>;