@cedx/ui 0.1.0

package/lib/Components/FullScreenToggler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FullScreenToggler.d.ts","sourceRoot":"","sources":["../../src/Client/Components/FullScreenToggler.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,WAAW;;IAwBjD;;OAEG;IACH,IAAI,MAAM,IAAI,MAAM,CAGnB;IACD,IAAI,MAAM,CAAC,KAAK,EAAE,MAAM,EAEvB;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,OAAO,CAEtB;IACD,IAAI,QAAQ,CAAC,KAAK,EAAE,OAAO,EAE1B;IAED;;OAEG;IACH,iBAAiB,IAAI,IAAI;IAOzB;;OAEG;IACH,oBAAoB,IAAI,IAAI;IAI5B;;;;OAIG;IACG,gBAAgB,CAAC,KAAK,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;CAsCpD;AAED;;GAEG;AACH,OAAO,CAAC,MAAM,CAAC;IAEd;;OAEG;IACH,UAAU,qBAAqB;QAC9B,oBAAoB,EAAE,iBAAiB,CAAC;KACxC;CACD"}

package/lib/Components/FullScreenToggler.js

@@ -0,0 +1,103 @@
+/**
+ * A component for toggling an element to full-screen.
+ */
+export class FullScreenToggler extends HTMLElement {
+    /**
+     * The abort controller used to remove the event listeners.
+     */
+    #abortController = null;
+    /**
+     * The target element.
+     */
+    #element = document.body;
+    /**
+     * The handle to the underlying platform wake lock.
+     */
+    #sentinel = null;
+    /**
+     * Registers the component.
+     */
+    static {
+        customElements.define("fullscreen-toggler", this);
+    }
+    /**
+     * The CSS selector specifying the target element.
+     */
+    get target() {
+        const value = this.getAttribute("target") ?? "";
+        return value.trim() || "body";
+    }
+    set target(value) {
+        this.setAttribute("target", value);
+    }
+    /**
+     * Value indicating whether to prevent the device screen from dimming or locking when in full-screen mode.
+     */
+    get wakeLock() {
+        return this.hasAttribute("wakeLock");
+    }
+    set wakeLock(value) {
+        this.toggleAttribute("wakeLock", value);
+    }
+    /**
+     * Method invoked when this component is connected.
+     */
+    connectedCallback() {
+        this.#abortController = new AbortController;
+        document.addEventListener("visibilitychange", () => this.#onVisibilityChanged(), { signal: this.#abortController.signal });
+        this.#element = document.querySelector(this.target) ?? document.body;
+        this.#element.addEventListener("fullscreenchange", () => this.#onFullScreenChanged(), { signal: this.#abortController.signal });
+    }
+    /**
+     * Method invoked when this component is disconnected.
+     */
+    disconnectedCallback() {
+        this.#abortController?.abort();
+    }
+    /**
+     * Toggles the full-screen mode of the associated element.
+     * @param event The dispatched event.
+     * @returns Completes when the full-screen mode has been toggled.
+     */
+    async toggleFullScreen(event) {
+        event?.preventDefault();
+        if (document.fullscreenElement)
+            await document.exitFullscreen();
+        else
+            await this.#element.requestFullscreen();
+    }
+    /**
+     * Acquires a new wake lock.
+     * @returns Completes when the wake lock has been acquired.
+     */
+    async #acquireWakeLock() {
+        if (this.wakeLock && (!this.#sentinel || this.#sentinel.released))
+            this.#sentinel = await navigator.wakeLock.request();
+    }
+    /**
+     * Acquires or releases the wake lock when the document enters or exits the full-screen mode.
+     * @param event The dispatched event.
+     */
+    #onFullScreenChanged() {
+        if (document.fullscreenElement)
+            void this.#acquireWakeLock();
+        else
+            void this.#releaseWakeLock();
+    }
+    /**
+     * Eventually acquires a new wake lock when the document visibility has changed.
+     * @param event The dispatched event.
+     */
+    #onVisibilityChanged() {
+        if (document.fullscreenElement && !document.hidden)
+            void this.#acquireWakeLock();
+    }
+    /**
+     * Releases the acquired wake lock.
+     * @returns Completes when the wake lock has been released.
+     */
+    async #releaseWakeLock() {
+        if (this.#sentinel && !this.#sentinel.released)
+            await this.#sentinel.release();
+    }
+}

