element-book 6.0.3 → 7.0.1

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

@@ -0,0 +1,147 @@
+import { extractEventTarget } from '@augment-vir/browser';
+import { isRuntimeTypeOf } from '@augment-vir/common';
+import { css, defineElementEvent, html, listen } from 'element-vir';
+import { BookPageControlTypeEnum, isControlInitType, } from '../../../../data/book-entry/book-page/book-page-controls';
+import { colorThemeCssVars } from '../../../color-theme/color-theme';
+import { defineBookElement } from '../../define-book-element';
+export const BookPageControls = defineBookElement()({
+    tagName: 'book-page-controls',
+    events: {
+        controlValueChange: defineElementEvent(),
+    },
+    hostClasses: {
+        'book-page-controls-has-controls': ({ inputs }) => !!Object.keys(inputs.config).length,
+    },
+    styles: ({ hostClasses }) => css `
+        :host {
+            display: flex;
+            flex-wrap: wrap;
+            opacity: 0.7;
+            gap: 16px;
+            color: ${colorThemeCssVars['element-book-page-foreground-faint-level-1-color'].value};
+        }
+
+        ${hostClasses['book-page-controls-has-controls'].selector} {
+            margin-top: 8px;
+        }
+
+        .control-wrapper {
+            display: flex;
+            gap: 4px;
+            flex-direction: column;
+        }
+
+        .error {
+            font-weight: bold;
+            color: red;
+        }
+    `,
+    renderCallback({ inputs, dispatch, events }) {
+        if (!Object.entries(inputs.config).length) {
+            return '';
+        }
+        return Object.entries(inputs.config).map(([controlName, controlInit,]) => {
+            if (controlInit.controlType === BookPageControlTypeEnum.Hidden) {
+                return '';
+            }
+            const controlInputTemplate = createControlInput(inputs.currentValues[controlName], controlInit, (newValue) => {
+                const fullUrlBreadcrumbs = isRuntimeTypeOf(inputs.fullUrlBreadcrumbs, 'array')
+                    ? inputs.fullUrlBreadcrumbs
+                    : inputs.fullUrlBreadcrumbs[controlName];
+                if (!fullUrlBreadcrumbs) {
+                    throw new Error(`Failed to find breadcrumbs from given control name: '${controlName}'`);
+                }
+                dispatch(new events.controlValueChange({
+                    fullUrlBreadcrumbs,
+                    newValues: {
+                        ...inputs.currentValues,
+                        [controlName]: newValue,
+                    },
+                }));
+            });
+            return html `
+                    <label class="control-wrapper">
+                        <span>${controlName}</span>
+                        ${controlInputTemplate}
+                    </label>
+                `;
+        });
+    },
+});
+function createControlInput(value, controlInit, valueChange) {
+    if (isControlInitType(controlInit, BookPageControlTypeEnum.Hidden)) {
+        return '';
+    }
+    else if (isControlInitType(controlInit, BookPageControlTypeEnum.Checkbox)) {
+        return html `
+            <input
+                type="checkbox"
+                .value=${value}
+                ${listen('input', (event) => {
+            const inputElement = extractEventTarget(event, HTMLInputElement);
+            valueChange(inputElement.checked);
+        })}
+            />
+        `;
+    }
+    else if (isControlInitType(controlInit, BookPageControlTypeEnum.Color)) {
+        return html `
+            <input
+                type="color"
+                .value=${value}
+                ${listen('input', (event) => {
+            const inputElement = extractEventTarget(event, HTMLInputElement);
+            valueChange(inputElement.value);
+        })}
+            />
+        `;
+    }
+    else if (isControlInitType(controlInit, BookPageControlTypeEnum.Text)) {
+        return html `
+            <input
+                type="text"
+                .value=${value}
+                ${listen('input', (event) => {
+            const inputElement = extractEventTarget(event, HTMLInputElement);
+            valueChange(inputElement.value);
+        })}
+            />
+        `;
+    }
+    else if (isControlInitType(controlInit, BookPageControlTypeEnum.Number)) {
+        return html `
+            <input
+                type="number"
+                .value=${value}
+                ${listen('input', (event) => {
+            const inputElement = extractEventTarget(event, HTMLInputElement);
+            valueChange(inputElement.value);
+        })}
+            />
+        `;
+    }
+    else if (isControlInitType(controlInit, BookPageControlTypeEnum.Dropdown)) {
+        return html `
+            <select
+                .value=${value}
+                ${listen('input', (event) => {
+            const selectElement = extractEventTarget(event, HTMLSelectElement);
+            valueChange(selectElement.value);
+        })}
+            >
+                ${controlInit.options.map((optionLabel, optionIndex) => {
+            return html `
+                        <option ?selected=${optionIndex === value} value=${optionIndex}>
+                            ${optionLabel}
+                        </option>
+                    `;
+        })}
+            </select>
+        `;
+    }
+    else {
+        return html `
+            <p class="error">${controlInit.controlType} controls are not implemented yet.</p>
+        `;
+    }
+}

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

