@loadsmart/miranda-wc 2.0.0 → 2.1.0

package/dist/components/steps/steps.d.ts

@@ -0,0 +1,33 @@
+import type { PropertyValues } from 'lit';
+import { Component } from '../component';
+export type StepsProps = {
+    /**
+     * Controlled value of the selected step.
+     */
+    activeStep?: string;
+};
+export type NavigateStepEventDetail = string;
+export declare class Steps extends Component {
+    #private;
+    static styles: import("lit").CSSResult[][];
+    static get properties(): {
+        activeStep: {
+            type: StringConstructor;
+            attribute: string;
+            reflect: boolean;
+        };
+    };
+    /**
+     * Controlled value of the selected step.
+     */
+    activeStep: StepsProps['activeStep'];
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected update(changedProperties: PropertyValues<this>): void;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-steps': Steps;
+    }
+}

package/dist/components/steps/steps.styles.d.ts

@@ -0,0 +1,2 @@
+export declare function stepsStyles(): import("lit").CSSResult[];
+export declare function stepStyles(): import("lit").CSSResult[];

package/dist/components/switch/index.d.ts

@@ -0,0 +1,2 @@
+export { Switch } from './switch';
+export type { SwitchProps, SwitchChangeEventDetail, SwitchSize, } from './switch';

package/dist/components/switch/switch.d.ts

@@ -0,0 +1,62 @@
+import type { PropertyValues } from 'lit';
+import { Component } from '../component';
+export type SwitchSize = 'default' | 'large';
+export type SwitchChangeEventDetail = {
+    name?: string;
+    checked: boolean;
+};
+export interface SwitchProps {
+    name?: string;
+    disabled?: boolean;
+    checked?: boolean;
+    size?: SwitchSize;
+    'm-change'?: (event: CustomEvent<SwitchChangeEventDetail>) => void;
+}
+export declare class Switch extends Component implements SwitchProps {
+    #private;
+    static styles: import("lit").CSSResult[][];
+    static get properties(): {
+        name: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            reflect: boolean;
+        };
+        checked: {
+            type: BooleanConstructor;
+            reflect: boolean;
+        };
+        size: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+    };
+    /**
+     * Switch name.
+     */
+    name: SwitchProps['name'];
+    /**
+     * Option to disable the switch.
+     */
+    disabled: SwitchProps['disabled'];
+    /**
+     * Option to check the switch.
+     */
+    checked: SwitchProps['checked'];
+    /**
+     * Switch size.
+     */
+    size: SwitchProps['size'];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    updated(changedProperties: PropertyValues<this>): void;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-switch': Switch;
+    }
+}

package/dist/components/{focus-trap/focus-trap.styles.d.ts → switch/switch.styles.d.ts}

@@ -1,3 +1,2 @@
 declare function styles(): import("lit").CSSResult[];
 export default styles;
-//# sourceMappingURL=focus-trap.styles.d.ts.map

package/dist/components/table/index.d.ts

@@ -0,0 +1,11 @@
+export { Table, defaultTableProps } from './table';
+export { TableHead } from './table-head';
+export { TableHeadCell, defaultTableHeadCellProps } from './table-head-cell';
+export { TableBody } from './table-body';
+export { TableFoot } from './table-foot';
+export { TableRow } from './table-row';
+export { TableCell, defaultTableCellProps } from './table-cell';
+export { TableToolbar } from './table-toolbar';
+export { TableFeedback } from './table-feedback';
+export { TableActions } from './table-actions';
+export type { TableProps, TableCellProps, TableHeadCellProps, TableCellAlignment, TableSize, TableSortDirection, TableHeadCellSortEventDetails, } from './table.types';

package/dist/components/table/table-actions.d.ts

@@ -0,0 +1,27 @@
+import { LitElement } from 'lit';
+import type { TableActionsProps } from './table.types';
+export declare class TableActions extends LitElement implements TableActionsProps {
+    static styles: import("lit").CSSResult[];
+    static get properties(): {
+        slot: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        role: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        sticky: {
+            type: BooleanConstructor;
+            reflect: boolean;
+        };
+    };
+    sticky: TableActionsProps['sticky'];
+    constructor();
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-table-actions': TableActions;
+    }
+}

package/dist/components/table/table-body.d.ts

@@ -0,0 +1,21 @@
+import { LitElement } from 'lit';
+export declare class TableBody extends LitElement {
+    static styles: import("lit").CSSResult[];
+    static get properties(): {
+        slot: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        role: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+    };
+    constructor();
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-table-body': TableBody;
+    }
+}

package/dist/components/table/table-cell.d.ts

