@covalent/components 11.0.0-beta.4 → 11.0.0-beta.6

package/action-ribbon/action-ribbon-base.d.ts

@@ -0,0 +1,29 @@
+import { MDCBannerAdapter } from '@material/banner/adapter';
+import { CloseReason } from '@material/banner/constants';
+import { MDCBannerFoundation } from '@material/banner';
+import { LitElement, TemplateResult } from 'lit';
+export declare class ActionRibbonBase extends LitElement {
+    protected mdcFoundation: MDCBannerFoundation;
+    protected readonly mdcFoundationClass: typeof MDCBannerFoundation;
+    protected mdcRoot: HTMLElement;
+    protected mdcContent: HTMLElement;
+    protected primaryActionEl: HTMLElement;
+    open: boolean;
+    labelText: string;
+    icon: string;
+    iconAriaLabel: string;
+    centered: boolean;
+    /**
+     * The state representation active|negative|positive|caution|loading|pending|checked
+     */
+    state?: 'active' | 'negative' | 'positive' | 'caution' | 'loading' | 'pending' | 'checked';
+    protected reason: CloseReason;
+    protected render(): TemplateResult<1>;
+    protected renderIcon(): TemplateResult;
+    protected createAdapter(): MDCBannerAdapter;
+    /** @export */
+    show(): void;
+    /** @export */
+    close(reason?: CloseReason): void;
+    protected firstUpdated(): Promise<void>;
+}

package/action-ribbon/action-ribbon.d.ts

@@ -0,0 +1,15 @@
+import { ActionRibbonBase } from './action-ribbon-base';
+/**
+ * Action ribbon
+ *
+ * @slot - This element has a slot
+ */
+export declare class CovalentActionRibbon extends ActionRibbonBase {
+    static styles: import("lit").CSSResult[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'cv-action-ribbon': CovalentActionRibbon;
+    }
+}
+export default CovalentActionRibbon;

package/alert/alert-base.d.ts

@@ -0,0 +1,36 @@
+import { MDCBannerFoundation } from '@material/banner/foundation';
+import { MDCBannerAdapter } from '@material/banner/adapter';
+import { CloseReason } from '@material/banner/constants';
+import { LitElement, TemplateResult } from 'lit';
+import '../icon/icon';
+export declare class AlertBase extends LitElement {
+    protected mdcFoundation: MDCBannerFoundation;
+    protected readonly mdcFoundationClass: typeof MDCBannerFoundation;
+    private _resizeObserver;
+    protected mdcRoot: HTMLElement;
+    protected mdcContent: HTMLElement;
+    protected mdcGraphicTextWrapper: HTMLElement;
+    protected currentWidth: number;
+    open: boolean;
+    titleText: string;
+    descriptionText: string;
+    icon: string;
+    iconAriaLabel: string;
+    inline: boolean;
+    /**
+     * The state representation active|negative|positive|caution
+     */
+    state: string;
+    constructor();
+    disconnectedCallback(): void;
+    protected reason: CloseReason;
+    protected render(): TemplateResult<1>;
+    /** @soyTemplate */
+    protected renderIcon(): TemplateResult;
+    protected createAdapter(): MDCBannerAdapter;
+    /** @export */
+    show(): void;
+    /** @export */
+    close(reason?: CloseReason): void;
+    protected firstUpdated(): Promise<void>;
+}

package/alert/alert.d.ts

@@ -0,0 +1,15 @@
+import { AlertBase } from './alert-base';
+/**
+ * Action ribbon
+ *
+ * @slot - This element has a slot
+ */
+export declare class CovalentAlert extends AlertBase {
+    static styles: import("lit").CSSResult[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'cv-alert': CovalentAlert;
+    }
+}
+export default CovalentAlert;

package/app-shell/app-shell.d.ts

