@tet/tet-components 1.4.22-testing → 1.4.23-production

package/dist/collection/components/basic/misc/tet-counter/tet-counter.js

@@ -0,0 +1,583 @@
+import { Host, h } from "@stencil/core";
+const DEFAULT_EASING_START_PROGRESS = 0.2;
+const DEFAULT_EASING_PROGRESS_AT_START = 0.5;
+const DEFAULT_EASING_POWER = 3;
+export class TetCounter {
+    constructor() {
+        this.startValue = 0;
+        this.endValue = 10;
+        this.duration = 2000;
+        this.delay = 0;
+        this.valueSteps = 0;
+        this.stepValues = undefined;
+        this.loopInterval = 0;
+        this.easing = undefined;
+        this.easingConfig = undefined;
+        this.disableAnimation = false;
+        this.thousandSeparator = true;
+        this.startOnViewport = true;
+        this.currentValue = 0;
+    }
+    hostElement;
+    /** Emitted when counter run starts. */
+    counterStarted;
+    /** Emitted when counter reaches end value. */
+    counterFinished;
+    animationFrameId;
+    loopTimeoutId;
+    startDelayTimeoutId;
+    viewportObserver;
+    hasEnteredViewport = false;
+    componentWillLoad() {
+        this.scheduleCounterStart();
+    }
+    disconnectedCallback() {
+        this.clearTimer();
+        this.clearViewportObserver();
+    }
+    onCounterConfigChanged() {
+        this.scheduleCounterStart();
+    }
+    /** Restarts the counter animation from its configured start value. */
+    async restartCounter() {
+        this.scheduleCounterStart({ requireViewport: true });
+    }
+    clearViewportObserver() {
+        this.viewportObserver?.disconnect();
+        this.viewportObserver = undefined;
+    }
+    scheduleCounterStart(options = {}) {
+        const shouldWaitForViewport = this.startOnViewport && (options.requireViewport || !this.hasEnteredViewport);
+        if (!shouldWaitForViewport) {
+            this.clearViewportObserver();
+            this.startCounter();
+            return;
+        }
+        this.clearTimer();
+        this.currentValue = this.startValue;
+        if (globalThis.IntersectionObserver === undefined) {
+            this.hasEnteredViewport = true;
+            this.startCounter();
+            return;
+        }
+        if (this.viewportObserver)
+            return;
+        this.viewportObserver = new globalThis.IntersectionObserver((entries) => {
+            const isVisible = entries.some((entry) => entry.isIntersecting);
+            if (!isVisible)
+                return;
+            this.hasEnteredViewport = true;
+            this.clearViewportObserver();
+            this.startCounter();
+        });
+        this.viewportObserver.observe(this.hostElement);
+    }
+    getSafeStepCount() {
+        const normalizedStepCount = Math.floor(this.valueSteps);
+        if (normalizedStepCount < 2)
+            return 0;
+        const valueRange = Math.abs(this.endValue - this.startValue);
+        if (valueRange === 0)
+            return 0;
+        return Math.min(normalizedStepCount, valueRange + 1);
+    }
+    getExplicitStepValues() {
+        if (!Array.isArray(this.stepValues) || this.stepValues.length === 0)
+            return null;
+        const normalizedValues = this.stepValues
+            .filter((value) => Number.isFinite(value))
+            .map((value) => Math.round(value));
+        if (normalizedValues.length === 0)
+            return null;
+        const withBoundaries = [...normalizedValues];
+        if (withBoundaries[0] !== this.startValue) {
+            withBoundaries.unshift(this.startValue);
+        }
+        if (withBoundaries.at(-1) !== this.endValue) {
+            withBoundaries.push(this.endValue);
+        }
+        const deduplicatedValues = withBoundaries.filter((value, index, values) => index === 0 || value !== values[index - 1]);
+        return deduplicatedValues.length >= 2 ? deduplicatedValues : null;
+    }
+    getRandomizedStepValues(stepCount) {
+        const minValue = Math.min(this.startValue, this.endValue);
+        const maxValue = Math.max(this.startValue, this.endValue);
+        const values = new Set([this.startValue, this.endValue]);
+        while (values.size < stepCount) {
+            const randomValue = Math.floor(Math.random() * (maxValue - minValue + 1)) + minValue;
+            values.add(randomValue);
+        }
+        const sortedValues = Array.from(values).sort((first, second) => first - second);
+        if (this.startValue > this.endValue) {
+            sortedValues.reverse();
+        }
+        return sortedValues;
+    }
+    clearTimer() {
+        if (this.animationFrameId !== undefined) {
+            globalThis.cancelAnimationFrame(this.animationFrameId);
+            this.animationFrameId = undefined;
+        }
+        if (this.loopTimeoutId !== undefined) {
+            globalThis.clearTimeout(this.loopTimeoutId);
+            this.loopTimeoutId = undefined;
+        }
+        if (this.startDelayTimeoutId !== undefined) {
+            globalThis.clearTimeout(this.startDelayTimeoutId);
+            this.startDelayTimeoutId = undefined;
+        }
+    }
+    scheduleLoopRestart() {
+        const safeLoopIntervalMs = Number.isFinite(this.loopInterval) ? Math.max(0, this.loopInterval) : 0;
+        if (safeLoopIntervalMs === 0)
+            return;
+        this.loopTimeoutId = globalThis.setTimeout(() => {
+            this.loopTimeoutId = undefined;
+            this.startCounter({ skipDelay: true });
+        }, safeLoopIntervalMs);
+    }
+    getAnimationProgress(normalizedProgress) {
+        if (this.easing === 'ease-out') {
+            return this.getEasingCurveProgress(normalizedProgress);
+        }
+        if (this.easing === 'ease-in') {
+            return 1 - this.getEasingCurveProgress(1 - normalizedProgress);
+        }
+        return normalizedProgress;
+    }
+    getEasingCurveProgress(normalizedProgress) {
+        const startProgressValue = this.easingConfig?.startProgress ?? DEFAULT_EASING_START_PROGRESS;
+        const progressAtStartValue = this.easingConfig?.progressAtStart ?? DEFAULT_EASING_PROGRESS_AT_START;
+        const powerValue = this.easingConfig?.power ?? DEFAULT_EASING_POWER;
+        const normalizedStartProgress = Number.isFinite(startProgressValue) ? startProgressValue : DEFAULT_EASING_START_PROGRESS;
+        const normalizedProgressAtStart = Number.isFinite(progressAtStartValue) ? progressAtStartValue : DEFAULT_EASING_PROGRESS_AT_START;
+        const normalizedPower = Number.isFinite(powerValue) ? powerValue : DEFAULT_EASING_POWER;
+        const easingStartProgress = Math.min(0.99, Math.max(0.01, normalizedStartProgress));
+        const progressAtEasingStart = Math.min(0.99, Math.max(easingStartProgress, normalizedProgressAtStart));
+        const easingPower = Math.max(1.01, normalizedPower);
+        if (normalizedProgress <= easingStartProgress) {
+            return (progressAtEasingStart / easingStartProgress) * normalizedProgress;
+        }
+        const secondHalfProgress = (normalizedProgress - easingStartProgress) / (1 - easingStartProgress);
+        const easedSecondHalfProgress = 1 - Math.pow(1 - secondHalfProgress, easingPower);
+        const blendFactor = Math.min(0.85, Math.max(0.55, 1 - (1 / easingPower)));
+        const stabilizedSecondHalfProgress = (blendFactor * easedSecondHalfProgress) + ((1 - blendFactor) * secondHalfProgress);
+        return progressAtEasingStart + ((1 - progressAtEasingStart) * stabilizedSecondHalfProgress);
+    }
+    getProgressValue(animationProgress) {
+        const valueDifference = this.endValue - this.startValue;
+        const rawValue = this.startValue + (valueDifference * animationProgress);
+        if (valueDifference >= 0) {
+            return Math.floor(rawValue);
+        }
+        return Math.ceil(rawValue);
+    }
+    startCounter(options = {}) {
+        this.clearTimer();
+        const safeStartDelayMs = Number.isFinite(this.delay) ? Math.max(0, this.delay) : 0;
+        if (!options.skipDelay && safeStartDelayMs > 0) {
+            this.currentValue = this.startValue;
+            this.startDelayTimeoutId = globalThis.setTimeout(() => {
+                this.startDelayTimeoutId = undefined;
+                this.startCounter({ skipDelay: true });
+            }, safeStartDelayMs);
+            return;
+        }
+        this.counterStarted.emit();
+        if (this.disableAnimation) {
+            this.currentValue = this.endValue;
+            this.counterFinished.emit();
+            return;
+        }
+        this.currentValue = this.startValue;
+        if (this.startValue === this.endValue) {
+            this.counterFinished.emit();
+            this.scheduleLoopRestart();
+            return;
+        }
+        const safeDuration = Math.max(0, this.duration);
+        if (safeDuration === 0) {
+            this.currentValue = this.endValue;
+            this.counterFinished.emit();
+            this.scheduleLoopRestart();
+            return;
+        }
+        const explicitStepValues = this.getExplicitStepValues();
+        const safeStepCount = this.getSafeStepCount();
+        const stepValues = explicitStepValues ?? (safeStepCount > 0 ? this.getRandomizedStepValues(safeStepCount) : []);
+        const hasStepMode = stepValues.length > 0;
+        const lastStepIndex = hasStepMode ? stepValues.length - 1 : 0;
+        const startTimestamp = performance.now();
+        const tick = (timestamp) => {
+            const elapsed = timestamp - startTimestamp;
+            const normalizedProgress = Math.min(1, Math.max(0, elapsed / safeDuration));
+            const animationProgress = this.getAnimationProgress(normalizedProgress);
+            if (hasStepMode) {
+                const stepIndex = Math.max(0, Math.min(lastStepIndex, Math.floor(animationProgress * lastStepIndex)));
+                this.currentValue = stepValues[stepIndex] ?? this.endValue;
+            }
+            else {
+                this.currentValue = this.getProgressValue(animationProgress);
+            }
+            if (normalizedProgress >= 1) {
+                this.currentValue = this.endValue;
+                this.clearTimer();
+                this.counterFinished.emit();
+                this.scheduleLoopRestart();
+                return;
+            }
+            this.animationFrameId = globalThis.requestAnimationFrame(tick);
+        };
+        this.animationFrameId = globalThis.requestAnimationFrame(tick);
+    }
+    formatValue(value) {
+        if (!this.thousandSeparator)
+            return String(value);
+        return value.toLocaleString('lv-LV').replaceAll('\u00A0', ' ');
+    }
+    outputValue() {
+        return this.disableAnimation ? this.formatValue(this.endValue) : this.formatValue(this.currentValue);
+    }
+    render() {
+        return (h(Host, { key: 'e13bec371c06dfe2347fedab93e48b3a56e12554' }, h("span", { key: '05201f960f7c0ca1867c115dd54d7d8f126cd431', part: "counter", "aria-hidden": "true" }, this.outputValue()), h("span", { key: '87842c7a8fd6344c5b1c527d484179b56eb4a2f6', class: "sr-only" }, this.formatValue(this.endValue))));
+    }
+    static get is() { return "tet-counter"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["tet-counter.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["tet-counter.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "startValue": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Initial value shown by the counter."
+                },
+                "attribute": "start-value",
+                "reflect": false,
+                "defaultValue": "0"
+            },
+            "endValue": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Target value the counter should reach."
+                },
+                "attribute": "end-value",
+                "reflect": false,
+                "defaultValue": "10"
+            },
+            "duration": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Animation duration in milliseconds."
+                },
+                "attribute": "duration",
+                "reflect": false,
+                "defaultValue": "2000"
+            },
+            "delay": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Delay in milliseconds before the counter animation starts."
+                },
+                "attribute": "delay",
+                "reflect": false,
+                "defaultValue": "0"
+            },
+            "valueSteps": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Number of randomized displayed values (including start and end) during the animation."
+                },
+                "attribute": "value-steps",
+                "reflect": false,
+                "defaultValue": "0"
+            },
+            "stepValues": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "StepValues",
+                    "resolved": "number[]",
+                    "references": {
+                        "StepValues": {
+                            "location": "local",
+                            "path": "/__w/internal-tet-web-components-tet-components/internal-tet-web-components-tet-components/src/src/components/basic/misc/tet-counter/tet-counter.tsx",
+                            "id": "src/components/basic/misc/tet-counter/tet-counter.tsx::StepValues"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Optional explicit values to display during animation. Includes start/end automatically if omitted."
+                }
+            },
+            "loopInterval": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Delay in milliseconds before restarting the counter after completion."
+                },
+                "attribute": "loop-interval",
+                "reflect": false,
+                "defaultValue": "0"
+            },
+            "easing": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "EasingMode",
+                    "resolved": "\"ease-in\" | \"ease-out\"",
+                    "references": {
+                        "EasingMode": {
+                            "location": "local",
+                            "path": "/__w/internal-tet-web-components-tet-components/internal-tet-web-components-tet-components/src/src/components/basic/misc/tet-counter/tet-counter.tsx",
+                            "id": "src/components/basic/misc/tet-counter/tet-counter.tsx::EasingMode"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Optional easing mode for the animation timeline."
+                },
+                "attribute": "easing",
+                "reflect": false
+            },
+            "easingConfig": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "EasingConfig",
+                    "resolved": "EasingConfig",
+                    "references": {
+                        "EasingConfig": {
+                            "location": "local",
+                            "path": "/__w/internal-tet-web-components-tet-components/internal-tet-web-components-tet-components/src/src/components/basic/misc/tet-counter/tet-counter.tsx",
+                            "id": "src/components/basic/misc/tet-counter/tet-counter.tsx::EasingConfig"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Optional object config for the selected easing behavior."
+                }
+            },
+            "disableAnimation": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Disables counting animation and shows the end value immediately."
+                },
+                "attribute": "disable-animation",
+                "reflect": false,
+                "defaultValue": "false"
+            },
+            "thousandSeparator": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Formats the displayed number with thousand separators when enabled."
+                },
+                "attribute": "thousand-separator",
+                "reflect": false,
+                "defaultValue": "true"
+            },
+            "startOnViewport": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Starts counting only after the component enters the viewport."
+                },
+                "attribute": "start-on-viewport",
+                "reflect": false,
+                "defaultValue": "true"
+            }
+        };
+    }
+    static get states() {
+        return {
+            "currentValue": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "counterStarted",
+                "name": "counterStarted",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Emitted when counter run starts."
+                },
+                "complexType": {
+                    "original": "void",
+                    "resolved": "void",
+                    "references": {}
+                }
+            }, {
+                "method": "counterFinished",
+                "name": "counterFinished",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Emitted when counter reaches end value."
+                },
+                "complexType": {
+                    "original": "void",
+                    "resolved": "void",
+                    "references": {}
+                }
+            }];
+    }
+    static get methods() {
+        return {
+            "restartCounter": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Restarts the counter animation from its configured start value.",
+                    "tags": []
+                }
+            }
+        };
+    }
+    static get elementRef() { return "hostElement"; }
+    static get watchers() {
+        return [{
+                "propName": "startValue",
+                "methodName": "onCounterConfigChanged"
+            }, {
+                "propName": "endValue",
+                "methodName": "onCounterConfigChanged"
+            }, {
+                "propName": "duration",
+                "methodName": "onCounterConfigChanged"
+            }, {
+                "propName": "delay",
+                "methodName": "onCounterConfigChanged"
+            }, {
+                "propName": "valueSteps",
+                "methodName": "onCounterConfigChanged"
+            }, {
+                "propName": "stepValues",
+                "methodName": "onCounterConfigChanged"
+            }, {
+                "propName": "loopInterval",
+                "methodName": "onCounterConfigChanged"
+            }, {
+                "propName": "easing",
+                "methodName": "onCounterConfigChanged"
+            }, {
+                "propName": "easingConfig",
+                "methodName": "onCounterConfigChanged"
+            }, {
+                "propName": "disableAnimation",
+                "methodName": "onCounterConfigChanged"
+            }, {
+                "propName": "startOnViewport",
+                "methodName": "onCounterConfigChanged"
+            }];
+    }
+}

