@momentum-ui/web-components 2.16.8 → 2.16.9

package/dist/types/components/list/List.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) Cisco Systems, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import { LitElement, PropertyValues } from "lit-element";
+export declare namespace List {
+    const ELEMENT_base: typeof LitElement & import("../../mixins/RovingTabIndexMixin").AnyConstructor<import("../../mixins/RovingTabIndexMixin").RovingTabIndexInterface & import("../../mixins/SlottedMixin").SlotableInterface & import("../../mixins/SlottedMixin").SlotableClass & import("../../mixins/RovingTabIndexMixin").RovingTabIndexClass>;
+    export class ELEMENT extends ELEMENT_base {
+        alignment: "horizontal" | "vertical";
+        label: string;
+        activated: number;
+        listItemSlot?: HTMLSlotElement;
+        private _role;
+        protected firstUpdated(changedProperties: PropertyValues): void;
+        private notifySelectedChange;
+        /**
+         * @override
+         * Overridden isFocusable method.
+         * @param {Element} slottedItem - The slotted item to check.
+         * @returns {boolean} - Returns true if the slotted item does not have the "hidden" attribute, false otherwise.
+         */
+        private isFocusable;
+        connectedCallback(): void;
+        disconnectedCallback(): void;
+        private findListItemIndex;
+        private switchListItemOnArrowPress;
+        private setActivated;
+        private findSelectedListItemIndex;
+        private setSelected;
+        protected updated(changedProperties: PropertyValues): void;
+        private isListItemDisabled;
+        handleClick(event: MouseEvent): void;
+        handleKeyDown(event: KeyboardEvent): void;
+        get slotElement(): HTMLSlotElement | undefined;
+        static get styles(): import("lit-element").CSSResult[];
+        render(): import("lit-element").TemplateResult;
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-list": List.ELEMENT;
+    }
+}

package/dist/types/components/list/ListItem.d.ts

@@ -0,0 +1,26 @@
+import { LitElement } from "lit-element";
+export declare namespace ListItem {
+    const ELEMENT_base: typeof LitElement & import("../../mixins/FocusMixin").AnyConstructor<import("../../mixins/FocusMixin").FocusClass>;
+    export class ELEMENT extends ELEMENT_base {
+        role: "listitem" | "option";
+        tabIndex: number;
+        shape: "pill" | "rounded";
+        private _disabled;
+        get disabled(): boolean;
+        set disabled(value: boolean);
+        private _selected;
+        get selected(): boolean;
+        set selected(value: boolean);
+        get listItemTemplateClassMap(): {
+            [x: string]: boolean;
+        };
+        static get styles(): import("lit-element").CSSResult[];
+        render(): import("lit-element").TemplateResult;
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-list-item": ListItem.ELEMENT;
+    }
+}

package/dist/types/components/loading/Loading.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) Cisco Systems, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import { LitElement } from "lit-element";
+export declare namespace Loading {
+    type LoadingSize = "small" | "middle" | "large" | "";
+    class ELEMENT extends LitElement {
+        size: LoadingSize;
+        static get styles(): import("lit-element").CSSResult[];
+        get loadingClassMap(): {
+            [x: string]: boolean;
+        };
+        render(): import("lit-element").TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-loading": Loading.ELEMENT;
+    }
+}

package/dist/types/components/meeting-alert/CompositeAvatar.d.ts

@@ -0,0 +1 @@
+export declare const templateHTML: (attendees: Array<Record<string, any>>) => import("lit-element").TemplateResult;

package/dist/types/components/meeting-alert/MeetingAlert.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) Cisco Systems, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import "@/components/avatar/Avatar";
+import "@/components/button/Button";
+import "@/components/icon/Icon";
+import { LitElement, TemplateResult } from "lit-element";
+export declare const MeetingAlertRole: readonly ["alert", "alertdialog", "button", "checkbox", "dialog", "link", "option", "status"];
+export declare namespace MeetingAlert {
+    type Role = (typeof MeetingAlertRole)[number];
+    class ELEMENT extends LitElement {
+        attendees: {
+            title: string;
+            src: null;
+            alt: string;
+        }[];
+        closeAriaLabel: string;
+        onKeyDown: MeetingAlert.ELEMENT["handleKeyDown"] | null;
+        onSnooze: MeetingAlert.ELEMENT["handleSnooze"] | null;
+        message: string;
+        snoozeAriaLabel: string;
+        role: Role;
+        show: boolean;
+        src: string;
+        status: string;
+        userStyles: string;
+        title: string;
+        _onSnooze: (e: Event) => void;
+        _onClose: (e: Event) => void;
+        handleSnooze: (e: Event) => void;
+        handleClose: (e: Event) => void;
+        handleKeyDown: (e: KeyboardEvent) => void;
+        getStyles(): TemplateResult;
+        static get styles(): import("lit-element").CSSResult[];
+        render(): TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-meeting-alert": MeetingAlert.ELEMENT;
+    }
+}

