tuix-webcomponents 0.64.0 → 0.66.0

package/dist/src/tuix-input/TuixInput.styles.d.ts

@@ -0,0 +1,8 @@
+export declare const hostStyles: import("lit").CSSResult;
+export declare const inputComponentStyles: import("lit").CSSResult;
+export declare const inputFontStyles: import("lit").CSSResult;
+export declare const inputColorStyles: import("lit").CSSResult;
+export declare const inputTitleStyles: import("lit").CSSResult;
+export declare const inputIconStyles: import("lit").CSSResult;
+export declare const inputSearchStyles: import("lit").CSSResult;
+export declare const inputDescriptionStyles: import("lit").CSSResult;

package/dist/src/tuix-input/TuixInput.styles.js

@@ -0,0 +1,295 @@
+import { css, unsafeCSS } from 'lit';
+import { ScreenSizes } from '../utils/screenSizes.enum';
+import { Palette } from '../utils/colors';
+import { DarkPalette } from '../utils/darkColors';
+import { hexToRgb } from '../utils/hex-rgb';
+const inputVars = {
+    gapX: '10px',
+    iconDesktopSize: '1.5rem',
+    iconMobileSize: '1rem',
+    paddingX: '1.25rem',
+};
+const rgbDarkValidation = hexToRgb(DarkPalette.VALIDATION);
+const rgbDarkError = hexToRgb(DarkPalette.ERROR);
+export const hostStyles = css `
+  :host {
+    --t-field-color-form: ${unsafeCSS(Palette.PRIMARY_50)};
+    --t-field-color-title: ${unsafeCSS(Palette.PRIMARY_600)};
+    --t-field-color-text: ${unsafeCSS(Palette.BLACK)};
+    --t-field-color-description: ${unsafeCSS(Palette.NEUTRAL_600)};
+    --t-field-color-stroke-hover: ${unsafeCSS(Palette.PRIMARY_300)};
+    --t-field-color-stroke-focus: ${unsafeCSS(Palette.MAIN)};
+    --t-field-color-text-disabled: ${unsafeCSS(Palette.PRIMARY_300)};
+    --t-field-color-stroke-validation: ${unsafeCSS(Palette.VALIDATION_200)};
+    --t-field-color-bg-validation: ${unsafeCSS(Palette.VALIDATION_50)};
+    --t-field-color-stroke-loading: ${unsafeCSS(Palette.PRIMARY_300)};
+    --t-field-color-bg-error: ${unsafeCSS(Palette.ERROR_50)};
+    --t-field-color-stroke-error: ${unsafeCSS(Palette.ERROR_200)};
+    --t-field-input-cursor: auto;
+    --t-field-font-size: 1rem;
+    --t-field-font-weight: 300;
+    --t-field-line-height: 1.25rem;
+    --t-field-padding-x: 1.25rem;
+    --t-field-padding-y: 1.125rem;
+    --t-field-padding-top: 1.625rem;
+    --t-field-padding-bottom: 0.625rem;
+    --t-field-title-left-position: 1.25rem;
+  }
+  :host([dark]) {
+    --t-field-color-form: ${unsafeCSS(DarkPalette.PRIMARY_950)};
+    --t-field-color-text: ${unsafeCSS(DarkPalette.PRIMARY_100)};
+    --t-field-color-description: ${unsafeCSS(DarkPalette.NEUTRAL_200)};
+    --t-field-color-stroke-focus: ${unsafeCSS(DarkPalette.SECONDARY)};
+    --t-field-color-text-disabled: ${unsafeCSS(DarkPalette.PRIMARY_800)};
+    --t-field-color-stroke-validation: ${unsafeCSS(DarkPalette.VALIDATION_200)};
+    --t-field-color-bg-validation: rgba(
+      ${rgbDarkValidation.r},
+      ${rgbDarkValidation.g},
+      ${rgbDarkValidation.b},
+      0.2
+    );
+    --t-field-color-bg-error: rgba(
+      ${rgbDarkError.r},
+      ${rgbDarkError.g},
+      ${rgbDarkError.b},
+      0.2
+    );
+    --t-field-color-stroke-error: ${unsafeCSS(DarkPalette.ERROR_200)};
+  }
+`;
+export const inputComponentStyles = css `
+  .t-textarea-main-container {
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+    height: 100%;
+  }
+  .t-input-container {
+    position: relative;
+    --t-padding-x-desktop-with-icon: calc(
+      var(--t-field-padding-x) + ${unsafeCSS(inputVars.iconDesktopSize)} +
+        ${unsafeCSS(inputVars.gapX)}
+    );
+    --t-padding-x-mobile-with-icon: calc(
+      var(--t-field-padding-x) + ${unsafeCSS(inputVars.iconMobileSize)} +
+        ${unsafeCSS(inputVars.gapX)}
+    );
+    --t-border-size: 1px;
+  }
+  .t-input-container.t-textarea-container {
+    height: 100%;
+  }
+  .t-input {
+    padding: calc(var(--t-field-padding-y) - var(--t-border-size))
+      var(--t-field-padding-x);
+    border-radius: 4px;
+    font-family: 'Rubik', sans-serif;
+    cursor: var(--t-field-input-cursor);
+    width: 100%;
+    box-sizing: border-box;
+  }
+  .t-input.t-textarea {
+    height: 100%;
+    display: block;
+  }
+  .t-input.with-title {
+    padding-top: calc(var(--t-field-padding-top) - var(--t-border-size));
+    padding-bottom: calc(var(--t-field-padding-bottom) - var(--t-border-size));
+  }
+  .t-input.with-icon-right {
+    padding-right: var(--t-padding-x-desktop-with-icon);
+  }
+  @media only screen and (max-width: ${ScreenSizes.MOBILE}px) {
+    .t-input.with-icon-right {
+      padding-right: var(--t-padding-x-mobile-with-icon);
+    }
+  }
+`;
+export const inputFontStyles = css `
+  .t-input::placeholder,
+  .t-input,
+  .t-title {
+    font-size: var(--t-field-font-size);
+    font-weight: var(--t-field-font-weight);
+    line-height: var(--t-field-line-height);
+  }
+  @media only screen and (max-width: ${ScreenSizes.TABLET}px) {
+    :host {
+      --t-field-font-size: 0.813rem;
+      --t-field-line-height: 1.125rem;
+      --t-field-padding-y: 1.063rem;
+      --t-field-padding-top: 1.5rem;
+    }
+  }
+  @media only screen and (max-width: ${ScreenSizes.MOBILE}px) {
+    :host {
+      --t-field-font-size: 0.813rem;
+      --t-field-line-height: 1rem;
+      --t-field-padding-y: 1rem;
+      --t-field-padding-top: 1.375rem;
+    }
+  }
+`;
+export const inputColorStyles = css `
+  .t-input {
+    background-color: var(--t-field-color-form);
+    border: 1px solid var(--t-field-color-form);
+    color: var(--t-field-color-text);
+  }
+  .t-input-container:hover .t-input,
+  .t-input:hover {
+    border: 1px solid var(--t-field-color-stroke-hover);
+  }
+  .t-input:focus {
+    border: 1px solid var(--t-field-color-stroke-focus);
+    outline: 1px solid var(--t-field-color-stroke-focus);
+  }
+  .t-input[disabled]:disabled {
+    cursor: not-allowed;
+    border: 1px solid var(--t-field-color-form);
+    color: var(--t-field-color-text-disabled);
+  }
+  .t-input.with-title::placeholder {
+    color: transparent;
+  }
+  .t-input::placeholder,
+  .t-input.with-title:focus::placeholder {
+    color: var(--t-field-color-title);
+  }
+  .t-input.with-warning {
+    border: 1px solid var(--t-field-color-stroke-validation);
+    background-color: var(--t-field-color-bg-validation);
+  }
+  .t-input.with-error {
+    border: 1px solid var(--t-field-color-stroke-error);
+    background-color: var(--t-field-color-bg-error);
+  }
+  .t-input.with-loading {
+    border: 1px solid var(--t-field-color-stroke-loading);
+  }
+`;
+export const inputTitleStyles = css `
+  .t-title {
+    position: absolute;
+    top: 50%;
+    left: var(--t-field-title-left-position);
+    font-family: 'Rubik', sans-serif;
+    color: var(--t-field-color-title);
+    transform: translateY(-50%);
+    transition-duration: 0.3s;
+    pointer-events: none;
+    -webkit-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+  }
+  .t-textarea-container .t-title {
+    top: 1rem;
+    transform: none;
+  }
+  .t-input.with-title:focus + .t-title,
+  .t-input.with-title:not(:placeholder-shown) + .t-title {
+    font-size: 0.75rem;
+    font-weight: 300;
+    line-height: 0.875rem;
+    transform: translateY(0);
+    top: 0.5rem;
+  }
+`;
+export const inputIconStyles = css `
+  .t-input-container .t-icon-set-container {
+    height: ${unsafeCSS(inputVars.iconDesktopSize)};
+    width: ${unsafeCSS(inputVars.iconDesktopSize)};
+    cursor: var(--t-field-input-cursor);
+  }
+  .t-icon-set-container.t-icon-click {
+    cursor: pointer;
+  }
+  .t-input-container .t-icon-set-container.t-icon-right {
+    position: absolute;
+    top: 50%;
+    right: var(--t-field-padding-x);
+    transform: translateY(-50%);
+  }
+  .t-input-container .t-icon-set-container.t-icon-left {
+    position: absolute;
+    top: 50%;
+    left: var(--t-field-padding-x);
+    transform: translateY(-50%);
+  }
+  .t-icon-inactive {
+    display: inline;
+  }
+  .t-icon-active {
+    display: none;
+  }
+  .t-icon-disabled {
+    display: none;
+  }
+  .t-input-container:hover .t-icon-set-container .t-icon-inactive,
+  .t-input:hover ~ .t-icon-set-container .t-icon-inactive,
+  .t-input:focus ~ .t-icon-set-container .t-icon-inactive {
+    display: none;
+  }
+  .t-input-container:hover .t-icon-set-container .t-icon-active,
+  .t-input:hover ~ .t-icon-set-container .t-icon-active,
+  .t-input:focus ~ .t-icon-set-container .t-icon-active {
+    display: inline;
+  }
+  .t-input[disabled] ~ .t-icon-set-container .t-icon-active {
+    display: none;
+  }
+  .t-input[disabled] ~ .t-icon-set-container .t-icon-inactive {
+    display: none;
+  }
+  .t-input[disabled] ~ .t-icon-set-container .t-icon-disabled {
+    display: inline;
+    cursor: not-allowed;
+  }
+  @media only screen and (max-width: ${ScreenSizes.MOBILE}px) {
+    .t-input-container .t-icon-set-container {
+      height: ${unsafeCSS(inputVars.iconMobileSize)};
+      width: ${unsafeCSS(inputVars.iconMobileSize)};
+    }
+  }
+`;
+export const inputSearchStyles = css `
+  .t-input[type='search'] {
+    padding-left: var(--t-padding-x-desktop-with-icon);
+  }
+  .t-input[type='search'] + .t-title {
+    left: var(--t-padding-x-desktop-with-icon);
+  }
+  @media only screen and (max-width: ${ScreenSizes.MOBILE}px) {
+    .t-input[type='search'] {
+      padding-left: var(--t-padding-x-mobile-with-icon);
+    }
+    .t-input[type='search'] + .t-title {
+      left: var(--t-padding-x-mobile-with-icon);
+    }
+  }
+  input[type='search']::-webkit-search-decoration,
+  input[type='search']::-webkit-search-cancel-button,
+  input[type='search']::-webkit-search-results-button,
+  input[type='search']::-webkit-search-results-decoration {
+    display: none;
+  }
+`;
+export const inputDescriptionStyles = css `
+  .t-input-description-container {
+    margin-top: 0.5rem;
+    font-family: 'Rubik', sans-serif;
+    font-size: 0.75rem;
+    line-height: 1rem;
+    color: var(--t-field-color-description);
+    display: flex;
+    justify-content: space-between;
+  }
+  .t-input-description-container .t-letter-counter {
+    align-self: flex-end;
+  }
+  .t-input-description-container .t-input-description {
+    display: flex;
+    gap: 0.5rem;
+  }
+`;

