@momentum-ui/web-components 2.14.13 → 2.14.14

package/dist/types/components/draggable/Draggable.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 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 Sortable from "sortablejs";
+export declare namespace Draggable {
+    const ELEMENT_base: typeof LitElement & import("../../mixins/SlottedMixin").AnyConstructor<import("../../mixins/SlottedMixin").SlotableClass & import("../../mixins/SlottedMixin").SlotableInterface>;
+    export class ELEMENT extends ELEMENT_base {
+        delay: number;
+        animation: number;
+        handle: string;
+        filter: string;
+        easing: string;
+        direction: "horizontal" | "vertical";
+        group: Sortable.GroupOptions | null;
+        draggableItems: string;
+        ghostClass: string;
+        chosenClass: string;
+        dragClass: string;
+        fallbackClass: string;
+        swapThreshold: number;
+        touchStartThreshold: number;
+        forceFallback: boolean;
+        sort: boolean;
+        disabled: boolean;
+        editable: boolean;
+        draggableSlot: HTMLSlotElement;
+        private sortableInstance;
+        static get styles(): import("lit-element").CSSResult[];
+        get slotElement(): HTMLSlotElement;
+        private generateOptions;
+        private initializeSortable;
+        private dispatchDragEvent;
+        handleOnChange: (event: Sortable.SortableEvent) => void;
+        handleOnClone: (event: Sortable.SortableEvent) => void;
+        handleOnUnchoose: (event: Sortable.SortableEvent) => void;
+        handleOnRemove: (event: Sortable.SortableEvent) => void;
+        handleOnAdd: (event: Sortable.SortableEvent) => void;
+        handleOnChoose: (event: Sortable.SortableEvent) => void;
+        handleOnEnd: (event: Sortable.SortableEvent) => void;
+        handleOnMove: (this: unknown, ...args: any[]) => void;
+        handleOnStart: (event: Sortable.SortableEvent) => void;
+        private cleanupSortable;
+        connectedCallback(): void;
+        disconnectedCallback(): void;
+        private setSortableOption;
+        private updateSortableInstance;
+        protected updated(changedProperties: PropertyValues): void;
+        protected slottedChanged(): void;
+        render(): import("lit-element").TemplateResult;
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-draggable": Draggable.ELEMENT;
+    }
+}

package/dist/types/components/draggable/DraggableItem.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 DraggableItem {
+    const ELEMENT_base: typeof LitElement & import("../../mixins/FocusMixin").AnyConstructor<import("../../mixins/FocusMixin").FocusClass>;
+    export class ELEMENT extends ELEMENT_base {
+        disabled: boolean;
+        extended: boolean;
+        editable: boolean;
+        static get styles(): import("lit-element").CSSResult[];
+        get draggableItemClassMap(): {
+            extended: boolean;
+            default: boolean;
+            disabled: boolean;
+        };
+        render(): import("lit-element").TemplateResult;
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-draggable-item": DraggableItem.ELEMENT;
+    }
+}

package/dist/types/components/dropdown/Dropdown.d.ts