package/dist/types/components/menu/Menu.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) Cisco Systems, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import { LitElement, PropertyValues } from "lit-element";
+import { MenuItem } from "./MenuItem";
+export declare const MORE_MENU_ITEM_COPY_ID_PREFIX = "more-menu-item-";
+export declare namespace Menu {
+    const ELEMENT_base: typeof LitElement & import("@/mixins/RovingTabIndexMixin").AnyConstructor<import("@/mixins/RovingTabIndexMixin").RovingTabIndexInterface & import("@/mixins/SlottedMixin").SlotableInterface & import("@/mixins/SlottedMixin").SlotableClass & import("@/mixins/RovingTabIndexMixin").RovingTabIndexClass> & import("@/mixins/SlottedMixin").AnyConstructor<import("@/mixins/SlottedMixin").SlotableClass & import("@/mixins/SlottedMixin").SlotableInterface>;
+    export class ELEMENT extends ELEMENT_base {
+        justified: boolean;
+        direction: string;
+        menuSlotElement?: HTMLSlotElement;
+        menuSubElement?: HTMLSlotElement;
+        private items;
+        private itemsHash;
+        private itemsIdxHash;
+        private getNormalizedItemId;
+        static get styles(): import("lit-element").CSSResult[];
+        get slotItem(): HTMLSlotElement | undefined;
+        private linkMenuItems;
+        private setupMenuItems;
+        private getChildrenFromTree;
+        private updateSelectedItem;
+        private changeSelectedItemIdx;
+        handleItemClick(event: CustomEvent<MenuItem.MenuItemEvent>): void;
+        handleItemKeydown(event: CustomEvent<MenuItem.MenuItemKeyDownEvent>): void;
+        connectedCallback(): void;
+        protected updated(changedProperties: PropertyValues): Promise<void>;
+        disconnectedCallback(): void;
+        get menuClassMap(): {
+            [x: string]: string | boolean;
+            justified: boolean;
+        };
+        render(): import("lit-element").TemplateResult;
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-menu": Menu.ELEMENT;
+    }
+}

package/dist/types/components/menu/MenuItem.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) Cisco Systems, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import { LitElement, PropertyValues } from "lit-element";
+export declare namespace MenuItem {
+    type MenuItemEvent = {
+        id: string;
+    };
+    type MenuItemKeyDownEvent = {
+        id: string;
+        key: string;
+        srcEvent: KeyboardEvent;
+    };
+    class ELEMENT extends LitElement {
+        href: string;
+        label: string;
+        tabIndex: number;
+        private _disabled;
+        get disabled(): boolean;
+        set disabled(value: boolean);
+        private _selected;
+        get selected(): boolean;
+        set selected(value: boolean);
+        static get styles(): import("lit-element").CSSResult[];
+        private setupEvents;
+        protected firstUpdated(changedProperties: PropertyValues): void;
+        protected update(changedProperties: PropertyValues): void;
+        handleClick(event: MouseEvent): void;
+        handleKeyDown(event: KeyboardEvent): void;
+        private notifySelectedItem;
+        get menuItemClassMap(): {
+            "md-menu-item--selected": boolean;
+            disabled: boolean;
+        };
+        render(): import("lit-element").TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-menu-item": MenuItem.ELEMENT;
+    }
+}

