@momentum-ui/web-components 2.16.8 → 2.16.10

package/dist/types/components/popover/Popover.d.ts

@@ -0,0 +1,184 @@
+/**
+ * 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";
+import { PlacementType, PopoverRoleType } from "./Popover.types";
+export declare namespace Popover {
+    const ELEMENT_base: typeof LitElement & import("@/mixins/FocusTrapMixin").AnyConstructor<import("@/mixins/FocusTrapMixin").FocusTrapClass & import("@/mixins/FocusTrapMixin").FocusTrapInterface & import("../../mixins/FocusMixin").FocusClass>;
+    /**
+     * @fires popover-open-changed - Fired when the popover is opened or closed.
+     */
+    export class ELEMENT extends ELEMENT_base {
+        /**
+         * The placement of the popover relative to the trigger element.
+         *
+         * This property specifies where the popover should appear in relation to the trigger element.
+         * The default placement is "bottom", but it can be customized to other positions such as "top", "left", or "right".
+         *
+         * @type {PlacementType}
+         */
+        placement: PlacementType;
+        /**
+         * Indicates whether the popover is open.
+         *
+         * This property controls the visibility of the popover. When set to true, the popover is displayed.
+         * When set to false, the popover is hidden.
+         *
+         * @type {boolean}
+         */
+        isOpen: boolean;
+        /**
+         * Indicates whether the arrow should be shown on the popover.
+         *
+         * This property controls the visibility of the arrow on the popover. When set to true, the arrow is displayed.
+         * When set to false, the arrow is hidden.
+         *
+         * @type {boolean}
+         */
+        showArrow: boolean;
+        /**
+         * Indicates whether the close button should be shown on the popover.
+         *
+         * This property controls the visibility of the close button on the popover. When set to true, the close button is displayed.
+         * When set to false, the close button is hidden.
+         *
+         * @type {boolean}
+         */
+        showClose?: boolean | undefined;
+        /**
+         * Indicates whether the popover is interactive.
+         *
+         * When set to true, the popover will allow user interactions within it.
+         * This property is used to determine if the popover should trap focus.
+         *
+         * @type {boolean}
+         */
+        interactive: boolean;
+        shouldWrapFocus: () => boolean;
+        /**
+         * The role attribute for the popover.
+         *
+         * This property specifies the `role` attribute for the popover, which defines its role in the accessibility tree.
+         * The default role is "dialog", but it can be customized to "dialog", "menu" or "tooltip.
+         *
+         * @type {PopoverRoleType}
+         */
+        role: PopoverRoleType;
+        /**
+         * The accessible label for the popover.
+         *
+         * This property specifies the `aria-label` attribute for the popover, which provides an accessible name for the popover element.
+         * It is used by screen readers to announce the purpose of the popover to users with visual impairments.
+         *
+         * @type {string | null}
+         */
+        ariaLabel: string | null;
+        /**
+         * The offset distance (in pixels) from the trigger element.
+         *
+         * This property specifies the distance between the trigger element and the popover.
+         * It is used to control the spacing between the trigger element and the popover when the popover is displayed.
+         *
+         * @type {number}
+         */
+        offsetDistance: number;
+        /**
+         * The slot element that contains the trigger element for the popover.
+         *
+         * This property is used to query the slot with the name "triggerElement" and store a reference to it.
+         * The trigger element is the element that, when interacted with, will open or close the popover.
+         *
+         * @type {HTMLSlotElement}
+         */
+        triggerSlot: HTMLSlotElement;
+        /**
+         * The popover container element.
+         *
+         * This property is used to query the popover container element in the DOM.
+         * The popover container is the main element that contains the popover content.
+         *
+         * @type {HTMLDivElement}
+         */
+        popoverContainer: HTMLDivElement;
+        /**
+         * The popover arrow element.
+         *
+         * This property is used to query the popover arrow element in the DOM.
+         * The popover arrow is the element that visually connects the popover to the trigger element.
+         *
+         * @type {HTMLDivElement}
+         */
+        popoverArrow: HTMLDivElement;
+        /**
+         * The event that triggers the popover.
+         *
+         * This property specifies the event that will trigger the popover to open or close.
+         * The default event is "click", but it can be customized to other events such as "mouseenter" or "focus".
+         *
+         * @type {string}
+         */
+        trigger?: string;
+        /**
+         * The trigger element for the popover.
+         *
+         * This property holds a reference to the trigger element that, when interacted with, will open or close the popover.
+         *
+         * @type {HTMLElement | null}
+         */
+        private triggerElement;
+        /**
+         * The Popper.js instance used to manage the positioning of the popover.
+         *
+         * This instance is created when the popover is opened and destroyed when the popover is closed.
+         * It is used to handle the positioning and alignment of the popover relative to the trigger element.
+         */
+        private popperInstance;
+        /**
+         * If mouse is over the trigger element or popover container.
+         *
+         * This property is used when both focus and mouse triggers are present
+         * When focus leaves the trigger element if mouse is hovering we should not close the popover
+         */
+        private isMouseOver;
+        static get styles(): import("lit-element").CSSResult[];
+        connectedCallback(): void;
+        disconnectedCallback(): void;
+        private setupTriggerEvents;
+        onOutsideOverlayClick: (event: MouseEvent) => void;
+        onWindowBlurEvent: () => void;
+        onOutsideOverlayKeydown: (event: KeyboardEvent) => Promise<void>;
+        private handleTriggerElementSlotChange;
+        private onContentSlotChanged;
+        onTriggerElementClicked: () => void;
+        onTriggerElementKeydown: (event: KeyboardEvent) => Promise<void>;
+        onFocusInTrigger: () => void;
+        onFocusOutTrigger: () => void;
+        onMouseEnteredTriggerOrPopup: (_event: MouseEvent) => void;
+        onMouseLeaveTriggerOrPopup: (_event: MouseEvent) => void;
+        private shouldStayOpenOnTriggerFocus;
+        private setIsOpenDebounced;
+        protected firstUpdated(changedProperties: PropertyValues): void;
+        private focusInsideOverlay;
+        private focusOnTrigger;
+        private toggleOverlay;
+        private handleCreatePopperFirstUpdate;
+        private createInstance;
+        private destroyInstance;
+        protected updated(changedProperties: PropertyValues): void;
+        private isOpenUpdated;
+        private dispatchPopoverIsOpenChanged;
+        render(): import("lit-element").TemplateResult;
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-popover": Popover.ELEMENT;
+    }
+}

