@loadsmart/miranda-wc 2.0.1 → 3.0.0-alpha.1

package/dist/components/dropdown/dropdown-item.d.ts

@@ -0,0 +1,39 @@
+import type { PropertyValues } from 'lit';
+import { Component } from '../component';
+export interface DropdownItemProps {
+    disabled?: boolean;
+    destructive?: boolean;
+}
+declare const DropdownItem_base: typeof Component;
+export declare class DropdownItem extends DropdownItem_base implements DropdownItemProps {
+    static styles: import("lit").CSSResult[][];
+    static get properties(): {
+        disabled: {
+            type: BooleanConstructor;
+            reflect: boolean;
+        };
+        destructive: {
+            type: BooleanConstructor;
+            reflect: boolean;
+        };
+    };
+    /**
+     * Should the menu item be disabled?
+     */
+    disabled: DropdownItemProps['disabled'];
+    /**
+     * Should the menu item represent a destructive action?
+     */
+    destructive: DropdownItemProps['destructive'];
+    constructor();
+    connectedCallback(): void;
+    updated(changedProperties: PropertyValues<this>): void;
+    render(): import("lit-html").TemplateResult<1>;
+    protected handleClick: (event: MouseEvent) => void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-dropdown-item': DropdownItem;
+    }
+}
+export {};

package/dist/components/dropdown/dropdown-menu.d.ts

@@ -0,0 +1,12 @@
+import { Component } from '../component';
+declare const DropdownMenu_base: typeof Component;
+export declare class DropdownMenu extends DropdownMenu_base {
+    connectedCallback(): void;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-dropdown-menu': DropdownMenu;
+    }
+}
+export {};

package/dist/components/dropdown/dropdown-trigger.d.ts

@@ -0,0 +1,28 @@
+import { Component } from '../component';
+import '../icon';
+export type DropdownTriggerProps = {
+    disabled?: boolean;
+};
+declare const DropdownTrigger_base: typeof Component;
+export declare class DropdownTrigger extends DropdownTrigger_base implements DropdownTriggerProps {
+    static styles: import("lit").CSSResult[][];
+    static get properties(): {
+        disabled: {
+            type: BooleanConstructor;
+            reflect: boolean;
+        };
+    };
+    /**
+     * Should the button be disabled.
+     */
+    disabled?: boolean;
+    constructor();
+    connectedCallback(): void;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-dropdown-trigger': DropdownTrigger;
+    }
+}
+export {};

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

@@ -0,0 +1,3 @@
+export declare const TRIGGER_SELECTOR = "[aria-haspopup=\"true\"]";
+export declare const MENU_SELECTOR = "[role=\"menu\"]";
+export declare const ITEM_SELECTOR = "[role=\"menuitem\"]";

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

@@ -0,0 +1,69 @@
+import type { PropertyValues } from 'lit';
+import { Popover } from '../popover';
+import type { PositionalFocus } from '../../controllers/focus-manager';
+import type { PopoverProps, PopoverPlacement } from '../popover';
+export type DropdownPlacement = PopoverPlacement;
+export type DropdownSize = 'small' | 'default' | 'large';
+export interface DropdownProps extends PopoverProps {
+    disabled?: boolean;
+    size?: DropdownSize;
+    'm-collapse'?: (event: CustomEvent) => void;
+    'm-expand'?: (event: CustomEvent) => void;
+}
+export declare class Dropdown extends Popover implements DropdownProps {
+    #private;
+    static styles: (import("lit").CSSResult | import("lit").CSSResult[])[][];
+    static get properties(): {
+        disabled: {
+            type: BooleanConstructor;
+            reflect: boolean;
+        };
+        size: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        position: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        placement: {
+            type: StringConstructor;
+        };
+        open: {
+            type: BooleanConstructor;
+            reflect: boolean;
+        };
+        asPopover: {
+            type: BooleanConstructor;
+            attribute: string;
+        };
+    };
+    /**
+     * Should the dropdown be disabled?
+     */
+    disabled: DropdownProps['disabled'];
+    /**
+     * Dropdown size.
+     */
+    size?: DropdownProps['size'];
+    constructor();
+    firstUpdated(): void;
+    updated(changedProperties: PropertyValues<this>): void;
+    getReferenceElement(): HTMLElement | null;
+    getFloatingElement(): HTMLElement | null;
+    getArrowElement(): null;
+    getFloatingOffset: () => number;
+    render(): import("lit-html").TemplateResult<1>;
+    expand(args?: {
+        position?: PositionalFocus;
+    }): Promise<void>;
+    collapse(): Promise<void>;
+    toggle(args?: {
+        position?: PositionalFocus;
+    }): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-dropdown': Dropdown;
+    }
+}

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