@@ -0,0 +1,75 @@
+import { nothing } from 'lit';
+import { DrawerBase } from '@material/mwc-drawer/mwc-drawer-base';
+import '../top-app-bar/top-app-bar-fixed';
+import '../icon-button/icon-button';
+import '../card/card';
+declare global {
+    interface HTMLElementTagNameMap {
+        'cv-app-shell': CovalentAppShell;
+    }
+}
+/**
+ * App Shell element.
+ *
+ * @slot - This element has a slot
+ */
+export declare class CovalentAppShell extends DrawerBase {
+    static styles: import("lit").CSSResult[];
+    element: Element | null;
+    helpWidth: number;
+    private _startX;
+    private _startWidth;
+    private _resizing;
+    navigationListElements: HTMLElement[];
+    userMenuElements: HTMLElement[];
+    /**
+     * The name of the application to show in the small app bar
+     */
+    appName: string;
+    /**
+     * The name of the section shown above the navigation
+     */
+    sectionName: string;
+    drawerOpen: boolean;
+    helpOpen: boolean;
+    /**
+     * Make help resizable with drag/drop handle
+     */
+    helpResizable: boolean;
+    /**
+     * Wrap the main area with a contained card surface
+     */
+    contained: boolean;
+    /**
+     * Force the left navigation visibly open
+     */
+    forcedOpen: boolean;
+    /**
+     * Make the content area full width
+     */
+    fullWidth: boolean;
+    private hovered;
+    private hoverTimeout;
+    private hoverEntryDuration;
+    private hoverExitDuration;
+    constructor();
+    setupHelpPanelListeners(): void;
+    toggleHelpPanel(open?: boolean): void;
+    private _setupEventListeners;
+    private _startResizing;
+    private _resize;
+    private _stopResize;
+    private _toggleOpen;
+    private updateHelpPanelWidth;
+    private _handleMenuClick;
+    private _handleNavMouseOver;
+    private _handleNavMouseOut;
+    private _handleDrawerClosed;
+    resizeEvent(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected renderSection(): import("lit-html").TemplateResult<1> | typeof nothing;
+    protected renderMain(): import("lit-html").TemplateResult<1>;
+    render(): import("lit-html").TemplateResult<1>;
+}
+export default CovalentAppShell;

package/badge/badge.d.ts

@@ -0,0 +1,50 @@
+import { LitElement } from 'lit';
+export type BadgeSize = 'small' | 'large';
+export type BadgeAlignmentVertical = 'top' | 'bottom';
+export type BadgeAlignmentHorizonatal = 'left' | 'right';
+/**
+ * Badge
+ *
+ * @slot - This element has a slot
+ */
+export declare class CovalentBadge extends LitElement {
+    static styles: import("lit").CSSResult[];
+    /**
+     * The content to be displayed in the badge
+     */
+    content?: number | string;
+    /**
+     * Caps the value of badge content
+     */
+    max?: number;
+    /**
+     * Sets the size of the badge
+     * 'small' represents a dot to notify that something has changed without providing content
+     */
+    size?: BadgeSize;
+    /**
+     * Controls the visibility of the badge
+     */
+    hideBadge?: boolean | undefined;
+    /**
+     * Aligns the badge vertically in the wrapped element
+     */
+    verticalAlignment?: BadgeAlignmentVertical;
+    /**
+     * Aligns the badge horizontally in the wrapped element
+     */
+    horizontalAlignment?: BadgeAlignmentHorizonatal;
+    /**
+     * Shows the badge when count is zero
+     */
+    showZero?: boolean;
+    firstUpdated(): void;
+    getContent(): number | string;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'cv-badge': CovalentBadge;
+    }
+}
+export default CovalentBadge;

package/button/button.d.ts

@@ -0,0 +1,10 @@
+import { ButtonBase } from '@material/mwc-button/mwc-button-base';
+declare global {
+    interface HTMLElementTagNameMap {
+        'cv-button': CovalentButton;
+    }
+}
+export declare class CovalentButton extends ButtonBase {
+    static styles: import("lit").CSSResult[];
+}
+export default CovalentButton;

package/card/card-base.d.ts

@@ -0,0 +1,28 @@
+import { LitElement } from 'lit';
+export declare class CardBase extends LitElement {
+    /**
+     * The title of the card
+     */
+    cardTitle: string;
+    /**
+     * The sub-title of the card
+     */
+    subTitle: string;
+    /**
+     * Displays the action bar
+     */
+    actionBar: boolean;
+    /**
+     * Displays the ripple affect in primary area
+     */
+    interactive: boolean;
+    /**
+     * Style the card as an outline variant
+     */
+    outlined: boolean;
+    /**
+     * Style the card 100% height
+     */
+    fullHeight: boolean;
+    render(): import("lit-html").TemplateResult<1>;
+}

package/card/card.d.ts

@@ -0,0 +1,10 @@
+import { CardBase } from './card-base';
+declare global {
+    interface HTMLElementTagNameMap {
+        'cv-card': CovalentCard;
+    }
+}
+export declare class CovalentCard extends CardBase {
+    static styles: import("lit").CSSResult[];
+}
+export default CovalentCard;

package/checkbox/checkbox.d.ts