package/dist/types/components/popover/Popover.types.d.ts

@@ -0,0 +1,8 @@
+export declare const Placement: 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 ARROW_HEIGHT = 16;
+export declare const Strategy: readonly ["fixed", "absolute"];
+export declare const PopoverRole: readonly ["dialog", "menu", "tooltip"];
+export declare const Triggers: readonly ["click", "mouseenter", "manual"];
+export type PlacementType = (typeof Placement)[number];
+export type StrategyType = (typeof Strategy)[number];
+export type PopoverRoleType = (typeof PopoverRole)[number];

package/dist/types/components/progress-bar/ProgressBar.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 ProgressBar {
+    type BarFormat = "none" | "fraction" | "percentage";
+    type BarType = "determinate" | "indeterminate";
+    class ELEMENT extends LitElement {
+        dynamic: boolean;
+        color: string;
+        label: string;
+        displayFormat: ProgressBar.BarFormat;
+        type: ProgressBar.BarType;
+        min: number;
+        max: number;
+        value: number;
+        adjustedValue: number;
+        valueFraction: number;
+        meterWidth: string;
+        connectedCallback(): void;
+        getDisplayFormat: () => string | null;
+        getColor: () => string | undefined;
+        static get styles(): import("lit-element").CSSResult[];
+        render(): import("lit-element").TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-progress-bar": ProgressBar.ELEMENT;
+    }
+}