package/lib/Components/KeyboardAccelerator.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Associates a shortcut key with its child content.
+ */
+export declare class KeyboardAccelerator extends HTMLElement {
+    #private;
+    /**
+     * Identifies the key for the keyboard accelerator.
+     */
+    get key(): string;
+    set key(value: string);
+    /**
+     * Identifies the modifiers for the keyboard accelerator.
+     */
+    get modifiers(): number;
+    set modifiers(value: number);
+    /**
+     * Method invoked when this component is connected.
+     */
+    connectedCallback(): void;
+    /**
+     * Method invoked when this component is disconnected.
+     */
+    disconnectedCallback(): void;
+}
+/**
+ * Declaration merging.
+ */
+declare global {
+    /**
+     * The map of HTML tag names.
+     */
+    interface HTMLElementTagNameMap {
+        "keyboard-accelerator": KeyboardAccelerator;
+    }
+}
+//# sourceMappingURL=KeyboardAccelerator.d.ts.map

package/lib/Components/KeyboardAccelerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyboardAccelerator.d.ts","sourceRoot":"","sources":["../../src/Client/Components/KeyboardAccelerator.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,WAAW;;IAmBnD;;OAEG;IACH,IAAI,GAAG,IAAI,MAAM,CAEhB;IACD,IAAI,GAAG,CAAC,KAAK,EAAE,MAAM,EAEpB;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,MAAM,CAItB;IACD,IAAI,SAAS,CAAC,KAAK,EAAE,MAAM,EAK1B;IAED;;OAEG;IACH,iBAAiB,IAAI,IAAI;IAKzB;;OAEG;IACH,oBAAoB,IAAI,IAAI;CAuB5B;AAED;;GAEG;AACH,OAAO,CAAC,MAAM,CAAC;IAEd;;OAEG;IACH,UAAU,qBAAqB;QAC9B,sBAAsB,EAAE,mBAAmB,CAAC;KAC5C;CACD"}

package/lib/Components/KeyboardAccelerator.js