package/dist/src/tuix-input/enums/tuix-input.enums.d.ts

@@ -0,0 +1,38 @@
+import { IconName } from '../../tuix-icon/enums/tuix-icon.enums';
+import { Palette } from '../../utils/colors';
+import { DarkPalette } from '../../utils/darkColors';
+export declare enum InputType {
+    TEXT = "text",
+    SEARCH = "search",
+    PASSWORD = "password",
+    TEXT_AREA = "textarea"
+}
+export declare enum InputIconLocation {
+    LEFT = "left",
+    RIGHT = "right"
+}
+export declare enum DescriptionType {
+    TEXT = "text",
+    WARNING = "warning",
+    ERROR = "error",
+    SUCCESS = "success",
+    LOADING = "loading"
+}
+export declare const IconByDescriptionType: {
+    warning: IconName;
+    error: IconName;
+    success: IconName;
+    loading: IconName;
+};
+export declare const IconDescriptionColorLight: {
+    warning: Palette;
+    error: Palette;
+    success: Palette;
+    loading: Palette;
+};
+export declare const IconDescriptionColorDark: {
+    warning: DarkPalette;
+    error: DarkPalette;
+    success: DarkPalette;
+    loading: DarkPalette;
+};

package/dist/src/tuix-input/enums/tuix-input.enums.js