@@ -0,0 +1,10 @@
+import { CheckboxBase } from '@material/mwc-checkbox/mwc-checkbox-base';
+declare global {
+    interface HTMLElementTagNameMap {
+        'cv-checkbox': CovalentCheckbox;
+    }
+}
+export declare class CovalentCheckbox extends CheckboxBase {
+    static styles: import("lit").CSSResult[];
+}
+export default CovalentCheckbox;

package/chips/chip-base.d.ts

@@ -0,0 +1,51 @@
+import { MDCChipFoundation } from '@material/chips/chip/foundation';
+import { MDCChipAnimation } from '@material/chips/chip/constants';
+import { MDCChipAction } from '@material/chips/action';
+import { MDCChipActionFocusBehavior, MDCChipActionType } from '@material/chips/action/constants';
+import { MDCChipAdapter } from '@material/chips/chip/adapter';
+import { LitElement } from 'lit';
+export declare class ChipBase extends LitElement {
+    protected mdcFoundation?: MDCChipFoundation;
+    protected readonly mdcFoundationClass: typeof MDCChipFoundation;
+    protected actions: Map<MDCChipActionType, MDCChipAction>;
+    protected chipId: number;
+    protected mdcRoot: HTMLElement;
+    /**
+     * The text label of the chip
+     */
+    label: string;
+    /**
+     * The icon name to use for primary or leading chip
+     */
+    icon: string;
+    trailingIcon: boolean;
+    avatar: boolean;
+    /**
+     * The text label of the chip
+     */
+    disabled: boolean;
+    /**
+     * Set the filter chip varient
+     */
+    filter: boolean;
+    /**
+     * The state representation secondary|negative|positive|caution
+     */
+    state?: 'secondary' | 'negative' | 'positive' | 'caution';
+    constructor();
+    protected render(): import("lit-html").TemplateResult<1>;
+    protected firstUpdated(): Promise<void>;
+    protected renderGraphic(): import("lit-html").TemplateResult<1>;
+    protected renderCheckMark(): import("lit-html").TemplateResult<1>;
+    protected renderIcon(trailing?: boolean): import("lit-html").TemplateResult<1>;
+    protected renderTrailing(): import("lit-html").TemplateResult<1>;
+    protected createAdapter(): MDCChipAdapter;
+    getActions(): MDCChipActionType[];
+    getElementID(): string;
+    isActionFocusable(action: MDCChipActionType): boolean;
+    isActionSelectable(action: MDCChipActionType): boolean;
+    isActionSelected(action: MDCChipActionType): boolean;
+    setActionFocus(action: MDCChipActionType, focus: MDCChipActionFocusBehavior): void | undefined;
+    setActionSelected(actionType: MDCChipActionType, isSelected: boolean): void | undefined;
+    startAnimation(animation: MDCChipAnimation): void | undefined;
+}

package/chips/chip-set-base.d.ts

@@ -0,0 +1,32 @@
+import { MDCChipSetAdapter } from '@material/chips/chip-set/adapter';
+import { MDCChipSetFoundation } from '@material/chips/chip-set/foundation';
+import { LitElement, PropertyValues } from 'lit';
+import { CovalentChip } from './chip';
+export declare class ChipSetBase extends LitElement {
+    protected mdcFoundation: MDCChipSetFoundation;
+    protected mdcRoot: HTMLElement;
+    /**
+     * Set if the chips are selectable/actionable
+     */
+    selectable: boolean;
+    /**
+     * Set the chips are mulit-selectable
+     */
+    multi: boolean;
+    /**
+     * The arial label for the the chip set
+     */
+    label: string;
+    activeIndex: number;
+    protected _previousActiveIndex: number;
+    protected chips: CovalentChip[];
+    render(): import("lit-html").TemplateResult<1>;
+    protected updated(changedProps: PropertyValues): Promise<void>;
+    protected firstUpdated(changedProps: PropertyValues): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected createAdapter(): MDCChipSetAdapter;
+    private _handleChipAnimation;
+    private _handleChipInteraction;
+    private _handleChipNavigation;
+}

package/chips/chip-set.d.ts

@@ -0,0 +1,15 @@
+import { ChipSetBase } from './chip-set-base';
+/**
+ * Action ribbon
+ *
+ * @slot - This element has a slot
+ */
+export declare class CovalentChipSet extends ChipSetBase {
+    static styles: import("lit").CSSResult[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'cv-chip-set': CovalentChipSet;
+    }
+}
+export default CovalentChipSet;

package/chips/chip.d.ts

