@ukic/web-components 3.4.0 → 3.6.0

package/dist/collection/components/ic-loading-indicator/ic-loading-indicator.js

@@ -1,6 +1,20 @@
 import { h, Host } from "@stencil/core";
+const LOADING_INDICATOR_WIDTHS = {
+    large: 120,
+    medium: 80,
+    small: 40,
+    icon: 20,
+};
 export class LoadingIndicator {
     constructor() {
+        this.labelList = [];
+        this.circularDiameter = 0;
+        this.circularLineWidth = 0;
+        this.circularDimensions = {
+            x: 0,
+            y: 0,
+            r: 0,
+        };
         this.clipInnerElement = false;
         /**
          * The description that will be set as the aria-label of the loading indicator when not using a visible label.
@@ -32,185 +46,156 @@ export class LoadingIndicator {
          * The size of the loading indicator.
          */
         this.size = "medium";
-        /**
-         * The type of indicator, either linear or circular.
-         */
-        this.type = "circular";
         /**
          * Sets the theme color to the dark or light theme color. "inherit" will set the color based on the system settings or ic-theme component.
          */
         this.theme = "inherit";
-        this.updateCircularProgressMeter = () => {
-            if (!this.indeterminate && this.circularMeter) {
-                this.circularMeter.style.setProperty("--progress-value", String(this.progress));
-            }
-        };
-        this.getLabel = (labelIndex, setLabel) => {
-            return new Promise(() => {
-                this.interval = setInterval(() => {
-                    if (labelIndex < this.labelList.length - 1) {
-                        labelIndex++;
-                    }
-                    else {
-                        labelIndex = 0;
-                    }
-                    setLabel(this.labelList[labelIndex]);
-                }, this.labelDuration);
-            });
-        };
+        /**
+         * The type of indicator, either linear or circular.
+         */
+        this.type = "circular";
+        this.getLabel = (labelIndex) => new Promise(() => {
+            this.interval = setInterval(() => {
+                if (labelIndex < this.labelList.length - 1) {
+                    labelIndex++;
+                }
+                else {
+                    labelIndex = 0;
+                }
+                this.indicatorLabel = this.labelList[labelIndex];
+            }, this.labelDuration);
+        });
         this.getLabelVariant = () => {
-            var _a;
-            let variant = "h4";
-            const width = (_a = this.outerElement) === null || _a === void 0 ? void 0 : _a.offsetWidth;
-            if (this.size === "small" ||
-                (width && this.type === "circular" && width < 60)) {
-                variant = "label";
+            const width = this.type === "circular" ? this.calculateWidth() : 0;
+            if (this.size === "small" || (width && width < 60)) {
+                return "label";
             }
-            else if (this.size === "large" ||
-                (width && this.type === "circular" && width >= 120)) {
-                variant = "h2";
+            else if (this.size === "large" || width >= 120) {
+                return "h2";
             }
-            return variant;
+            return "h4";
         };
-        // Sets the circular indicator line width - accounting for the circle size being altered using the CSS custom property
-        this.setCircleLineWidth = () => {
-            const compactStepCircularLineWidth = this.el.classList.contains("compact-step-progress-indicator")
-                ? 40
-                : 0;
-            const toastDismissTimerCircularLineWidth = this.el.classList.contains("toast-dismiss-timer")
-                ? 20
-                : 0;
+        this.calculateWidth = () => {
+            var _a, _b, _c;
+            if ((_a = this.outerElement) === null || _a === void 0 ? void 0 : _a.offsetWidth)
+                return this.outerElement.offsetWidth;
             if (this.outerElement) {
-                const { offsetWidth: width } = this.outerElement;
-                if (width ||
-                    compactStepCircularLineWidth ||
-                    toastDismissTimerCircularLineWidth) {
-                    this.circularLineWidth =
-                        (compactStepCircularLineWidth ||
-                            toastDismissTimerCircularLineWidth ||
-                            width) * 0.1;
-                    this.circularDiameter =
-                        compactStepCircularLineWidth ||
-                            toastDismissTimerCircularLineWidth ||
-                            width;
-                    this.outerElement.style.setProperty("--circular-line-width", `${this.circularLineWidth}px`);
+                const { width } = window.getComputedStyle(this.outerElement);
+                if (width) {
+                    // Regex to check the units of the css string
+                    if (((_b = width.match(/\D+$/)) === null || _b === void 0 ? void 0 : _b[0]) !== "%")
+                        return parseFloat(width);
+                    const parentWidth = (_c = this.outerElement.parentElement) === null || _c === void 0 ? void 0 : _c.offsetWidth;
+                    if (parentWidth)
+                        return parentWidth * (parseFloat(width) / 100);
                 }
             }
+            return LOADING_INDICATOR_WIDTHS[this.size];
+        };
+        this.calculateProportion = (progress) => {
+            const minProgress = Math.min(this.max, Math.max(this.min, progress));
+            return (minProgress - this.min) / (this.max - this.min);
         };
         this.setLinearDeterminateWidth = () => {
-            const max = this.max;
-            const min = this.min;
-            if (!this.innerElement)
-                return;
             // Ensure progress cannot be out of bounds
-            if (this.progress) {
-                const progress = Math.min(max, Math.max(min, this.progress));
-                const proportion = (progress - min) / (max - min);
-                this.clipInnerElement = proportion > 0.5;
-                if (this.clipInnerElement) {
-                    this.innerElement.classList.remove("clip");
-                }
-                else {
-                    this.innerElement.classList.add("clip");
-                }
-                this.innerElement.style.setProperty("--linear-width", `${proportion * 100}%`);
+            if (!this.innerElement || !this.progress)
+                return;
+            const proportion = this.calculateProportion(this.progress);
+            this.clipInnerElement = proportion > 0.5;
+            if (this.clipInnerElement) {
+                this.innerElement.classList.remove("clip");
             }
-        };
-        this.calcOuterClass = () => {
-            let cls = `ic-loading-${this.type}-outer`;
-            cls += this.indeterminate ? " indeterminate" : " determinate";
-            return cls;
-        };
-        this.updateLabel = () => {
-            if (this.label !== undefined) {
-                if (typeof this.label === "string") {
-                    this.indicatorLabel = this.label;
-                }
-                else {
-                    this.labelList = this.label;
-                    const labelIndex = 0;
-                    this.indicatorLabel = this.labelList[labelIndex];
-                    if (this.labelList.length > 1) {
-                        this.getLabel(labelIndex, (label) => {
-                            this.indicatorLabel = label;
-                        });
-                    }
-                }
+            else {
+                this.innerElement.classList.add("clip");
             }
+            this.innerElement.style.setProperty("--linear-width", `${proportion * 100}%`);
         };
-        this.setCircleXY = () => {
-            if (this.circularDiameter > 0) {
-                const r = this.circularDiameter / 2;
-                const x = r;
-                const y = r;
-                const nextRadius = r - this.circularLineWidth / 2;
-                this.setDashSteps(nextRadius);
-                return { x, y, r: nextRadius };
+        this.updateLabel = () => {
+            if (!this.label)
+                return;
+            if (typeof this.label === "string") {
+                this.indicatorLabel = this.label;
             }
-            return { x: 0, y: 0, r: 0 };
-        };
-        this.setDashSteps = (radius) => {
-            const dashArray = 2 * Math.PI * radius;
-            if (this.circularMeter) {
-                this.circularMeter.style.setProperty("--stroke-dasharray", `${dashArray}px`);
-                if (!this.indeterminate && this.progress) {
-                    const min = this.min;
-                    const max = this.max;
-                    const progress = Math.min(Math.max(this.progress, min), max);
-                    const proportion = -1 - (progress - min) / (max - min);
-                    this.circularMeter.style.setProperty("--circular-steps-max", String(this.max));
-                    this.circularMeter.style.setProperty("--stroke-dashoffset", `${proportion * dashArray}px`);
+            else {
+                this.labelList = this.label;
+                this.indicatorLabel = this.labelList[0];
+                if (this.labelList.length > 1) {
+                    this.getLabel(0);
                 }
             }
         };
+        this.setCircleDimensions = () => {
+            if (this.circularDiameter <= 0)
+                return;
+            const r = this.circularDiameter / 2;
+            const nextRadius = r - this.circularLineWidth / 2;
+            const dashArray = 2 * Math.PI * nextRadius;
+            this.circularDimensions = {
+                x: r,
+                y: r,
+                r: nextRadius,
+                dashArray: `${dashArray}px`,
+                dashOffset: this.progress
+                    ? `${(-1 - this.calculateProportion(this.progress)) * dashArray}px`
+                    : undefined,
+            };
+        };
     }
     watchPropHandler() {
         this.updateLabel();
     }
-    watchProgressHandler() {
+    handleProgressChange() {
+        if (this.type === "linear") {
+            this.setLinearDeterminateWidth();
+        }
+        else {
+            this.setCircleDimensions();
+        }
+    }
+    setIndicatorDimensions() {
         if (this.type === "circular") {
-            this.updateCircularProgressMeter();
+            // Sets the circular indicator line width - accounting for the circle size being altered using the CSS custom property
+            const diameter = this.calculateWidth();
+            if (this.outerElement && diameter !== this.circularDiameter) {
+                this.circularLineWidth = diameter * 0.1;
+                this.circularDiameter = diameter;
+                this.outerElement.style.setProperty("--circular-line-width", `${this.circularLineWidth}px`);
+            }
+            this.setCircleDimensions();
+        }
+        else {
+            this.setLinearDeterminateWidth();
         }
     }
     disconnectedCallback() {
         clearInterval(this.interval);
     }
     componentWillLoad() {
-        this.indeterminate = this.progress === undefined;
         this.updateLabel();
         this.el.setAttribute("exportparts", "ic-loading-container");
     }
     componentDidLoad() {
-        var _a;
-        if (this.type === "circular") {
-            this.setCircleLineWidth();
-            this.circularMeter = (_a = this.el.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector(".ic-loading-circular-svg circle:nth-child(2)");
-            this.updateCircularProgressMeter();
-        }
-        if (Number(this.progress) >= 0 && this.type === "linear") {
-            this.setLinearDeterminateWidth();
-        }
-    }
-    componentWillUpdate() {
-        this.indeterminate = this.progress === undefined;
-    }
-    componentDidUpdate() {
-        if (Number(this.progress) >= 0 && this.type === "linear") {
-            this.setLinearDeterminateWidth();
-        }
+        this.setIndicatorDimensions();
     }
     render() {
-        const { theme, label, description, size, fullWidth, innerLabel, monochrome, } = this;
-        const { x, y, r } = this.setCircleXY();
-        return (h(Host, { key: '0031fe76c51b9cfcdb3916451bd2b56f6aac8721', class: {
+        const { circularDiameter, circularDimensions: { x, y, r, dashArray, dashOffset }, description, fullWidth, indicatorLabel, innerLabel, label, max, min, monochrome, progress, size, theme, type, } = this;
+        return (h(Host, { key: '8ee440b25dde3874c36eb6c70f3eaac1bf7649d1', class: {
                 [`ic-theme-${theme}`]: theme !== "inherit",
+                "ic-loading-indicator-full-width": fullWidth,
                 "ic-loading-indicator-label": !!label,
-                "ic-loading-indicator-full-width": !!fullWidth,
+                "ic-loading-indicator-monochrome": monochrome,
+            } }, h("div", { key: '3d06914b8253b77c9df58d5c94a44442ea3f2d16', class: "ic-loading-container", part: "ic-loading-container" }, h("div", { key: '43a11cf45e813b5560721472c431452a761593fb', ref: (el) => (this.outerElement = el), class: {
+                [`ic-loading-${type}-outer`]: true,
+                [progress === undefined ? "indeterminate" : "determinate"]: true,
+            }, role: "progressbar", "aria-labelledby": label && size !== "icon" && "ic-loading-label", "aria-label": description, "aria-valuenow": progress, "aria-valuemin": min, "aria-valuemax": max }, h("div", { key: 'a95cd8ed7e58821c8ac4001c8926d202719e63f7', ref: (el) => (this.innerElement = el), class: {
+                [`ic-loading-${type}-inner`]: true,
                 "inner-label": !!innerLabel,
-                "ic-loading-indicator-monochrome": !!monochrome,
-            } }, h("div", { key: 'f0d87cb81fe19c7923cab83352692a820f864353', class: "ic-loading-container", part: "ic-loading-container" }, h("div", { key: 'eed9c9ec0fa7677a73d97f84f2f0c4254ae895f9', ref: (el) => (this.outerElement = el), class: this.calcOuterClass(), role: "progressbar", "aria-labelledby": this.label && this.size !== "icon" && "ic-loading-label", "aria-label": description, "aria-valuenow": this.progress, "aria-valuemin": this.min, "aria-valuemax": this.max }, h("div", { key: 'e6f08d5b7d7f7d3531f26773d82bdaab8b746de6', ref: (el) => (this.innerElement = el), class: `ic-loading-${this.type}-inner` }, this.innerLabel &&
-            this.innerLabel !== undefined &&
-            this.size === "small" && (h("ic-typography", { key: 'e5e16b071e7886eeaeddbe5d4ba9982d2dd835ac', variant: "subtitle-small", class: "inner-text" }, this.innerLabel)), this.type === "circular" && (h("svg", { key: '242ce0f64c6b81f0495ce74844d42952d60889b1', class: "ic-loading-circular-svg", viewBox: `0 0 ${this.circularDiameter || 0} ${this.circularDiameter || 0}` }, h("circle", { key: '89efba17cfc44471af357fac9fad70a80ee8f9c2', cx: `${x}`, cy: `${y}`, r: `${r}` }), h("circle", { key: '47a39e6acf845c27e2817d563559fc332c9be3db', cx: `${x}`, cy: `${y}`, r: `${r}` }))))), label && size !== "icon" && (h("ic-typography", { key: '383cf6d17daaaaa8275b8b381e6a65334f8b832e', id: "ic-loading-label", class: "ic-loading-label", role: "status", variant: this.getLabelVariant() }, h("p", { key: 'b0009c0c194d3ebdf8b8bca21fcee5db1919ac1a' }, this.indicatorLabel))))));
+            } }, innerLabel && size === "small" && (h("ic-typography", { key: '04b25f8cba789f316ba2db771b4a7d30eac7fe10', variant: "subtitle-small", class: "inner-text" }, innerLabel)), type === "circular" && (h("svg", { key: 'ff98da2b3f382ad698855d7ce1b0a553dbfadae3', class: "ic-loading-circular-svg", viewBox: `0 0 ${circularDiameter} ${circularDiameter}` }, h("circle", { key: 'b53c7477ae972370739b908141776337f277fc48', cx: x, cy: y, r: r }), h("circle", { key: 'b652351de6695c077a1f276710e0fe558ff393e4', style: {
+                "--circular-steps-max": progress ? `${max}` : undefined,
+                "--progress-value": progress !== undefined ? `${progress}` : undefined,
+                "--stroke-dasharray": dashArray,
+                "--stroke-dashoffset": dashOffset,
+            }, cx: x, cy: y, r: r }))))), label && size !== "icon" && (h("ic-typography", { key: 'b070b1975f52606aa8df8f8575859a12ab4e7982', id: "ic-loading-label", class: "ic-loading-label", role: "alert", variant: this.getLabelVariant() }, h("p", { key: 'b654d871fff4ad30b2fa7bfff7b2756f0b7475ed' }, indicatorLabel))))));
     }
     static get is() { return "ic-loading-indicator"; }
     static get encapsulation() { return "shadow"; }
@@ -231,11 +216,11 @@ export class LoadingIndicator {
                 "mutable": false,
                 "complexType": {
                     "original": "string",
-                    "resolved": "string | undefined",
+                    "resolved": "string",
                     "references": {}
                 },
                 "required": false,
-                "optional": true,
+                "optional": false,
                 "docs": {
                     "tags": [],
                     "text": "The description that will be set as the aria-label of the loading indicator when not using a visible label."
@@ -251,11 +236,11 @@ export class LoadingIndicator {
                 "mutable": false,
                 "complexType": {
                     "original": "boolean",
-                    "resolved": "boolean | undefined",
+                    "resolved": "boolean",
                     "references": {}
                 },
                 "required": false,
-                "optional": true,
+                "optional": false,
                 "docs": {
                     "tags": [],
                     "text": "If `true`, when linear, the full-width variant (i.e. without a border radius) will be displayed."
@@ -288,16 +273,35 @@ export class LoadingIndicator {
                 "attribute": "inner-label",
                 "reflect": false
             },
+            "label": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string | string[]",
+                    "resolved": "string | string[] | undefined",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "The label to be displayed beneath the loading indicator.\nDisplay a changing label by supplying an array of messages."
+                },
+                "getter": false,
+                "setter": false,
+                "attribute": "label",
+                "reflect": false
+            },
             "labelDuration": {
                 "type": "number",
                 "mutable": false,
                 "complexType": {
                     "original": "number",
-                    "resolved": "number | undefined",
+                    "resolved": "number",
                     "references": {}
                 },
                 "required": false,
-                "optional": true,
+                "optional": false,
                 "docs": {
                     "tags": [],
                     "text": "The time in milliseconds before the label changes."
@@ -313,11 +317,11 @@ export class LoadingIndicator {
                 "mutable": false,
                 "complexType": {
                     "original": "number",
-                    "resolved": "number | undefined",
+                    "resolved": "number",
                     "references": {}
                 },
                 "required": false,
-                "optional": true,
+                "optional": false,
                 "docs": {
                     "tags": [],
                     "text": "The maximum value that the progress value can take.\nUsed to calculate the proportional width of the progress bar."
@@ -333,11 +337,11 @@ export class LoadingIndicator {
                 "mutable": false,
                 "complexType": {
                     "original": "number",
-                    "resolved": "number | undefined",
+                    "resolved": "number",
                     "references": {}
                 },
                 "required": false,
-                "optional": true,
+                "optional": false,
                 "docs": {
                     "tags": [],
                     "text": "The minimum value that the progress value can take.\nUsed to calculate the proportional width of the progress bar."
@@ -353,11 +357,11 @@ export class LoadingIndicator {
                 "mutable": false,
                 "complexType": {
                     "original": "boolean",
-                    "resolved": "boolean | undefined",
+                    "resolved": "boolean",
                     "references": {}
                 },
                 "required": false,
-                "optional": true,
+                "optional": false,
                 "docs": {
                     "tags": [],
                     "text": "If `true`, the element will display as black and white."
@@ -368,121 +372,102 @@ export class LoadingIndicator {
                 "reflect": false,
                 "defaultValue": "false"
             },
-            "size": {
-                "type": "string",
+            "progress": {
+                "type": "number",
                 "mutable": false,
                 "complexType": {
-                    "original": "IcLoadingSizes",
-                    "resolved": "\"icon\" | \"large\" | \"medium\" | \"small\" | undefined",
-                    "references": {
-                        "IcLoadingSizes": {
-                            "location": "import",
-                            "path": "./ic-loading-indicator.types",
-                            "id": "src/components/ic-loading-indicator/ic-loading-indicator.types.tsx::IcLoadingSizes"
-                        }
-                    }
+                    "original": "number",
+                    "resolved": "number | undefined",
+                    "references": {}
                 },
                 "required": false,
                 "optional": true,
                 "docs": {
                     "tags": [],
-                    "text": "The size of the loading indicator."
+                    "text": "The current amount of progress made.\nIf not provided, component acts as an indeterminate loading indicator."
                 },
                 "getter": false,
                 "setter": false,
-                "attribute": "size",
-                "reflect": true,
-                "defaultValue": "\"medium\""
+                "attribute": "progress",
+                "reflect": false
             },
-            "type": {
+            "size": {
                 "type": "string",
                 "mutable": false,
                 "complexType": {
-                    "original": "IcLoadingTypes",
-                    "resolved": "\"circular\" | \"linear\" | undefined",
+                    "original": "IcLoadingSizes",
+                    "resolved": "\"icon\" | \"large\" | \"medium\" | \"small\"",
                     "references": {
-                        "IcLoadingTypes": {
+                        "IcLoadingSizes": {
                             "location": "import",
                             "path": "./ic-loading-indicator.types",
-                            "id": "src/components/ic-loading-indicator/ic-loading-indicator.types.tsx::IcLoadingTypes"
+                            "id": "src/components/ic-loading-indicator/ic-loading-indicator.types.tsx::IcLoadingSizes"
                         }
                     }
                 },
                 "required": false,
-                "optional": true,
+                "optional": false,
                 "docs": {
                     "tags": [],
-                    "text": "The type of indicator, either linear or circular."
+                    "text": "The size of the loading indicator."
                 },
                 "getter": false,
                 "setter": false,
-                "attribute": "type",
+                "attribute": "size",
                 "reflect": true,
-                "defaultValue": "\"circular\""
+                "defaultValue": "\"medium\""
             },
-            "label": {
+            "theme": {
                 "type": "string",
                 "mutable": false,
                 "complexType": {
-                    "original": "string | string[]",
-                    "resolved": "string | string[] | undefined",
-                    "references": {}
-                },
-                "required": false,
-                "optional": true,
-                "docs": {
-                    "tags": [],
-                    "text": "The label to be displayed beneath the loading indicator.\nDisplay a changing label by supplying an array of messages."
-                },
-                "getter": false,
-                "setter": false,
-                "attribute": "label",
-                "reflect": false
-            },
-            "progress": {
-                "type": "number",
-                "mutable": false,
-                "complexType": {
-                    "original": "number",
-                    "resolved": "number | undefined",
-                    "references": {}
+                    "original": "IcThemeMode",
+                    "resolved": "\"dark\" | \"inherit\" | \"light\"",
+                    "references": {
+                        "IcThemeMode": {
+                            "location": "import",
+                            "path": "../../utils/types",
+                            "id": "src/utils/types.ts::IcThemeMode"
+                        }
+                    }
                 },
                 "required": false,
-                "optional": true,
+                "optional": false,
                 "docs": {
                     "tags": [],
-                    "text": "The current amount of progress made.\nIf not provided, component acts as an indeterminate loading indicator."
+                    "text": "Sets the theme color to the dark or light theme color. \"inherit\" will set the color based on the system settings or ic-theme component."
                 },
                 "getter": false,
                 "setter": false,
-                "attribute": "progress",
-                "reflect": false
+                "attribute": "theme",
+                "reflect": false,
+                "defaultValue": "\"inherit\""
             },
-            "theme": {
+            "type": {
                 "type": "string",
                 "mutable": false,
                 "complexType": {
-                    "original": "IcThemeMode",
-                    "resolved": "\"dark\" | \"inherit\" | \"light\" | undefined",
+                    "original": "IcLoadingTypes",
+                    "resolved": "\"circular\" | \"linear\"",
                     "references": {
-                        "IcThemeMode": {
+                        "IcLoadingTypes": {
                             "location": "import",
-                            "path": "../../utils/types",
-                            "id": "src/utils/types.ts::IcThemeMode"
+                            "path": "./ic-loading-indicator.types",
+                            "id": "src/components/ic-loading-indicator/ic-loading-indicator.types.tsx::IcLoadingTypes"
                         }
                     }
                 },
                 "required": false,
-                "optional": true,
+                "optional": false,
                 "docs": {
                     "tags": [],
-                    "text": "Sets the theme color to the dark or light theme color. \"inherit\" will set the color based on the system settings or ic-theme component."
+                    "text": "The type of indicator, either linear or circular."
                 },
                 "getter": false,
                 "setter": false,
-                "attribute": "theme",
-                "reflect": false,
-                "defaultValue": "\"inherit\""
+                "attribute": "type",
+                "reflect": true,
+                "defaultValue": "\"circular\""
             }
         };
     }
@@ -490,7 +475,7 @@ export class LoadingIndicator {
         return {
             "circularDiameter": {},
             "circularLineWidth": {},
-            "indeterminate": {},
+            "circularDimensions": {},
             "indicatorLabel": {},
             "clipInnerElement": {}
         };
@@ -500,9 +485,18 @@ export class LoadingIndicator {
         return [{
                 "propName": "label",
                 "methodName": "watchPropHandler"
+            }, {
+                "propName": "max",
+                "methodName": "handleProgressChange"
+            }, {
+                "propName": "min",
+                "methodName": "handleProgressChange"
             }, {
                 "propName": "progress",
-                "methodName": "watchProgressHandler"
+                "methodName": "handleProgressChange"
+            }, {
+                "propName": "type",
+                "methodName": "setIndicatorDimensions"
             }];
     }
 }