@@ -0,0 +1,42 @@
+import { LitElement } from 'lit';
+import type { PropertyValues } from 'lit';
+import type { TableCellProps } from './table.types';
+export declare const defaultTableCellProps: {
+    readonly alignment: "left";
+    readonly verticalAlign: "middle";
+};
+export declare class TableCell extends LitElement implements TableCellProps {
+    static styles: import("lit").CSSResult[];
+    static get properties(): {
+        slot: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        role: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        alignment: {
+            type: StringConstructor;
+        };
+        verticalAlign: {
+            type: StringConstructor;
+            attribute: string;
+        };
+    };
+    alignment: TableCellProps['alignment'];
+    verticalAlign: TableCellProps['verticalAlign'];
+    constructor();
+    /**
+     * TODO: This role validation is not necessary anymore since we have a dedicated table-head-cell now.
+     * We can remove it for the next major release to avoid breaking changes.
+     */
+    protected firstUpdated(): void;
+    protected update(changedProperties: PropertyValues<TableCellProps>): void;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-table-cell': TableCell;
+    }
+}

package/dist/components/table/table-feedback.d.ts

@@ -0,0 +1,16 @@
+import { LitElement } from 'lit';
+export declare class TableFeedback extends LitElement {
+    static get properties(): {
+        slot: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+    };
+    constructor();
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-table-feedback': TableFeedback;
+    }
+}

package/dist/components/table/table-foot.d.ts

@@ -0,0 +1,21 @@
+import { LitElement } from 'lit';
+export declare class TableFoot extends LitElement {
+    static styles: import("lit").CSSResult[];
+    static get properties(): {
+        slot: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        role: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+    };
+    constructor();
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-table-foot': TableFoot;
+    }
+}

package/dist/components/table/table-head-cell.d.ts

@@ -0,0 +1,65 @@
+import type { PropertyValues } from 'lit';
+import '../icon';
+import { Component } from '../component';
+import type { TableHeadCellProps } from './table.types';
+export declare const defaultTableHeadCellProps: {
+    readonly alignment: "left";
+    readonly verticalAlign: "middle";
+    readonly sortable: false;
+    readonly sortDirection: undefined;
+    readonly disabled: false;
+};
+export declare class TableHeadCell extends Component implements TableHeadCellProps {
+    #private;
+    static styles: import("lit").CSSResult[][];
+    static get properties(): {
+        slot: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        role: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        alignment: {
+            type: StringConstructor;
+        };
+        verticalAlign: {
+            type: StringConstructor;
+            attribute: string;
+        };
+        columnId: {
+            type: StringConstructor;
+            attribute: string;
+        };
+        sortable: {
+            type: BooleanConstructor;
+            reflect: boolean;
+        };
+        sortDirection: {
+            type: StringConstructor;
+            attribute: string;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            reflect: boolean;
+        };
+    };
+    alignment: TableHeadCellProps['alignment'];
+    verticalAlign: TableHeadCellProps['verticalAlign'];
+    columnId: TableHeadCellProps['columnId'];
+    sortable: TableHeadCellProps['sortable'];
+    sortDirection: TableHeadCellProps['sortDirection'];
+    disabled: TableHeadCellProps['disabled'];
+    ['m-sort']: TableHeadCellProps['m-sort'];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected update(changedProperties: PropertyValues<TableHeadCellProps>): void;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-table-head-cell': TableHeadCell;
+    }
+}

package/dist/components/table/table-head.d.ts

@@ -0,0 +1,21 @@
+import { LitElement } from 'lit';
+export declare class TableHead extends LitElement {
+    static styles: import("lit").CSSResult[];
+    static get properties(): {
+        slot: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        role: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+    };
+    constructor();
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-table-head': TableHead;
+    }
+}

package/dist/components/table/table-row.d.ts

@@ -0,0 +1,21 @@
+import { LitElement } from 'lit';
+export declare class TableRow extends LitElement {
+    static styles: import("lit").CSSResult[];
+    static get properties(): {
+        slot: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        role: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+    };
+    constructor();
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-table-row': TableRow;
+    }
+}

package/dist/components/table/table-toolbar.d.ts

@@ -0,0 +1,17 @@
+import { LitElement } from 'lit';
+export declare class TableToolbar extends LitElement {
+    static styles: import("lit").CSSResult[];
+    static get properties(): {
+        slot: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+    };
+    constructor();
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-table-toolbar': TableToolbar;
+    }
+}

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

@@ -0,0 +1,27 @@
+import { LitElement } from 'lit';
+import type { TableProps } from './table.types';
+import '../layout';
+export declare const defaultTableProps: {
+    readonly size: "default";
+};
+export declare class Table extends LitElement implements TableProps {
+    static styles: import("lit").CSSResult[];
+    static get properties(): {
+        role: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        size: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+    };
+    size: TableProps['size'];
+    constructor();
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-table': Table;
+    }
+}