@@ -0,0 +1,15 @@
+import { ChipBase } from './chip-base';
+/**
+ * Action ribbon
+ *
+ * @slot - This element has a slot
+ */
+export declare class CovalentChip extends ChipBase {
+    static styles: import("lit").CSSResult[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'cv-chip': CovalentChip;
+    }
+}
+export default CovalentChip;

package/circular-progress/circular-progress.d.ts

@@ -0,0 +1,10 @@
+import { CircularProgressBase } from '@material/mwc-circular-progress/mwc-circular-progress-base';
+declare global {
+    interface HTMLElementTagNameMap {
+        'cv-circular-progress': CovalentCircularProgress;
+    }
+}
+export declare class CovalentCircularProgress extends CircularProgressBase {
+    static styles: import("lit").CSSResult[];
+}
+export default CovalentCircularProgress;

package/code-editor/code-editor.d.ts

@@ -0,0 +1,62 @@
+import { LitElement, PropertyValues } from 'lit';
+import { editor } from 'monaco-editor/esm/vs/editor/editor.api.js';
+import 'monaco-editor/esm/vs/basic-languages/html/html.contribution';
+import 'monaco-editor/esm/vs/basic-languages/css/css.contribution';
+import 'monaco-editor/esm/vs/basic-languages/javascript/javascript.contribution';
+import 'monaco-editor/esm/vs/basic-languages/typescript/typescript.contribution';
+import 'monaco-editor/esm/vs/basic-languages/python/python.contribution';
+import 'monaco-editor/esm/vs/basic-languages/sql/sql.contribution';
+import 'monaco-editor/esm/vs/basic-languages/markdown/markdown.contribution';
+import 'monaco-editor/esm/vs/basic-languages/r/r.contribution';
+export declare class CovalentCodeEditor extends LitElement {
+    /**
+     * The container where editor will be created
+     */
+    private container;
+    /**
+     * Editor instance
+     */
+    editor?: editor.IStandaloneCodeEditor;
+    /**
+     * Theme of the editor
+     */
+    theme?: string;
+    /**
+     * Language of th editor instance
+     */
+    language?: string;
+    /**
+     * Code entered into the editor
+     */
+    code?: string;
+    /**
+     * Disable scroll bar and set the editor height based on content
+     */
+    disableScroll?: boolean;
+    /**
+     * Options that can be set for the editor
+     */
+    options?: editor.IEditorOptions & editor.IGlobalEditorOptions;
+    static styles: import("lit").CSSResult[];
+    private getFile;
+    private getCode;
+    private getLang;
+    private getTheme;
+    private setTheme;
+    adjustHeight(): void;
+    createEditor(container: HTMLElement): void;
+    disconnectedCallback(): void;
+    firstUpdated(): void;
+    getEditorInstance(): editor.IStandaloneCodeEditor | undefined;
+    getValue(): string | undefined;
+    onModelChange(): void;
+    render(): import("lit-html").TemplateResult<1>;
+    setValue(value: string): void;
+    updated(changedProperties: PropertyValues): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'cv-code-editor': CovalentCodeEditor;
+    }
+}
+export default CovalentCodeEditor;

package/code-editor/code-editor.theme.d.ts

@@ -0,0 +1,72 @@
+export declare const cvEditorDarkTheme: {
+    base: string;
+    inherit: boolean;
+    rules: ({
+        token: string;
+        foreground: string;
+        background: string;
+        fontStyle?: undefined;
+    } | {
+        token: string;
+        foreground: string;
+        background?: undefined;
+        fontStyle?: undefined;
+    } | {
+        token: string;
+        foreground: string;
+        fontStyle: string;
+        background?: undefined;
+    } | {
+        token: string;
+        fontStyle: string;
+        foreground?: undefined;
+        background?: undefined;
+    })[];
+    colors: {
+        comment: string;
+        'editor.background': string;
+        'editor.foreground': string;
+        'editorCursor.foreground': string;
+        'editorLineNumber.activeForeground': string;
+        'editorLineNumber.foreground': string;
+        'editor.lineHighlightBackground': string;
+        'inputValidation.errorBackground': string;
+        'inputValidation.errorBorder': string;
+    };
+};
+export declare const cvEditorLightTheme: {
+    base: string;
+    inherit: boolean;
+    rules: ({
+        token: string;
+        foreground: string;
+        background: string;
+        fontStyle?: undefined;
+    } | {
+        token: string;
+        foreground: string;
+        background?: undefined;
+        fontStyle?: undefined;
+    } | {
+        token: string;
+        foreground: string;
+        fontStyle: string;
+        background?: undefined;
+    } | {
+        token: string;
+        fontStyle: string;
+        foreground?: undefined;
+        background?: undefined;
+    })[];
+    colors: {
+        comment: string;
+        'editor.background': string;
+        'editor.foreground': string;
+        'editorCursor.foreground': string;
+        'editorLineNumber.activeForeground': string;
+        'editorLineNumber.foreground': string;
+        'editor.lineHighlightBackground': string;
+        'inputValidation.errorBackground': string;
+        'inputValidation.errorBorder': string;
+    };
+};