package/dist/collection/components/basic/misc/tet-label/tet-label.js

@@ -13,12 +13,12 @@ export class TetLabel {
         this.showIcon = false;
     }
     render() {
-        return (h(Host, { key: '4464d4899687e52fabdbf7048855bb264873dfde' }, h("div", { key: '9fcbfd11d5cb5a0ef5c86ec3cd7e678ce2217517', class: {
+        return (h(Host, { key: 'c77468e7d0e8cf9309be371a5228820e78016d11' }, h("div", { key: '0893759ac35c617c8832f8cda94f22df4980ce17', class: {
                 label: true,
                 'label-active': this.active,
                 [`label-type-${this.type}`]: true,
                 [`theme-${this.theme}`]: true,
-            } }, this.labelTitle && h("p", { key: 'e6333dd8f28f5fbbd821deff3606d9e2c1dad2a6', class: "label-title" }, this.translateTitle ? t(this.labelTitle) : this.labelTitle), this.showIcon && h("tet-icon", { key: 'e1211871f95e89784725cc2f00f9caa0bdb6cd4e', class: "label-icon", name: "close-circle", part: "icon-selected" }))));
+            } }, this.labelTitle && h("p", { key: '357088a0ed3815c89d0004a8fe9626749c2e987f', class: "label-title" }, this.translateTitle ? t(this.labelTitle) : this.labelTitle), this.showIcon && h("tet-icon", { key: 'c783b3a210a19fa191927f7ec4ae0e6eadcc3111', class: "label-icon", name: "close-circle", part: "icon-selected" }))));
     }
     static get is() { return "tet-label"; }
     static get encapsulation() { return "shadow"; }