@@ -0,0 +1,3 @@
+export declare function dropdownStyles(): (import("lit").CSSResult | import("lit").CSSResult[])[];
+export declare function triggerStyles(): import("lit").CSSResult[];
+export declare function itemStyles(): import("lit").CSSResult[];

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

@@ -0,0 +1,7 @@
+export { Dropdown } from './dropdown';
+export { DropdownTrigger } from './dropdown-trigger';
+export { DropdownMenu } from './dropdown-menu';
+export { DropdownItem } from './dropdown-item';
+export type { DropdownPlacement, DropdownProps, DropdownSize, } from './dropdown';
+export type { DropdownItemProps } from './dropdown-item';
+export type { DropdownTriggerProps } from './dropdown-trigger';

package/dist/components/empty-state/empty-state-action.d.ts

@@ -0,0 +1,12 @@
+import { Button } from '../button';
+export declare class EmptyStateAction extends Button {
+    #private;
+    private context;
+    constructor();
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-empty-state-action': EmptyStateAction;
+    }
+}

package/dist/components/empty-state/empty-state-header.d.ts

@@ -0,0 +1,12 @@
+import { Text } from '../text';
+export declare class EmptyStateHeader extends Text {
+    #private;
+    private context;
+    constructor();
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-empty-state-header': EmptyStateHeader;
+    }
+}

package/dist/components/empty-state/empty-state-illustration.d.ts

@@ -0,0 +1,10 @@
+import { LitElement } from 'lit';
+export declare class EmptyStateIllustration extends LitElement {
+    protected createRenderRoot(): this;
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-empty-state-illustration': EmptyStateIllustration;
+    }
+}

package/dist/components/empty-state/empty-state-message.d.ts

@@ -0,0 +1,12 @@
+import { Text } from '../text';
+export declare class EmptyStateMessage extends Text {
+    #private;
+    private context;
+    constructor();
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-empty-state-message': EmptyStateMessage;
+    }
+}

package/dist/components/empty-state/empty-state.context.d.ts

@@ -0,0 +1,7 @@
+import type { EmptyStateVariant } from './empty-state.types';
+export type EmptyStateContext = {
+    variant?: EmptyStateVariant;
+};
+export declare const emptyStateContext: {
+    __context__: EmptyStateContext;
+};

package/dist/components/empty-state/empty-state.d.ts

@@ -0,0 +1,46 @@
+import type { PropertyValues } from 'lit';
+import { Component } from '../component';
+import type { EmptyStateVariant } from './empty-state.types';
+import '../button';
+/**
+ * @fires m-action
+ */
+export declare class EmptyState extends Component {
+    #private;
+    static styles: import("lit").CSSResult[];
+    static get properties(): {
+        variant: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        illustration: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        header: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        message: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        action: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+    };
+    variant?: EmptyStateVariant;
+    illustration?: string;
+    header?: string;
+    message?: string;
+    action?: string;
+    constructor();
+    updated(changedProperties: PropertyValues<this>): void;
+    render(): import("lit-html").TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-empty-state': EmptyState;
+    }
+}

package/dist/components/empty-state/empty-state.styles.d.ts

@@ -0,0 +1,2 @@
+export declare function styles(): import("lit").CSSResult;
+export declare function illustrationStyles(): import("lit").CSSResult;

package/dist/components/empty-state/empty-state.types.d.ts

@@ -0,0 +1,2 @@
+export declare const EMPTY_STATE_VARIANTS: readonly ["page", "panel", "card", "card-horizontal"];
+export type EmptyStateVariant = (typeof EMPTY_STATE_VARIANTS)[number];

package/dist/components/empty-state/empty-state.utils.d.ts

@@ -0,0 +1,3 @@
+import type { ButtonSize } from '../button';
+import type { EmptyStateVariant } from './empty-state.types';
+export declare function getActionSize(variant?: EmptyStateVariant): ButtonSize;

package/dist/components/empty-state/index.d.ts