package/dist/components/table/table.styles.d.ts

@@ -0,0 +1,9 @@
+export declare function tableStyles(): import("lit").CSSResult;
+export declare function tableToolbarStyles(): import("lit").CSSResult;
+export declare function tableHeadStyles(): import("lit").CSSResult;
+export declare function tableBodyStyles(): import("lit").CSSResult;
+export declare function tableFootStyles(): import("lit").CSSResult;
+export declare function tableRowStyles(): import("lit").CSSResult;
+export declare function tableCellStyles(): import("lit").CSSResult;
+export declare function tableHeadCellStyles(): import("lit").CSSResult[];
+export declare function tableActionsStyles(): import("lit").CSSResult;

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

@@ -0,0 +1,58 @@
+export type TableSize = 'small' | 'default' | 'large';
+export type TableCellAlignment = 'left' | 'center' | 'right';
+export type TableCellVerticalAlign = 'top' | 'middle' | 'bottom';
+export type TableSortDirection = 'asc' | 'desc';
+export type TableProps = {
+    /**
+     * Determines the height of the cell.
+     * @default 'default'
+     */
+    size?: TableSize;
+};
+export type TableCellProps = {
+    /**
+     * Text alignment value.
+     * @default 'left'
+     */
+    alignment?: TableCellAlignment;
+    /**
+     * Vertical align value.
+     * @default 'middle'
+     */
+    verticalAlign?: TableCellVerticalAlign;
+};
+export type TableHeadCellSortEventDetails = {
+    columnId: string;
+    sortDirection: TableSortDirection | undefined;
+};
+export type TableHeadCellProps = TableCellProps & {
+    /**
+     * Useful to identify the selected column header when sorting.
+     */
+    columnId: string;
+    /**
+     * If true, the sort handle will be rendered next to the main content.
+     * @default false
+     */
+    sortable?: boolean;
+    /**
+     * If sortable is true and sortDirection is provided, the handle icon will point to the given direction, otherwise, it will show up-down arrows.
+     */
+    sortDirection?: TableSortDirection;
+    /**
+     * Applies disabled styles to the cell. Even if sortable is true, it won't be clickable.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Click event handler for sortable head cells.
+     */
+    'm-sort'?: (event: CustomEvent<TableHeadCellSortEventDetails>) => void;
+};
+export type TableActionsProps = {
+    /**
+     * Should the actions section stick to the bottom of the table.
+     * @default false
+     */
+    sticky?: boolean;
+};

package/dist/components/tabs/index.d.ts

@@ -2,4 +2,3 @@ export { Tabs } from './tabs';
 export { Tab } from './tab';
 export { TabPanel } from './tab-panel';
 export type { TabsProps, TabProps, TabPanelProps, TabContentDirection, TabChangeEventDetail, } from './tabs.types';
-//# sourceMappingURL=index.d.ts.map

package/dist/components/tabs/tab-panel.d.ts

@@ -1,7 +1,7 @@
 import type { PropertyValues } from 'lit';
 import type { TabPanelProps } from './tabs.types';
 import { Box } from '../layout';
