tuix-webcomponents 0.0.21 → 0.0.24

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

@@ -0,0 +1,107 @@
+import { css, unsafeCSS } from 'lit';
+import { Palette } from '../utils/colors.js';
+import { ScreenSizes } from '../utils/screenSizes.enum.js';
+import { DarkPalette } from '../utils/darkColors.js';
+import { MainVariant } from '../utils/mainVariant.enum.js';
+import slottedClassName from '../utils/slottedClassName.js';
+import { TextSize } from '../tuix-text/enums/tuix-text.enums.js';
+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 `
+  ${unsafeCSS(`
+  ${slottedClassName(TextSize.Button)} {
+    font-size: 1rem;
+    font-weight: 400;
+    line-height: 1.25rem;
+  }
+  @media only screen and (max-width: ${ScreenSizes.TABLET}px) {
+    ${slottedClassName(TextSize.Button)} {
+      font-size: 0.938rem;
+      font-weight: 400;
+      line-height: 1.125rem;
+    }
+  }
+  @media only screen and (max-width: ${ScreenSizes.MOBILE}px) {
+    ${slottedClassName(TextSize.Button)} {
+      font-size: 0.875rem;
+      font-weight: 400;
+      line-height: 1rem;
+    }
+  }
+`)}
+`;
+export const buttonColorStyles = css `
+  :host([variant='${unsafeCSS(MainVariant.PRIMARY)}']) .button {
+    background-color: var(--t-button-primary-color);
+    outline: none;
+    color: var(--t-button-text-color);
+  }
+  :host([variant='${unsafeCSS(MainVariant.PRIMARY)}']) .button:hover {
+    background-color: var(--t-button-hover-primary-color);
+    cursor: pointer;
+  }
+  :host([variant='${unsafeCSS(MainVariant.PRIMARY)}']) .button:focus {
+    background-color: var(--t-button-hover-primary-color);
+    outline: 2px solid var(--t-button-accent-color);
+  }
+  :host([variant='${unsafeCSS(MainVariant.PRIMARY)}']) .button:active {
+    background-color: var(--t-button-active-primary-color);
+    outline: none;
+  }
+
+  :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);
+  }
+  :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;
+  }
+  :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);
+  }
+  :host([variant='${unsafeCSS(MainVariant.SECONDARY)}']) .button:disabled {
+    outline: 1px solid var(--t-button-text-muted-color);
+  }
+
+  :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;
+  }
+`;

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

@@ -0,0 +1,2 @@
+import { MainVariant } from '../../utils/mainVariant.enum.js';
+export declare const buttonTextColor: Record<MainVariant, string>;

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

@@ -0,0 +1,6 @@
+import { Palette } from '../../utils/colors.js';
+import { MainVariant } from '../../utils/mainVariant.enum.js';
+export const buttonTextColor = {
+    [MainVariant.PRIMARY]: Palette.WHITE,
+    [MainVariant.SECONDARY]: Palette.MAIN,
+};

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.js';
+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.js';
+import { TextSize, TextVariant } from '../tuix-text/enums/tuix-text.enums.js';
+import { checkboxCheckmarkStyles, checkboxContainerStyles, checkboxLabelStyles, hostStyles, } from './TuixCheckbox.styles.js';
+import { CheckboxIconColorDark, CheckboxIconColorLight, CheckboxIconMode, CheckboxLabelSide, } from './enums/tuix-checkbox.enums.js';
+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.js';
+import { DarkPalette } from '../utils/darkColors.js';
+import { ScreenSizes } from '../utils/screenSizes.enum.js';
+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.js';
+import { DarkPalette } from '../../utils/darkColors.js';
+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.js';
+import { DarkPalette } from '../../utils/darkColors.js';
+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.js';
+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

@@ -0,0 +1,56 @@
+import { LitElement, type PropertyValues, type TemplateResult } from 'lit';
+import '../tuix-input/TuixInput.js';
+import type { TuixDropdownExtendedOption, TuixDropdownOption } from './interfaces/tuix-dropdown.interface.js';
+import { DescriptionType } from '../tuix-input/enums/tuix-input.enums.js';
+import { DropdownType } from './enums/tuix-dropdown.enums.js';
+export declare class TuixDropdown extends LitElement {
+    static styles: import("lit").CSSResult[];
+    value?: TuixDropdownOption;
+    options: TuixDropdownOption[];
+    placeholder: string;
+    title: string;
+    disabled: boolean;
+    dark: boolean;
+    description?: string;
+    descriptionType: DescriptionType;
+    type: DropdownType;
+    private _value;
+    private _isOptionsVisible;
+    private _searchingOption;
+    _extendedOptions: TuixDropdownExtendedOption[];
+    private _optionsContainer;
+    private _inputDropdown;
+    private _previousSelectedOption;
+    private _previousFocusedOption;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _onEnterPress;
+    private _onKeyDownOption;
+    private _onKeyPressOption;
+    private _onMouseOverOption;
+    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;
+    private _focusTargetOption;
+    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;
+}