@@ -0,0 +1,41 @@
+import { IconName } from '../../tuix-icon/enums/tuix-icon.enums';
+import { Palette } from '../../utils/colors';
+import { DarkPalette } from '../../utils/darkColors';
+export var InputType;
+(function (InputType) {
+    InputType["TEXT"] = "text";
+    InputType["SEARCH"] = "search";
+    InputType["PASSWORD"] = "password";
+    InputType["TEXT_AREA"] = "textarea";
+})(InputType || (InputType = {}));
+export var InputIconLocation;
+(function (InputIconLocation) {
+    InputIconLocation["LEFT"] = "left";
+    InputIconLocation["RIGHT"] = "right";
+})(InputIconLocation || (InputIconLocation = {}));
+export var DescriptionType;
+(function (DescriptionType) {
+    DescriptionType["TEXT"] = "text";
+    DescriptionType["WARNING"] = "warning";
+    DescriptionType["ERROR"] = "error";
+    DescriptionType["SUCCESS"] = "success";
+    DescriptionType["LOADING"] = "loading";
+})(DescriptionType || (DescriptionType = {}));
+export const IconByDescriptionType = {
+    [DescriptionType.WARNING]: IconName.TRIANGLE_EXCLAMATION,
+    [DescriptionType.ERROR]: IconName.CIRCLE_X,
+    [DescriptionType.SUCCESS]: IconName.CIRCLE_CHECK,
+    [DescriptionType.LOADING]: IconName.LOADER,
+};
+export const IconDescriptionColorLight = {
+    [DescriptionType.WARNING]: Palette.VALIDATION,
+    [DescriptionType.ERROR]: Palette.ERROR,
+    [DescriptionType.SUCCESS]: Palette.SUCCESS,
+    [DescriptionType.LOADING]: Palette.PRIMARY_300,
+};
+export const IconDescriptionColorDark = {
+    [DescriptionType.WARNING]: DarkPalette.VALIDATION,
+    [DescriptionType.ERROR]: DarkPalette.ERROR,
+    [DescriptionType.SUCCESS]: DarkPalette.SUCCESS,
+    [DescriptionType.LOADING]: DarkPalette.PRIMARY_300,
+};