package/code-snippet/code-snippet.d.ts

@@ -0,0 +1,22 @@
+import { LitElement } from 'lit';
+declare global {
+    interface HTMLElementTagNameMap {
+        'cv-code-snippet': CovalentCodeSnippet;
+    }
+}
+export declare class CovalentCodeSnippet extends LitElement {
+    static styles: import("lit").CSSResult[];
+    language?: string;
+    label?: string;
+    inline: boolean;
+    hideHeader: boolean;
+    _codeItems: Array<Node>;
+    maxHeight?: number;
+    private _code;
+    highlight(): void;
+    firstUpdated(): void;
+    render(): import("lit-html").TemplateResult<1>;
+    renderContainer(): import("lit-html").TemplateResult<1>;
+    renderHeader(): import("lit-html").TemplateResult<1>;
+}
+export default CovalentCodeSnippet;

package/dialog/dialog.d.ts

@@ -0,0 +1,14 @@
+import { DialogBase } from '@material/mwc-dialog/mwc-dialog-base';
+import { MDCDialogAdapter } from '@material/dialog/adapter.js';
+declare global {
+    interface HTMLElementTagNameMap {
+        'cv-dialog': CovalentDialog;
+    }
+}
+export declare class CovalentDialog extends DialogBase {
+    static styles: import("lit").CSSResult[];
+    /** Enables/Disables the trap focus functionality that uses blocking-elements library */
+    trapFocus: boolean;
+    protected createAdapter(): MDCDialogAdapter;
+}
+export default CovalentDialog;

package/drawer/drawer.d.ts

@@ -0,0 +1,10 @@
+import { DrawerBase } from '@material/mwc-drawer/mwc-drawer-base';
+declare global {
+    interface HTMLElementTagNameMap {
+        'cv-drawer': CovalentDrawer;
+    }
+}
+export declare class CovalentDrawer extends DrawerBase {
+    static styles: import("lit").CSSResult[];
+}
+export default CovalentDrawer;

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

@@ -0,0 +1,16 @@
+import { LitElement } from 'lit';
+import '../icon/icon';
+declare global {
+    interface HTMLElementTagNameMap {
+        'cv-empty-state': CovalentEmptyState;
+    }
+}
+export declare class CovalentEmptyState extends LitElement {
+    static styles: import("lit").CSSResult[];
+    headline: string;
+    subtitle: string;
+    icon: string;
+    card: boolean;
+    render(): import("lit-html").TemplateResult<1>;
+}
+export default CovalentEmptyState;

package/expansion-panel/expansion-panel-item.d.ts

@@ -0,0 +1,26 @@
+import { LitElement } from 'lit';
+import '../icon/icon';
+export declare class CovalentExpansionPanelItem extends LitElement {
+    static styles: import("lit").CSSResult[];
+    index: number;
+    open: boolean;
+    isTopPanel: boolean;
+    isInnerPanel: boolean;
+    isBottomPanel: boolean;
+    isSinglePanel: boolean;
+    belowOpenInnerPanel: boolean;
+    aboveOpenInnerPanel: boolean;
+    separateSinglePanel: boolean;
+    title: string;
+    contentPreview: string;
+    showFooter: boolean;
+    noSurface: boolean;
+    render(): import("lit-html").TemplateResult<1>;
+    resetPanel(): void;
+    private _toggleContent;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'cv-expansion-panel-item': CovalentExpansionPanelItem;
+    }
+}

package/expansion-panel/expansion-panel.d.ts

@@ -0,0 +1,15 @@
+import { LitElement } from 'lit';
+import { CovalentExpansionPanelItem } from './expansion-panel-item';
+export declare class CovalentExpansionPanel extends LitElement {
+    noSurface: boolean;
+    titleWidth: string;
+    panelItems: CovalentExpansionPanelItem[];
+    render(): import("lit-html").TemplateResult<1>;
+    private _handleToggle;
+    firstUpdated(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'cv-expansion-panel': CovalentExpansionPanel;
+    }
+}