package/dist/types/components/radio/Radio.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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 Radio {
+    const ELEMENT_base: typeof LitElement & import("../../mixins/FocusMixin").AnyConstructor<import("../../mixins/FocusMixin").FocusClass>;
+    export class ELEMENT extends ELEMENT_base {
+        tabIndex: number;
+        label: string;
+        value: string;
+        ariaLabel: string;
+        autofocus: boolean;
+        private _disabled;
+        get disabled(): boolean;
+        set disabled(value: boolean);
+        private _checked;
+        get checked(): boolean;
+        set checked(value: boolean);
+        protected firstUpdated(changedProperties: PropertyValues): void;
+        static get styles(): import("lit-element").CSSResult[];
+        render(): import("lit-element").TemplateResult;
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-radio": Radio.ELEMENT;
+    }
+}

package/dist/types/components/radio/RadioGroup.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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 RadioGroup {
+    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 {
+        label: string;
+        checked: number;
+        alignment: "horizontal" | "vertical";
+        radioSlot?: HTMLSlotElement;
+        private _disabled;
+        get disabled(): boolean;
+        set disabled(value: boolean);
+        protected firstUpdated(changedProperties: PropertyValues): void;
+        protected updated(changedProperties: PropertyValues): void;
+        get selectedRadioValue(): string;
+        private notifySelectedChange;
+        connectedCallback(): void;
+        disconnectedCallback(): void;
+        private setFirstChecked;
+        private findRadioIndex;
+        private findCheckedRadioIndex;
+        private setChecked;
+        private switchRadioOnArrowPress;
+        private isRadioDisabled;
+        handleClick(event: MouseEvent): false | undefined;
+        handleKeyDown(event: KeyboardEvent): false | undefined;
+        get slotElement(): HTMLSlotElement | undefined;
+        static get styles(): import("lit-element").CSSResult[];
+        render(): import("lit-element").TemplateResult;
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-radiogroup": RadioGroup.ELEMENT;
+    }
+}

package/dist/types/components/sass-stats/SassStats.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, PropertyValues } from "lit-element";
+export declare class SassStats extends LitElement {
+    component: string;
+    size: string;
+    gzipSize: string;
+    selectors: string;
+    declarations: string;
+    repeatedSelectors: never[];
+    static get styles(): import("lit-element").CSSResult[];
+    protected firstUpdated(changedProperties: PropertyValues): void;
+    private loopInstances;
+    private getContrast;
+    private formatNumber;
+    private fetchComponentStats;
+    connectedCallback(): void;
+    render(): import("lit-element").TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "sass-stats": SassStats;
+    }
+}

package/dist/types/components/slider/Slider.d.ts

@@ -0,0 +1,47 @@
+import { LitElement, PropertyValues } from "lit-element";
+export declare namespace Slider {
+    const ELEMENT_base: typeof LitElement & import("../../mixins/FocusMixin").AnyConstructor<import("../../mixins/FocusMixin").FocusClass>;
+    export class ELEMENT extends ELEMENT_base {
+        private _disabled;
+        private _now;
+        min: number;
+        max: number;
+        hideValue: boolean;
+        get now(): number;
+        set now(value: number);
+        text: number;
+        label: string;
+        step: number;
+        get disabled(): boolean;
+        set disabled(value: boolean);
+        private dragging;
+        private currentMouseEvent?;
+        private get pointerPosition();
+        private calculateHandlePosition;
+        private moveSliderTo;
+        private trackMouseEvent;
+        private ticksTemplate;
+        private displayValueTemplate;
+        private notifyChanges;
+        private notifyChanging;
+        handleMouseDown(event: MouseEvent): void;
+        handleKeyDown(event: KeyboardEvent): void;
+        get sliderPointerStyleMap(): {
+            left: string;
+        };
+        get sliderSelectionStyleMap(): {
+            right: string;
+        };
+        static get styles(): import("lit-element").CSSResult[];
+        protected firstUpdated(changedProperties: PropertyValues): void;
+        connectedCallback(): void;
+        disconnectedCallback(): void;
+        render(): import("lit-element").TemplateResult;
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-slider": Slider.ELEMENT;
+    }
+}