@@ -0,0 +1,10 @@
+import { BookEntryTypeEnum } from '../../../../data/book-entry/book-entry-type';
+import { CurrentControls } from '../../../../data/book-entry/book-page/current-controls';
+import { BookTreeNode } from '../../../../data/book-tree/book-tree-node';
+import { BookRouter } from '../../../../routing/book-routing';
+export declare const BookPageWrapper: import("element-vir").DeclarativeElementDefinition<"book-page-wrapper", {
+    isTopLevel: boolean;
+    pageNode: BookTreeNode<BookEntryTypeEnum.Page>;
+    router: BookRouter;
+    currentControls: CurrentControls;
+}, {}, {}, `book-page-wrapper-${string}`, `book-page-wrapper-${string}`, import("lit-html").HTMLTemplateResult>;

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

@@ -0,0 +1,92 @@
+import { combineErrors } from '@augment-vir/common';
+import { assign, css, html } from 'element-vir';
+import { traverseCurrentControls, } from '../../../../data/book-entry/book-page/current-controls';
+import { BookMainRoute } from '../../../../routing/book-routing';
+import { BookError } from '../../common/book-error.element';
+import { BookRouteLink } from '../../common/book-route-link.element';
+import { defineBookElement } from '../../define-book-element';
+import { BookEntryDescription } from '../book-entry-description.element';
+import { BookPageControls } from './book-page-controls.element';
+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;
+        }
+    `,
+    renderCallback({ 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 = combineErrors(inputs.pageNode.entry.errors);
+        if (error) {
+            console.error(error);
+        }
+        return html `
+            <div class="page-header block-entry">
+                <div class="title-group">
+                    <${BookRouteLink}
+                        ${assign(BookRouteLink, {
+            route: {
+                paths: linkPaths,
+                hash: undefined,
+                search: undefined,
+            },
+            router: inputs.router,
+        })}
+                    >
+                        ${titleTemplate}
+                    </${BookRouteLink}>
+                    ${!!error
+            ? html `
+                              <${BookError}
+                                  ${assign(BookError, { message: error.message })}
+                              ></${BookError}>
+                          `
+            : html `
+                              <${BookEntryDescription}
+                                  ${assign(BookEntryDescription, {
+                descriptionParagraphs: inputs.pageNode.entry.descriptionParagraphs ?? [],
+            })}
+                              ></${BookEntryDescription}>
+                              <${BookPageControls}
+                                  ${assign(BookPageControls, {
+                config: inputs.pageNode.entry.controls,
+                currentValues: traverseCurrentControls(inputs.currentControls, 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 { BookEntryTypeEnum } from '../../../../data/book-entry/book-entry-type';
+import { BookTreeNode } from '../../../../data/book-tree/book-tree-node';
+import { BookRouter } from '../../../../routing/book-routing';
+export declare const BookElementExampleControls: import("element-vir").DeclarativeElementDefinition<"book-element-example-controls", {
+    elementExampleNode: BookTreeNode<BookEntryTypeEnum.ElementExample>;
+    router: BookRouter;
+}, {}, {}, `book-element-example-controls-${string}`, `book-element-example-controls-${string}`, import("lit-html").HTMLTemplateResult>;

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

@@ -0,0 +1,36 @@
+import { assign, css, html } from 'element-vir';
+import { BookMainRoute } from '../../../../routing/book-routing';
+import { colorThemeCssVars } from '../../../color-theme/color-theme';
+import { BookRouteLink } from '../../common/book-route-link.element';
+import { defineBookElement } from '../../define-book-element';
+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;
+        }
+    `,
+    renderCallback({ inputs }) {
+        const linkPaths = [
+            BookMainRoute.Book,
+            ...inputs.elementExampleNode.fullUrlBreadcrumbs,
+        ];
+        return html `
+            <${BookRouteLink}
+                ${assign(BookRouteLink, {
+            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,9 @@
+import { BookEntryTypeEnum } from '../../../../data/book-entry/book-entry-type';
+import { BookPageControlsValues } from '../../../../data/book-entry/book-page/book-page-controls';
+import { BookTreeNode } from '../../../../data/book-tree/book-tree-node';
+import { BookRouter } from '../../../../routing/book-routing';
+export declare const BookElementExampleViewer: import("element-vir").DeclarativeElementDefinition<"book-element-example-viewer", {
+    elementExampleNode: BookTreeNode<BookEntryTypeEnum.ElementExample>;
+    currentPageControls: BookPageControlsValues;
+    router: BookRouter;
+}, any, {}, `book-element-example-viewer-${string}`, `book-element-example-viewer-${string}`, import("lit-html").HTMLTemplateResult>;

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

@@ -0,0 +1,57 @@
+import { combineErrors, extractErrorMessage } from '@augment-vir/common';
+import { assign, html, renderIf } from 'element-vir';
+import { unsetInternalState } from '../../../../data/unset';
+import { BookError } from '../../common/book-error.element';
+import { defineBookElement } from '../../define-book-element';
+export const BookElementExampleViewer = defineBookElement()({
+    tagName: 'book-element-example-viewer',
+    stateInitStatic: {
+        isUnset: unsetInternalState,
+    },
+    renderCallback({ state, inputs, updateState }) {
+        try {
+            if (inputs.elementExampleNode.entry.errors.length) {
+                throw combineErrors(inputs.elementExampleNode.entry.errors);
+            }
+            if (!inputs.elementExampleNode.entry.renderCallback ||
+                typeof inputs.elementExampleNode.entry.renderCallback === 'string') {
+                throw new Error(`Failed to render example '${inputs.elementExampleNode.entry.title}': renderCallback is not a function`);
+            }
+            if (state.isUnset === unsetInternalState) {
+                updateState({
+                    isUnset: undefined,
+                    ...inputs.elementExampleNode.entry.stateInitStatic,
+                });
+            }
+            const output = inputs.elementExampleNode.entry.renderCallback({
+                state,
+                updateState,
+                controls: inputs.currentPageControls,
+            });
+            if (output instanceof Promise) {
+                throw new Error('renderCallback 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);
+            return html `
+                <${BookError}
+                    ${assign(BookError, {
+                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 { BookEntryTypeEnum } from '../../../../data/book-entry/book-entry-type';
+import { BookPageControlsValues } from '../../../../data/book-entry/book-page/book-page-controls';
+import { BookTreeNode } from '../../../../data/book-tree/book-tree-node';
+import { BookRouter } from '../../../../routing/book-routing';
+export declare const BookElementExampleWrapper: import("element-vir").DeclarativeElementDefinition<"book-element-example-wrapper", {
+    elementExampleNode: BookTreeNode<BookEntryTypeEnum.ElementExample>;
+    currentPageControls: BookPageControlsValues;
+    router: BookRouter;
+}, {}, {}, `book-element-example-wrapper-${string}`, `book-element-example-wrapper-${string}`, import("lit-html").HTMLTemplateResult>;

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

@@ -0,0 +1,49 @@
+import { assign, css, html } from 'element-vir';
+import { colorThemeCssVars } from '../../../color-theme/color-theme';
+import { defineBookElement } from '../../define-book-element';
+import { BookElementExampleControls } from './book-element-example-controls.element';
+import { BookElementExampleViewer } from './book-element-example-viewer.element';
+export const BookElementExampleWrapper = defineBookElement()({
+    tagName: 'book-element-example-wrapper',
+    styles: css `
+        :host {
+            display: inline-flex;
+            flex-direction: column;
+            gap: 24px;
+        }
+
+        .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%;
+        }
+
+        ${BookElementExampleControls} {
+            color: ${colorThemeCssVars['element-book-accent-icon-color'].value};
+        }
+    `,
+    renderCallback({ inputs }) {
+        return html `
+            <div class="individual-example-wrapper">
+                <${BookElementExampleControls}
+                    ${assign(BookElementExampleControls, inputs)}
+                ></${BookElementExampleControls}>
+                <${BookElementExampleViewer}
+                    ${assign(BookElementExampleViewer, inputs)}
+                ></${BookElementExampleViewer}>
+            </div>
+        `;
+    },
+});

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

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

package/dist/util/type.d.ts

@@ -0,0 +1,40 @@
+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.
+ */
+export type InfiniteRecursionLimiter = [
+    30,
+    29,
+    28,
+    27,
+    26,
+    25,
+    24,
+    23,
+    22,
+    21,
+    20,
+    19,
+    18,
+    17,
+    16,
+    15,
+    14,
+    13,
+    12,
+    11,
+    10,
+    9,
+    8,
+    7,
+    6,
+    5,
+    4,
+    3,
+    2,
+    1,
+    0
+];

package/dist/util/type.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "element-book",
-    "version": "6.0.3",
+    "version": "7.0.1",
     "keywords": [
         "book",
         "design system",
@@ -35,28 +35,32 @@
         "compile:clean": "rm -rf dist && npm run compile",
         "test": "virmator test-web",
         "test:coverage": "npm run test coverage",
-        "test:types": "tsc --noEmit"
+        "test:types": "tsc --noEmit",
+        "test:watch": "web-test-runner --color --watch --config configs/web-test-runner.config.mjs"
     },
     "dependencies": {
-        "@augment-vir/common": "^14.2.2",
-        "@electrovir/icon-element": "^1.0.0",
+        "@augment-vir/browser": "^15.1.0",
+        "@augment-vir/common": "^15.1.0",
         "colorjs.io": "0.4.3",
-        "element-vir": "^13.0.1",
+        "element-vir": "^14.0.0",
         "lit-css-vars": "^2.0.3",
+        "object-shape-tester": "^0.3.0",
         "spa-router-vir": "^2.1.0",
-        "typed-event-target": "^1.2.1"
+        "typed-event-target": "^1.2.1",
+        "vira": "^0.4.0"
     },
     "devDependencies": {
-        "@augment-vir/browser-testing": "^14.2.2",
-        "@open-wc/testing": "^3.1.8",
+        "@augment-vir/browser-testing": "^15.1.0",
+        "@open-wc/testing": "^3.2.0",
+        "@types/chai": "^4.3.5",
         "@types/mocha": "^10.0.1",
         "@web/dev-server-esbuild": "^0.4.1",
         "@web/test-runner": "^0.16.1",
         "@web/test-runner-commands": "^0.7.0",
-        "@web/test-runner-playwright": "^0.10.0",
+        "@web/test-runner-playwright": "^0.10.1",
         "@web/test-runner-visual-regression": "^0.8.0",
         "istanbul-smart-text-reporter": "^1.1.2",
-        "type-fest": "^3.11.1",
-        "typescript": "^5.0.4"
+        "type-fest": "^3.12.0",
+        "typescript": "^5.1.3"
     }
 }

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

@@ -1,22 +0,0 @@
-import { Overwrite } from '@augment-vir/common';
-import { ElementBookEntryTypeEnum } from '../element-book-entry-type';
-export type ElementBookChapter = Overwrite<BaseElementBookEntry, {
-    entryType: ElementBookEntryTypeEnum.Chapter;
-}>;
-/** This is in the ElementBookChapter file so that they don't circularly depend on each other. */
-export type BaseElementBookEntry = {
-    /** Display name for the chapter or page. This is also used to create breadcrumbs and URL paths. */
-    title: string;
-    entryType: ElementBookEntryTypeEnum;
-    /**
-     * The parent chapter. A value of undefined here indicates that the chapter or page should be at
-     * the top level.
-     */
-    parent: ElementBookChapter | undefined;
-    /**
-     * A description for the chapter or page that will be displayed below the title. Each entry in
-     * the array will be a separate paragraph.
-     */
-    descriptionParagraphs?: ReadonlyArray<string> | undefined;
-};
-export declare function defineElementBookChapter(chapterSetup: Omit<ElementBookChapter, 'entryType'>): ElementBookChapter;

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

@@ -1,16 +0,0 @@
-import { ElementBookEntryTypeEnum } from '../element-book-entry-type';
-export function defineElementBookChapter(chapterSetup) {
-    if (!chapterSetup.title) {
-        /**
-         * We don't want the Error type to actually be a part of this function's return type, cause
-         * users shouldn't actually return errors, but we still want to pass errors to element-book
-         * so element-book can handle them.
-         */
-        return new Error(`Cannot have an element-book chapter with an empty title.`);
-    }
-    const chapter = {
-        entryType: ElementBookEntryTypeEnum.Chapter,
-        ...chapterSetup,
-    };
-    return chapter;
-}

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

@@ -1,8 +0,0 @@
-export declare enum ElementBookEntryTypeEnum {
-    /** A group of pages or sub-chapters. */
-    Chapter = "chapter",
-    /** An individual book page full of element examples. */
-    Page = "page",
-    /** Tree root. Not for external use. */
-    Root = "root"
-}

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

@@ -1,9 +0,0 @@
-export var ElementBookEntryTypeEnum;
-(function (ElementBookEntryTypeEnum) {
-    /** A group of pages or sub-chapters. */
-    ElementBookEntryTypeEnum["Chapter"] = "chapter";
-    /** An individual book page full of element examples. */
-    ElementBookEntryTypeEnum["Page"] = "page";
-    /** Tree root. Not for external use. */
-    ElementBookEntryTypeEnum["Root"] = "root";
-})(ElementBookEntryTypeEnum || (ElementBookEntryTypeEnum = {}));

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

@@ -1,14 +0,0 @@
-import { ElementBookChapter } from './element-book-chapter/element-book-chapter';
-import { ElementBookEntryTypeEnum } from './element-book-entry-type';
-import { ElementBookPage } from './element-book-page/element-book-page';
-export type ElementBookRoot = {
-    entryType: ElementBookEntryTypeEnum.Root;
-    title: string;
-    parent: undefined;
-};
-export type ElementBookEntry = ElementBookChapter | ElementBookPage | ElementBookRoot;
-export declare function isElementBookEntry<SpecificType extends ElementBookEntryTypeEnum>(entry: unknown, entryType: SpecificType): entry is Extract<ElementBookEntry, {
-    entryType: SpecificType;
-}>;
-export declare function listBreadcrumbs(entry: ElementBookEntry, includeSelf?: boolean): string[];
-export declare function titleToBreadcrumb(title: string): string;

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

@@ -1,22 +0,0 @@
-import { collapseWhiteSpace, typedHasProperty } from '@augment-vir/common';
-export function isElementBookEntry(entry, entryType) {
-    return typedHasProperty(entry, 'entryType') && entry.entryType === entryType;
-}
-export function listBreadcrumbs(entry, includeSelf) {
-    const entryBreadcrumb = titleToBreadcrumb(entry.title);
-    if (entry.parent) {
-        return [
-            titleToBreadcrumb(entry.parent.title),
-            ...listBreadcrumbs(entry.parent, false),
-        ].concat(includeSelf ? [entryBreadcrumb] : []);
-    }
-    else if (includeSelf) {
-        return [entryBreadcrumb];
-    }
-    else {
-        return [];
-    }
-}
-export function titleToBreadcrumb(title) {
-    return collapseWhiteSpace(title).toLowerCase().replaceAll(/\s/g, '-');
-}

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

@@ -1,13 +0,0 @@
-export declare enum ElementBookPageControlTypeEnum {
-    Checkbox = "checkbox",
-    Color = "color",
-    Dropdown = "dropdown",
-    Text = "text"
-}
-export type ElementBookPageControlValueType = {
-    [ElementBookPageControlTypeEnum.Checkbox]: boolean;
-    [ElementBookPageControlTypeEnum.Color]: string;
-    /** Value type corresponds to which option in the dropdown is selected. */
-    [ElementBookPageControlTypeEnum.Dropdown]: string;
-    [ElementBookPageControlTypeEnum.Text]: string;
-};

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

@@ -1,7 +0,0 @@
-export var ElementBookPageControlTypeEnum;
-(function (ElementBookPageControlTypeEnum) {
-    ElementBookPageControlTypeEnum["Checkbox"] = "checkbox";
-    ElementBookPageControlTypeEnum["Color"] = "color";
-    ElementBookPageControlTypeEnum["Dropdown"] = "dropdown";
-    ElementBookPageControlTypeEnum["Text"] = "text";
-})(ElementBookPageControlTypeEnum || (ElementBookPageControlTypeEnum = {}));