package/dist/types/components/menu-overlay/MenuOverlay.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) Cisco Systems, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import { LitElement, PropertyValues } from "lit-element";
+export declare enum OverlaySizes {
+    small = "260px",
+    large = "370px"
+}
+export declare const menuOverlaySize: readonly ["small", "large"];
+export declare const menuOverlayPlacement: readonly ["auto", "auto-start", "auto-end", "left-start", "left", "left-end", "right-start", "right", "right-end", "top-start", "top", "top-end", "bottom-start", "bottom", "bottom-end"];
+export declare const menuOverlayRole: readonly ["menu", "dialog"];
+export declare namespace MenuOverlay {
+    export type Size = (typeof menuOverlaySize)[number];
+    export type Placement = (typeof menuOverlayPlacement)[number];
+    export type Role = (typeof menuOverlayRole)[number];
+    const ELEMENT_base: typeof LitElement & import("@/mixins/FocusTrapMixin").AnyConstructor<import("@/mixins/FocusTrapMixin").FocusTrapClass & import("@/mixins/FocusTrapMixin").FocusTrapInterface & import("../../mixins/FocusMixin").FocusClass>;
+    export class ELEMENT extends ELEMENT_base {
+        private _isOpen;
+        private static activeOverlay;
+        get isOpen(): boolean;
+        set isOpen(newValue: boolean);
+        size: MenuOverlay.Size;
+        maxHeight: string;
+        customWidth: string;
+        showArrow: boolean;
+        disabled: boolean;
+        placement: MenuOverlay.Placement;
+        allowHoverToggle: boolean;
+        ariaRole: Role;
+        ariaLabel: string;
+        isDatePicker: boolean;
+        overlayOffset: number;
+        overlayContainer: HTMLDivElement;
+        arrow: HTMLDivElement;
+        trigger?: NodeListOf<HTMLElement>;
+        private popperInstance;
+        private triggerElement;
+        private renderMaxHeight;
+        shouldWrapFocus: () => boolean;
+        private renderOverflowY;
+        private renderWidth;
+        private getStyles;
+        updateActiveMenuOverlayOpened: (event: Event) => void;
+        updateActiveMenuOverlayClosed: (event: Event) => void;
+        connectedCallback(): void;
+        disconnectedCallback(): void;
+        checkIsInputField(element: HTMLElement): boolean;
+        protected firstUpdated(changedProperties: PropertyValues): Promise<void>;
+        protected update(changedProperties: PropertyValues): void;
+        protected updated(changedProperties: PropertyValues): void;
+        private dispatchMenuOpen;
+        private dispatchMenuClose;
+        private handleInstance;
+        private create;
+        private destroy;
+        private handleTriggerClick;
+        private toggleOverlay;
+        private setOverlay;
+        private expandPopup;
+        private collapsePopup;
+        handleOutsideOverlayKeydown: (event: KeyboardEvent) => Promise<void>;
+        handleTriggerKeyDown: (event: KeyboardEvent) => Promise<void>;
+        private focusOnTrigger;
+        private focusInsideOverlay;
+        private focusOnNestedTrigger;
+        handleOutsideOverlayClick: (event: MouseEvent) => void;
+        handleWindowBlurEvent(): void;
+        static get styles(): import("lit-element").CSSResult[];
+        render(): import("lit-element").TemplateResult;
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-menu-overlay": MenuOverlay.ELEMENT;
+    }
+}

package/dist/types/components/modal/Modal.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Copyright (c) Cisco Systems, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import "@/components/button/Button";
+import "@/components/icon/Icon";
+import { LitElement, PropertyValues } from "lit-element";
+export declare const modalType: readonly ["default", "full", "large", "small", "dialog"];
+/**
+ * Increasing latency above 13 ms has an increasingly negative impact
+ * on human performance for a given task. While imperceptible at first,
+ * added latency continues to degrade a human’s processing ability until
+ * approaching 75 to 100 ms.
+ * MIT: http://news.mit.edu/2014/in-the-blink-of-an-eye-0116
+ */
+export declare namespace Modal {
+    export type Type = (typeof modalType)[number];
+    const ELEMENT_base: typeof LitElement & import("../../mixins/FocusTrapMixin").AnyConstructor<import("../../mixins/FocusTrapMixin").FocusTrapClass & import("../../mixins/FocusTrapMixin").FocusTrapInterface & import("../../mixins/FocusMixin").FocusClass>;
+    export class ELEMENT extends ELEMENT_base {
+        show: boolean;
+        headerLabel: string;
+        headerMessage: string;
+        htmlId: string;
+        ariaLabel: string;
+        ariaLabelClose: string;
+        ariaLabelCancel: string;
+        ariaLabelSubmit: string;
+        ariaDescription: string;
+        showCloseButton: boolean;
+        backdropClickExit: boolean;
+        noExitOnEsc: boolean;
+        size: Type;
+        closeBtnName: string;
+        hideFooter: boolean;
+        hideHeader: boolean;
+        disableInitialFocus: boolean;
+        private animating;
+        backDrop: HTMLElement;
+        static get styles(): import("lit-element").CSSResult[];
+        connectedCallback(): void;
+        disconnectedCallback(): void;
+        protected update(changedProperties: PropertyValues): void;
+        private notifyModalClose;
+        private focusInsideModal;
+        handleCloseOutside: (event: KeyboardEvent) => void;
+        handleKeyDown(event: KeyboardEvent): void;
+        private transitionPromise;
+        private modalFadeIn;
+        private modalFadeOut;
+        handleCloseBackdrop(): void;
+        hideModal(): void;
+        private topCloseBtnTemplate;
+        private handleFooterClick;
+        private headerTemplate;
+        footerTemplate(): import("lit-element").TemplateResult;
+        get modalBackDropClassMap(): {
+            in: boolean;
+        };
+        get modalContainerClassMap(): {
+            [x: string]: boolean;
+            in: boolean;
+        };
+        render(): import("lit-element").TemplateResult;
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-modal": Modal.ELEMENT;
+    }
+}