package/dist/src/tuix-input/interfaces/tuix-input.interface.d.ts

@@ -0,0 +1,18 @@
+import { IconName } from '../../tuix-icon/enums/tuix-icon.enums';
+import { type DetailValue } from '../../utils/interfaces/detail-value.interface';
+import { InputIconLocation } from '../enums/tuix-input.enums';
+import { DarkPalette } from '../../utils/darkColors';
+import { Palette } from '../../utils/colors';
+export declare const InputState: {
+    INACTIVE: string;
+    ACTIVE: string;
+    DISABLED: string;
+};
+export type InputState = (typeof InputState)[keyof typeof InputState];
+export interface FormatIconSetParams {
+    iconName: IconName;
+    colorByState: Record<InputState, DarkPalette | Palette>;
+    location?: InputIconLocation;
+    clickHandler?: (e: MouseEvent) => void;
+}
+export type CustomEventTuixInput = CustomEvent<DetailValue<string>>;

package/dist/src/tuix-input/interfaces/tuix-input.interface.js

@@ -0,0 +1,5 @@
+export const InputState = {
+    INACTIVE: 'inactive',
+    ACTIVE: 'active',
+    DISABLED: 'disabled',
+};

package/dist/src/tuix-link/TuixLink.d.ts

@@ -0,0 +1,15 @@
+import { LitElement, type TemplateResult } from 'lit';
+import { MainVariant } from '../utils/mainVariant.enum';
+import { LinkTarget } from './enums/linkTarget.enum';
+export declare class TuixLink extends LitElement {
+    static styles: import("lit").CSSResult[];
+    href?: string;
+    target: LinkTarget;
+    variant: MainVariant;
+    disabled: boolean;
+    dark: boolean;
+    private _getClassMap;
+    private _anchorTemplate;
+    private _divTemplate;
+    render(): TemplateResult;
+}