@@ -0,0 +1,152 @@
+/**
+ * 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/icon/Icon";
+import { LitElement, PropertyValues } from "lit-element";
+export declare namespace Dropdown {
+    type OptionMember = {
+        [key: string]: string;
+    };
+    type Option = string | OptionMember;
+    type RenderOptionMember = {
+        key: string;
+        value: string;
+        option?: Option;
+    };
+    export type EventDetail = {
+        "dropdown-focus-in": undefined;
+        "dropdown-focus-out": undefined;
+        "dropdown-selected": {
+            option: Option;
+        };
+        "dropdown-selection-removed": undefined;
+    };
+    export type MessageType = "error" | "success" | "warning";
+    export type Message = {
+        type: MessageType;
+        message: string;
+        id?: string;
+        ariaLive?: "off" | "assertive" | "polite";
+    };
+    export class MessageController {
+        determineMessageType(array: Dropdown.Message[]): MessageType;
+        filterMessagesByType(array: Dropdown.Message[], value: string): string[];
+    }
+    const ELEMENT_base: typeof LitElement & import("../../mixins/FocusMixin").AnyConstructor<import("../../mixins/FocusMixin").FocusClass>;
+    export class ELEMENT extends ELEMENT_base {
+        title: string;
+        options: Option[];
+        optionId: string;
+        optionValue: string;
+        defaultOption: Option;
+        disabled: boolean;
+        customTabIndex: number;
+        allowUnselected: boolean;
+        visibleOptions: number;
+        newMomentum: boolean;
+        compact: boolean;
+        searchable: boolean;
+        searchItem: boolean;
+        inputValue: string;
+        placeholder: string;
+        readOnly: boolean;
+        autofocus: boolean;
+        leftIcon: string;
+        trimSpace: boolean;
+        resultsTextLocalization: string;
+        helpText: string;
+        messageArr: Dropdown.Message[];
+        htmlId: string;
+        clearAriaLabel: string;
+        clearIconHeight: string;
+        arrowAriaLabel: string;
+        popupChevronAriaHidden: string;
+        ariaLabel: string;
+        searchResultAriaLabel: string;
+        ariaLabelForDropdown: string;
+        private renderOptions;
+        private selectedKey;
+        private expanded;
+        private focusedIndex;
+        label: HTMLLabelElement;
+        input?: HTMLInputElement;
+        optionsList: HTMLUListElement;
+        optionsListItems?: HTMLLIElement[];
+        private readonly messageController;
+        private lastMaxHeight;
+        connectedCallback(): void;
+        disconnectedCallback(): void;
+        protected firstUpdated(changedProperties: PropertyValues): void;
+        protected updated(changedProperties: PropertyValues): void;
+        private notifySearchResultCount;
+        private setInitialValue;
+        private getOptionValue;
+        private getOptionId;
+        private isOptionObject;
+        updateRenderOptions(): void;
+        updateListDOM(): Promise<void>;
+        resizeDropdownList(): Promise<void>;
+        protected handleFocusIn(event: Event): void;
+        protected handleFocusOut(event: Event): void;
+        static get styles(): import("lit-element").CSSResult[];
+        get filteredOptions(): RenderOptionMember[] | {
+            key: string;
+            value: string;
+            disabled: boolean;
+        }[];
+        get messageType(): Dropdown.MessageType | null;
+        get messages(): string[] | null;
+        private setVisualListbox;
+        private updateOnNextFrame;
+        private setInputValue;
+        private shouldChangeButton;
+        toggleVisualListBox(e: any): void;
+        handleRemoveAll(event: MouseEvent): void;
+        private removeAllSelected;
+        setupEvents(): void;
+        teardownEvents(): void;
+        expand(): void;
+        collapse(): void;
+        toggle(): void;
+        select(): void;
+        onOutsideClick: (e: MouseEvent) => void;
+        onKeyDown: (e: KeyboardEvent) => void;
+        onLabelClick(): void;
+        focusFirst(): void;
+        focusLast(): void;
+        focusNext(): void;
+        focusPrev(): void;
+        focusToIndex(n: number): void;
+        focusToIndexWithOption(o: RenderOptionMember): void;
+        focusReset(): void;
+        scrollToIndex(n: number): Promise<void>;
+        getOptionKeyValuePair(option: Option): {
+            key: string;
+            value: string;
+        };
+        get labelTitle(): string;
+        get dropDownClassMap(): {
+            [x: string]: boolean;
+            "md-dropdown__expanded": boolean;
+            "md-new-dropdown": boolean;
+        };
+        handleInput(event: Event): void;
+        private notifyInputValueChanged;
+        helpTextTemplate(): {};
+        messagesTemplate(): {};
+        iconTemplate(): import("lit-element").TemplateResult;
+        clearButtonTemplate(): import("lit-element").TemplateResult;
+        arrowButtonTemplate(): import("lit-element").TemplateResult;
+        render(): import("lit-element").TemplateResult;
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-dropdown": Dropdown.ELEMENT;
+    }
+}

package/dist/types/components/editable-textfield/EditableTextfield.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 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 { numInputTypes } from "../../utils/enums";
+import { CSSResultArray, LitElement, PropertyValues } from "lit-element";
+import "@/components/input/Input";
+import { Input } from "../input/Input";
+export declare const alignment: readonly ["left", "right", "center"];
+export declare namespace EditableTextfield {
+    type Alignment = (typeof alignment)[number];
+    type InputType = (typeof numInputTypes)[number];
+    class ELEMENT extends LitElement {
+        alignment: EditableTextfield.Alignment;
+        disabled: boolean;
+        isEditing: boolean;
+        maxLines: string;
+        content: string;
+        message: Input.Message | undefined;
+        alert: boolean;
+        hideMessage: boolean;
+        pattern: string;
+        type: EditableTextfield.InputType[number] | null;
+        ariaLabel: string;
+        ariaDescribedBy: string;
+        private readonly messageController;
+        editableField: HTMLElement | undefined;
+        connectedCallback(): void;
+        disconnectedCallback(): void;
+        protected firstUpdated(changedProperties: PropertyValues): void;
+        protected updated(changedProperties: PropertyValues): void;
+        reportValidity: () => void;
+        checkValidity: (input: string) => boolean;
+        handleFocus: () => void;
+        setRange(): void;
+        handleKeydown: (e: KeyboardEvent) => void;
+        handleBlur: () => void;
+        handleValidation(): void;
+        showAlert(): void;
+        static get styles(): CSSResultArray;
+        get overflowStyles(): string | false | 0;
+        messagesTemplate(): {};
+        render(): import("lit-element").TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-editable-field": EditableTextfield.ELEMENT;
+    }
+}

package/dist/types/components/favorite/Favorite.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 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/icon/Icon";
+import { LitElement } from "lit-element";
+export declare namespace Favorite {
+    const ELEMENT_base: typeof LitElement & import("../../mixins/FocusMixin").AnyConstructor<import("../../mixins/FocusMixin").FocusClass>;
+    export class ELEMENT extends ELEMENT_base {
+        disabled: boolean;
+        checked: boolean;
+        value: string;
+        id: string;
+        label: string;
+        private customId;
+        connectedCallback(): void;
+        static get styles(): import("lit-element").CSSResult[];
+        handleFavorite(): void;
+        handleElectKeyDown(event: KeyboardEvent): void;
+        disconnectedCallback(): void;
+        get favoriteClassMap(): {
+            "md-favorite--active": boolean;
+            "md-favorite--disabled": boolean;
+        };
+        render(): import("lit-element").TemplateResult;
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-favorite": Favorite.ELEMENT;
+    }
+}

package/dist/types/components/floating-modal/FloatingMinimizedModal.d.ts

@@ -0,0 +1,53 @@
+import "@/components/button/Button";
+import "@/components/icon/Icon";
+import "@interactjs/actions/drag";
+import "@interactjs/actions/resize";
+import "@interactjs/auto-start";
+import "@interactjs/modifiers";
+import { LitElement, PropertyValues } from "lit-element";
+export declare namespace FloatingMinimizedModal {
+    const ELEMENT_base: typeof LitElement & import("../../mixins/FocusMixin").AnyConstructor<import("../../mixins/FocusMixin").FocusClass>;
+    export class ELEMENT extends ELEMENT_base {
+        heading: string;
+        label: string;
+        show: boolean;
+        closeAriaLabel: string;
+        minimize: boolean;
+        minPosition: {
+            x: number;
+            y: number;
+        } | undefined;
+        container?: HTMLDivElement;
+        header: HTMLDivElement;
+        private dragOccured;
+        private containerTransform;
+        private applyInitialPosition;
+        static get styles(): import("lit-element").CSSResult[];
+        connectedCallback(): void;
+        protected updated(changedProperties: PropertyValues): void;
+        private getInitialPosition;
+        private isNewPositionNotSame;
+        private setInitialTargetPosition;
+        private setFocusOnContainer;
+        private cleanContainerStyles;
+        private getContainerTransform;
+        private setContainerRect;
+        private setInteractInstance;
+        handleKeyDown(event: KeyboardEvent): void;
+        handleClose(event: MouseEvent): void;
+        handleMinimize(event: Event): void;
+        private getTransformValues;
+        private dragMoveListener;
+        private dragEndListener;
+        private setTargetPosition;
+        private destroyInteractInstance;
+        disconnectedCallback(): void;
+        render(): import("lit-element").TemplateResult;
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-floating-modal-minimized": FloatingMinimizedModal.ELEMENT;
+    }
+}

package/dist/types/components/floating-modal/FloatingModal.d.ts

@@ -0,0 +1,70 @@
+import "@/components/button/Button";
+import "@/components/icon/Icon";
+import "@interactjs/actions/drag";
+import "@interactjs/actions/resize";
+import "@interactjs/auto-start";
+import "@interactjs/modifiers";
+import { LitElement, PropertyValues } from "lit-element";
+import "./FloatingMinimizedModal";
+export declare namespace FloatingModal {
+    const ELEMENT_base: typeof LitElement & import("../../mixins/SlottedMixin").AnyConstructor<import("../../mixins/SlottedMixin").SlotableClass & import("../../mixins/SlottedMixin").SlotableInterface> & import("../../mixins/FocusMixin").AnyConstructor<import("../../mixins/FocusMixin").FocusClass>;
+    export class ELEMENT extends ELEMENT_base {
+        heading: string;
+        label: string;
+        show: boolean;
+        aspectRatio: boolean;
+        fixed: boolean;
+        full: boolean;
+        closeAriaLabel: string;
+        resizeAriaLabel: string;
+        maximizeScreenLabel: string;
+        minimizeAriaLabel: string;
+        private minimize;
+        position: {
+            x: number;
+            y: number;
+        } | undefined;
+        minPosition: {
+            x: number;
+            y: number;
+        } | undefined;
+        minimizable: boolean;
+        containerRect: DOMRect | null;
+        private dragOccured;
+        container?: HTMLDivElement;
+        body: HTMLDivElement;
+        header: HTMLDivElement;
+        minimizedHeader: HTMLDivElement;
+        headerSlot: HTMLSlotElement;
+        private containerTransform;
+        private applyInitialPosition;
+        static get styles(): import("lit-element").CSSResult[];
+        protected updated(changedProperties: PropertyValues): void;
+        private isNewPositionNotSame;
+        private setInitialTargetPosition;
+        private cleanContainerStyles;
+        private getContainerTransform;
+        private setContainerRect;
+        private setInteractInstance;
+        handleClose(event: MouseEvent): void;
+        handleMinimize(): void;
+        handleToggleExpandCollapse(): void;
+        private resizeMoveListener;
+        private resizeEndListener;
+        private getInitialPosition;
+        private getTransformValues;
+        private dragMoveListener;
+        private dragEndListener;
+        private setTargetPosition;
+        private destroyInteractInstance;
+        disconnectedCallback(): void;
+        renderedCallback(): void;
+        render(): import("lit-element").TemplateResult;
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-floating-modal": FloatingModal.ELEMENT;
+    }
+}

package/dist/types/components/form/Form.d.ts

@@ -0,0 +1,49 @@
+import { LitElement } from "lit-element";
+export declare namespace Form {
+    export type Method = "GET" | "get" | "POST" | "post" | "dialog";
+    export type Enctype = "application/x-www-form-urlencoded" | "multipart/form-data" | "text/plain";
+    export type Target = "_self" | "_blank" | "_parent" | "_top";
+    export type SubmittableElement = HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
+    const ELEMENT_base: typeof LitElement & import("../../mixins/SlottedMixin").AnyConstructor<import("../../mixins/SlottedMixin").SlotableClass & import("../../mixins/SlottedMixin").SlotableInterface>;
+    export class ELEMENT extends ELEMENT_base {
+        rel: string;
+        name: string;
+        action: string;
+        label: string;
+        method: Method;
+        target: Target;
+        enctype: Enctype;
+        novalidate: boolean;
+        charset: string;
+        isvalid: boolean;
+        token: string;
+        allowRedirect: boolean;
+        autofillname: string;
+        protected form: HTMLFormElement;
+        private formElement;
+        private get formMethod();
+        private isSubmittable;
+        private isDisabled;
+        private findSubmittable;
+        private validated;
+        handleSubmit: (event: Event) => void;
+        handleFormSubmit: (event: Event) => void;
+        private submitForm;
+        private get submitButton();
+        disconnectedCallback(): void;
+        private deleteWrappedForm;
+        private cleanupWrappedForms;
+        private createWrappedForm;
+        private teardownEvents;
+        private setupEvents;
+        private setupSubmittable;
+        protected slottedChanged(): void;
+        render(): import("lit-element").TemplateResult;
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-form": Form.ELEMENT;
+    }
+}

package/dist/types/components/grabber/Grabber.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/icon/Icon";
+import { LitElement } from "lit-element";
+export declare namespace Grabber {
+    const ELEMENT_base: typeof LitElement & import("../../mixins/FocusMixin").AnyConstructor<import("../../mixins/FocusMixin").FocusClass>;
+    export class ELEMENT extends ELEMENT_base {
+        /**
+         * aria label of unchecked grabber
+         */
+        label: string;
+        /**
+         * aria label of checked grabber
+         */
+        checkedLabel: string;
+        /**
+         * If true, the grabber is hovered. grabber-hover-changed event is dispatched on hover change
+         */
+        hovered: boolean;
+        /**
+         * If true, the grabber is disabled
+         */
+        disabled: boolean;
+        /**
+         * If true, the grabber is checked
+         */
+        checked: boolean;
+        /**
+         * If true, the grabber is visible. Grabber will also be visible if it is focused
+         */
+        visible: boolean;
+        /**
+         * True when grabber has keyboard focus
+         */
+        focused: boolean;
+        /**
+         * Alignment that says if the `md-grabbewr` is being used for leading, trailing, top or bottom
+         *
+         * Default: leading
+         */
+        alignment: "leading" | "trailing" | "top" | "bottom";
+        connectedCallback(): void;
+        disconnectedCallback(): void;
+        static get styles(): import("lit-element").CSSResult[];
+        toggleGrabber(): void;
+        handleMouseDown(): void;
+        handleKeyDown(e: KeyboardEvent): void;
+        handleMouseEnter(): void;
+        handleMouseLeave(): void;
+        handleFocus(): void;
+        handleBlur(): void;
+        dispatchHoverEvent(): void;
+        get collapsed(): boolean;
+        get grabberClassMap(): {
+            [x: string]: boolean | "top" | "bottom" | "leading" | "trailing";
+            "md-grabber--active": boolean;
+            "md-grabber--disabled": boolean;
+            visible: boolean;
+        };
+        get iconName(): "arrow-up-bold" | "arrow-down-bold" | "arrow-left-bold" | "arrow-right-bold";
+        render(): import("lit-element").TemplateResult;
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-grabber": Grabber.ELEMENT;
+    }
+}

package/dist/types/components/help-text/HelpText.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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";
+import { Input } from "../input/Input";
+export declare namespace HelpText {
+    class ELEMENT extends LitElement {
+        message: string;
+        messageType: Input.MessageType | undefined;
+        id: string;
+        ariaLive: "off" | "assertive" | "polite";
+        get inputMessageClassMap(): {
+            [x: string]: boolean;
+        };
+        static get styles(): import("lit-element").CSSResult[];
+        getIconName(): "" | "check-circle-badge-filled" | "error-legacy-badge-filled" | "warning-badge-filled" | "info-badge-filled";
+        render(): import("lit-element").TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-help-text": HelpText.ELEMENT;
+    }
+}