@m4l/components 0.0.6 → 0.0.9

package/dist/lodash.js

@@ -0,0 +1,489 @@
+import { c as commonjsGlobal } from "./commonjs.js";
+var FUNC_ERROR_TEXT$2 = "Expected a function";
+var NAN$1 = 0 / 0;
+var symbolTag$1 = "[object Symbol]";
+var reTrim$1 = /^\s+|\s+$/g;
+var reIsBadHex$1 = /^[-+]0x[0-9a-f]+$/i;
+var reIsBinary$1 = /^0b[01]+$/i;
+var reIsOctal$1 = /^0o[0-7]+$/i;
+var freeParseInt$1 = parseInt;
+var freeGlobal$2 = typeof commonjsGlobal == "object" && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+var freeSelf$2 = typeof self == "object" && self && self.Object === Object && self;
+var root$2 = freeGlobal$2 || freeSelf$2 || Function("return this")();
+var objectProto$2 = Object.prototype;
+var objectToString$2 = objectProto$2.toString;
+var nativeMax$1 = Math.max, nativeMin$1 = Math.min;
+var now$1 = function() {
+  return root$2.Date.now();
+};
+function debounce$1(func, wait, options) {
+  var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
+  if (typeof func != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT$2);
+  }
+  wait = toNumber$1(wait) || 0;
+  if (isObject$2(options)) {
+    leading = !!options.leading;
+    maxing = "maxWait" in options;
+    maxWait = maxing ? nativeMax$1(toNumber$1(options.maxWait) || 0, wait) : maxWait;
+    trailing = "trailing" in options ? !!options.trailing : trailing;
+  }
+  function invokeFunc(time) {
+    var args = lastArgs, thisArg = lastThis;
+    lastArgs = lastThis = void 0;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+  function leadingEdge(time) {
+    lastInvokeTime = time;
+    timerId = setTimeout(timerExpired, wait);
+    return leading ? invokeFunc(time) : result;
+  }
+  function remainingWait(time) {
+    var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, result2 = wait - timeSinceLastCall;
+    return maxing ? nativeMin$1(result2, maxWait - timeSinceLastInvoke) : result2;
+  }
+  function shouldInvoke(time) {
+    var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
+    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+  }
+  function timerExpired() {
+    var time = now$1();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    timerId = setTimeout(timerExpired, remainingWait(time));
+  }
+  function trailingEdge(time) {
+    timerId = void 0;
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = void 0;
+    return result;
+  }
+  function cancel() {
+    if (timerId !== void 0) {
+      clearTimeout(timerId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = void 0;
+  }
+  function flush() {
+    return timerId === void 0 ? result : trailingEdge(now$1());
+  }
+  function debounced() {
+    var time = now$1(), isInvoking = shouldInvoke(time);
+    lastArgs = arguments;
+    lastThis = this;
+    lastCallTime = time;
+    if (isInvoking) {
+      if (timerId === void 0) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxing) {
+        timerId = setTimeout(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === void 0) {
+      timerId = setTimeout(timerExpired, wait);
+    }
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+function throttle(func, wait, options) {
+  var leading = true, trailing = true;
+  if (typeof func != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT$2);
+  }
+  if (isObject$2(options)) {
+    leading = "leading" in options ? !!options.leading : leading;
+    trailing = "trailing" in options ? !!options.trailing : trailing;
+  }
+  return debounce$1(func, wait, {
+    "leading": leading,
+    "maxWait": wait,
+    "trailing": trailing
+  });
+}
+function isObject$2(value) {
+  var type = typeof value;
+  return !!value && (type == "object" || type == "function");
+}
+function isObjectLike$1(value) {
+  return !!value && typeof value == "object";
+}
+function isSymbol$1(value) {
+  return typeof value == "symbol" || isObjectLike$1(value) && objectToString$2.call(value) == symbolTag$1;
+}
+function toNumber$1(value) {
+  if (typeof value == "number") {
+    return value;
+  }
+  if (isSymbol$1(value)) {
+    return NAN$1;
+  }
+  if (isObject$2(value)) {
+    var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+    value = isObject$2(other) ? other + "" : other;
+  }
+  if (typeof value != "string") {
+    return value === 0 ? value : +value;
+  }
+  value = value.replace(reTrim$1, "");
+  var isBinary = reIsBinary$1.test(value);
+  return isBinary || reIsOctal$1.test(value) ? freeParseInt$1(value.slice(2), isBinary ? 2 : 8) : reIsBadHex$1.test(value) ? NAN$1 : +value;
+}
+var lodash_throttle = throttle;
+var FUNC_ERROR_TEXT$1 = "Expected a function";
+var NAN = 0 / 0;
+var symbolTag = "[object Symbol]";
+var reTrim = /^\s+|\s+$/g;
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+var reIsBinary = /^0b[01]+$/i;
+var reIsOctal = /^0o[0-7]+$/i;
+var freeParseInt = parseInt;
+var freeGlobal$1 = typeof commonjsGlobal == "object" && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+var freeSelf$1 = typeof self == "object" && self && self.Object === Object && self;
+var root$1 = freeGlobal$1 || freeSelf$1 || Function("return this")();
+var objectProto$1 = Object.prototype;
+var objectToString$1 = objectProto$1.toString;
+var nativeMax = Math.max, nativeMin = Math.min;
+var now = function() {
+  return root$1.Date.now();
+};
+function debounce(func, wait, options) {
+  var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
+  if (typeof func != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT$1);
+  }
+  wait = toNumber(wait) || 0;
+  if (isObject$1(options)) {
+    leading = !!options.leading;
+    maxing = "maxWait" in options;
+    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+    trailing = "trailing" in options ? !!options.trailing : trailing;
+  }
+  function invokeFunc(time) {
+    var args = lastArgs, thisArg = lastThis;
+    lastArgs = lastThis = void 0;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+  function leadingEdge(time) {
+    lastInvokeTime = time;
+    timerId = setTimeout(timerExpired, wait);
+    return leading ? invokeFunc(time) : result;
+  }
+  function remainingWait(time) {
+    var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, result2 = wait - timeSinceLastCall;
+    return maxing ? nativeMin(result2, maxWait - timeSinceLastInvoke) : result2;
+  }
+  function shouldInvoke(time) {
+    var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
+    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+  }
+  function timerExpired() {
+    var time = now();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    timerId = setTimeout(timerExpired, remainingWait(time));
+  }
+  function trailingEdge(time) {
+    timerId = void 0;
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = void 0;
+    return result;
+  }
+  function cancel() {
+    if (timerId !== void 0) {
+      clearTimeout(timerId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = void 0;
+  }
+  function flush() {
+    return timerId === void 0 ? result : trailingEdge(now());
+  }
+  function debounced() {
+    var time = now(), isInvoking = shouldInvoke(time);
+    lastArgs = arguments;
+    lastThis = this;
+    lastCallTime = time;
+    if (isInvoking) {
+      if (timerId === void 0) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxing) {
+        timerId = setTimeout(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === void 0) {
+      timerId = setTimeout(timerExpired, wait);
+    }
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+function isObject$1(value) {
+  var type = typeof value;
+  return !!value && (type == "object" || type == "function");
+}
+function isObjectLike(value) {
+  return !!value && typeof value == "object";
+}
+function isSymbol(value) {
+  return typeof value == "symbol" || isObjectLike(value) && objectToString$1.call(value) == symbolTag;
+}
+function toNumber(value) {
+  if (typeof value == "number") {
+    return value;
+  }
+  if (isSymbol(value)) {
+    return NAN;
+  }
+  if (isObject$1(value)) {
+    var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+    value = isObject$1(other) ? other + "" : other;
+  }
+  if (typeof value != "string") {
+    return value === 0 ? value : +value;
+  }
+  value = value.replace(reTrim, "");
+  var isBinary = reIsBinary.test(value);
+  return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+}
+var lodash_debounce = debounce;
+var FUNC_ERROR_TEXT = "Expected a function";
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+var funcTag = "[object Function]", genTag = "[object GeneratorFunction]";
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var freeGlobal = typeof commonjsGlobal == "object" && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal || freeSelf || Function("return this")();
+function getValue(object, key) {
+  return object == null ? void 0 : object[key];
+}
+function isHostObject(value) {
+  var result = false;
+  if (value != null && typeof value.toString != "function") {
+    try {
+      result = !!(value + "");
+    } catch (e) {
+    }
+  }
+  return result;
+}
+var arrayProto = Array.prototype, funcProto = Function.prototype, objectProto = Object.prototype;
+var coreJsData = root["__core-js_shared__"];
+var maskSrcKey = function() {
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+}();
+var funcToString = funcProto.toString;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var objectToString = objectProto.toString;
+var reIsNative = RegExp("^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
+var splice = arrayProto.splice;
+var Map = getNative(root, "Map"), nativeCreate = getNative(Object, "create");
+function Hash(entries) {
+  var index = -1, length = entries ? entries.length : 0;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+function hashClear() {
+  this.__data__ = nativeCreate ? nativeCreate(null) : {};
+}
+function hashDelete(key) {
+  return this.has(key) && delete this.__data__[key];
+}
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate) {
+    var result = data[key];
+    return result === HASH_UNDEFINED ? void 0 : result;
+  }
+  return hasOwnProperty.call(data, key) ? data[key] : void 0;
+}
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate ? data[key] !== void 0 : hasOwnProperty.call(data, key);
+}
+function hashSet(key, value) {
+  var data = this.__data__;
+  data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
+  return this;
+}
+Hash.prototype.clear = hashClear;
+Hash.prototype["delete"] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+function ListCache(entries) {
+  var index = -1, length = entries ? entries.length : 0;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+function listCacheClear() {
+  this.__data__ = [];
+}
+function listCacheDelete(key) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  return true;
+}
+function listCacheGet(key) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  return index < 0 ? void 0 : data[index][1];
+}
+function listCacheHas(key) {
+  return assocIndexOf(this.__data__, key) > -1;
+}
+function listCacheSet(key, value) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  if (index < 0) {
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype["delete"] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+function MapCache(entries) {
+  var index = -1, length = entries ? entries.length : 0;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+function mapCacheClear() {
+  this.__data__ = {
+    "hash": new Hash(),
+    "map": new (Map || ListCache)(),
+    "string": new Hash()
+  };
+}
+function mapCacheDelete(key) {
+  return getMapData(this, key)["delete"](key);
+}
+function mapCacheGet(key) {
+  return getMapData(this, key).get(key);
+}
+function mapCacheHas(key) {
+  return getMapData(this, key).has(key);
+}
+function mapCacheSet(key, value) {
+  getMapData(this, key).set(key, value);
+  return this;
+}
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype["delete"] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+function baseIsNative(value) {
+  if (!isObject(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction(value) || isHostObject(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource(value));
+}
+function getMapData(map, key) {
+  var data = map.__data__;
+  return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+function getNative(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : void 0;
+}
+function isKeyable(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+function isMasked(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString.call(func);
+    } catch (e) {
+    }
+    try {
+      return func + "";
+    } catch (e) {
+    }
+  }
+  return "";
+}
+function memoize(func, resolver) {
+  if (typeof func != "function" || resolver && typeof resolver != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  var memoized = function() {
+    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    var result = func.apply(this, args);
+    memoized.cache = cache.set(key, result);
+    return result;
+  };
+  memoized.cache = new (memoize.Cache || MapCache)();
+  return memoized;
+}
+memoize.Cache = MapCache;
+function eq(value, other) {
+  return value === other || value !== value && other !== other;
+}
+function isFunction(value) {
+  var tag = isObject(value) ? objectToString.call(value) : "";
+  return tag == funcTag || tag == genTag;
+}
+function isObject(value) {
+  var type = typeof value;
+  return !!value && (type == "object" || type == "function");
+}
+var lodash_memoize = memoize;
+export { lodash_debounce as a, lodash_memoize as b, lodash_throttle as l };

package/dist/node_modules.js

@@ -0,0 +1,54 @@
+import { get, set, appendErrors } from "react-hook-form";
+var e = function(i, e2, t2) {
+  if (i && "reportValidity" in i) {
+    var f2 = get(t2, e2);
+    i.setCustomValidity(f2 && f2.message || ""), i.reportValidity();
+  }
+}, t = function(r, i) {
+  var t2 = function(t3) {
+    var f3 = i.fields[t3];
+    f3 && f3.ref && "reportValidity" in f3.ref ? e(f3.ref, t3, r) : f3.refs && f3.refs.forEach(function(i2) {
+      return e(i2, t3, r);
+    });
+  };
+  for (var f2 in i.fields)
+    t2(f2);
+}, f = function(e2, f2) {
+  f2.shouldUseNativeValidation && t(e2, f2);
+  var o2 = {};
+  for (var a in e2) {
+    var n = get(f2.fields, a);
+    set(o2, a, Object.assign(e2[a], { ref: n && n.ref }));
+  }
+  return o2;
+};
+var o = function(o2, n, a) {
+  return n === void 0 && (n = {}), a === void 0 && (a = {}), function(s, i, c) {
+    try {
+      return Promise.resolve(function(t$1, r) {
+        try {
+          var u = (n.context && false, Promise.resolve(o2[a.mode === "sync" ? "validateSync" : "validate"](s, Object.assign({ abortEarly: false }, n, { context: i }))).then(function(t$12) {
+            return c.shouldUseNativeValidation && t({}, c), { values: a.rawValues ? s : t$12, errors: {} };
+          }));
+        } catch (e2) {
+          return r(e2);
+        }
+        return u && u.then ? u.then(void 0, r) : u;
+      }(0, function(e2) {
+        if (!e2.inner)
+          throw e2;
+        return { values: {}, errors: f((o3 = e2, n2 = !c.shouldUseNativeValidation && c.criteriaMode === "all", (o3.inner || []).reduce(function(e3, t2) {
+          if (e3[t2.path] || (e3[t2.path] = { message: t2.message, type: t2.type }), n2) {
+            var o4 = e3[t2.path].types, a2 = o4 && o4[t2.type];
+            e3[t2.path] = appendErrors(t2.path, n2, e3, t2.type, a2 ? [].concat(a2, t2.message) : t2.message);
+          }
+          return e3;
+        }, {})), c) };
+        var o3, n2;
+      }));
+    } catch (e2) {
+      return Promise.reject(e2);
+    }
+  };
+};
+export { o };

package/dist/react-draggable.js

@@ -1,5 +1,5 @@
 import require$$0 from "react";
-import require$$1 from "prop-types";
+import PropTypes from "prop-types";
 import require$$2 from "react-dom";
 import clsx from "clsx";
 var cjs = { exports: {} };
@@ -494,7 +494,7 @@ Object.defineProperty(DraggableCore$2, "__esModule", {
 });
 DraggableCore$2.default = void 0;
 var React = _interopRequireWildcard(require$$0);
-var _propTypes = _interopRequireDefault(require$$1);
+var _propTypes = _interopRequireDefault(PropTypes);
 var _reactDom = _interopRequireDefault(require$$2);
 var _domFns = domFns;
 var _positionFns = positionFns;
@@ -956,7 +956,7 @@ _defineProperty(DraggableCore$1, "defaultProps", {
   });
   exports.default = void 0;
   var React2 = _interopRequireWildcard2(require$$0);
-  var _propTypes2 = _interopRequireDefault2(require$$1);
+  var _propTypes2 = _interopRequireDefault2(PropTypes);
   var _reactDom2 = _interopRequireDefault2(require$$2);
   var _clsx2 = _interopRequireDefault2(clsx);
   var _domFns2 = domFns;

package/dist/react-resizable.js

@@ -1,6 +1,6 @@
 import require$$0 from "react";
 import { c as cjs } from "./react-draggable.js";
-import require$$1 from "prop-types";
+import PropTypes from "prop-types";
 var reactResizable = { exports: {} };
 var Resizable$1 = {};
 var utils = {};
@@ -60,7 +60,7 @@ function cloneElement(element, props) {
 var propTypes = {};
 propTypes.__esModule = true;
 propTypes.resizableProps = void 0;
-var _propTypes$2 = _interopRequireDefault$1(require$$1);
+var _propTypes$2 = _interopRequireDefault$1(PropTypes);
 function _interopRequireDefault$1(obj) {
   return obj && obj.__esModule ? obj : { default: obj };
 }
@@ -389,7 +389,7 @@ var ResizableBox$2 = {};
 ResizableBox$2.__esModule = true;
 ResizableBox$2.default = void 0;
 var React = _interopRequireWildcard(require$$0);
-var _propTypes = _interopRequireDefault(require$$1);
+var _propTypes = _interopRequireDefault(PropTypes);
 var _Resizable = _interopRequireDefault(Resizable$1);
 var _propTypes2 = propTypes;
 var _excluded = ["handle", "handleSize", "onResize", "onResizeStart", "onResizeStop", "draggableOpts", "minConstraints", "maxConstraints", "lockAspectRatio", "axis", "width", "height", "resizeHandles", "style", "transformScale"];

package/dist/react-splitter-layout.js

@@ -1,10 +1,10 @@
 import { g as getDefaultExportFromCjs } from "./commonjs.js";
-import require$$1 from "prop-types";
+import PropTypes from "prop-types";
 import require$$0 from "react";
 var lib = { exports: {} };
 (function(module, exports) {
   !function(e, t) {
-    module.exports = t(require$$1, require$$0);
+    module.exports = t(PropTypes, require$$0);
   }(window, function(e, t) {
     return function(e2) {
       var t2 = {};