@@ -0,0 +1,78 @@
+import { KeyboardModifiers } from "../KeyboardModifiers.js";
+/**
+ * Associates a shortcut key with its child content.
+ */
+export class KeyboardAccelerator extends HTMLElement {
+    /**
+     * The mapping between the modifier names and their values.
+     */
+    static #modifiers = new Map(Object.entries(KeyboardModifiers).filter(([key]) => key != "None"));
+    /**
+     * The abort controller used to remove the event listeners.
+     */
+    #abortController = null;
+    /**
+     * Registers the component.
+     */
+    static {
+        customElements.define("keyboard-accelerator", this);
+    }
+    /**
+     * Identifies the key for the keyboard accelerator.
+     */
+    get key() {
+        return (this.getAttribute("key") ?? "").trim();
+    }
+    set key(value) {
+        this.setAttribute("key", value);
+    }
+    /**
+     * Identifies the modifiers for the keyboard accelerator.
+     */
+    get modifiers() {
+        return (this.getAttribute("modifiers") ?? "").split(",")
+            .map(value => value.trim())
+            .reduce((modifiers, value) => modifiers | (KeyboardAccelerator.#modifiers.get(value) ?? 0), KeyboardModifiers.None);
+    }
+    set modifiers(value) {
+        this.setAttribute("modifiers", !value ? "None" : KeyboardAccelerator.#modifiers.entries()
+            .filter(([, flag]) => (value & flag) != 0)
+            .map(([key]) => key)
+            .toArray().join(", "));
+    }
+    /**
+     * Method invoked when this component is connected.
+     */
+    connectedCallback() {
+        this.#abortController = new AbortController;
+        addEventListener("keyup", event => this.#activateChildContent(event), { signal: this.#abortController.signal });
+    }
+    /**
+     * Method invoked when this component is disconnected.
+     */
+    disconnectedCallback() {
+        this.#abortController?.abort();
+    }
+    /**
+     * Activates the child content when the specified keyboard event designates the same key and modifiers as this keyboard accelerator.
+     * @param event The dispatched event.
+     */
+    #activateChildContent(event) {
+        if (event.key != this.key)
+            return;
+        const { activeElement } = document;
+        if (activeElement instanceof HTMLInputElement || activeElement instanceof HTMLTextAreaElement)
+            return;
+        const { modifiers } = this;
+        if (!(modifiers & KeyboardModifiers.Ctrl) && event.ctrlKey)
+            return;
+        if (!(modifiers & KeyboardModifiers.Shift) && event.shiftKey)
+            return;
+        if (!(modifiers & KeyboardModifiers.Alt) && event.altKey)
+            return;
+        if (!(modifiers & KeyboardModifiers.Meta) && event.metaKey)
+            return;
+        event.preventDefault();
+        this.firstElementChild?.click();
+    }
+}

package/lib/Components/LoadingIndicator.d.ts

@@ -0,0 +1,58 @@
+/**
+ * A component that shows up when an HTTP request starts, and hides when all concurrent HTTP requests are completed.
+ */
+export declare class LoadingIndicator extends HTMLElement {
+    #private;
+    /**
+     * The list of observed attributes.
+     */
+    static readonly observedAttributes: string[];
+    /**
+     * Value indicating whether to apply a transition.
+     */
+    get fade(): boolean;
+    set fade(value: boolean);
+    /**
+     * Value indicating whether this component is shown.
+     */
+    get isShown(): boolean;
+    /**
+     * Value indicating whether to initially show this component.
+     */
+    get open(): boolean;
+    set open(value: boolean);
+    /**
+     * Method invoked when an attribute has been changed.
+     * @param attribute The attribute name.
+     * @param oldValue The previous attribute value.
+     * @param newValue The new attribute value.
+     */
+    attributeChangedCallback(attribute: string, oldValue: string | null, newValue: string | null): void;
+    /**
+     * Method invoked when this component is connected.
+     */
+    connectedCallback(): void;
+    /**
+     * Hides this loading indicator.
+     * @param options Value indicating whether to force the loading indicator to hide.
+     */
+    hide(options?: {
+        force?: boolean;
+    }): void;
+    /**
+     * Shows this loading indicator.
+     */
+    show(): void;
+}
+/**
+ * Declaration merging.
+ */
+declare global {
+    /**
+     * The map of HTML tag names.
+     */
+    interface HTMLElementTagNameMap {
+        "loading-indicator": LoadingIndicator;
+    }
+}
+//# sourceMappingURL=LoadingIndicator.d.ts.map

package/lib/Components/LoadingIndicator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoadingIndicator.d.ts","sourceRoot":"","sources":["../../src/Client/Components/LoadingIndicator.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,WAAW;;IAEhD;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,kBAAkB,WAAY;IAc9C;;OAEG;IACH,IAAI,IAAI,IAAI,OAAO,CAElB;IACD,IAAI,IAAI,CAAC,KAAK,EAAE,OAAO,EAEtB;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,OAAO,CAElB;IACD,IAAI,IAAI,CAAC,KAAK,EAAE,OAAO,EAEtB;IAED;;;;;OAKG;IACH,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAC,IAAI,GAAG,IAAI;IAO/F;;OAEG;IACH,iBAAiB,IAAI,IAAI;IAKzB;;;OAGG;IACH,IAAI,CAAC,OAAO,GAAE;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAM,GAAG,IAAI;IAS3C;;OAEG;IACH,IAAI,IAAI,IAAI;CAaZ;AAED;;GAEG;AACH,OAAO,CAAC,MAAM,CAAC;IAEd;;OAEG;IACH,UAAU,qBAAqB;QAC9B,mBAAmB,EAAE,gBAAgB,CAAC;KACtC;CACD"}

package/lib/Components/LoadingIndicator.js

@@ -0,0 +1,93 @@
+/**
+ * A component that shows up when an HTTP request starts, and hides when all concurrent HTTP requests are completed.
+ */
+export class LoadingIndicator extends HTMLElement {
+    /**
+     * The list of observed attributes.
+     */
+    static observedAttributes = ["fade"];
+    /**
+     * The number of concurrent HTTP requests.
+     */
+    #requestCount = 0;
+    /**
+     * Registers the component.
+     */
+    static {
+        customElements.define("loading-indicator", this);
+    }
+    /**
+     * Value indicating whether to apply a transition.
+     */
+    get fade() {
+        return this.hasAttribute("fade");
+    }
+    set fade(value) {
+        this.toggleAttribute("fade", value);
+    }
+    /**
+     * Value indicating whether this component is shown.
+     */
+    get isShown() {
+        return this.classList.contains("show");
+    }
+    /**
+     * Value indicating whether to initially show this component.
+     */
+    get open() {
+        return this.hasAttribute("open");
+    }
+    set open(value) {
+        this.toggleAttribute("open", value);
+    }
+    /**
+     * Method invoked when an attribute has been changed.
+     * @param attribute The attribute name.
+     * @param oldValue The previous attribute value.
+     * @param newValue The new attribute value.
+     */
+    attributeChangedCallback(attribute, oldValue, newValue) {
+        if (newValue != oldValue)
+            switch (attribute) {
+                case "fade":
+                    this.#updateFade(newValue != null);
+                    break;
+                // No default
+            }
+    }
+    /**
+     * Method invoked when this component is connected.
+     */
+    connectedCallback() {
+        this.#requestCount = 0;
+        if (this.open)
+            this.show();
+    }
+    /**
+     * Hides this loading indicator.
+     * @param options Value indicating whether to force the loading indicator to hide.
+     */
+    hide(options = {}) {
+        this.#requestCount--;
+        if (this.#requestCount <= 0 || options.force) {
+            this.#requestCount = 0;
+            this.classList.add("hide");
+            this.classList.remove("show");
+        }
+    }
+    /**
+     * Shows this loading indicator.
+     */
+    show() {
+        this.#requestCount++;
+        this.classList.remove("hide");
+        this.classList.add("show");
+    }
+    /**
+     * Updates the value indicating whether to apply a transition.
+     * @param value The new value.
+     */
+    #updateFade(value) {
+        this.classList.toggle("fade", value);
+    }
+}

package/lib/Components/MenuActivator.d.ts

@@ -0,0 +1,26 @@
+/**
+ * A component that activates the items of a menu, based on the current document URL.
+ */
+export declare class MenuActivator extends HTMLElement {
+    #private;
+    /**
+     * Method invoked when this component is connected.
+     */
+    connectedCallback(): void;
+    /**
+     * Method invoked when this component is disconnected.
+     */
+    disconnectedCallback(): void;
+}
+/**
+ * Declaration merging.
+ */
+declare global {
+    /**
+     * The map of HTML tag names.
+     */
+    interface HTMLElementTagNameMap {
+        "menu-activator": MenuActivator;
+    }
+}
+//# sourceMappingURL=MenuActivator.d.ts.map

package/lib/Components/MenuActivator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MenuActivator.d.ts","sourceRoot":"","sources":["../../src/Client/Components/MenuActivator.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,aAAc,SAAQ,WAAW;;IAc7C;;OAEG;IACH,iBAAiB,IAAI,IAAI;IAOzB;;OAEG;IACH,oBAAoB,IAAI,IAAI;CAc5B;AAED;;GAEG;AACH,OAAO,CAAC,MAAM,CAAC;IAEd;;OAEG;IACH,UAAU,qBAAqB;QAC9B,gBAAgB,EAAE,aAAa,CAAC;KAChC;CACD"}

package/lib/Components/MenuActivator.js

@@ -0,0 +1,42 @@
+/**
+ * A component that activates the items of a menu, based on the current document URL.
+ */
+export class MenuActivator extends HTMLElement {
+    /**
+     * The abort controller used to remove the event listeners.
+     */
+    #abortController = null;
+    /**
+     * Registers the component.
+     */
+    static {
+        customElements.define("menu-activator", this);
+    }
+    /**
+     * Method invoked when this component is connected.
+     */
+    connectedCallback() {
+        this.#abortController = new AbortController;
+        this.#update();
+        addEventListener("popstate", () => this.#update(), { signal: this.#abortController.signal });
+        document.body.addEventListener("htmx:pushedIntoHistory", () => this.#update(), { signal: this.#abortController.signal });
+    }
+    /**
+     * Method invoked when this component is disconnected.
+     */
+    disconnectedCallback() {
+        this.#abortController?.abort();
+    }
+    /**
+     * Updates this component.
+     */
+    #update() {
+        for (const element of this.querySelectorAll(".active"))
+            element.classList.remove("active");
+        for (const element of this.querySelectorAll("a"))
+            if (element.href == location.href) {
+                element.classList.add("active");
+                element.closest(".dropdown")?.querySelector(".dropdown-toggle")?.classList.add("active");
+            }
+    }
+}

package/lib/Components/OfflineIndicator.d.ts

@@ -0,0 +1,59 @@
+/**
+ * A component that shows up when the network is unavailable, and hides when connectivity is restored.
+ */
+export declare class OfflineIndicator extends HTMLElement {
+    #private;
+    /**
+     * The list of observed attributes.
+     */
+    static readonly observedAttributes: string[];
+    /**
+     * Value indicating whether to apply a transition.
+     */
+    get fade(): boolean;
+    set fade(value: boolean);
+    /**
+     * Value indicating whether this component is shown.
+     */
+    get isShown(): boolean;
+    /**
+     * Value indicating whether to initially show this component.
+     */
+    get open(): boolean;
+    set open(value: boolean);
+    /**
+     * Method invoked when an attribute has been changed.
+     * @param attribute The attribute name.
+     * @param oldValue The previous attribute value.
+     * @param newValue The new attribute value.
+     */
+    attributeChangedCallback(attribute: string, oldValue: string | null, newValue: string | null): void;
+    /**
+     * Method invoked when this component is connected.
+     */
+    connectedCallback(): void;
+    /**
+     * Method invoked when this component is disconnected.
+     */
+    disconnectedCallback(): void;
+    /**
+     * Hides this offline indicator.
+     */
+    hide(): void;
+    /**
+     * Shows this offline indicator.
+     */
+    show(): void;
+}
+/**
+ * Declaration merging.
+ */
+declare global {
+    /**
+     * The map of HTML tag names.
+     */
+    interface HTMLElementTagNameMap {
+        "offline-indicator": OfflineIndicator;
+    }
+}
+//# sourceMappingURL=OfflineIndicator.d.ts.map

package/lib/Components/OfflineIndicator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OfflineIndicator.d.ts","sourceRoot":"","sources":["../../src/Client/Components/OfflineIndicator.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,WAAW;;IAEhD;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,kBAAkB,WAAY;IAc9C;;OAEG;IACH,IAAI,IAAI,IAAI,OAAO,CAElB;IACD,IAAI,IAAI,CAAC,KAAK,EAAE,OAAO,EAEtB;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,OAAO,CAElB;IACD,IAAI,IAAI,CAAC,KAAK,EAAE,OAAO,EAEtB;IAED;;;;;OAKG;IACH,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAC,IAAI,GAAG,IAAI;IAO/F;;OAEG;IACH,iBAAiB,IAAI,IAAI;IAQzB;;OAEG;IACH,oBAAoB,IAAI,IAAI;IAI5B;;OAEG;IACH,IAAI,IAAI,IAAI;IAKZ;;OAEG;IACH,IAAI,IAAI,IAAI;CAoBZ;AAED;;GAEG;AACH,OAAO,CAAC,MAAM,CAAC;IAEd;;OAEG;IACH,UAAU,qBAAqB;QAC9B,mBAAmB,EAAE,gBAAgB,CAAC;KACtC;CACD"}

package/lib/Components/OfflineIndicator.js

@@ -0,0 +1,106 @@
+/**
+ * A component that shows up when the network is unavailable, and hides when connectivity is restored.
+ */
+export class OfflineIndicator extends HTMLElement {
+    /**
+     * The list of observed attributes.
+     */
+    static observedAttributes = ["fade"];
+    /**
+     * The abort controller used to remove the event listeners.
+     */
+    #abortController = null;
+    /**
+     * Registers the component.
+     */
+    static {
+        customElements.define("offline-indicator", this);
+    }
+    /**
+     * Value indicating whether to apply a transition.
+     */
+    get fade() {
+        return this.hasAttribute("fade");
+    }
+    set fade(value) {
+        this.toggleAttribute("fade", value);
+    }
+    /**
+     * Value indicating whether this component is shown.
+     */
+    get isShown() {
+        return this.classList.contains("show");
+    }
+    /**
+     * Value indicating whether to initially show this component.
+     */
+    get open() {
+        return this.hasAttribute("open");
+    }
+    set open(value) {
+        this.toggleAttribute("open", value);
+    }
+    /**
+     * Method invoked when an attribute has been changed.
+     * @param attribute The attribute name.
+     * @param oldValue The previous attribute value.
+     * @param newValue The new attribute value.
+     */
+    attributeChangedCallback(attribute, oldValue, newValue) {
+        if (newValue != oldValue)
+            switch (attribute) {
+                case "fade":
+                    this.#updateFade(newValue != null);
+                    break;
+                // No default
+            }
+    }
+    /**
+     * Method invoked when this component is connected.
+     */
+    connectedCallback() {
+        this.#abortController = new AbortController;
+        for (const event of ["online", "offline"])
+            addEventListener(event, () => this.#updateVisibility(), { signal: this.#abortController.signal });
+        if (this.open)
+            this.show();
+        else
+            this.#updateVisibility();
+    }
+    /**
+     * Method invoked when this component is disconnected.
+     */
+    disconnectedCallback() {
+        this.#abortController?.abort();
+    }
+    /**
+     * Hides this offline indicator.
+     */
+    hide() {
+        this.classList.remove("show");
+        this.classList.add("hide");
+    }
+    /**
+     * Shows this offline indicator.
+     */
+    show() {
+        this.classList.remove("hide");
+        this.classList.add("show");
+    }
+    /**
+     * Updates the value indicating whether to apply a transition.
+     * @param value The new value.
+     */
+    #updateFade(value) {
+        this.classList.toggle("fade", value);
+    }
+    /**
+     * Updates the visibility of this component.
+     */
+    #updateVisibility() {
+        if (navigator.onLine)
+            this.hide();
+        else
+            this.show();
+    }
+}

package/lib/Components/TabActivator.d.ts

@@ -0,0 +1,49 @@
+import { StorageArea } from "../StorageArea.js";
+/**
+ * A component that activates a tab, based on its index saved in the web storage.
+ */
+export declare class TabActivator extends HTMLElement {
+    /**
+     * Creates a new tab activator.
+     */
+    constructor();
+    /**
+     * The index of the active tab.
+     */
+    get activeTabIndex(): number;
+    set activeTabIndex(value: number);
+    /**
+     * The storage object corresponding to the current {@link storageArea}.
+     */
+    get storage(): globalThis.Storage;
+    /**
+     * The storage area to use.
+     */
+    get storageArea(): StorageArea;
+    set storageArea(value: StorageArea);
+    /**
+     * The key of the storage entry providing the active tab index.
+     */
+    get storageKey(): string;
+    set storageKey(value: string);
+    /**
+     * The tab list.
+     */
+    get tabs(): NodeListOf<HTMLElement>;
+    /**
+     * Method invoked when this component is connected.
+     */
+    connectedCallback(): void;
+}
+/**
+ * Declaration merging.
+ */
+declare global {
+    /**
+     * The map of HTML tag names.
+     */
+    interface HTMLElementTagNameMap {
+        "tab-activator": TabActivator;
+    }
+}
+//# sourceMappingURL=TabActivator.d.ts.map

package/lib/Components/TabActivator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TabActivator.d.ts","sourceRoot":"","sources":["../../src/Client/Components/TabActivator.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,WAAW,EAAC,MAAM,mBAAmB,CAAC;AAE9C;;GAEG;AACH,qBAAa,YAAa,SAAQ,WAAW;IAE5C;;OAEG;;IAgBH;;OAEG;IACH,IAAI,cAAc,IAAI,MAAM,CAG3B;IACD,IAAI,cAAc,CAAC,KAAK,EAAE,MAAM,EAE/B;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,UAAU,CAAC,OAAO,CAEhC;IAED;;OAEG;IACH,IAAI,WAAW,IAAI,WAAW,CAG7B;IACD,IAAI,WAAW,CAAC,KAAK,EAAE,WAAW,EAEjC;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,MAAM,CAGvB;IACD,IAAI,UAAU,CAAC,KAAK,EAAE,MAAM,EAE3B;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,UAAU,CAAC,WAAW,CAAC,CAElC;IAED;;OAEG;IACH,iBAAiB,IAAI,IAAI;CAGzB;AAED;;GAEG;AACH,OAAO,CAAC,MAAM,CAAC;IAEd;;OAEG;IACH,UAAU,qBAAqB;QAC9B,eAAe,EAAE,YAAY,CAAC;KAC9B;CACD"}