package/dist/collection/components/basic/steppers/tet-round-stepper/tet-round-stepper.js

@@ -59,7 +59,7 @@ export class TetRoundStepper {
         this.calculateContainerWidth();
     }
     render() {
-        return (h(Host, { key: '8e42b967b9d58d6e87ec7b93d6cef5068b9d3d7c' }, h("div", { key: 'fa7684c1ef92e0c50f6184d0b2bdfaeb03a652dd', class: {
+        return (h(Host, { key: '8a5a3b29be17614f8335bfbf68ce0809d01383a7' }, h("div", { key: 'cf8b4828ac4cb737d7371ee7d7cc76eee9435789', class: {
                 'round-stepper': true,
                 'column': this.forcedColumn,
                 'hide-icons': this.hideIcons

package/dist/collection/components/basic/steppers/tet-stepper/tet-stepper.js

@@ -75,7 +75,7 @@ export class TetStepper {
         return this.stepperData.length - 1 > index ? h("li", { class: lineClasses }) : null;
     };
     render() {
-        return (h(Host, { key: 'a6a7802ab34526c8aa60ff8da25395d9e09ae948' }, h("ol", { key: 'f8c5be24d448a87462d9b5116a2bccacf851c639', class: "stepper" }, this.stepperData.map(this.renderStep))));
+        return (h(Host, { key: '75c32c0134cfec39a5a6e28752981aec67997ac8' }, h("ol", { key: '8c5827988374deacb4f8b94a7292b168c62dedf4', class: "stepper" }, this.stepperData.map(this.renderStep))));
     }
     static get is() { return "tet-stepper"; }
     static get encapsulation() { return "shadow"; }

package/dist/collection/components/basic/steppers/tet-stepper-v2/tet-stepper-v2.js

@@ -35,7 +35,7 @@ export class TetStepperV2 {
         return isLastStep ? h("div", { class: { 'stepper-line': true, active } }) : null;
     };
     render() {
-        return (h(Host, { key: 'e7202349ca7978dd2238477b3c74f7b8f93473af' }, h("ol", { key: '202f2f1e98b84a36a76b0d4b5a28f44a1b4e8961', class: {
+        return (h(Host, { key: '5f17828ac9be1e79feb0da7a6fee85663961d26d' }, h("ol", { key: 'b42b945a5e444853df9e0c73ca7d19a126129640', class: {
                 'stepper': true,
                 [this.theme]: true,
             } }, this.stepperData.map(this.renderStep.bind(this)))));

package/dist/collection/components/basic/steppers/tet-stepper-v3/tet-stepper-v3.js

@@ -27,7 +27,7 @@ export class TetStepperV3 {
         return description ? h("div", { class: "content-description", innerHTML: description }) : null;
     };
     render() {
-        return (h(Host, { key: '604570fe0fec515a66f1cd117e7f7b9bbc24dc30' }, h("ol", { key: '69978325b90779995fa17e6036a73d87d25574e8', class: {
+        return (h(Host, { key: '80ab39b826b3c78e316f1834bddc9f9091ec3b70' }, h("ol", { key: 'bca96ce3d01fc609435e9443c72c66ff127bdc2f', class: {
                 stepper: true,
                 [this.theme]: true
             } }, this.stepperData.map(this.renderStep.bind(this)))));

package/dist/collection/components/simple/filter/tet-filter/tet-filter.js

@@ -39,11 +39,11 @@ export class TetFilter {
         this.filterChange.emit(this.filterState);
     };
     render() {
-        return (h(Host, { key: '9ade9366c52f7d448df01da09da68ec44f6523ab' }, h("div", { key: '1b236c884b2f6feade1c36fd7c8ccab55dd17a70', class: { 'filter-container': true, [`theme-${this.theme}`]: true } }, h("tet-tag-group", { key: 'fa18eea22e16da37ac698caba9e0b537fdc10df2', tags: this.filterState.map(tag => ({
+        return (h(Host, { key: 'eff35285c891a8cf8ab0035061a31fdf61a3d6da' }, h("div", { key: '4754cd18461b0778723419eba5b93851a4f70fdd', class: { 'filter-container': true, [`theme-${this.theme}`]: true } }, h("tet-tag-group", { key: 'cc4b599acb3a7faf1241af9479c63078f71b1afc', tags: this.filterState.map(tag => ({
                 ...tag,
                 clickAction: () => this.handleTagClick(tag),
                 showIcon: tag.active && !tag.disabled
-            })), theme: this.theme }), this.showClearFilterButton && this.filterState.some(tag => tag.active) && (h("button", { key: '9ba3835aff82fba382202cfb5e8c5bf2f6be7834', class: "clear-button", onClick: this.handleClearClick }, h("tet-icon", { key: '21c0b94c943f04d4c783c916aff82adc5713558d', name: "tc-reload", style: { '--icon-size': '1rem', '--icon-container-display': 'flex' }, accessibilityLabel: this.clearFilterButtonTitle }), this.clearFilterButtonTitle)))));
+            })), theme: this.theme }), this.showClearFilterButton && this.filterState.some(tag => tag.active) && (h("button", { key: '7d4b9d5a2b382efc7859a4260b89b6310d2b2308', class: "clear-button", onClick: this.handleClearClick }, h("tet-icon", { key: '33699626600987d5ce619a0ad219ba9dd7a8a195', name: "tc-reload", style: { '--icon-size': '1rem', '--icon-container-display': 'flex' }, accessibilityLabel: this.clearFilterButtonTitle }), this.clearFilterButtonTitle)))));
     }
     static get is() { return "tet-filter"; }
     static get encapsulation() { return "shadow"; }

package/dist/collection/components/simple/inputs/tet-datepicker/partials/tet-datepicker-header/tet-datepicker-header.js

@@ -55,9 +55,9 @@ export class TetDatepickerHeader {
         this.datepickerViewChanged.emit(view);
     };
     render() {
-        return (h("div", { key: 'b25bef75fb2835fd0375ce247274c6c37be923a6', class: "header" }, this.datepickerView !== 'year'
+        return (h("div", { key: '680ac39611eaeff615289e20b845fa484613f300', class: "header" }, this.datepickerView !== 'year'
             ? (h("div", { class: "icon-container", onClick: () => this.subtractDates() }, h("tet-icon", { class: "arrow-left", name: "arrow-left" })))
-            : h("div", null), h("div", { key: 'fcc50ae46d034b95ca99e4698207426be41fb3af', class: "control-button", onClick: () => this.changeDatepickerView() }, this.getControlButtonDate(), h("tet-icon", { key: '15d50b7f0141399ecd3b3bed437df7103923edc3', class: "chevron-down", name: this.datepickerView === 'month' ? 'chevron-down' : 'chevron-up' })), this.datepickerView !== 'year'
+            : h("div", null), h("div", { key: '370eadab0ce764da8252c38f5c27eada0a97cd79', class: "control-button", onClick: () => this.changeDatepickerView() }, this.getControlButtonDate(), h("tet-icon", { key: 'eb1797ccea14f21a193ca5e9cbe3de263fab42a5', class: "chevron-down", name: this.datepickerView === 'month' ? 'chevron-down' : 'chevron-up' })), this.datepickerView !== 'year'
             ? (h("div", { class: "icon-container", onClick: () => this.addDates() }, h("tet-icon", { class: "arrow-left", name: "arrow-right" })))
             : h("div", null)));
     }