@selfdecode/sd-component-library 4.0.76 → 4.0.77

package/lib/sd-component-library345.js

@@ -1,11 +1,557 @@
-import o from "./sd-component-library481.js";
-import e from "./sd-component-library486.js";
-import n from "./sd-component-library585.js";
-function u(t, r) {
-  var m = r.start, a = r.end;
-  return n(2, arguments), e([o([t, m]), a]);
-}
+import { commonjsGlobal as fe } from "./sd-component-library275.js";
+import { __module as V } from "./sd-component-library583.js";
+import { p as ce } from "./sd-component-library278.js";
+import he from "react";
+(function(N, me) {
+  (function(d, y) {
+    y(ce, he);
+  })(typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : fe, function(d, y) {
+    d = Y(d), y = W(y);
+    var w, I;
+    function A() {
+      if (typeof WeakMap != "function")
+        return null;
+      var t = /* @__PURE__ */ new WeakMap();
+      return A = function() {
+        return t;
+      }, t;
+    }
+    function W(t) {
+      if (t && t.__esModule)
+        return t;
+      if (t === null || g(t) !== "object" && typeof t != "function")
+        return { default: t };
+      var a = A();
+      if (a && a.has(t))
+        return a.get(t);
+      var n = {}, r = Object.defineProperty && Object.getOwnPropertyDescriptor;
+      for (var e in t)
+        if (Object.prototype.hasOwnProperty.call(t, e)) {
+          var i = r ? Object.getOwnPropertyDescriptor(t, e) : null;
+          i && (i.get || i.set) ? Object.defineProperty(n, e, i) : n[e] = t[e];
+        }
+      return n.default = t, a && a.set(t, n), n;
+    }
+    function Y(t) {
+      return t && t.__esModule ? t : { default: t };
+    }
+    function g(t) {
+      "@babel/helpers - typeof";
+      return typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? g = function(n) {
+        return typeof n;
+      } : g = function(n) {
+        return n && typeof Symbol == "function" && n.constructor === Symbol && n !== Symbol.prototype ? "symbol" : typeof n;
+      }, g(t);
+    }
+    function B(t, a) {
+      if (!(t instanceof a))
+        throw new TypeError("Cannot call a class as a function");
+    }
+    function k(t, a) {
+      for (var n = 0; n < a.length; n++) {
+        var r = a[n];
+        r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object.defineProperty(t, r.key, r);
+      }
+    }
+    function F(t, a, n) {
+      return a && k(t.prototype, a), n && k(t, n), t;
+    }
+    function U(t, a) {
+      if (typeof a != "function" && a !== null)
+        throw new TypeError("Super expression must either be null or a function");
+      t.prototype = Object.create(a && a.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), a && x(t, a);
+    }
+    function x(t, a) {
+      return x = Object.setPrototypeOf || function(r, e) {
+        return r.__proto__ = e, r;
+      }, x(t, a);
+    }
+    function q(t) {
+      var a = j();
+      return function() {
+        var r = E(t), e;
+        if (a) {
+          var i = E(this).constructor;
+          e = Reflect.construct(r, arguments, i);
+        } else
+          e = r.apply(this, arguments);
+        return Z(this, e);
+      };
+    }
+    function Z(t, a) {
+      return a && (g(a) === "object" || typeof a == "function") ? a : H(t);
+    }
+    function H(t) {
+      if (t === void 0)
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+      return t;
+    }
+    function j() {
+      if (typeof Reflect > "u" || !Reflect.construct || Reflect.construct.sham)
+        return !1;
+      if (typeof Proxy == "function")
+        return !0;
+      try {
+        return Date.prototype.toString.call(Reflect.construct(Date, [], function() {
+        })), !0;
+      } catch {
+        return !1;
+      }
+    }
+    function E(t) {
+      return E = Object.setPrototypeOf ? Object.getPrototypeOf : function(n) {
+        return n.__proto__ || Object.getPrototypeOf(n);
+      }, E(t);
+    }
+    function L(t, a) {
+      var n = Object.keys(t);
+      if (Object.getOwnPropertySymbols) {
+        var r = Object.getOwnPropertySymbols(t);
+        a && (r = r.filter(function(e) {
+          return Object.getOwnPropertyDescriptor(t, e).enumerable;
+        })), n.push.apply(n, r);
+      }
+      return n;
+    }
+    function M(t) {
+      for (var a = 1; a < arguments.length; a++) {
+        var n = arguments[a] != null ? arguments[a] : {};
+        a % 2 ? L(Object(n), !0).forEach(function(r) {
+          O(t, r, n[r]);
+        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(t, Object.getOwnPropertyDescriptors(n)) : L(Object(n)).forEach(function(r) {
+          Object.defineProperty(t, r, Object.getOwnPropertyDescriptor(n, r));
+        });
+      }
+      return t;
+    }
+    function O(t, a, n) {
+      return a in t ? Object.defineProperty(t, a, { value: n, enumerable: !0, configurable: !0, writable: !0 }) : t[a] = n, t;
+    }
+    var X = {
+      x: "clientWidth",
+      y: "clientHeight"
+    }, J = {
+      x: "clientTop",
+      y: "clientLeft"
+    }, Q = {
+      x: "innerWidth",
+      y: "innerHeight"
+    }, _ = {
+      x: "offsetWidth",
+      y: "offsetHeight"
+    }, D = {
+      x: "offsetLeft",
+      y: "offsetTop"
+    }, ee = {
+      x: "overflowX",
+      y: "overflowY"
+    }, te = {
+      x: "scrollWidth",
+      y: "scrollHeight"
+    }, G = {
+      x: "scrollLeft",
+      y: "scrollTop"
+    }, re = {
+      x: "width",
+      y: "height"
+    }, P = function() {
+    }, b = function() {
+      if (typeof window > "u")
+        return !1;
+      var t = !1;
+      try {
+        document.createElement("div").addEventListener("test", P, {
+          get passive() {
+            return t = !0, !1;
+          }
+        });
+      } catch {
+      }
+      return t;
+    }() ? {
+      passive: !0
+    } : !1, ie = "ReactList failed to reach a stable state.", ae = 40, ne = function(a, n) {
+      for (var r in n)
+        if (a[r] !== n[r])
+          return !1;
+      return !0;
+    }, se = function(a) {
+      for (var n = a.props.axis, r = a.getEl(), e = ee[n]; r = r.parentElement; )
+        switch (window.getComputedStyle(r)[e]) {
+          case "auto":
+          case "scroll":
+          case "overlay":
+            return r;
+        }
+      return window;
+    }, oe = function(a) {
+      var n = a.props.axis, r = a.scrollParent;
+      return r === window ? window[Q[n]] : r[X[n]];
+    }, R = function(a, n) {
+      var r = a.length, e = a.minSize, i = a.type, s = n.from, o = n.size, l = n.itemsPerRow;
+      o = Math.max(o, e);
+      var u = o % l;
+      return u && (o += l - u), o > r && (o = r), s = i === "simple" || !s ? 0 : Math.max(Math.min(s, r - o), 0), (u = s % l) && (s -= u, o += u), s === n.from && o == n.size ? n : M(M({}, n), {}, {
+        from: s,
+        size: o
+      });
+    };
+    N.exports = (I = w = /* @__PURE__ */ function(t) {
+      U(n, t);
+      var a = q(n);
+      F(n, null, [{
+        key: "getDerivedStateFromProps",
+        value: function(e, i) {
+          var s = R(e, i);
+          return s === i ? null : s;
+        }
+      }]);
+      function n(r) {
+        var e;
+        return B(this, n), e = a.call(this, r), e.state = R(r, {
+          itemsPerRow: 1,
+          from: r.initialIndex,
+          size: 0
+        }), e.cache = {}, e.cachedScrollPosition = null, e.prevPrevState = {}, e.unstable = !1, e.updateCounter = 0, e;
+      }
+      return F(n, [{
+        key: "componentDidMount",
+        value: function() {
+          this.updateFrameAndClearCache = this.updateFrameAndClearCache.bind(this), window.addEventListener("resize", this.updateFrameAndClearCache), this.updateFrame(this.scrollTo.bind(this, this.props.initialIndex));
+        }
+      }, {
+        key: "componentDidUpdate",
+        value: function(e) {
+          var i = this;
+          if (this.props.axis !== e.axis && this.clearSizeCache(), !this.unstable) {
+            if (++this.updateCounter > ae)
+              return this.unstable = !0, console.error(ie);
+            this.updateCounterTimeoutId || (this.updateCounterTimeoutId = setTimeout(function() {
+              i.updateCounter = 0, delete i.updateCounterTimeoutId;
+            }, 0)), this.updateFrame();
+          }
+        }
+      }, {
+        key: "maybeSetState",
+        value: function(e, i) {
+          if (ne(this.state, e))
+            return i();
+          this.setState(e, i);
+        }
+      }, {
+        key: "componentWillUnmount",
+        value: function() {
+          window.removeEventListener("resize", this.updateFrameAndClearCache), this.scrollParent.removeEventListener("scroll", this.updateFrameAndClearCache, b), this.scrollParent.removeEventListener("mousewheel", P, b);
+        }
+      }, {
+        key: "getOffset",
+        value: function(e) {
+          var i = this.props.axis, s = e[J[i]] || 0, o = D[i];
+          do
+            s += e[o] || 0;
+          while (e = e.offsetParent);
+          return s;
+        }
+      }, {
+        key: "getEl",
+        value: function() {
+          return this.el || this.items;
+        }
+      }, {
+        key: "getScrollPosition",
+        value: function() {
+          if (typeof this.cachedScrollPosition == "number")
+            return this.cachedScrollPosition;
+          var e = this.scrollParent, i = this.props.axis, s = G[i], o = e === window ? (
+            // Firefox always returns document.body[scrollKey] as 0 and Chrome/Safari
+            // always return document.documentElement[scrollKey] as 0, so take
+            // whichever has a value.
+            document.body[s] || document.documentElement[s]
+          ) : e[s], l = this.getScrollSize() - this.props.scrollParentViewportSizeGetter(this), u = Math.max(0, Math.min(o, l)), m = this.getEl();
+          return this.cachedScrollPosition = this.getOffset(e) + u - this.getOffset(m), this.cachedScrollPosition;
+        }
+      }, {
+        key: "setScroll",
+        value: function(e) {
+          var i = this.scrollParent, s = this.props.axis;
+          if (e += this.getOffset(this.getEl()), i === window)
+            return window.scrollTo(0, e);
+          e -= this.getOffset(this.scrollParent), i[G[s]] = e;
+        }
+      }, {
+        key: "getScrollSize",
+        value: function() {
+          var e = this.scrollParent, i = document, s = i.body, o = i.documentElement, l = te[this.props.axis];
+          return e === window ? Math.max(s[l], o[l]) : e[l];
+        }
+      }, {
+        key: "hasDeterminateSize",
+        value: function() {
+          var e = this.props, i = e.itemSizeGetter, s = e.type;
+          return s === "uniform" || i;
+        }
+      }, {
+        key: "getStartAndEnd",
+        value: function() {
+          var e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.props.threshold, i = this.getScrollPosition(), s = Math.max(0, i - e), o = i + this.props.scrollParentViewportSizeGetter(this) + e;
+          return this.hasDeterminateSize() && (o = Math.min(o, this.getSpaceBefore(this.props.length))), {
+            start: s,
+            end: o
+          };
+        }
+      }, {
+        key: "getItemSizeAndItemsPerRow",
+        value: function() {
+          var e = this.props, i = e.axis, s = e.useStaticSize, o = this.state, l = o.itemSize, u = o.itemsPerRow;
+          if (s && l && u)
+            return {
+              itemSize: l,
+              itemsPerRow: u
+            };
+          var m = this.items.children;
+          if (!m.length)
+            return {};
+          var c = m[0], f = c[_[i]], h = Math.abs(f - l);
+          if ((isNaN(h) || h >= 1) && (l = f), !l)
+            return {};
+          var v = D[i], p = c[v];
+          u = 1;
+          for (var S = m[u]; S && S[v] === p; S = m[u])
+            ++u;
+          return {
+            itemSize: l,
+            itemsPerRow: u
+          };
+        }
+      }, {
+        key: "clearSizeCache",
+        value: function() {
+          this.cachedScrollPosition = null;
+        }
+        // Called by 'scroll' and 'resize' events, clears scroll position cache.
+      }, {
+        key: "updateFrameAndClearCache",
+        value: function(e) {
+          return this.clearSizeCache(), this.updateFrame(e);
+        }
+      }, {
+        key: "updateFrame",
+        value: function(e) {
+          switch (this.updateScrollParent(), typeof e != "function" && (e = P), this.props.type) {
+            case "simple":
+              return this.updateSimpleFrame(e);
+            case "variable":
+              return this.updateVariableFrame(e);
+            case "uniform":
+              return this.updateUniformFrame(e);
+          }
+        }
+      }, {
+        key: "updateScrollParent",
+        value: function() {
+          var e = this.scrollParent;
+          this.scrollParent = this.props.scrollParentGetter(this), e !== this.scrollParent && (e && (e.removeEventListener("scroll", this.updateFrameAndClearCache), e.removeEventListener("mousewheel", P)), this.clearSizeCache(), this.scrollParent.addEventListener("scroll", this.updateFrameAndClearCache, b), this.scrollParent.addEventListener("mousewheel", P, b));
+        }
+      }, {
+        key: "updateSimpleFrame",
+        value: function(e) {
+          var i = this.getStartAndEnd(), s = i.end, o = this.items.children, l = 0;
+          if (o.length) {
+            var u = this.props.axis, m = o[0], c = o[o.length - 1];
+            l = this.getOffset(c) + c[_[u]] - this.getOffset(m);
+          }
+          if (l > s)
+            return e();
+          var f = this.props, h = f.pageSize, v = f.length, p = Math.min(this.state.size + h, v);
+          this.maybeSetState({
+            size: p
+          }, e);
+        }
+      }, {
+        key: "updateVariableFrame",
+        value: function(e) {
+          this.props.itemSizeGetter || this.cacheSizes();
+          for (var i = this.getStartAndEnd(), s = i.start, o = i.end, l = this.props, u = l.length, m = l.pageSize, c = 0, f = 0, h = 0, v = u - 1; f < v; ) {
+            var p = this.getSizeOfItem(f);
+            if (p == null || c + p > s)
+              break;
+            c += p, ++f;
+          }
+          for (var S = u - f; h < S && c < o; ) {
+            var z = this.getSizeOfItem(f + h);
+            if (z == null) {
+              h = Math.min(h + m, S);
+              break;
+            }
+            c += z, ++h;
+          }
+          this.maybeSetState(R(this.props, {
+            from: f,
+            itemsPerRow: 1,
+            size: h
+          }), e);
+        }
+      }, {
+        key: "updateUniformFrame",
+        value: function(e) {
+          var i = this.getItemSizeAndItemsPerRow(), s = i.itemSize, o = i.itemsPerRow;
+          if (!s || !o)
+            return e();
+          var l = this.getStartAndEnd(), u = l.start, m = l.end, c = R(this.props, {
+            from: Math.floor(u / s) * o,
+            size: (Math.ceil((m - u) / s) + 1) * o,
+            itemsPerRow: o
+          }), f = c.from, h = c.size;
+          return this.maybeSetState({
+            itemsPerRow: o,
+            from: f,
+            itemSize: s,
+            size: h
+          }, e);
+        }
+      }, {
+        key: "getSpaceBefore",
+        value: function(e) {
+          var i = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+          if (i[e] != null)
+            return i[e];
+          var s = this.state, o = s.itemSize, l = s.itemsPerRow;
+          if (o)
+            return i[e] = Math.floor(e / l) * o;
+          for (var u = e; u > 0 && i[--u] == null; )
+            ;
+          for (var m = i[u] || 0, c = u; c < e; ++c) {
+            i[c] = m;
+            var f = this.getSizeOfItem(c);
+            if (f == null)
+              break;
+            m += f;
+          }
+          return i[e] = m;
+        }
+      }, {
+        key: "cacheSizes",
+        value: function() {
+          for (var e = this.cache, i = this.state.from, s = this.items.children, o = _[this.props.axis], l = 0, u = s.length; l < u; ++l)
+            e[i + l] = s[l][o];
+        }
+      }, {
+        key: "getSizeOfItem",
+        value: function(e) {
+          var i = this.cache, s = this.items, o = this.props, l = o.axis, u = o.itemSizeGetter, m = o.itemSizeEstimator, c = o.type, f = this.state, h = f.from, v = f.itemSize, p = f.size;
+          if (v)
+            return v;
+          if (u)
+            return u(e);
+          if (e in i)
+            return i[e];
+          if (c === "simple" && e >= h && e < h + p && s) {
+            var S = s.children[e - h];
+            if (S)
+              return S[_[l]];
+          }
+          if (m)
+            return m(e, i);
+        }
+      }, {
+        key: "scrollTo",
+        value: function(e) {
+          e != null && this.setScroll(this.getSpaceBefore(e));
+        }
+      }, {
+        key: "scrollAround",
+        value: function(e) {
+          var i = this.getScrollPosition(), s = this.getSpaceBefore(e), o = s - this.props.scrollParentViewportSizeGetter(this) + this.getSizeOfItem(e), l = Math.min(o, s), u = Math.max(o, s);
+          if (i <= l)
+            return this.setScroll(l);
+          if (i > u)
+            return this.setScroll(u);
+        }
+      }, {
+        key: "getVisibleRange",
+        value: function() {
+          for (var e = this.state, i = e.from, s = e.size, o = this.getStartAndEnd(0), l = o.start, u = o.end, m = {}, c, f, h = i; h < i + s; ++h) {
+            var v = this.getSpaceBefore(h, m), p = v + this.getSizeOfItem(h);
+            c == null && p > l && (c = h), c != null && v < u && (f = h);
+          }
+          return [c, f];
+        }
+      }, {
+        key: "renderItems",
+        value: function() {
+          for (var e = this, i = this.props, s = i.itemRenderer, o = i.itemsRenderer, l = this.state, u = l.from, m = l.size, c = [], f = 0; f < m; ++f)
+            c.push(s(u + f, f));
+          return o(c, function(h) {
+            return e.items = h;
+          });
+        }
+      }, {
+        key: "render",
+        value: function() {
+          var e = this, i = this.props, s = i.axis, o = i.length, l = i.type, u = i.useTranslate3d, m = this.state, c = m.from, f = m.itemsPerRow, h = this.renderItems();
+          if (l === "simple")
+            return h;
+          var v = {
+            position: "relative"
+          }, p = {}, S = Math.ceil(o / f) * f, z = this.getSpaceBefore(S, p);
+          z && (v[re[s]] = z, s === "x" && (v.overflowX = "hidden"));
+          var T = this.getSpaceBefore(c, p), $ = s === "x" ? T : 0, K = s === "y" ? T : 0, C = u ? "translate3d(".concat($, "px, ").concat(K, "px, 0)") : "translate(".concat($, "px, ").concat(K, "px)"), le = {
+            msTransform: C,
+            WebkitTransform: C,
+            transform: C
+          };
+          return /* @__PURE__ */ y.default.createElement("div", {
+            style: v,
+            ref: function(ue) {
+              return e.el = ue;
+            }
+          }, /* @__PURE__ */ y.default.createElement("div", {
+            style: le
+          }, h));
+        }
+      }]), n;
+    }(y.Component), O(w, "displayName", "ReactList"), O(w, "propTypes", {
+      axis: d.default.oneOf(["x", "y"]),
+      initialIndex: d.default.number,
+      itemRenderer: d.default.func,
+      itemSizeEstimator: d.default.func,
+      itemSizeGetter: d.default.func,
+      itemsRenderer: d.default.func,
+      length: d.default.number,
+      minSize: d.default.number,
+      pageSize: d.default.number,
+      scrollParentGetter: d.default.func,
+      scrollParentViewportSizeGetter: d.default.func,
+      threshold: d.default.number,
+      type: d.default.oneOf(["simple", "variable", "uniform"]),
+      useStaticSize: d.default.bool,
+      useTranslate3d: d.default.bool
+    }), O(w, "defaultProps", {
+      axis: "y",
+      itemRenderer: function(a, n) {
+        return /* @__PURE__ */ y.default.createElement("div", {
+          key: n
+        }, a);
+      },
+      itemsRenderer: function(a, n) {
+        return /* @__PURE__ */ y.default.createElement("div", {
+          ref: n
+        }, a);
+      },
+      length: 0,
+      minSize: 1,
+      pageSize: 10,
+      scrollParentGetter: se,
+      scrollParentViewportSizeGetter: oe,
+      threshold: 100,
+      type: "simple",
+      useStaticSize: !1,
+      useTranslate3d: !1
+    }), I);
+  });
+})(V);
+var ge = V.exports;
 export {
-  u as default
+  ge as r
 };
 //# sourceMappingURL=sd-component-library345.js.map