package/dist/types/components/pagination/Pagination.d.ts

@@ -0,0 +1,33 @@
+import "@/components/button/Button";
+import "@/components/icon/Icon";
+import { LitElement } from "lit-element";
+export declare namespace Pagination {
+    class ELEMENT extends LitElement {
+        private _currentPage;
+        hasDots: boolean;
+        onlyDots: boolean;
+        noNavigation: boolean;
+        totalPage: number;
+        visiblePage: number;
+        get currentPage(): number;
+        set currentPage(newPage: number);
+        static get styles(): import("lit-element").CSSResult[];
+        private computePrevious;
+        private computeNext;
+        private computeFirst;
+        private computeLast;
+        private computeCurrent;
+        private notifyPageChange;
+        get hasPreviousPage(): boolean;
+        get hasNextPage(): boolean;
+        private computePageList;
+        private pagesTemplate;
+        private dotsTemplate;
+        render(): import("lit-element").TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-pagination": Pagination.ELEMENT;
+    }
+}

package/dist/types/components/phone-input/PhoneInput.d.ts

@@ -0,0 +1,72 @@
+import "@/components/combobox/ComboBox";
+import "@/components/input/Input";
+import { LitElement } from "lit-element";
+export declare namespace PhoneInput {
+    interface Country {
+        name: string;
+        value: string;
+        code: string;
+    }
+    type Attributes = {
+        codePlaceholder: string;
+        numberPlaceholder: string;
+        countryCallingCode: string;
+        pill: boolean;
+        value: string;
+        errorMessage: string;
+        flagClass: string;
+        showErrorMessage: string;
+    };
+    type CountryCalling = {
+        id: string;
+        value: string;
+    };
+    class ELEMENT extends LitElement {
+        codePlaceholder: string;
+        numberPlaceholder: string;
+        countryCallingCode: string;
+        showFlags: boolean;
+        pill: boolean;
+        disabled: boolean;
+        value: string;
+        errorMessage: string;
+        showErrorMessage: boolean;
+        clearIconHeight: string;
+        countryCodeAriaLabel: string;
+        dialNumberAriaLabel: string;
+        clearAriaLabel: string;
+        clearCountryCodeAriaLabel: string;
+        id: string;
+        newMomentum: boolean;
+        private countryCode;
+        private codeList;
+        private formattedValue;
+        private isValid;
+        combobox: HTMLElement;
+        connectedCallback(): void;
+        getCountryFlag(code: string): import("lit-element").TemplateResult;
+        countryCodeOptionTemplate(country: PhoneInput.Country, index: number): import("lit-element").TemplateResult;
+        validateNumber(): void;
+        handleCountryChange(event: CustomEvent): void;
+        handlePhoneChange(event: CustomEvent): void;
+        handleKeydown(event: Event): void;
+        handleBlur(event: Event): void;
+        removeCountryCode(): void;
+        validateInput(input: string): void;
+        get flagClassMap(): {
+            "new-momentum": boolean;
+        };
+        getFormatedCountryCallingCode(): {
+            id: string;
+            value: string;
+        };
+        getModStyle(): import("lit-element").TemplateResult;
+        static get styles(): import("lit-element").CSSResult[];
+        render(): import("lit-element").TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-phone-input": PhoneInput.ELEMENT;
+    }
+}