@hortiview/shared-components 0.0.11528 → 0.0.11587

package/dist/components/LoadingSpinner/Default/LoadingSpinner.js

@@ -1,58 +1,527 @@
-import { jsx as n, jsxs as u } from "react/jsx-runtime";
-import { CircularProgress as s, Padding as h, Group as S, TypoBody as x } from "@element-public/react-components";
-import { useState as C, useEffect as y, useMemo as v } from "react";
-import { B as b } from "../../../BigLoadingSpinner-D7H28pr5.js";
-import '../../../assets/LoadingSpinner.css';const A = "_loadingSpinnerContainer_1f3ss_1", B = {
-  loadingSpinnerContainer: A
-}, k = ({
-  size: r,
-  center: l = !1,
-  text: i,
-  textPosition: g = "bottom",
-  color: t = "primary",
-  spinnerOnly: c = !1,
+import { jsx as y, jsxs as B } from "react/jsx-runtime";
+import { _ as M, c as P, P as c } from "../../../identity-DLWZln-X.js";
+import t, { forwardRef as z, useRef as W, useImperativeHandle as F, useEffect as k, useCallback as $, useState as j, useMemo as H } from "react";
+import { h as U, d as V } from "../../../index.es-da0cf7oE.js";
+import { b as R, c as I } from "../../../tslib.es6-BDCynO9F.js";
+import { M as G, a as K } from "../../../component-neHBNHRu.js";
+import { G as q } from "../../../index.es-DntoATwO.js";
+import { P as J } from "../../../index.es-D-CKRzIB.js";
+import { b as Q } from "../../../index.es-CF_xy2ns.js";
+import { B as X } from "../../../BigLoadingSpinner-iegTbDcD.js";
+import '../../../assets/LoadingSpinner.css';/**
+ * @license
+ * Copyright 2020 Google Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+var m = {
+  INDETERMINATE_CLASS: "mdc-circular-progress--indeterminate",
+  CLOSED_CLASS: "mdc-circular-progress--closed"
+}, l = {
+  ARIA_HIDDEN: "aria-hidden",
+  ARIA_VALUENOW: "aria-valuenow",
+  DETERMINATE_CIRCLE_SELECTOR: ".mdc-circular-progress__determinate-circle",
+  RADIUS: "r",
+  STROKE_DASHOFFSET: "stroke-dashoffset"
+};
+/**
+ * @license
+ * Copyright 2020 Google Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+var L = (
+  /** @class */
+  function(a) {
+    R(e, a);
+    function e(r) {
+      return a.call(this, I(I({}, e.defaultAdapter), r)) || this;
+    }
+    return Object.defineProperty(e, "cssClasses", {
+      get: function() {
+        return m;
+      },
+      enumerable: !1,
+      configurable: !0
+    }), Object.defineProperty(e, "strings", {
+      get: function() {
+        return l;
+      },
+      enumerable: !1,
+      configurable: !0
+    }), Object.defineProperty(e, "defaultAdapter", {
+      get: function() {
+        return {
+          addClass: function() {
+          },
+          getDeterminateCircleAttribute: function() {
+            return null;
+          },
+          hasClass: function() {
+            return !1;
+          },
+          removeClass: function() {
+          },
+          removeAttribute: function() {
+          },
+          setAttribute: function() {
+          },
+          setDeterminateCircleAttribute: function() {
+          }
+        };
+      },
+      enumerable: !1,
+      configurable: !0
+    }), e.prototype.init = function() {
+      this.closed = this.adapter.hasClass(m.CLOSED_CLASS), this.determinate = !this.adapter.hasClass(m.INDETERMINATE_CLASS), this.progress = 0, this.determinate && this.adapter.setAttribute(l.ARIA_VALUENOW, this.progress.toString()), this.radius = Number(this.adapter.getDeterminateCircleAttribute(l.RADIUS));
+    }, e.prototype.setDeterminate = function(r) {
+      this.determinate = r, this.determinate ? (this.adapter.removeClass(m.INDETERMINATE_CLASS), this.setProgress(this.progress)) : (this.adapter.addClass(m.INDETERMINATE_CLASS), this.adapter.removeAttribute(l.ARIA_VALUENOW));
+    }, e.prototype.isDeterminate = function() {
+      return this.determinate;
+    }, e.prototype.setProgress = function(r) {
+      if (this.progress = r, this.determinate) {
+        var d = (1 - this.progress) * (2 * Math.PI * this.radius);
+        this.adapter.setDeterminateCircleAttribute(l.STROKE_DASHOFFSET, "" + d), this.adapter.setAttribute(l.ARIA_VALUENOW, this.progress.toString());
+      }
+    }, e.prototype.getProgress = function() {
+      return this.progress;
+    }, e.prototype.open = function() {
+      this.closed = !1, this.adapter.removeClass(m.CLOSED_CLASS), this.adapter.removeAttribute(l.ARIA_HIDDEN);
+    }, e.prototype.close = function() {
+      this.closed = !0, this.adapter.addClass(m.CLOSED_CLASS), this.adapter.setAttribute(l.ARIA_HIDDEN, "true");
+    }, e.prototype.isClosed = function() {
+      return this.closed;
+    }, e;
+  }(G)
+);
+/**
+ * @license
+ * Copyright 2020 Google Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+var Y = (
+  /** @class */
+  function(a) {
+    R(e, a);
+    function e() {
+      return a !== null && a.apply(this, arguments) || this;
+    }
+    return e.prototype.initialize = function() {
+      this.determinateCircle_ = this.root.querySelector(L.strings.DETERMINATE_CIRCLE_SELECTOR);
+    }, e.attachTo = function(r) {
+      return new e(r);
+    }, Object.defineProperty(e.prototype, "determinate", {
+      /**
+       * Sets whether the progress indicator is in determinate mode.
+       * @param isDeterminate Whether the indicator should be determinate.
+       */
+      set: function(r) {
+        this.foundation.setDeterminate(r);
+      },
+      enumerable: !1,
+      configurable: !0
+    }), Object.defineProperty(e.prototype, "progress", {
+      /**
+       * Sets the current progress value. In indeterminate mode, this has no
+       * visual effect but will be reflected if the indicator is switched to
+       * determinate mode.
+       * @param value The current progress value, which must be between 0 and 1.
+       */
+      set: function(r) {
+        this.foundation.setProgress(r);
+      },
+      enumerable: !1,
+      configurable: !0
+    }), Object.defineProperty(e.prototype, "isClosed", {
+      /**
+       * Whether the progress indicator is hidden.
+       */
+      get: function() {
+        return this.foundation.isClosed();
+      },
+      enumerable: !1,
+      configurable: !0
+    }), e.prototype.open = function() {
+      this.foundation.open();
+    }, e.prototype.close = function() {
+      this.foundation.close();
+    }, e.prototype.getDefaultFoundation = function() {
+      var r = this, d = {
+        addClass: function(s) {
+          return r.root.classList.add(s);
+        },
+        getDeterminateCircleAttribute: function(s) {
+          return r.determinateCircle_.getAttribute(s);
+        },
+        hasClass: function(s) {
+          return r.root.classList.contains(s);
+        },
+        removeClass: function(s) {
+          return r.root.classList.remove(s);
+        },
+        removeAttribute: function(s) {
+          return r.root.removeAttribute(s);
+        },
+        setAttribute: function(s, i) {
+          return r.root.setAttribute(s, i);
+        },
+        setDeterminateCircleAttribute: function(s, i) {
+          return r.determinateCircle_.setAttribute(s, i);
+        }
+      };
+      return new L(d);
+    }, e;
+  }(K)
+);
+const Z = {
+  /**
+   * Accessibility label.
+   *
+   * Defaults to **'Progress Indicator'**.
+   */
+  ariaLabel: c.string,
+  /**
+   * The css class name to be passed through to the component markup.
+   *
+   * Defaults to **undefined**.
+   */
+  className: c.string,
+  /**
+   * The size of the progress indicator.
+   *
+   * Defaults to **'lg'**.
+   */
+  indicatorSize: c.oneOf(["sm", "md", "lg"]),
+  /**
+   * Sets the visibility of the progress indicator.
+   *
+   * Defaults to **true**.
+   */
+  open: c.bool,
+  /**
+   * The current progress of a determinate progress indicator. Must be between 0 and 1.
+   *
+   * Defaults to **0**.
+   */
+  progress: c.number,
+  /**
+   * @deprecated _Renamed, see indicatorSize instead._
+   *
+   * The size of the progress indicator.
+   *
+   * Defaults to **undefined**.
+   */
+  size: V(c.oneOf(["sm", "md", "lg"]), "CircularProgress", "Renamed, see indicatorSize instead."),
+  /**
+   * Color of the indicator stroke with 'primary' or 'secondary' theme color.
+   *
+   * Defaults to **'primary'**.
+   */
+  themeColor: c.oneOf(["primary", "secondary", "primary-variant", "secondary-variant", "two-color", "two-color-variant"]),
+  /**
+   * An indeterminate CircularProgress indicator will continue spinning until closed. A determinate CircularProgress indicator will display the current progress.
+   *
+   * Defaults to **'indeterminate'**.
+   */
+  variant: c.oneOf(["determinate", "indeterminate"])
+}, ee = {
+  ariaLabel: "Progress Indicator",
+  className: void 0,
+  indicatorSize: "lg",
+  open: !0,
+  progress: 0,
+  size: void 0,
+  themeColor: "primary",
+  variant: "indeterminate"
+}, A = /* @__PURE__ */ z((a, e) => {
+  const {
+    ariaLabel: r,
+    className: d,
+    open: s,
+    progress: i,
+    size: D,
+    indicatorSize: v,
+    themeColor: u,
+    variant: p,
+    ...E
+  } = a, g = W(), h = W();
+  F(e, () => g.current, []), k(() => (h.current = Y.attachTo(g.current), () => {
+    h.current.destroy();
+  }), []), k(() => {
+    (p === "determinate" && i < 0 || i > 1) && U("CircularProgress: `progress` must be between 0 and 1."), h.current.determinate = p === "determinate", h.current.progress = i;
+  }, [i, p]);
+  const T = () => {
+    switch (v) {
+      case "xs":
+        return {
+          heightWidth: "16px",
+          viewBox: "24",
+          cxCy: "12",
+          r: "8.75",
+          strokeWidth: "2.5",
+          strokeWidth80: "2",
+          strokeDashArray: "54.978",
+          strokeDashoffset: "54",
+          halfStrokeDashoffset: "27.489"
+        };
+      case "sm":
+        return {
+          heightWidth: "24px",
+          viewBox: "24",
+          cxCy: "12",
+          r: "8.75",
+          strokeWidth: "2.5",
+          strokeWidth80: "2",
+          strokeDashArray: "54.978",
+          strokeDashoffset: "54.978",
+          halfStrokeDashoffset: "27.489"
+        };
+      case "md":
+        return {
+          heightWidth: "36px",
+          viewBox: "32",
+          cxCy: "16",
+          r: "12.5",
+          strokeWidth: "3",
+          strokeWidth80: "2.4",
+          strokeDashArray: "78.54",
+          strokeDashoffset: "78.54",
+          halfStrokeDashoffset: "39.27"
+        };
+      case "lg":
+        return {
+          heightWidth: "48px",
+          viewBox: "48",
+          cxCy: "24",
+          r: "18",
+          strokeWidth: "4",
+          strokeWidth80: "3.2",
+          strokeDashArray: "113.097",
+          strokeDashoffset: "113.097",
+          halfStrokeDashoffset: "56.549"
+        };
+      case "xl":
+        return {
+          heightWidth: "60px",
+          viewBox: "48",
+          cxCy: "24",
+          r: "18",
+          strokeWidth: "3",
+          strokeWidth80: "2.8",
+          strokeDashArray: "113.097",
+          strokeDashoffset: "113.097",
+          halfStrokeDashoffset: "56.549"
+        };
+      default:
+        return {
+          heightWidth: "48px",
+          viewBox: "48",
+          cxCy: "24",
+          r: "18",
+          strokeWidth: "4",
+          strokeWidth80: "3.2",
+          strokeDashArray: "113.097",
+          strokeDashoffset: "113.097",
+          halfStrokeDashoffset: "56.549"
+        };
+    }
+  }, {
+    heightWidth: x,
+    viewBox: n,
+    cxCy: o,
+    r: f,
+    strokeWidth: C,
+    strokeWidth80: w,
+    strokeDashArray: _,
+    strokeDashoffset: O,
+    halfStrokeDashoffset: S
+  } = T(), b = $(() => /* @__PURE__ */ t.createElement(t.Fragment, null, /* @__PURE__ */ t.createElement("div", {
+    className: "mdc-circular-progress__circle-clipper mdc-circular-progress__circle-left"
+  }, /* @__PURE__ */ t.createElement("svg", {
+    className: "mdc-circular-progress__indeterminate-circle-graphic",
+    viewBox: `0 0 ${n} ${n}`,
+    xmlns: "http://www.w3.org/2000/svg"
+  }, /* @__PURE__ */ t.createElement("circle", {
+    cx: o,
+    cy: o,
+    r: f,
+    strokeDasharray: _,
+    strokeDashoffset: S,
+    strokeWidth: C
+  }))), /* @__PURE__ */ t.createElement("div", {
+    className: "mdc-circular-progress__gap-patch"
+  }, /* @__PURE__ */ t.createElement("svg", {
+    className: "mdc-circular-progress__indeterminate-circle-graphic",
+    viewBox: `0 0 ${n} ${n}`,
+    xmlns: "http://www.w3.org/2000/svg"
+  }, /* @__PURE__ */ t.createElement("circle", {
+    cx: o,
+    cy: o,
+    r: f,
+    strokeDasharray: _,
+    strokeDashoffset: S,
+    strokeWidth: w
+  }))), /* @__PURE__ */ t.createElement("div", {
+    className: "mdc-circular-progress__circle-clipper mdc-circular-progress__circle-right"
+  }, /* @__PURE__ */ t.createElement("svg", {
+    className: "mdc-circular-progress__indeterminate-circle-graphic",
+    viewBox: `0 0 ${n} ${n}`,
+    xmlns: "http://www.w3.org/2000/svg"
+  }, /* @__PURE__ */ t.createElement("circle", {
+    cx: o,
+    cy: o,
+    r: f,
+    strokeDasharray: _,
+    strokeDashoffset: S,
+    strokeWidth: C
+  })))), [o, S, f, _, C, w, n]), N = u === "two-color" || u === "two-color-variant";
+  return /* @__PURE__ */ t.createElement("div", M({
+    ref: g,
+    className: P("lmnt", "mdc-circular-progress", p === "indeterminate" && "mdc-circular-progress--indeterminate", !s && "mdc-circular-progress--closed", u && `lmnt-circular-progress--${u}`, d),
+    style: {
+      width: x,
+      height: x
+    },
+    role: "progressbar",
+    "aria-label": r,
+    "aria-valuemin": "0",
+    "aria-valuemax": "1",
+    "aria-valuenow": i
+  }, E), /* @__PURE__ */ t.createElement("div", {
+    className: "mdc-circular-progress__determinate-container"
+  }, /* @__PURE__ */ t.createElement("svg", {
+    className: "mdc-circular-progress__determinate-circle-graphic",
+    viewBox: `0 0 ${n} ${n}`,
+    xmlns: "http://www.w3.org/2000/svg"
+  }, /* @__PURE__ */ t.createElement("circle", {
+    className: "mdc-circular-progress__determinate-track",
+    cx: o,
+    cy: o,
+    r: f,
+    strokeWidth: C
+  }), /* @__PURE__ */ t.createElement("circle", {
+    className: "mdc-circular-progress__determinate-circle",
+    cx: o,
+    cy: o,
+    r: f,
+    strokeDasharray: _,
+    strokeDashoffset: O,
+    strokeWidth: C
+  }))), /* @__PURE__ */ t.createElement("div", {
+    className: "mdc-circular-progress__indeterminate-container"
+  }, /* @__PURE__ */ t.createElement("div", {
+    className: P("mdc-circular-progress__spinner-layer", N && "mdc-circular-progress__color-1")
+  }, b()), N && /* @__PURE__ */ t.createElement(t.Fragment, null, /* @__PURE__ */ t.createElement("div", {
+    className: "mdc-circular-progress__spinner-layer mdc-circular-progress__color-2"
+  }, b()), /* @__PURE__ */ t.createElement("div", {
+    className: "mdc-circular-progress__spinner-layer mdc-circular-progress__color-3"
+  }, b()), /* @__PURE__ */ t.createElement("div", {
+    className: "mdc-circular-progress__spinner-layer mdc-circular-progress__color-4"
+  }, b()))));
+});
+A.displayName = "CircularProgress";
+A.propTypes = Z;
+A.defaultProps = ee;
+const re = "_loadingSpinnerContainer_1f3ss_1", te = {
+  loadingSpinnerContainer: re
+}, pe = ({
+  size: a,
+  center: e = !1,
+  text: r,
+  textPosition: d = "bottom",
+  color: s = "primary",
+  spinnerOnly: i = !1,
   //Due to we don't have (and want) to use a translation logic in this component, we are using a hardcoded message
-  impatienceMessage: e = "This is taking longer than expected. Please be patient.",
-  impatienceTimeout: o = 10
+  impatienceMessage: D = "This is taking longer than expected. Please be patient.",
+  impatienceTimeout: v = 10
 }) => {
-  const [a, p] = C(0);
-  y(() => {
-    const m = setInterval(() => {
-      p((f) => f + 1);
+  const [u, p] = j(0);
+  k(() => {
+    const g = setInterval(() => {
+      p((h) => h + 1);
     }, 1e3);
-    return () => clearInterval(m);
+    return () => clearInterval(g);
   }, []);
-  const d = v(() => e && a > o ? e : i, [e, o, i, a]);
-  return r === "big" ? /* @__PURE__ */ n(b, { text: d }) : c ? /* @__PURE__ */ n(
-    s,
+  const E = H(() => D && u > v ? D : r, [D, v, r, u]);
+  return a === "big" ? /* @__PURE__ */ y(X, { text: E }) : i ? /* @__PURE__ */ y(
+    A,
     {
       "data-testid": "loading-spinner",
-      themeColor: t,
-      indicatorSize: r ?? "md"
+      themeColor: s,
+      indicatorSize: a ?? "md"
     }
-  ) : /* @__PURE__ */ n(
-    h,
+  ) : /* @__PURE__ */ y(
+    J,
     {
       variant: "standard",
       style: { textAlign: "center" },
-      className: l ? B.loadingSpinnerContainer : "",
-      children: /* @__PURE__ */ u(
-        S,
+      className: e ? te.loadingSpinnerContainer : "",
+      children: /* @__PURE__ */ B(
+        q,
         {
-          direction: g === "right" ? "horizontal" : "vertical",
+          direction: d === "right" ? "horizontal" : "vertical",
           gap: "dense",
           primaryAlign: "center",
           secondaryAlign: "center",
           children: [
-            /* @__PURE__ */ n(
-              s,
+            /* @__PURE__ */ y(
+              A,
               {
                 "data-testid": "loading-spinner",
-                themeColor: t,
-                indicatorSize: r ?? "lg"
+                themeColor: s,
+                indicatorSize: a ?? "lg"
               }
             ),
-            /* @__PURE__ */ n(x, { themeColor: `text-${t}-on-background`, tag: "div", "data-testid": "loading-text", children: d })
+            /* @__PURE__ */ y(Q, { themeColor: `text-${s}-on-background`, tag: "div", "data-testid": "loading-text", children: E })
           ]
         }
       )
@@ -60,5 +529,5 @@ import '../../../assets/LoadingSpinner.css';const A = "_loadingSpinnerContainer_
   );
 };
 export {
-  k as LoadingSpinner
+  pe as LoadingSpinner
 };

package/dist/components/Modal/Modal.d.ts

@@ -1,3 +1,3 @@
-import { ModalProps } from '@element-public/react-components';
+import { ModalProps } from '@element-public/react-modal';
 
 export declare const Modal: (props: ModalProps & React.HTMLProps<HTMLElement> & React.DOMAttributes<HTMLElement>) => import("react/jsx-runtime").JSX.Element;