-export declare class TabPanel extends Box {
+export declare class TabPanel extends Box implements TabPanelProps {
     #private;
     static styles: import("lit").CSSResult[];
     static get properties(): {
@@ -80,4 +80,3 @@ declare global {
         'm-tab-panel': TabPanel;
     }
 }
-//# sourceMappingURL=tab-panel.d.ts.map

package/dist/components/tabs/tab-panel.styles.d.ts

@@ -1,3 +1,2 @@
 declare function styles(): import("lit").CSSResult;
 export default styles;
-//# sourceMappingURL=tab-panel.styles.d.ts.map

package/dist/components/tabs/tab.d.ts

@@ -1,7 +1,7 @@
 import type { PropertyValues } from 'lit';
 import { Component } from '../component';
 import type { TabProps } from './tabs.types';
-export declare class Tab extends Component {
+export declare class Tab extends Component implements TabProps {
     #private;
     static styles: import("lit").CSSResult[];
     static get properties(): {
@@ -38,4 +38,3 @@ declare global {
         'm-tab': Tab;
     }
 }
-//# sourceMappingURL=tab.d.ts.map

package/dist/components/tabs/tab.styles.d.ts

@@ -1,3 +1,2 @@
 declare function styles(): import("lit").CSSResult;
 export default styles;
-//# sourceMappingURL=tab.styles.d.ts.map

package/dist/components/tabs/tabs.constants.d.ts

@@ -1,2 +1 @@
 export declare const TAB_SELECT_EVENT = "m-select-tab";
-//# sourceMappingURL=tabs.constants.d.ts.map

package/dist/components/tabs/tabs.context.d.ts

@@ -3,4 +3,3 @@ declare const tabsContext: {
     __context__: TabsContext;
 };
 export default tabsContext;
-//# sourceMappingURL=tabs.context.d.ts.map

package/dist/components/tabs/tabs.d.ts

@@ -2,7 +2,7 @@ import type { PropertyValues } from 'lit';
 import type { SelectionState, SelectionType } from '../../controllers/selection';
 import { Component } from '../component';
 import type { TabsProps } from './tabs.types';
-export declare class Tabs extends Component {
+export declare class Tabs extends Component implements TabsProps {
     #private;
     static styles: import("lit").CSSResult[];
     static get properties(): {
@@ -45,7 +45,7 @@ export declare class Tabs extends Component {
     lazy: TabsProps['lazy'];
     /**
      * Type of selection to be managed.
-     * It is necessary due to elegibility as a SelectionHost for the SelectionController.
+     * It is necessary due to eligibility as a SelectionHost for the SelectionController.
      */
     type: SelectionType;
     /**
@@ -63,4 +63,3 @@ declare global {
         'm-tabs': Tabs;
     }
 }
-//# sourceMappingURL=tabs.d.ts.map

package/dist/components/tabs/tabs.styles.d.ts

@@ -1,3 +1,2 @@
 declare function styles(): import("lit").CSSResult;
 export default styles;
-//# sourceMappingURL=tabs.styles.d.ts.map

package/dist/components/tabs/tabs.types.d.ts

@@ -1,7 +1,7 @@
 import type { AcceptedType, SelectionState } from '../../controllers/selection';
 export type TabContentDirection = 'vertical' | 'horizontal';
 export type TabChangeEventDetail = {
-    value: SelectionState;
+    value: AcceptedType;
 };
 export type TabsProps = {
     /**
@@ -51,4 +51,3 @@ export type TabPanelProps = {
 export type TabsContext = Pick<TabsProps, 'tabContentDirection' | 'disabled' | 'lazy'> & {
     selection: SelectionState;
 };
-//# sourceMappingURL=tabs.types.d.ts.map

package/dist/components/tag/actionable-tag.d.ts

@@ -0,0 +1,96 @@
+import { Component } from '../component';
+import type { TagProps } from './tag';
+import '../close-button';
+import '../text';
+export type ActionableTagVariant = 'default' | 'accent';
+export type ActionableTagChangeEventDetail = {
+    selected: boolean;
+};
+export interface ActionableTagProps extends Pick<TagProps, 'size' | 'isSkeleton'> {
+    variant?: ActionableTagVariant;
+    selectable?: boolean;
+    selected?: boolean;
+    removable?: boolean;
+    disabled?: boolean;
+    'm-remove'?: (event: CustomEvent) => void;
+    'm-change'?: (event: CustomEvent<ActionableTagChangeEventDetail>) => void;
+}
+export declare class ActionableTag extends Component implements ActionableTagProps {
+    #private;
+    static styles: (import("lit").CSSResult | import("lit").CSSResult[])[][];
+    static get properties(): {
+        variant: {
+            type: StringConstructor;
+        };
+        size: {
+            type: StringConstructor;
+        };
+        selectable: {
+            type: BooleanConstructor;
+            reflect: boolean;
+        };
+        selected: {
+            type: BooleanConstructor;
+            reflect: boolean;
+        };
+        removable: {
+            type: BooleanConstructor;
+            reflect: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            reflect: boolean;
+        };
+        isSkeleton: {
+            type: BooleanConstructor;
+            attribute: string;
+        };
+    };
+    /**
+     * Tag variant.
+     */
+    variant: ActionableTagProps['variant'];
+    /**
+     * Tag size.
+     */
+    size: ActionableTagProps['size'];
+    /**
+     * Should the tag be clickable?
+     */
+    selectable: ActionableTagProps['selectable'];
+    /**
+     * Is the tag selected?
+     */
+    selected: ActionableTagProps['selected'];
+    /**
+     * Should it show the remove button?
+     */
+    removable: ActionableTagProps['removable'];
+    /**
+     * Is the tag and/or the close button disabled?
+     */
+    disabled: ActionableTagProps['disabled'];
+    /**
+     * Tag skeleton loader.
+     */
+    isSkeleton: ActionableTagProps['isSkeleton'];
+    /**
+     * Event handler for removing the tag.
+     */
+    ['m-remove']: ActionableTagProps['m-remove'];
+    /**
+     * Event handler for selecting or unselecting the tag.
+     */
+    ['m-change']: ActionableTagProps['m-change'];
+    constructor();
+    /**
+     * Which HTML tag should be used to render this element.
+     */
+    private get tag();
+    render(): import("lit-html").TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-actionable-tag': ActionableTag;
+    }
+}