package/dist/src/tuix-link/TuixLink.js

@@ -0,0 +1,71 @@
+import { __decorate } from "tslib";
+import { html, LitElement } from 'lit';
+import { customElement, property } from 'lit/decorators.js';
+import { MainVariant } from '../utils/mainVariant.enum';
+import { LinkTarget } from './enums/linkTarget.enum';
+import { classMap } from 'lit/directives/class-map.js';
+import { linkStyles } from './TuixLink.styles';
+import { linkFontStyles } from '../tuix-text/TuixText.styles';
+let TuixLink = class TuixLink extends LitElement {
+    constructor() {
+        super(...arguments);
+        this.target = LinkTarget.BLANK;
+        this.variant = MainVariant.PRIMARY;
+        this.disabled = false;
+        this.dark = false;
+    }
+    static { this.styles = [linkStyles, linkFontStyles]; }
+    _getClassMap() {
+        return {
+            link: true,
+            disabled: this.disabled,
+            [MainVariant.SECONDARY]: this.variant === MainVariant.SECONDARY,
+        };
+    }
+    _anchorTemplate() {
+        return html `
+      <a
+        target="${this.disabled ? LinkTarget.SELF : this.target}"
+        class="${classMap(this._getClassMap())}"
+        href="${this.disabled ? 'javascript:void(0)' : this.href}"
+      >
+        <slot></slot>
+      </a>
+    `;
+    }
+    _divTemplate() {
+        return html `
+      <div class="${classMap(this._getClassMap())}">
+        <slot></slot>
+      </div>
+    `;
+    }
+    render() {
+        const isValidAnchor = this.href && !this.disabled;
+        if (isValidAnchor) {
+            return this._anchorTemplate();
+        }
+        else {
+            return this._divTemplate();
+        }
+    }
+};
+__decorate([
+    property({ type: String })
+], TuixLink.prototype, "href", void 0);
+__decorate([
+    property({ type: LinkTarget })
+], TuixLink.prototype, "target", void 0);
+__decorate([
+    property({ type: MainVariant, reflect: true })
+], TuixLink.prototype, "variant", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], TuixLink.prototype, "disabled", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], TuixLink.prototype, "dark", void 0);
+TuixLink = __decorate([
+    customElement('tuix-link')
+], TuixLink);
+export { TuixLink };

package/dist/src/tuix-link/TuixLink.styles.d.ts

@@ -0,0 +1,2 @@
+export declare const LINK_TEXT_COLOR_VAR_NAME = "--t-link-text-color";
+export declare const linkStyles: import("lit").CSSResult;

package/dist/src/tuix-link/TuixLink.styles.js

@@ -0,0 +1,55 @@
+import { css, unsafeCSS } from 'lit';
+import { MainVariant } from '../utils/mainVariant.enum';
+import { Palette } from '../utils/colors';
+import { DarkPalette } from '../utils/darkColors';
+export const LINK_TEXT_COLOR_VAR_NAME = '--t-link-text-color';
+export const linkStyles = css `
+  ${unsafeCSS(`
+  :host {
+    --t-link-border-color: ${Palette.MAIN};
+    ${LINK_TEXT_COLOR_VAR_NAME}: ${Palette.MAIN}
+  }
+
+  :host([dark]) {
+    --t-link-border-color: ${DarkPalette.MAIN};
+    ${LINK_TEXT_COLOR_VAR_NAME}: ${DarkPalette.MAIN}
+  }
+
+  :host([variant=${MainVariant.SECONDARY}]) {
+    --t-link-border-color: ${Palette.WHITE};
+    ${LINK_TEXT_COLOR_VAR_NAME}: ${Palette.WHITE}
+  }
+
+  :host([variant=${MainVariant.SECONDARY}][dark]) {
+    --t-link-border-color: ${DarkPalette.WHITE};
+    ${LINK_TEXT_COLOR_VAR_NAME}: ${DarkPalette.WHITE}
+  }
+
+  :host([disabled]) .link.disabled {
+    --t-link-border-color: ${Palette.PRIMARY_300};
+    ${LINK_TEXT_COLOR_VAR_NAME}: ${Palette.PRIMARY_300}
+  }
+
+  .link {    
+    text-decoration: none;
+    display: inline;
+    color: var(${LINK_TEXT_COLOR_VAR_NAME});
+    border-bottom: solid 1px var(--t-link-border-active-color, transparent);
+  }
+  .link:hover {
+    border-bottom: solid 1px var(--t-link-border-color);
+    cursor: pointer;
+  }
+  .link.secondary {
+    color: var(${LINK_TEXT_COLOR_VAR_NAME});
+  }
+  .link.secondary:hover {
+    border-bottom: solid 1px var(--t-link-border-color);
+  }  
+  .link.disabled {
+    border-bottom: solid 1px var(--t-link-border-color);
+    color: var(${LINK_TEXT_COLOR_VAR_NAME});
+    cursor: not-allowed;
+  }  
+`)}
+`;