@@ -0,0 +1,7 @@
+export { EmptyStateAction } from './empty-state-action';
+export { EmptyStateHeader } from './empty-state-header';
+export { EmptyStateIllustration } from './empty-state-illustration';
+export { EmptyStateMessage } from './empty-state-message';
+export { EmptyState } from './empty-state';
+export { EMPTY_STATE_VARIANTS } from './empty-state.types';
+export type { EmptyStateVariant } from './empty-state.types';

package/dist/components/field/field-hint.d.ts

@@ -5,7 +5,7 @@ import '../layout/group';
 export interface FieldHintProps extends HTMLElement {
     status?: FieldStatus;
 }
-export declare class FieldHint extends Component {
+export declare class FieldHint extends Component implements FieldHintProps {
     #private;
     static styles: import("lit").CSSResult[][];
     static get properties(): {
@@ -14,6 +14,7 @@ export declare class FieldHint extends Component {
         };
         slot: {
             type: StringConstructor;
+            reflect: boolean;
         };
     };
     /**
@@ -30,4 +31,3 @@ declare global {
         'm-field-hint': FieldHint;
     }
 }
-//# sourceMappingURL=field-hint.d.ts.map

package/dist/components/field/field-label.d.ts

@@ -1,39 +1,14 @@
-import { Component } from '../component';
-import type { FieldSize } from './field.types';
-export interface FieldLabelProps extends HTMLElement {
-    size?: FieldSize;
-    required?: boolean;
-}
-export declare class FieldLabel extends Component {
-    #private;
-    static styles: import("lit").CSSResult[][];
-    static get properties(): {
-        required: {
-            type: BooleanConstructor;
-        };
-        size: {
-            type: StringConstructor;
-        };
-        slot: {
-            type: StringConstructor;
-        };
-    };
-    /**
-     * Is this field required.
-     */
-    required: FieldLabelProps['required'];
-    /**
-     * Field size.
-     */
-    size: FieldLabelProps['size'];
-    slot: string;
+import { Label } from '../label';
+import type { LabelProps } from '../label';
+export { type LabelProps as FieldLabelProps } from '../label';
+export declare class FieldLabel extends Label implements LabelProps {
     private field;
-    constructor();
-    render(): import("lit-html").TemplateResult<1>;
+    connectedCallback(): void;
+    isRequired(): boolean;
+    getSize(): import("./field.types").FieldSize | undefined;
 }
 declare global {
     interface HTMLElementTagNameMap {
         'm-field-label': FieldLabel;
     }
 }
-//# sourceMappingURL=field-label.d.ts.map

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

@@ -1,11 +1,10 @@
 import type { FieldSize, FieldStatus } from './field.types';
 export interface FieldContext {
-    required?: boolean;
+    required: boolean;
     status?: FieldStatus;
-    size?: FieldSize;
+    size: FieldSize;
 }
 declare const fieldContext: {
     __context__: FieldContext;
 };
 export default fieldContext;
-//# sourceMappingURL=field.context.d.ts.map

package/dist/components/field/field.d.ts

@@ -15,7 +15,8 @@ export interface FieldProps {
     required?: boolean;
     align?: StackProps['align'];
 }
-export declare class Field extends Component {
+export declare class Field extends Component implements FieldProps {
+    static styles: import("lit").CSSResult[][];
     static get properties(): {
         label: {
             type: StringConstructor;
@@ -70,4 +71,3 @@ declare global {
         'm-field': Field;
     }
 }
-//# sourceMappingURL=field.d.ts.map

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

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

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

@@ -1,4 +1,3 @@
 export declare const FIELD_STATUSES: readonly ["default", "danger"];
 export type FieldStatus = (typeof FIELD_STATUSES)[number];
 export type FieldSize = 'small' | 'default';
-//# sourceMappingURL=field.types.d.ts.map

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

@@ -6,4 +6,3 @@ export type { FieldProps } from './field';
 export type { FieldHintProps } from './field-hint';
 export type { FieldLabelProps } from './field-label';
 export type { FieldSize, FieldStatus } from './field.types';
-//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,18 @@
+import { LitElement } from 'lit';
+export declare class HeaderActions extends LitElement {
+    static styles: import("lit").CSSResult[];
+    static get properties(): {
+        slot: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+    };
+    slot: string;
+    constructor();
+    render(): import("lit-html").TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-header-actions': HeaderActions;
+    }
+}

package/dist/components/header/header-content.d.ts

@@ -0,0 +1,18 @@
+import { LitElement } from 'lit';
+export declare class HeaderContent extends LitElement {
+    static styles: import("lit").CSSResult[];
+    static get properties(): {
+        slot: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+    };
+    slot: string;
+    constructor();
+    render(): import("lit-html").TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-header-content': HeaderContent;
+    }
+}

package/dist/components/header/header-title.d.ts

@@ -0,0 +1,18 @@
+import { LitElement } from 'lit';
+export declare class HeaderTitle extends LitElement {
+    static styles: import("lit").CSSResult[];
+    static get properties(): {
+        slot: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+    };
+    slot: string;
+    constructor();
+    render(): import("lit-html").TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-header-title': HeaderTitle;
+    }
+}

package/dist/components/header/header.d.ts

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

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

@@ -0,0 +1,6 @@
+declare function styles(): import("lit").CSSResult;
+export declare function headerTitleStyles(): import("lit").CSSResult;
+export declare function headerActionStyles(): import("lit").CSSResult;
+export declare function headerContentStyles(): import("lit").CSSResult;
+export declare function subHeaderStyles(): import("lit").CSSResult;
+export default styles;

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

@@ -0,0 +1,5 @@
+export { Header } from './header';
+export { HeaderActions } from './header-actions';
+export { HeaderContent } from './header-content';
+export { HeaderTitle } from './header-title';
+export { SubHeader } from './sub-header';

package/dist/components/header/sub-header.d.ts

@@ -0,0 +1,19 @@
+import { LitElement } from 'lit';
+import '../divider';
+export declare class SubHeader extends LitElement {
+    static styles: import("lit").CSSResult[];
+    static get properties(): {
+        slot: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+    };
+    slot: string;
+    constructor();
+    render(): import("lit-html").TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-sub-header': SubHeader;
+    }
+}

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

@@ -1,4 +1 @@
-export { Icon } from './icon';
-export type { IconProps } from './icon';
-export type { IconName } from './available-icons';
-//# sourceMappingURL=index.d.ts.map
+export * from '@loadsmart/miranda-icons';

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

@@ -0,0 +1 @@
+export * from './label';

package/dist/components/label/label.d.ts

@@ -0,0 +1,33 @@
+import { nothing } from 'lit';
+import { Component } from '../component';
+export interface LabelProps extends HTMLElement {
+    size?: 'small' | 'default';
+    required?: boolean;
+}
+export declare class Label extends Component implements LabelProps {
+    static styles: import("lit").CSSResult[][];
+    static get properties(): {
+        required: {
+            type: BooleanConstructor;
+        };
+        size: {
+            type: StringConstructor;
+        };
+        slot: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+    };
+    required: LabelProps['required'];
+    size: LabelProps['size'];
+    requiredTemplate(): import("lit-html").TemplateResult<1> | typeof nothing;
+    private labelClassList;
+    render(): import("lit-html").TemplateResult<1>;
+    getSize(): LabelProps['size'];
+    isRequired(): boolean;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-label': Label;
+    }
+}

package/dist/components/{icon/icon.styles.d.ts → label/label.styles.d.ts}

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

package/dist/components/labeled-value/index.d.ts

@@ -0,0 +1,3 @@
+export * from './labeled-value';
+export * from './labeled-value-label';
+export * from './labeled-value-value';

package/dist/components/labeled-value/labeled-value-label.d.ts

@@ -0,0 +1,35 @@
+import type { PropertyValues } from 'lit';
+import { Text } from '../text';
+export declare class LabeledValueLabel extends Text {
+    static get properties(): {
+        role: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        as: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        color: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        ellipsized: {
+            type: BooleanConstructor;
+            reflect: boolean;
+        };
+        variant: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+    };
+    role: string;
+    constructor();
+    connectedCallback(): void;
+    update(changedProperties: PropertyValues<this>): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-labeled-value-label': LabeledValueLabel;
+    }
+}

package/dist/components/labeled-value/labeled-value-value.d.ts

@@ -0,0 +1,9 @@
+import { Text } from '../text';
+export declare class LabeledValueValue extends Text {
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'm-labeled-value-value': LabeledValueValue;
+    }
+}