bitz-react-admin-ui 2.7.4 → 2.7.5

package/dist/node_modules/react-resizable/build/propTypes.mjs

@@ -0,0 +1,118 @@
+import { __exports as f } from "../../../_virtual/propTypes.mjs";
+import { p as d } from "../../prop-types/index.mjs";
+import "../../react-draggable/build/cjs/cjs.mjs";
+f.__esModule = !0;
+f.resizableProps = void 0;
+var e = o(d);
+function o(r) {
+  return r && r.__esModule ? r : { default: r };
+}
+var s = {
+  /*
+  * Restricts resizing to a particular axis (default: 'both')
+  * 'both' - allows resizing by width or height
+  * 'x' - only allows the width to be changed
+  * 'y' - only allows the height to be changed
+  * 'none' - disables resizing altogether
+  * */
+  axis: e.default.oneOf(["both", "x", "y", "none"]),
+  className: e.default.string,
+  /*
+  * Require that one and only one child be present.
+  * */
+  children: e.default.element.isRequired,
+  /*
+  * These will be passed wholesale to react-draggable's DraggableCore
+  * */
+  draggableOpts: e.default.shape({
+    allowAnyClick: e.default.bool,
+    cancel: e.default.string,
+    children: e.default.node,
+    disabled: e.default.bool,
+    enableUserSelectHack: e.default.bool,
+    offsetParent: e.default.node,
+    grid: e.default.arrayOf(e.default.number),
+    handle: e.default.string,
+    nodeRef: e.default.object,
+    onStart: e.default.func,
+    onDrag: e.default.func,
+    onStop: e.default.func,
+    onMouseDown: e.default.func,
+    scale: e.default.number
+  }),
+  /*
+  * Initial height
+  * */
+  height: function() {
+    for (var u = arguments.length, a = new Array(u), t = 0; t < u; t++)
+      a[t] = arguments[t];
+    var l = a[0];
+    if (l.axis === "both" || l.axis === "y") {
+      var n;
+      return (n = e.default.number).isRequired.apply(n, a);
+    }
+    return e.default.number.apply(e.default, a);
+  },
+  /*
+  * Customize cursor resize handle
+  * */
+  handle: e.default.oneOfType([e.default.node, e.default.func]),
+  /*
+  * If you change this, be sure to update your css
+  * */
+  handleSize: e.default.arrayOf(e.default.number),
+  lockAspectRatio: e.default.bool,
+  /*
+  * Max X & Y measure
+  * */
+  maxConstraints: e.default.arrayOf(e.default.number),
+  /*
+  * Min X & Y measure
+  * */
+  minConstraints: e.default.arrayOf(e.default.number),
+  /*
+  * Called on stop resize event
+  * */
+  onResizeStop: e.default.func,
+  /*
+  * Called on start resize event
+  * */
+  onResizeStart: e.default.func,
+  /*
+  * Called on resize event
+  * */
+  onResize: e.default.func,
+  /*
+  * Defines which resize handles should be rendered (default: 'se')
+  * 's' - South handle (bottom-center)
+  * 'w' - West handle (left-center)
+  * 'e' - East handle (right-center)
+  * 'n' - North handle (top-center)
+  * 'sw' - Southwest handle (bottom-left)
+  * 'nw' - Northwest handle (top-left)
+  * 'se' - Southeast handle (bottom-right)
+  * 'ne' - Northeast handle (top-center)
+  * */
+  resizeHandles: e.default.arrayOf(e.default.oneOf(["s", "w", "e", "n", "sw", "nw", "se", "ne"])),
+  /*
+  * If `transform: scale(n)` is set on the parent, this should be set to `n`.
+  * */
+  transformScale: e.default.number,
+  /*
+   * Initial width
+   */
+  width: function() {
+    for (var u = arguments.length, a = new Array(u), t = 0; t < u; t++)
+      a[t] = arguments[t];
+    var l = a[0];
+    if (l.axis === "both" || l.axis === "x") {
+      var n;
+      return (n = e.default.number).isRequired.apply(n, a);
+    }
+    return e.default.number.apply(e.default, a);
+  }
+};
+f.resizableProps = s;
+export {
+  f as default
+};

package/dist/node_modules/react-resizable/build/utils.mjs

