tuix-webcomponents 0.0.22 → 0.0.25

package/dist/src/tuix-button/TuixButton.js

@@ -1,63 +1,25 @@
 import { __decorate } from "tslib";
-import { LitElement, css, html, nothing } from 'lit';
+import { css, html, nothing } from 'lit';
 import { IconName, IconSizeVariant } from '../tuix-icon/enums/tuix-icon.enums';
-import { buttonSizeStyles, buttonColorStyles } from './TuixButton.styles';
+import { buttonSizeStyles, buttonColorStyles, hostButtonStyles, } from './TuixButton.styles';
 import { customElement, property } from 'lit/decorators.js';
-import '../tuix-icon/TuixIcon.js';
-import { palette } from '../utils/colors';
-import { MainVariant } from '../utils/mainVariant.enum';
-import { buttonTextColor } from './enums/tuix-button.enums';
 import { ScreenSizes } from '../utils/screenSizes.enum';
-let TuixButton = class TuixButton extends LitElement {
+import { TuixBaseButton } from './TuixBaseButton';
+let TuixButton = class TuixButton extends TuixBaseButton {
     constructor() {
         super(...arguments);
-        this.iconColor = '';
-        this.variant = MainVariant.PRIMARY;
-        this.disabled = false;
+        this.full = false;
     }
-    _getIconColor() {
-        this.iconColor = buttonTextColor[this.variant];
-        if (this.disabled)
-            this.iconColor = palette.primary_300;
-        return this.iconColor;
-    }
-    _handleClick() {
-        this.dispatchEvent(new CustomEvent('click', { bubbles: true }));
-    }
-    _iconTemplate(iconName) {
-        let iconSize = IconSizeVariant.MEDIUM;
-        if (screen.width <= ScreenSizes.TABLET) {
-            iconSize = IconSizeVariant.SMALL;
-        }
-        return html `<tuix-icon
-      size="${iconSize}"
-      name="${iconName}"
-      color="${this._getIconColor()}"
-    ></tuix-icon>`;
-    }
-    getButtonStyles() {
-        return `${this.variant}`;
-    }
-    render() {
-        return html `<button
-      @click=${this._handleClick}
-      class="button ${this.getButtonStyles()}"
-      ?disabled="${this.disabled}"
-    >
-      <div class="container">
-        ${this.iconLeft ? this._iconTemplate(this.iconLeft) : nothing}
-        <slot></slot>
-        ${this.iconRight ? this._iconTemplate(this.iconRight) : nothing}
-      </div>
-    </button>`;
-    }
-};
-TuixButton.styles = [
-    css `
+    static { this.styles = [
+        css `
+      :host([full]) .button {
+        width: 100%;
+      }
       .button {
         padding: 16px 32px;
         border-radius: 4px;
-        font-family: 'rubik', sans-serif;
+        border: none;
+        font-family: 'Rubik', sans-serif;
       }
 
       @media only screen and (max-width: ${ScreenSizes.TABLET}px) {
@@ -86,15 +48,30 @@ TuixButton.styles = [
         }
       }
     `,
-    buttonColorStyles,
-    buttonSizeStyles,
-];
-__decorate([
-    property({ type: MainVariant })
-], TuixButton.prototype, "variant", void 0);
+        hostButtonStyles,
+        buttonColorStyles,
+        buttonSizeStyles,
+    ]; }
+    _updateIconColor() {
+        if (!this.iconLeft && !this.iconRight)
+            return;
+        this.iconColor = this._getTextColor();
+    }
+    _buttonContent() {
+        let iconSize = IconSizeVariant.MEDIUM;
+        if (screen.width <= ScreenSizes.TABLET) {
+            iconSize = IconSizeVariant.SMALL;
+        }
+        return html ` <div class="container">
+      ${this.iconLeft ? this._iconTemplate(this.iconLeft, iconSize) : nothing}
+      <slot></slot>
+      ${this.iconRight ? this._iconTemplate(this.iconRight, iconSize) : nothing}
+    </div>`;
+    }
+};
 __decorate([
-    property({ type: Boolean })
-], TuixButton.prototype, "disabled", void 0);
+    property({ type: Boolean, reflect: true })
+], TuixButton.prototype, "full", void 0);
 __decorate([
     property({ type: IconName })
 ], TuixButton.prototype, "iconRight", void 0);
@@ -105,4 +82,3 @@ TuixButton = __decorate([
     customElement('tuix-button')
 ], TuixButton);
 export { TuixButton };
-//# sourceMappingURL=TuixButton.js.map

package/dist/src/tuix-button/TuixButton.styles.d.ts

@@ -1,2 +1,3 @@
+export declare const hostButtonStyles: import("lit").CSSResult;
 export declare const buttonSizeStyles: import("lit").CSSResult;
 export declare const buttonColorStyles: import("lit").CSSResult;

package/dist/src/tuix-button/TuixButton.styles.js

@@ -1,74 +1,107 @@
 import { css, unsafeCSS } from 'lit';
-import { palette } from '../utils/colors';
+import { Palette } from '../utils/colors';
 import { ScreenSizes } from '../utils/screenSizes.enum';
+import { DarkPalette } from '../utils/darkColors';
+import { MainVariant } from '../utils/mainVariant.enum';
+import slottedClassName from '../utils/slottedClassName';
+import { TextSize } from '../tuix-text/enums/tuix-text.enums';
+export const hostButtonStyles = css `
+  :host {
+    --t-button-primary-color: ${unsafeCSS(Palette.MAIN)};
+    --t-button-secondary-color: ${unsafeCSS(Palette.WHITE)};
+    --t-button-accent-color: ${unsafeCSS(Palette.SECONDARY)};
+    --t-button-text-color: ${unsafeCSS(Palette.WHITE)};
+    --t-button-text-secondary-color: ${unsafeCSS(Palette.MAIN)};
+    --t-button-text-muted-color: ${unsafeCSS(Palette.PRIMARY_300)};
+    --t-button-disabled-bg-color: ${unsafeCSS(Palette.PRIMARY_100)};
+    --t-button-hover-primary-color: ${unsafeCSS(Palette.PRIMARY_600)};
+    --t-button-active-primary-color: ${unsafeCSS(Palette.PRIMARY_800)};
+    --t-button-hover-secondary-color: ${unsafeCSS(Palette.PRIMARY_100)};
+    --t-button-active-secondary-color: ${unsafeCSS(Palette.PRIMARY_200)};
+  }
+  :host([dark]) {
+    --t-button-primary-color: ${unsafeCSS(DarkPalette.MAIN)};
+    --t-button-text-color: ${unsafeCSS(DarkPalette.WHITE)};
+    --t-button-text-muted-color: ${unsafeCSS(Palette.PRIMARY_800)};
+    --t-button-disabled-bg-color: ${unsafeCSS(Palette.PRIMARY_950)};
+    --t-button-hover-primary-color: ${unsafeCSS(Palette.MAIN)};
+    --t-button-active-primary-color: ${unsafeCSS(Palette.PRIMARY_600)};
+    --t-button-secondary-color: ${unsafeCSS(Palette.BLACK)};
+    --t-button-hover-secondary-color: ${unsafeCSS(Palette.PRIMARY_950)};
+    --t-button-active-secondary-color: ${unsafeCSS(Palette.PRIMARY_800)};
+  }
+`;
 export const buttonSizeStyles = css `
-  .button {
-    font-size: 1.25rem;
+  ${unsafeCSS(`
+  ${slottedClassName(TextSize.Button)} {
+    font-size: 1rem;
     font-weight: 400;
-    line-height: 1.5rem;
+    line-height: 1.25rem;
   }
   @media only screen and (max-width: ${ScreenSizes.TABLET}px) {
-    .button {
-      font-size: 1rem;
+    ${slottedClassName(TextSize.Button)} {
+      font-size: 0.938rem;
       font-weight: 400;
-      line-height: 1.25rem;
+      line-height: 1.125rem;
     }
   }
   @media only screen and (max-width: ${ScreenSizes.MOBILE}px) {
-    .button {
+    ${slottedClassName(TextSize.Button)} {
       font-size: 0.875rem;
       font-weight: 400;
       line-height: 1rem;
     }
   }
+`)}
 `;
 export const buttonColorStyles = css `
-  .button.primary {
-    background-color: ${unsafeCSS(palette.main)};
-    border: none;
-    color: ${unsafeCSS(palette.white)};
+  :host([variant='${unsafeCSS(MainVariant.PRIMARY)}']) .button {
+    background-color: var(--t-button-primary-color);
+    outline: none;
+    color: var(--t-button-text-color);
   }
-  .button.primary:hover {
-    background-color: ${unsafeCSS(palette.primary_600)};
+  :host([variant='${unsafeCSS(MainVariant.PRIMARY)}']) .button:hover {
+    background-color: var(--t-button-hover-primary-color);
     cursor: pointer;
   }
-  .button.primary:focus {
-    background-color: ${unsafeCSS(palette.primary_600)};
-    border: 2px solid ${unsafeCSS(palette.secondary)};
+  :host([variant='${unsafeCSS(MainVariant.PRIMARY)}']) .button:focus {
+    background-color: var(--t-button-hover-primary-color);
+    outline: 2px solid var(--t-button-accent-color);
   }
-  .button.primary:active {
-    background-color: ${unsafeCSS(palette.primary_800)};
-    border: none;
+  :host([variant='${unsafeCSS(MainVariant.PRIMARY)}']) .button:active {
+    background-color: var(--t-button-active-primary-color);
+    outline: none;
   }
-  .button.primary:disabled {
-    background-color: ${unsafeCSS(palette.primary_100)};
-    color: ${unsafeCSS(palette.primary_300)};
-    cursor: not-allowed;
-  }
-  .button.secondary {
-    background-color: ${unsafeCSS(palette.white)};
-    border: 2px solid ${unsafeCSS(palette.main)};
-    color: ${unsafeCSS(palette.main)};
+
+  :host([variant='${unsafeCSS(MainVariant.SECONDARY)}']) .button {
+    background-color: var(--t-button-secondary-color);
+    outline: 1px solid var(--t-button-hover-primary-color);
+    color: var(--t-button-text-secondary-color);
   }
-  .button.secondary:hover {
-    background-color: ${unsafeCSS(palette.primary_100)};
-    border: 2px solid ${unsafeCSS(palette.main)};
+  :host([variant='${unsafeCSS(MainVariant.SECONDARY)}']) .button:hover {
+    background-color: var(--t-button-hover-secondary-color);
+    outline: 1px solid var(--t-button-primary-color);
+    color: var(--t-button-primary-color);
     cursor: pointer;
   }
-  .button.secondary:focus {
-    background-color: ${unsafeCSS(palette.primary_100)};
-    border: 2px solid ${unsafeCSS(palette.secondary)};
+  :host([variant='${unsafeCSS(MainVariant.SECONDARY)}']) .button:focus {
+    background-color: var(--t-button-hover-secondary-color);
+    outline: 2px solid var(--t-button-accent-color);
+    color: var(--t-button-primary-color);
+  }
+  :host([variant='${unsafeCSS(MainVariant.SECONDARY)}']) .button:active {
+    background-color: var(--t-button-active-secondary-color);
+    outline: 1px solid var(--t-button-primary-color);
+    color: var(--t-button-primary-color);
   }
-  .button.secondary:active {
-    background-color: ${unsafeCSS(palette.primary_200)};
-    border: none;
-    color: ${unsafeCSS(palette.main)};
+  :host([variant='${unsafeCSS(MainVariant.SECONDARY)}']) .button:disabled {
+    outline: 1px solid var(--t-button-text-muted-color);
   }
-  .button.secondary:disabled {
-    background-color: ${unsafeCSS(palette.primary_100)};
-    border: none;
-    color: ${unsafeCSS(palette.primary_300)};
+
+  :host([variant='${unsafeCSS(MainVariant.SECONDARY)}'][disabled]) .button,
+  :host([variant='${unsafeCSS(MainVariant.PRIMARY)}'][disabled]) .button {
+    background-color: var(--t-button-disabled-bg-color);
+    color: var(--t-button-text-muted-color);
     cursor: not-allowed;
   }
 `;
-//# sourceMappingURL=TuixButton.styles.js.map

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

@@ -1,7 +1,6 @@
-import { palette } from '../../utils/colors';
+import { Palette } from '../../utils/colors';
 import { MainVariant } from '../../utils/mainVariant.enum';
 export const buttonTextColor = {
-    [MainVariant.PRIMARY]: palette.white,
-    [MainVariant.SECONDARY]: palette.main,
+    [MainVariant.PRIMARY]: Palette.WHITE,
+    [MainVariant.SECONDARY]: Palette.MAIN,
 };
-//# sourceMappingURL=tuix-button.enums.js.map

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

@@ -0,0 +1 @@
+export type CustomEventTuixButton = CustomEvent<undefined>;

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

@@ -0,0 +1 @@
+export {};

package/dist/src/tuix-checkbox/TuixCheckbox.d.ts

@@ -0,0 +1,17 @@
+import { LitElement, type TemplateResult } from 'lit';
+import '../tuix-icon/TuixIcon.js';
+import '../tuix-text/TuixText.js';
+import { CheckboxLabelSide } from './enums/tuix-checkbox.enums';
+export declare class TuixCheckbox extends LitElement {
+    static styles: import("lit").CSSResult[];
+    checked: boolean;
+    disabled: boolean;
+    dark: boolean;
+    error: boolean;
+    label: string;
+    labelSide: CheckboxLabelSide;
+    private _onCheckboxChange;
+    private _getIconMode;
+    private _getFullContainerClasses;
+    protected render(): TemplateResult;
+}

package/dist/src/tuix-checkbox/TuixCheckbox.js

@@ -0,0 +1,108 @@
+import { __decorate } from "tslib";
+import { LitElement, html } from 'lit';
+import { customElement, property } from 'lit/decorators.js';
+import { classMap } from 'lit/directives/class-map.js';
+import '../tuix-icon/TuixIcon.js';
+import '../tuix-text/TuixText.js';
+import { IconName, IconSizeVariant } from '../tuix-icon/enums/tuix-icon.enums';
+import { TextSize, TextVariant } from '../tuix-text/enums/tuix-text.enums';
+import { checkboxCheckmarkStyles, checkboxContainerStyles, checkboxLabelStyles, hostStyles, } from './TuixCheckbox.styles';
+import { CheckboxIconColorDark, CheckboxIconColorLight, CheckboxIconMode, CheckboxLabelSide, } from './enums/tuix-checkbox.enums';
+let TuixCheckbox = class TuixCheckbox extends LitElement {
+    constructor() {
+        super(...arguments);
+        this.checked = false;
+        this.disabled = false;
+        this.dark = false;
+        this.error = false;
+        this.label = '';
+        this.labelSide = CheckboxLabelSide.RIGHT;
+    }
+    static { this.styles = [
+        hostStyles,
+        checkboxContainerStyles,
+        checkboxCheckmarkStyles,
+        checkboxLabelStyles,
+    ]; }
+    _onCheckboxChange(event) {
+        this.dispatchEvent(new CustomEvent('change', {
+            detail: {
+                value: event.target.checked,
+                label: this.label,
+            },
+            bubbles: true,
+        }));
+    }
+    _getIconMode() {
+        if (this.disabled) {
+            return CheckboxIconMode.DISABLED;
+        }
+        if (this.error) {
+            return CheckboxIconMode.ERROR;
+        }
+        return CheckboxIconMode.DEFAULT;
+    }
+    _getFullContainerClasses() {
+        return {
+            't-checkbox-full-container': true,
+            't-with-error': this.error && !this.disabled,
+            't-with-label-left': this.labelSide === CheckboxLabelSide.LEFT,
+        };
+    }
+    render() {
+        return html `<label class="${classMap(this._getFullContainerClasses())}">
+      <div class="t-checkbox-container">
+        <input
+          type="checkbox"
+          class="t-checkbox"
+          .checked="${this.checked}"
+          ?disabled="${this.disabled}"
+          @change="${this._onCheckboxChange}"
+        />
+        <div class="t-checkbox-checkmark">
+          <tuix-icon
+            size="${IconSizeVariant.FULL}"
+            name="${IconName.CHECK}"
+            color="${this.dark
+            ? CheckboxIconColorDark[this._getIconMode()]
+            : CheckboxIconColorLight[this._getIconMode()]}"
+          >
+          </tuix-icon>
+        </div>
+      </div>
+      <div class="t-checkbox-label">
+        <slot>
+          <tuix-text
+            size="${TextSize.FieldPlaceholder}"
+            color="${TextVariant.PRIMARY}"
+            ?dark="${this.dark}"
+          >
+            ${this.label}
+          </tuix-text>
+        </slot>
+      </div>
+    </label>`;
+    }
+};
+__decorate([
+    property({ type: Boolean })
+], TuixCheckbox.prototype, "checked", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], TuixCheckbox.prototype, "disabled", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], TuixCheckbox.prototype, "dark", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], TuixCheckbox.prototype, "error", void 0);
+__decorate([
+    property({ type: String })
+], TuixCheckbox.prototype, "label", void 0);
+__decorate([
+    property({ type: String })
+], TuixCheckbox.prototype, "labelSide", void 0);
+TuixCheckbox = __decorate([
+    customElement('tuix-checkbox')
+], TuixCheckbox);
+export { TuixCheckbox };

package/dist/src/tuix-checkbox/TuixCheckbox.styles.d.ts

@@ -0,0 +1,4 @@
+export declare const hostStyles: import("lit").CSSResult;
+export declare const checkboxContainerStyles: import("lit").CSSResult;
+export declare const checkboxCheckmarkStyles: import("lit").CSSResult;
+export declare const checkboxLabelStyles: import("lit").CSSResult;

package/dist/src/tuix-checkbox/TuixCheckbox.styles.js

@@ -0,0 +1,132 @@
+import { css, unsafeCSS } from 'lit';
+import { Palette } from '../utils/colors';
+import { DarkPalette } from '../utils/darkColors';
+import { ScreenSizes } from '../utils/screenSizes.enum';
+export const hostStyles = css `
+  :host {
+    --t-main-color-tuix: ${unsafeCSS(Palette.MAIN)};
+    --t-bg-color-primary: ${unsafeCSS(Palette.WHITE)};
+    --t-bg-color-disabled: ${unsafeCSS(Palette.PRIMARY_100)};
+    --t-text-color-error: ${unsafeCSS(Palette.ERROR)};
+    --t-stroke-color-focus: ${unsafeCSS(Palette.SECONDARY)};
+    --t-stroke-color-grey: ${unsafeCSS(Palette.PRIMARY_300)};
+    --t-text-color-label: ${unsafeCSS(Palette.BLACK)};
+    --t-label-right-default-justify: flex-start;
+    --t-label-left-default-justify: space-between;
+  }
+  :host([dark]) {
+    --t-main-color-tuix: ${unsafeCSS(DarkPalette.MAIN)};
+    --t-bg-color-primary: ${unsafeCSS(DarkPalette.BLACK)};
+    --t-bg-color-disabled: ${unsafeCSS(DarkPalette.PRIMARY_800)};
+    --t-text-color-error: ${unsafeCSS(DarkPalette.ERROR)};
+    --t-stroke-color-focus: ${unsafeCSS(DarkPalette.SECONDARY)};
+    --t-stroke-color-grey: ${unsafeCSS(DarkPalette.PRIMARY_100)};
+    --t-text-color-label: ${unsafeCSS(DarkPalette.WHITE)};
+  }
+`;
+export const checkboxContainerStyles = css `
+  .t-checkbox-full-container {
+    display: flex;
+    justify-content: var(--t-label-right-default-justify, flex-start);
+    cursor: pointer;
+    -webkit-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+  }
+  :host([disabled]) .t-checkbox-full-container {
+    cursor: not-allowed;
+  }
+  .t-checkbox-container {
+    --t-checkbox-size-box: 1.5rem;
+    --t-checkbox-shadow-width: 2px;
+    --t-checkbox-border-radius: 0.25rem;
+    display: block;
+    position: relative;
+    height: var(--t-checkbox-size-box);
+    width: var(--t-checkbox-size-box);
+    min-width: var(--t-checkbox-size-box);
+  }
+  .t-checkbox-container .t-checkbox {
+    position: absolute;
+    opacity: 0;
+    height: 0;
+    width: 0;
+  }
+  @media only screen and (max-width: ${ScreenSizes.MOBILE}px) {
+    .t-checkbox-container {
+      --t-checkbox-size-box: 1rem;
+      --t-checkbox-shadow-width: 1px;
+      --t-checkbox-border-radius: 0.125rem;
+      margin-top: 1px;
+    }
+  }
+`;
+export const checkboxCheckmarkStyles = css `
+  .t-checkbox-container .t-checkbox-checkmark {
+    position: absolute;
+    top: 0;
+    left: 0;
+    display: flex;
+    height: var(--t-checkbox-size-box);
+    width: var(--t-checkbox-size-box);
+    border-radius: var(--t-checkbox-border-radius);
+    background-color: var(--t-bg-color-primary);
+    border: 1px solid var(--t-stroke-color-grey);
+    box-sizing: border-box;
+  }
+  .t-checkbox-container .t-checkbox-checkmark tuix-icon {
+    margin: auto;
+    display: none;
+    width: calc(var(--t-checkbox-size-box) - 0.5rem);
+    height: calc(var(--t-checkbox-size-box) - 0.5rem);
+  }
+  .t-checkbox-container .t-checkbox:checked ~ .t-checkbox-checkmark {
+    background-color: var(--t-main-color-tuix);
+    border: none;
+  }
+  .t-checkbox-container .t-checkbox:focus ~ .t-checkbox-checkmark {
+    box-shadow: 0 0 0px var(--t-checkbox-shadow-width)
+      var(--t-stroke-color-focus);
+    border: 1px solid var(--t-main-color-tuix);
+  }
+  .t-checkbox-container .t-checkbox:checked ~ .t-checkbox-checkmark tuix-icon {
+    display: block;
+  }
+  .t-checkbox-full-container:hover .t-checkbox-container .t-checkbox-checkmark {
+    border: 1px solid var(--t-main-color-tuix);
+  }
+  .t-checkbox-full-container.t-with-error
+    .t-checkbox-container
+    .t-checkbox-checkmark {
+    border: 1px solid var(--t-text-color-error);
+  }
+  .t-checkbox-full-container.t-with-error
+    .t-checkbox-container
+    .t-checkbox:checked
+    ~ .t-checkbox-checkmark {
+    background-color: var(--t-text-color-error);
+    border: none;
+  }
+
+  .t-checkbox-container .t-checkbox:disabled ~ .t-checkbox-checkmark {
+    background-color: var(--t-bg-color-disabled);
+    border: none;
+    box-shadow: none;
+  }
+`;
+export const checkboxLabelStyles = css `
+  .t-checkbox-label {
+    display: block;
+    color: var(--t-text-color-label);
+    margin-left: 0.625rem;
+  }
+  .t-checkbox-full-container.t-with-label-left {
+    flex-direction: row-reverse;
+    justify-content: var(--t-label-left-default-justify, space-between);
+  }
+  .t-checkbox-full-container.t-with-label-left .t-checkbox-label {
+    margin-right: 0.625rem;
+    margin-left: 0;
+  }
+`;

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

@@ -0,0 +1,21 @@
+import { Palette } from '../../utils/colors';
+import { DarkPalette } from '../../utils/darkColors';
+export declare enum CheckboxIconMode {
+    DEFAULT = "default",
+    DISABLED = "disabled",
+    ERROR = "error"
+}
+export declare enum CheckboxLabelSide {
+    LEFT = "left",
+    RIGHT = "right"
+}
+export declare const CheckboxIconColorLight: {
+    default: Palette;
+    disabled: Palette;
+    error: Palette;
+};
+export declare const CheckboxIconColorDark: {
+    default: DarkPalette;
+    disabled: DarkPalette;
+    error: DarkPalette;
+};

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

@@ -0,0 +1,23 @@
+import { Palette } from '../../utils/colors';
+import { DarkPalette } from '../../utils/darkColors';
+export var CheckboxIconMode;
+(function (CheckboxIconMode) {
+    CheckboxIconMode["DEFAULT"] = "default";
+    CheckboxIconMode["DISABLED"] = "disabled";
+    CheckboxIconMode["ERROR"] = "error";
+})(CheckboxIconMode || (CheckboxIconMode = {}));
+export var CheckboxLabelSide;
+(function (CheckboxLabelSide) {
+    CheckboxLabelSide["LEFT"] = "left";
+    CheckboxLabelSide["RIGHT"] = "right";
+})(CheckboxLabelSide || (CheckboxLabelSide = {}));
+export const CheckboxIconColorLight = {
+    [CheckboxIconMode.DEFAULT]: Palette.WHITE,
+    [CheckboxIconMode.DISABLED]: Palette.PRIMARY_300,
+    [CheckboxIconMode.ERROR]: Palette.WHITE,
+};
+export const CheckboxIconColorDark = {
+    [CheckboxIconMode.DEFAULT]: DarkPalette.WHITE,
+    [CheckboxIconMode.DISABLED]: DarkPalette.PRIMARY_100,
+    [CheckboxIconMode.ERROR]: DarkPalette.WHITE,
+};

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

@@ -0,0 +1,5 @@
+import { type DetailValue } from '../../utils/interfaces/detail-value.interface';
+export interface DetailValueCheckbox extends DetailValue<boolean> {
+    label?: string;
+}
+export type CustomEventTuixCheckbox = CustomEvent<DetailValueCheckbox>;

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

@@ -0,0 +1 @@
+export {};

package/dist/src/tuix-dropdown/TuixDropdown.d.ts

@@ -1,5 +1,6 @@
-import { LitElement, PropertyValues, TemplateResult } from 'lit';
-import { TuixDropdownOption } from './interfaces/tuix-dropdown.interface';
+import { LitElement, type PropertyValues, type TemplateResult } from 'lit';
+import '../tuix-input/TuixInput.js';
+import type { TuixDropdownExtendedOption, TuixDropdownOption } from './interfaces/tuix-dropdown.interface';
 import { DescriptionType } from '../tuix-input/enums/tuix-input.enums';
 import { DropdownType } from './enums/tuix-dropdown.enums';
 export declare class TuixDropdown extends LitElement {
@@ -10,11 +11,13 @@ export declare class TuixDropdown extends LitElement {
     title: string;
     disabled: boolean;
     dark: boolean;
-    description: undefined;
+    description?: string;
     descriptionType: DescriptionType;
     type: DropdownType;
     private _value;
     private _isOptionsVisible;
+    private _searchingOption;
+    _extendedOptions: TuixDropdownExtendedOption[];
     private _optionsContainer;
     private _inputDropdown;
     private _previousSelectedOption;
@@ -28,7 +31,12 @@ export declare class TuixDropdown extends LitElement {
     private _onClickOption;
     protected _onInputSingle(e: CustomEvent): void;
     protected _handleSelectEvent(event: MouseEvent | KeyboardEvent): void;
+    private _handleBlur;
+    private _getOptionName;
+    private _getOptionValue;
+    private _findIndex;
     private _handleInputBase;
+    private _extendOptionsList;
     private _handleArrowDown;
     private _handleArrowUp;
     private _handleClickOutside;
@@ -36,11 +44,13 @@ export declare class TuixDropdown extends LitElement {
     private _toggleOptions;
     private _focusOptionsContainer;
     private _unselectPreviousOption;
+    private _hasCompleteDescription;
     private _getOptionsContainerClasses;
     private _triggerUpdateByExternalValueChange;
     private _resetPreviousSelection;
     private _getOptionsTemplate;
     protected updated(changedProperties: Map<string, any>): void;
     protected willUpdate(changedProperties: PropertyValues<this>): void;
+    protected firstUpdated(changedProperties: PropertyValues<this>): void;
     protected render(): TemplateResult;
 }