package/dist/src/tuix-link/enums/linkTarget.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum LinkTarget {
+    BLANK = "_blank",
+    SELF = "_self",
+    PARENT = "_parent",
+    TOP = "_top"
+}

package/dist/src/tuix-link/enums/linkTarget.enum.js

@@ -0,0 +1,7 @@
+export var LinkTarget;
+(function (LinkTarget) {
+    LinkTarget["BLANK"] = "_blank";
+    LinkTarget["SELF"] = "_self";
+    LinkTarget["PARENT"] = "_parent";
+    LinkTarget["TOP"] = "_top";
+})(LinkTarget || (LinkTarget = {}));

package/dist/src/tuix-modal/TuixModal.d.ts

@@ -0,0 +1,9 @@
+import { LitElement } from 'lit';
+export declare class TuixModal extends LitElement {
+    static styles: import("lit").CSSResult[];
+    visible: boolean;
+    dark: boolean;
+    scrollable: boolean;
+    protected _onClose(): void;
+    render(): import("lit-html").TemplateResult<1>;
+}

package/dist/src/tuix-modal/TuixModal.js

@@ -0,0 +1,63 @@
+import { __decorate } from "tslib";
+import { html, LitElement } from 'lit';
+import { customElement, property } from 'lit/decorators.js';
+import { BorderRadiusPaper, PaperElevation, } from '../tuix-paper/enums/tuix-paper.enum.js';
+import { commonModalStyles, mobileModalStyles } from './TuixModal.styles.js';
+import { TextVariant } from '../tuix-text/enums/tuix-text.enums.js';
+import { IconName, IconSizeVariant, } from '../tuix-icon/enums/tuix-icon.enums.js';
+let TuixModal = class TuixModal extends LitElement {
+    constructor() {
+        super(...arguments);
+        this.visible = false;
+        this.dark = false;
+        this.scrollable = false;
+    }
+    static { this.styles = [commonModalStyles, mobileModalStyles]; }
+    _onClose() {
+        this.visible = false;
+        this.dispatchEvent(new CustomEvent('on-close', { bubbles: true }));
+    }
+    render() {
+        return html `
+      <tuix-paper
+        class="modal-container"
+        elevation=${PaperElevation.VARIANT_4}
+        border-radius=${BorderRadiusPaper.SOFT}
+        ?dark=${this.dark}
+      >
+        <div class="content">
+          <header>
+            <slot name="title"></slot>
+            <tuix-icon
+              @click=${this._onClose}
+              class="close-icon"
+              size="${IconSizeVariant.MEDIUM}"
+              name="${IconName.X}"
+              color="${TextVariant.MAIN}"
+              ?dark=${this.dark}
+            ></tuix-icon>
+          </header>
+          <div class="body" ?scrollable=${this.scrollable}>
+            <slot name="body"></slot>
+          </div>
+          <div class="action-buttons">
+            <slot name="actions"></slot>
+          </div>
+        </div>
+      </tuix-paper>
+    `;
+    }
+};
+__decorate([
+    property({ type: Boolean, reflect: true })
+], TuixModal.prototype, "visible", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], TuixModal.prototype, "dark", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], TuixModal.prototype, "scrollable", void 0);
+TuixModal = __decorate([
+    customElement('tuix-modal')
+], TuixModal);
+export { TuixModal };

package/dist/src/tuix-modal/TuixModal.styles.d.ts

@@ -0,0 +1,2 @@
+export declare const commonModalStyles: import("lit").CSSResult;
+export declare const mobileModalStyles: import("lit").CSSResult;