package/dist/types/components/spinner/Spinner.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 Spinner {
+    class ELEMENT extends LitElement {
+        size: number;
+        static get styles(): import("lit-element").CSSResult[];
+        get spinnerStyleMap(): {
+            width: string;
+            height: string;
+        };
+        render(): import("lit-element").TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-spinner": Spinner.ELEMENT;
+    }
+}

package/dist/types/components/table/Table.d.ts

@@ -0,0 +1,57 @@
+/**
+ * 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";
+import { nothing, TemplateResult } from "lit-html";
+import Papa from "papaparse";
+export declare const formatType: readonly ["number", "default"];
+type Warn = {
+    [key: number]: any;
+};
+export declare namespace Table {
+    type Format = (typeof formatType)[number];
+    class ELEMENT extends LitElement {
+        tabledata: string;
+        zebra: boolean;
+        clean: boolean;
+        sorting: boolean;
+        nodata: string;
+        stickheader: boolean;
+        label: string;
+        noBorders: boolean;
+        format: Table.Format;
+        warning: (any | Warn)[];
+        errors: (any | Warn)[];
+        private sort;
+        csvData: any;
+        rowTable?: HTMLTableRowElement[];
+        headerRow: any;
+        results: any;
+        config: Papa.ParseConfig;
+        connectedCallback(): void;
+        get rowItem(): HTMLTableRowElement[] | undefined;
+        linkCellItems(): void;
+        sortTab(ev: Event, key: any): void;
+        protected update(changedProperties: PropertyValues): void;
+        static get styles(): import("lit-element").CSSResult[];
+        get tableClassMap(): {
+            "md-table--clean": boolean;
+            "md-table--no-borders": boolean;
+            "md-table--stripped": boolean;
+            "md-table--sorting": boolean;
+        };
+        getSortTemplate(key: any): TemplateResult | typeof nothing;
+        render(): TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-table": Table.ELEMENT;
+    }
+}
+export {};

package/dist/types/components/table-advanced/TableAdvanced.d.ts

@@ -0,0 +1,169 @@
+/**
+ * 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 "@/components/menu-overlay/MenuOverlay";
+import { LitElement, PropertyValues } from "lit-element";
+import { nothing, TemplateResult } from "lit-html";
+import { Evt, TemplateCallback, TemplateInfo } from "./src/decorators";
+import { Filter } from "./src/filter";
+export declare namespace TableAdvanced {
+    const ELEMENT_base: typeof LitElement & import("@/mixins/FocusTrapMixin").AnyConstructor<import("@/mixins/FocusTrapMixin").FocusTrapClass & import("@/mixins/FocusTrapMixin").FocusTrapInterface & import("../../mixins/FocusMixin").FocusClass>;
+    /**
+     * @element md-table-advanced
+     * @fires md-table-advanced-change
+     */
+    export class ELEMENT extends ELEMENT_base {
+        config: Config | string;
+        data: Data | string;
+        isRowFocusable: string;
+        "md-table-advanced-change": Evt<ChangeEvent>;
+        tableConfig: Config;
+        tableData: Data;
+        private error;
+        private COLS;
+        private ROWS;
+        private updCols;
+        private updRows;
+        private dragRow;
+        private dropRow;
+        private drops;
+        private dragRowElem;
+        private dragCol;
+        private dropCol;
+        private isResizing;
+        private isSelectable;
+        private selected;
+        private expandedRowIdx;
+        private dragover;
+        tableRaws?: HTMLTableRowElement[];
+        disconnectedCallback(): void;
+        connectedCallback(): void;
+        protected update(changedProperties: PropertyValues): void;
+        private updateTableData;
+        private updateTableConfig;
+        private populateColumns;
+        private populateData;
+        private validateData;
+        private populateTemplate;
+        private setDefaultFilterAndSort;
+        private populateTable;
+        private updateDataInTable;
+        private onDropRow;
+        private onDropCol;
+        private sort;
+        private filter;
+        private selectRow;
+        private clearSelection;
+        private collapseToggle;
+        private eX;
+        private onResize;
+        render(): TemplateResult;
+        private ariaSortOrder;
+        private renderHead;
+        sortIconTemplate(sortOrder: SortOrder): TemplateResult | typeof nothing;
+        private renderCol;
+        private renderColDrag;
+        private renderColResize;
+        private renderBody;
+        private renderRow;
+        static get styles(): import("lit-element").CSSResult[];
+    }
+    type ColId = string;
+    export type Data = {
+        csv: string;
+    } | {
+        list: string[];
+    } | {
+        list2d: string[][];
+    };
+    export type Config = {
+        isStickyHeader?: boolean;
+        isInfiniteScroll?: boolean;
+        cols: {
+            define: (ColOptions | ColOptionsGroup)[];
+            isDraggable?: boolean;
+            isResizable?: boolean;
+            collapse?: ColId;
+        };
+        rows?: {
+            isDraggable?: boolean;
+            selectable?: "none" | "single" | "multiple";
+        };
+        cellTemplates?: Record<string, CellTemplate>;
+        default?: {
+            col?: Pick<ColOptions, "filters" | "sorter">;
+            sort?: {
+                colId: ColId;
+                order: SortOrder;
+            };
+            filter?: {
+                colId: ColId;
+                input: string;
+                selectedIndex: number;
+            };
+        };
+        head?: {
+            caption?: string;
+            summary?: string;
+            tableDescription?: string;
+        };
+    };
+    type ColOptions = {
+        id: string;
+        title: string;
+        width?: string;
+        sorter?: "byString" | "byNumber" | SortComparator;
+        filters?: "forString" | "forNumber" | Filter.Options[];
+        isHeader?: boolean;
+    };
+    type ColOptionsGroup = {
+        groupName: string;
+        children: ColOptions[];
+    };
+    type SortOrder = "default" | "ascending" | "descending";
+    type SortComparator = (a: string, b: string, direction: 1 | -1) => number;
+    type CellTemplate = {
+        templateName: string;
+        contentUse?: "insert" | "replace";
+        contentCb?: CellContentCallback;
+        templateCb?: TemplateCallback;
+    };
+    type CellContentCallback = (p: TemplateInfo) => string;
+    export type ChangeEvent = {
+        detail: {
+            type: "filter-on";
+            filter: Filter.Options;
+            input: string;
+        } | {
+            type: "filter-off";
+            filter: Filter.Options;
+        } | {
+            type: "sort";
+            order: SortOrder;
+        } | {
+            type: "select";
+            index: number;
+        } | {
+            type: "multi-select";
+            rows: number[];
+        } | {
+            type: "expand";
+            row: number;
+        } | {
+            type: "collapse";
+            row: number;
+        };
+    };
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-table-advanced": TableAdvanced.ELEMENT;
+    }
+}

package/dist/types/components/table-advanced/src/decorators.d.ts

@@ -0,0 +1,32 @@
+export declare function debounce(ms?: number): (target: any, key: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function evt(): (protoOrDescriptor: any, name: string) => any;
+type Detail<T> = {
+    detail: T;
+};
+export declare class Evt<T extends Detail<V>, V = any> {
+    private target;
+    private eventName;
+    constructor(target: HTMLElement, eventName: string);
+    emit(value: T extends Detail<infer U> ? U : never, options?: {
+        bubbles?: boolean;
+        composed?: boolean;
+        cancelable?: boolean;
+    }): void;
+}
+import { Part } from "lit-html";
+export type TemplateInfo = {
+    content: string;
+    insertIndex: number;
+    col: number;
+    row: number;
+};
+type TCallback = TemplateInfo & {
+    fragment: DocumentFragment;
+};
+type TPayload = TemplateInfo & {
+    template: HTMLTemplateElement;
+    cb: TemplateCallback;
+};
+export type TemplateCallback = (p: TCallback) => void;
+export declare const templateCallback: (p: TPayload) => (part: Part) => void;
+export {};