@@ -0,0 +1,54 @@
+import { __exports as a } from "../../../_virtual/utils.mjs";
+import f from "react";
+a.__esModule = !0;
+a.cloneElement = y;
+var l = c(f);
+function c(e) {
+  return e && e.__esModule ? e : { default: e };
+}
+function i(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    r && (n = n.filter(function(u) {
+      return Object.getOwnPropertyDescriptor(e, u).enumerable;
+    })), t.push.apply(t, n);
+  }
+  return t;
+}
+function o(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = arguments[r] != null ? arguments[r] : {};
+    r % 2 ? i(Object(t), !0).forEach(function(n) {
+      s(e, n, t[n]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : i(Object(t)).forEach(function(n) {
+      Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(t, n));
+    });
+  }
+  return e;
+}
+function s(e, r, t) {
+  return r = m(r), r in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e;
+}
+function m(e) {
+  var r = p(e, "string");
+  return typeof r == "symbol" ? r : String(r);
+}
+function p(e, r) {
+  if (typeof e != "object" || e === null)
+    return e;
+  var t = e[Symbol.toPrimitive];
+  if (t !== void 0) {
+    var n = t.call(e, r || "default");
+    if (typeof n != "object")
+      return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (r === "string" ? String : Number)(e);
+}
+function y(e, r) {
+  return r.style && e.props.style && (r.style = o(o({}, e.props.style), r.style)), r.className && e.props.className && (r.className = e.props.className + " " + r.className), /* @__PURE__ */ l.default.cloneElement(e, r);
+}
+export {
+  a as default
+};

package/dist/node_modules/react-resizable/index.mjs

@@ -0,0 +1,13 @@
+import { __module as e } from "../../_virtual/index5.mjs";
+import "./build/Resizable.mjs";
+import "./build/ResizableBox.mjs";
+import { __exports as r } from "../../_virtual/Resizable.mjs";
+import { __exports as t } from "../../_virtual/ResizableBox.mjs";
+e.exports = function() {
+  throw new Error("Don't instantiate Resizable directly! Use require('react-resizable').Resizable");
+};
+var p = e.exports.Resizable = r.default;
+e.exports.ResizableBox = t.default;
+export {
+  p as Resizable
+};

package/dist/node_modules/resize-observer-polyfill/dist/ResizeObserver.es.mjs

@@ -0,0 +1,290 @@
+var _ = function() {
+  if (typeof Map < "u")
+    return Map;
+  function e(t, n) {
+    var r = -1;
+    return t.some(function(i, o) {
+      return i[0] === n ? (r = o, !0) : !1;
+    }), r;
+  }
+  return (
+    /** @class */
+    function() {
+      function t() {
+        this.__entries__ = [];
+      }
+      return Object.defineProperty(t.prototype, "size", {
+        /**
+         * @returns {boolean}
+         */
+        get: function() {
+          return this.__entries__.length;
+        },
+        enumerable: !0,
+        configurable: !0
+      }), t.prototype.get = function(n) {
+        var r = e(this.__entries__, n), i = this.__entries__[r];
+        return i && i[1];
+      }, t.prototype.set = function(n, r) {
+        var i = e(this.__entries__, n);
+        ~i ? this.__entries__[i][1] = r : this.__entries__.push([n, r]);
+      }, t.prototype.delete = function(n) {
+        var r = this.__entries__, i = e(r, n);
+        ~i && r.splice(i, 1);
+      }, t.prototype.has = function(n) {
+        return !!~e(this.__entries__, n);
+      }, t.prototype.clear = function() {
+        this.__entries__.splice(0);
+      }, t.prototype.forEach = function(n, r) {
+        r === void 0 && (r = null);
+        for (var i = 0, o = this.__entries__; i < o.length; i++) {
+          var s = o[i];
+          n.call(r, s[1], s[0]);
+        }
+      }, t;
+    }()
+  );
+}(), v = typeof window < "u" && typeof document < "u" && window.document === document, f = function() {
+  return typeof global < "u" && global.Math === Math ? global : typeof self < "u" && self.Math === Math ? self : typeof window < "u" && window.Math === Math ? window : Function("return this")();
+}(), O = function() {
+  return typeof requestAnimationFrame == "function" ? requestAnimationFrame.bind(f) : function(e) {
+    return setTimeout(function() {
+      return e(Date.now());
+    }, 1e3 / 60);
+  };
+}(), E = 2;
+function R(e, t) {
+  var n = !1, r = !1, i = 0;
+  function o() {
+    n && (n = !1, e()), r && a();
+  }
+  function s() {
+    O(o);
+  }
+  function a() {
+    var u = Date.now();
+    if (n) {
+      if (u - i < E)
+        return;
+      r = !0;
+    } else
+      n = !0, r = !1, setTimeout(s, t);
+    i = u;
+  }
+  return a;
+}
+var M = 20, x = ["top", "right", "bottom", "left", "width", "height", "size", "weight"], A = typeof MutationObserver < "u", z = (
+  /** @class */
+  function() {
+    function e() {
+      this.connected_ = !1, this.mutationEventsAdded_ = !1, this.mutationsObserver_ = null, this.observers_ = [], this.onTransitionEnd_ = this.onTransitionEnd_.bind(this), this.refresh = R(this.refresh.bind(this), M);
+    }
+    return e.prototype.addObserver = function(t) {
+      ~this.observers_.indexOf(t) || this.observers_.push(t), this.connected_ || this.connect_();
+    }, e.prototype.removeObserver = function(t) {
+      var n = this.observers_, r = n.indexOf(t);
+      ~r && n.splice(r, 1), !n.length && this.connected_ && this.disconnect_();
+    }, e.prototype.refresh = function() {
+      var t = this.updateObservers_();
+      t && this.refresh();
+    }, e.prototype.updateObservers_ = function() {
+      var t = this.observers_.filter(function(n) {
+        return n.gatherActive(), n.hasActive();
+      });
+      return t.forEach(function(n) {
+        return n.broadcastActive();
+      }), t.length > 0;
+    }, e.prototype.connect_ = function() {
+      !v || this.connected_ || (document.addEventListener("transitionend", this.onTransitionEnd_), window.addEventListener("resize", this.refresh), A ? (this.mutationsObserver_ = new MutationObserver(this.refresh), this.mutationsObserver_.observe(document, {
+        attributes: !0,
+        childList: !0,
+        characterData: !0,
+        subtree: !0
+      })) : (document.addEventListener("DOMSubtreeModified", this.refresh), this.mutationEventsAdded_ = !0), this.connected_ = !0);
+    }, e.prototype.disconnect_ = function() {
+      !v || !this.connected_ || (document.removeEventListener("transitionend", this.onTransitionEnd_), window.removeEventListener("resize", this.refresh), this.mutationsObserver_ && this.mutationsObserver_.disconnect(), this.mutationEventsAdded_ && document.removeEventListener("DOMSubtreeModified", this.refresh), this.mutationsObserver_ = null, this.mutationEventsAdded_ = !1, this.connected_ = !1);
+    }, e.prototype.onTransitionEnd_ = function(t) {
+      var n = t.propertyName, r = n === void 0 ? "" : n, i = x.some(function(o) {
+        return !!~r.indexOf(o);
+      });
+      i && this.refresh();
+    }, e.getInstance = function() {
+      return this.instance_ || (this.instance_ = new e()), this.instance_;
+    }, e.instance_ = null, e;
+  }()
+), m = function(e, t) {
+  for (var n = 0, r = Object.keys(t); n < r.length; n++) {
+    var i = r[n];
+    Object.defineProperty(e, i, {
+      value: t[i],
+      enumerable: !1,
+      writable: !1,
+      configurable: !0
+    });
+  }
+  return e;
+}, c = function(e) {
+  var t = e && e.ownerDocument && e.ownerDocument.defaultView;
+  return t || f;
+}, y = d(0, 0, 0, 0);
+function h(e) {
+  return parseFloat(e) || 0;
+}
+function b(e) {
+  for (var t = [], n = 1; n < arguments.length; n++)
+    t[n - 1] = arguments[n];
+  return t.reduce(function(r, i) {
+    var o = e["border-" + i + "-width"];
+    return r + h(o);
+  }, 0);
+}
+function T(e) {
+  for (var t = ["top", "right", "bottom", "left"], n = {}, r = 0, i = t; r < i.length; r++) {
+    var o = i[r], s = e["padding-" + o];
+    n[o] = h(s);
+  }
+  return n;
+}
+function C(e) {
+  var t = e.getBBox();
+  return d(0, 0, t.width, t.height);
+}
+function S(e) {
+  var t = e.clientWidth, n = e.clientHeight;
+  if (!t && !n)
+    return y;
+  var r = c(e).getComputedStyle(e), i = T(r), o = i.left + i.right, s = i.top + i.bottom, a = h(r.width), u = h(r.height);
+  if (r.boxSizing === "border-box" && (Math.round(a + o) !== t && (a -= b(r, "left", "right") + o), Math.round(u + s) !== n && (u -= b(r, "top", "bottom") + s)), !G(e)) {
+    var l = Math.round(a + o) - t, p = Math.round(u + s) - n;
+    Math.abs(l) !== 1 && (a -= l), Math.abs(p) !== 1 && (u -= p);
+  }
+  return d(i.left, i.top, a, u);
+}
+var D = function() {
+  return typeof SVGGraphicsElement < "u" ? function(e) {
+    return e instanceof c(e).SVGGraphicsElement;
+  } : function(e) {
+    return e instanceof c(e).SVGElement && typeof e.getBBox == "function";
+  };
+}();
+function G(e) {
+  return e === c(e).document.documentElement;
+}
+function L(e) {
+  return v ? D(e) ? C(e) : S(e) : y;
+}
+function P(e) {
+  var t = e.x, n = e.y, r = e.width, i = e.height, o = typeof DOMRectReadOnly < "u" ? DOMRectReadOnly : Object, s = Object.create(o.prototype);
+  return m(s, {
+    x: t,
+    y: n,
+    width: r,
+    height: i,
+    top: n,
+    right: t + r,
+    bottom: i + n,
+    left: t
+  }), s;
+}
+function d(e, t, n, r) {
+  return { x: e, y: t, width: n, height: r };
+}
+var W = (
+  /** @class */
+  function() {
+    function e(t) {
+      this.broadcastWidth = 0, this.broadcastHeight = 0, this.contentRect_ = d(0, 0, 0, 0), this.target = t;
+    }
+    return e.prototype.isActive = function() {
+      var t = L(this.target);
+      return this.contentRect_ = t, t.width !== this.broadcastWidth || t.height !== this.broadcastHeight;
+    }, e.prototype.broadcastRect = function() {
+      var t = this.contentRect_;
+      return this.broadcastWidth = t.width, this.broadcastHeight = t.height, t;
+    }, e;
+  }()
+), j = (
+  /** @class */
+  function() {
+    function e(t, n) {
+      var r = P(n);
+      m(this, { target: t, contentRect: r });
+    }
+    return e;
+  }()
+), F = (
+  /** @class */
+  function() {
+    function e(t, n, r) {
+      if (this.activeObservations_ = [], this.observations_ = new _(), typeof t != "function")
+        throw new TypeError("The callback provided as parameter 1 is not a function.");
+      this.callback_ = t, this.controller_ = n, this.callbackCtx_ = r;
+    }
+    return e.prototype.observe = function(t) {
+      if (!arguments.length)
+        throw new TypeError("1 argument required, but only 0 present.");
+      if (!(typeof Element > "u" || !(Element instanceof Object))) {
+        if (!(t instanceof c(t).Element))
+          throw new TypeError('parameter 1 is not of type "Element".');
+        var n = this.observations_;
+        n.has(t) || (n.set(t, new W(t)), this.controller_.addObserver(this), this.controller_.refresh());
+      }
+    }, e.prototype.unobserve = function(t) {
+      if (!arguments.length)
+        throw new TypeError("1 argument required, but only 0 present.");
+      if (!(typeof Element > "u" || !(Element instanceof Object))) {
+        if (!(t instanceof c(t).Element))
+          throw new TypeError('parameter 1 is not of type "Element".');
+        var n = this.observations_;
+        n.has(t) && (n.delete(t), n.size || this.controller_.removeObserver(this));
+      }
+    }, e.prototype.disconnect = function() {
+      this.clearActive(), this.observations_.clear(), this.controller_.removeObserver(this);
+    }, e.prototype.gatherActive = function() {
+      var t = this;
+      this.clearActive(), this.observations_.forEach(function(n) {
+        n.isActive() && t.activeObservations_.push(n);
+      });
+    }, e.prototype.broadcastActive = function() {
+      if (this.hasActive()) {
+        var t = this.callbackCtx_, n = this.activeObservations_.map(function(r) {
+          return new j(r.target, r.broadcastRect());
+        });
+        this.callback_.call(t, n, t), this.clearActive();
+      }
+    }, e.prototype.clearActive = function() {
+      this.activeObservations_.splice(0);
+    }, e.prototype.hasActive = function() {
+      return this.activeObservations_.length > 0;
+    }, e;
+  }()
+), g = typeof WeakMap < "u" ? /* @__PURE__ */ new WeakMap() : new _(), w = (
+  /** @class */
+  function() {
+    function e(t) {
+      if (!(this instanceof e))
+        throw new TypeError("Cannot call a class as a function.");
+      if (!arguments.length)
+        throw new TypeError("1 argument required, but only 0 present.");
+      var n = z.getInstance(), r = new F(t, n, this);
+      g.set(this, r);
+    }
+    return e;
+  }()
+);
+[
+  "observe",
+  "unobserve",
+  "disconnect"
+].forEach(function(e) {
+  w.prototype[e] = function() {
+    var t;
+    return (t = g.get(this))[e].apply(t, arguments);
+  };
+});
+var H = function() {
+  return typeof f.ResizeObserver < "u" ? f.ResizeObserver : w;
+}();
+export {
+  H as default
+};

package/dist/node_modules/screenfull/index.mjs

@@ -0,0 +1,122 @@
+const o = [
+  [
+    "requestFullscreen",
+    "exitFullscreen",
+    "fullscreenElement",
+    "fullscreenEnabled",
+    "fullscreenchange",
+    "fullscreenerror"
+  ],
+  // New WebKit
+  [
+    "webkitRequestFullscreen",
+    "webkitExitFullscreen",
+    "webkitFullscreenElement",
+    "webkitFullscreenEnabled",
+    "webkitfullscreenchange",
+    "webkitfullscreenerror"
+  ],
+  // Old WebKit
+  [
+    "webkitRequestFullScreen",
+    "webkitCancelFullScreen",
+    "webkitCurrentFullScreenElement",
+    "webkitCancelFullScreen",
+    "webkitfullscreenchange",
+    "webkitfullscreenerror"
+  ],
+  [
+    "mozRequestFullScreen",
+    "mozCancelFullScreen",
+    "mozFullScreenElement",
+    "mozFullScreenEnabled",
+    "mozfullscreenchange",
+    "mozfullscreenerror"
+  ],
+  [
+    "msRequestFullscreen",
+    "msExitFullscreen",
+    "msFullscreenElement",
+    "msFullscreenEnabled",
+    "MSFullscreenChange",
+    "MSFullscreenError"
+  ]
+], t = (() => {
+  if (typeof document > "u")
+    return !1;
+  const e = o[0], r = {};
+  for (const n of o)
+    if ((n == null ? void 0 : n[1]) in document) {
+      for (const [s, u] of n.entries())
+        r[e[s]] = u;
+      return r;
+    }
+  return !1;
+})(), i = {
+  change: t.fullscreenchange,
+  error: t.fullscreenerror
+};
+let l = {
+  // eslint-disable-next-line default-param-last
+  request(e = document.documentElement, r) {
+    return new Promise((n, c) => {
+      const s = () => {
+        l.off("change", s), n();
+      };
+      l.on("change", s);
+      const u = e[t.requestFullscreen](r);
+      u instanceof Promise && u.then(s).catch(c);
+    });
+  },
+  exit() {
+    return new Promise((e, r) => {
+      if (!l.isFullscreen) {
+        e();
+        return;
+      }
+      const n = () => {
+        l.off("change", n), e();
+      };
+      l.on("change", n);
+      const c = document[t.exitFullscreen]();
+      c instanceof Promise && c.then(n).catch(r);
+    });
+  },
+  toggle(e, r) {
+    return l.isFullscreen ? l.exit() : l.request(e, r);
+  },
+  onchange(e) {
+    l.on("change", e);
+  },
+  onerror(e) {
+    l.on("error", e);
+  },
+  on(e, r) {
+    const n = i[e];
+    n && document.addEventListener(n, r, !1);
+  },
+  off(e, r) {
+    const n = i[e];
+    n && document.removeEventListener(n, r, !1);
+  },
+  raw: t
+};
+Object.defineProperties(l, {
+  isFullscreen: {
+    get: () => !!document[t.fullscreenElement]
+  },
+  element: {
+    enumerable: !0,
+    get: () => document[t.fullscreenElement] ?? void 0
+  },
+  isEnabled: {
+    enumerable: !0,
+    // Coerce to boolean in case of old WebKit.
+    get: () => !!document[t.fullscreenEnabled]
+  }
+});
+t || (l = { isEnabled: !1 });
+const f = l;
+export {
+  f as default
+};

package/dist/node_modules/stylis/src/Enum.mjs

@@ -0,0 +1,12 @@
+var r = "-ms-", a = "-moz-", v = "-webkit-", E = "comm", e = "rule", m = "decl", M = "@import", R = "@keyframes", T = "@layer";
+export {
+  E as COMMENT,
+  m as DECLARATION,
+  M as IMPORT,
+  R as KEYFRAMES,
+  T as LAYER,
+  a as MOZ,
+  r as MS,
+  e as RULESET,
+  v as WEBKIT
+};

package/dist/node_modules/stylis/src/Middleware.mjs

@@ -0,0 +1,18 @@
+import { sizeof as p } from "./Utility.mjs";
+function c(t) {
+  var r = p(t);
+  return function(f, n, i, a) {
+    for (var o = "", u = 0; u < r; u++)
+      o += t[u](f, n, i, a) || "";
+    return o;
+  };
+}
+function d(t) {
+  return function(r) {
+    r.root || (r = r.return) && t(r);
+  };
+}
+export {
+  c as middleware,
+  d as rulesheet
+};