@sheinx/hooks 3.0.0-alpha.1

package/esm/utils/object.js

@@ -0,0 +1,290 @@
+"use strict";
+
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.symbol.description.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.entries = exports.deepSet = exports.deepRemove = exports.deepMerge = exports.deepHas = exports.deepGet = void 0;
+exports.insertPoint = insertPoint;
+exports.objectValues = void 0;
+exports.pathGenerator = pathGenerator;
+exports.removeProps = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.string.replace.js");
+require("core-js/modules/es.array.map.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+require("core-js/modules/es.array.index-of.js");
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.string.includes.js");
+require("core-js/modules/es.array.splice.js");
+var _is = require("./is");
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function insertPoint(name) {
+  var reg = /(\[\d+\])/gi;
+  return name.replace(reg, function (s, m, i) {
+    return s.replace(m, i === 0 ? m : ".".concat(m));
+  });
+}
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var PATH_MODE = {
+  loose: '?',
+  strict: '!',
+  insert: '^',
+  append: '$'
+};
+// Object.values()
+var objectValues = function objectValues(obj) {
+  if (!obj) return [];
+  return Object.keys(obj).map(function (k) {
+    return obj[k];
+  });
+};
+
+// object only, not handle array.
+exports.objectValues = objectValues;
+var deepMerge = function deepMerge() {
+  var target = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var source = arguments.length > 1 ? arguments[1] : undefined;
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var clone = options.clone,
+    removeUndefined = options.removeUndefined,
+    skipUndefined = options.skipUndefined;
+  if (!(0, _is.isMergeable)(source)) return source;
+  var dest = {};
+  if ((0, _is.isMergeable)(target)) {
+    Object.keys(target).forEach(function (k) {
+      dest[k] = clone ? deepMerge({}, target[k], options) : target[k];
+      if (removeUndefined && dest[k] === undefined) delete dest[k];
+    });
+  }
+  Object.keys(source).forEach(function (k) {
+    if ((0, _is.isMergeable)(source[k]) && (0, _is.isMergeable)(target[k])) {
+      dest[k] = deepMerge(target[k], source[k], options);
+    } else {
+      if (skipUndefined && source[k] === undefined) return;
+      dest[k] = deepMerge({}, source[k], options);
+      if (removeUndefined && dest[k] === undefined) delete dest[k];
+    }
+  });
+  return dest;
+};
+exports.deepMerge = deepMerge;
+function pathGenerator(raw) {
+  var path = insertPoint(raw);
+  var reg = /^\[(\d+)\]$/;
+  var pathModeValues = objectValues(PATH_MODE);
+  var index = 0;
+  var last = 0;
+  var prop = '';
+  var results = [];
+  while (index >= 0) {
+    index = path.indexOf('.', last);
+    prop = path.substring(last, index === -1 ? undefined : index);
+    var mode = void 0;
+    var lastChar = prop.charAt(prop.length - 1);
+    if (pathModeValues.includes(lastChar)) {
+      mode = lastChar;
+      prop = prop.substring(0, prop.length - 1);
+    }
+
+    // array index
+    var match = reg.exec(prop);
+    // eslint-disable-next-line
+    if (match) prop = parseInt(match[1], 10);
+    last = index + 1;
+    results.push([prop, index === -1 ? undefined : path.substring(last), mode]);
+  }
+  return results;
+}
+var deepSet = function deepSet(target, path, value) {
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  if (!(0, _is.isObject)(target)) throw new Error('Target must be an object.');
+  if (typeof path !== 'string') throw new Error('Path must be a string.');
+  var removeUndefined = options.removeUndefined,
+    skipUndefined = options.skipUndefined;
+  var mergeOptions = {
+    clone: true,
+    removeUndefined: removeUndefined,
+    skipUndefined: skipUndefined
+  };
+
+  // empty root
+  if (path === '') {
+    var dest = deepMerge(target, value, mergeOptions);
+    Object.keys(dest).forEach(function (k) {
+      target[k] = dest[k];
+    });
+    return target;
+  }
+  var current = target;
+  var _iterator = _createForOfIteratorHelper(pathGenerator(path)),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = (0, _slicedToArray2.default)(_step.value, 3),
+        prop = _step$value[0],
+        next = _step$value[1],
+        mode = _step$value[2];
+      if (next) {
+        var nextIsArray = /^\[\d+\]/.test(next);
+        if (!current[prop]) current[prop] = nextIsArray ? [] : {};
+        if (nextIsArray && !Array.isArray(current[prop])) {
+          throw new Error("Path ".concat(path, " expect an array."));
+        } else if (Array.isArray(current[prop]) && !nextIsArray) {
+          throw new Error("Path ".concat(path, " is an array, expect an object."));
+        }
+        current = current[prop];
+        continue;
+      }
+      if (options.forceSet) {
+        current[prop] = value;
+      } else if (mode === PATH_MODE.insert) {
+        current.splice(prop, 0, value);
+      } else if (mode === PATH_MODE.append) {
+        current.splice(prop + 1, 0, value);
+      } else {
+        if (skipUndefined && value === undefined) break;
+        current[prop] = (0, _is.isMergeable)(current[prop]) && (0, _is.isMergeable)(value) ? deepMerge(current[prop], value, mergeOptions) : value;
+      }
+      if (removeUndefined && value === undefined) delete current[prop];
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return target;
+};
+exports.deepSet = deepSet;
+var deepGet = function deepGet(target, path) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  if (!(0, _is.isObject)(target)) throw new Error('Target must be an object.');
+  if (typeof path !== 'string') throw new Error('Path must be a string.');
+
+  // empty root
+  if (path === '') return target;
+  var defaultValue = options.defaultValue,
+    strictMode = options.strictMode;
+  var current = target;
+  var _iterator2 = _createForOfIteratorHelper(pathGenerator(path)),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _step2$value = (0, _slicedToArray2.default)(_step2.value, 3),
+        prop = _step2$value[0],
+        mode = _step2$value[2];
+      var isStrict = mode === PATH_MODE.strict || strictMode && defaultValue === undefined && mode !== PATH_MODE.loose;
+      // eslint-disable-next-line eqeqeq
+      if (current != null && hasOwnProperty.call(current, prop)) {
+        current = current[prop];
+      } else if (isStrict) {
+        throw new Error("Path ".concat(path, " is not exist."));
+      } else {
+        current = defaultValue;
+        break;
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return current;
+};
+exports.deepGet = deepGet;
+var deepRemove = function deepRemove(target, path) {
+  if (!(0, _is.isObject)(target)) throw new Error('Target must be an object.');
+  if (typeof path !== 'string' || !path) throw new Error('Path must be a string.');
+  var current = target;
+  var nextIsArray = false;
+  var _iterator3 = _createForOfIteratorHelper(pathGenerator(path)),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var _step3$value = (0, _slicedToArray2.default)(_step3.value, 2),
+        prop = _step3$value[0],
+        next = _step3$value[1];
+      // eslint-disable-next-line eqeqeq
+      if (current == null || !hasOwnProperty.call(current, prop)) {
+        break;
+      }
+      if (next) {
+        current = current[prop];
+        nextIsArray = /^\[\d+\]/.test(next);
+      } else if ((0, _is.isObject)(current)) {
+        if (nextIsArray) throw new Error('Target is an object, expect array');
+        delete current[prop];
+      } else {
+        if (!nextIsArray) {
+          throw new Error('Target is an array, expect object');
+        }
+        current.splice(prop, 1);
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  return target;
+};
+exports.deepRemove = deepRemove;
+var deepHas = function deepHas(target, path) {
+  if (!(0, _is.isObject)(target)) throw new Error('Target must be an object.');
+  if (typeof path !== 'string') throw new Error('Path must be a string.');
+  if (path === '') return true;
+  var current = target;
+  var _iterator4 = _createForOfIteratorHelper(pathGenerator(path)),
+    _step4;
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var _step4$value = (0, _slicedToArray2.default)(_step4.value, 2),
+        prop = _step4$value[0];
+      if (!current || !hasOwnProperty.call(current, prop)) return false;
+      current = current[prop];
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+  return true;
+};
+exports.deepHas = deepHas;
+var entries = function entries(obj) {
+  if (!obj) return [];
+  var keys = Object.keys(obj);
+  return keys.map(function (key) {
+    return [key, obj[key]];
+  });
+};
+exports.entries = entries;
+var removeProps = function removeProps(target, remove) {
+  var a = {};
+  var _iterator5 = _createForOfIteratorHelper(entries(target)),
+    _step5;
+  try {
+    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+      var _step5$value = (0, _slicedToArray2.default)(_step5.value, 2),
+        key = _step5$value[0],
+        value = _step5$value[1];
+      if (!(key in remove)) {
+        a[key] = value;
+      }
+    }
+  } catch (err) {
+    _iterator5.e(err);
+  } finally {
+    _iterator5.f();
+  }
+  return a;
+};
+exports.removeProps = removeProps;

package/esm/utils/position.d.ts

@@ -0,0 +1,2 @@
+export declare const getPosition: (target: HTMLElement | null, priorityDirection: "vertical" | "horizontal" | "auto" | undefined, mode: 'popover' | 'menu' | 'list') => "bottom" | "left" | "right" | "top" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | "left-top" | "left-bottom" | "right-top" | "right-bottom";
+//# sourceMappingURL=position.d.ts.map

package/esm/utils/position.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"position.d.ts","sourceRoot":"","sources":["position.ts"],"names":[],"mappings":"AAgFA,eAAO,MAAM,WAAW,WACd,WAAW,GAAG,IAAI,2EAEpB,SAAS,GAAG,MAAM,GAAG,MAAM,gKAKlC,CAAC"}

package/esm/utils/position.js

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPosition = void 0;
+var _document = require("./document");
+var getMenuPosition = function getMenuPosition(target) {
+  var priorityDirection = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'vertical';
+  var position = 'bottom-left';
+  if (!target) return position;
+  var rect = target.getBoundingClientRect();
+  var tempPriorityDirection = priorityDirection;
+  var horizontalPoint = rect.left + rect.width / 2;
+  var verticalPoint = rect.top + rect.height / 2;
+  var windowHeight = _document.docSize.height;
+  var windowWidth = _document.docSize.width;
+  if (priorityDirection === 'auto') {
+    var maxX = Math.max(rect.left, windowWidth - rect.right);
+    var maxY = Math.max(rect.top, windowHeight - rect.bottom);
+    tempPriorityDirection = maxX > maxY ? 'horizontal' : 'vertical';
+  }
+  if (tempPriorityDirection === 'horizontal') {
+    if (horizontalPoint > windowWidth / 2) position = 'left';else position = 'right';
+    if (verticalPoint >= windowHeight / 2) {
+      position += '-bottom';
+    } else {
+      position += '-top';
+    }
+  } else {
+    if (verticalPoint > windowHeight / 2) position = 'top';else position = 'bottom';
+    if (horizontalPoint >= windowWidth / 2) {
+      position += '-right';
+    } else {
+      position += '-left';
+    }
+  }
+  return position;
+};
+var getPopoverPosition = function getPopoverPosition(target) {
+  var priorityDirection = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'vertical';
+  var position = 'bottom-left';
+  if (!target) return position;
+  var rect = target.getBoundingClientRect();
+  var tempPriorityDirection = priorityDirection;
+  var horizontalPoint = rect.left + rect.width / 2;
+  var verticalPoint = rect.top + rect.height / 2;
+  var windowHeight = _document.docSize.height;
+  var windowWidth = _document.docSize.width;
+  if (priorityDirection === 'auto') {
+    var maxX = Math.max(rect.left, windowWidth - rect.right);
+    var maxY = Math.max(rect.top, windowHeight - rect.bottom);
+    tempPriorityDirection = maxX > maxY ? 'horizontal' : 'vertical';
+  }
+  if (tempPriorityDirection === 'horizontal') {
+    if (horizontalPoint > windowWidth / 2) position = 'left';else position = 'right';
+    if (verticalPoint > windowHeight * 0.6) {
+      position += '-bottom';
+    } else if (verticalPoint < windowHeight * 0.4) {
+      position += '-top';
+    }
+  } else {
+    if (verticalPoint > windowHeight / 2) position = 'top';else position = 'bottom';
+    if (horizontalPoint > windowWidth * 0.6) {
+      position += '-right';
+    } else if (horizontalPoint < windowWidth * 0.4) {
+      position += '-left';
+    }
+  }
+  return position;
+};
+var getPosition = function getPosition(target) {
+  var priorityDirection = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'vertical';
+  var mode = arguments.length > 2 ? arguments[2] : undefined;
+  if (mode === 'popover') return getPopoverPosition(target, priorityDirection);
+  if (mode === 'menu') return getMenuPosition(target, priorityDirection);
+  return 'bottom-left';
+};
+exports.getPosition = getPosition;

package/esm/utils/react-render.d.ts

@@ -0,0 +1,10 @@
+import type * as React from 'react';
+import type { Root } from 'react-dom/client';
+declare const MARK = "__sheinout_root__";
+declare type ContainerType = (Element | DocumentFragment) & {
+    [MARK]?: Root;
+};
+export declare const ReactRender: (node: React.ReactElement, container: ContainerType) => void;
+export declare const ReactUnmount: (container: ContainerType) => Promise<void> | undefined;
+export {};
+//# sourceMappingURL=react-render.d.ts.map

package/esm/utils/react-render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-render.d.ts","sourceRoot":"","sources":["react-render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAS7C,QAAA,MAAM,IAAI,sBAAsB,CAAC;AAEjC,aAAK,aAAa,GAAG,CAAC,OAAO,GAAG,gBAAgB,CAAC,GAAG;IAClD,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC;CACf,CAAC;AA6BF,eAAO,MAAM,WAAW,SAAU,MAAM,YAAY,aAAa,aAAa,SAQ7E,CAAC;AAcF,eAAO,MAAM,YAAY,cAAe,aAAa,8BAMpD,CAAC"}

package/esm/utils/react-render.js

@@ -0,0 +1,85 @@
+"use strict";
+
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.weak-map.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ReactUnmount = exports.ReactRender = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+require("core-js/modules/es.promise.js");
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var ReactDOM = _interopRequireWildcard(require("react-dom"));
+var _client = require("react-dom/client");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var fullClone = _objectSpread({}, ReactDOM);
+var MARK = '__sheinout_root__';
+var version = fullClone.version,
+  reactRender = fullClone.render,
+  unmountComponentAtNode = fullClone.unmountComponentAtNode;
+var createRoot;
+try {
+  var mainVersion = Number((version || '').split('.')[0]);
+  if (mainVersion >= 18) {
+    createRoot = _client.createRoot;
+  }
+} catch (e) {
+  // Nothing;
+}
+var modernRender = function modernRender(node, container) {
+  var root = container[MARK] || createRoot(container);
+  root.render(node);
+  container[MARK] = root;
+};
+var legacyRender = function legacyRender(node, container) {
+  reactRender(node, container);
+};
+var ReactRender = function ReactRender(node, container) {
+  // @ts-ignore
+  if (createRoot) {
+    modernRender(node, container);
+    return;
+  }
+  legacyRender(node, container);
+};
+exports.ReactRender = ReactRender;
+var modernUnmount = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(container) {
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          return _context.abrupt("return", Promise.resolve().then(function () {
+            var _container$MARK;
+            (_container$MARK = container[MARK]) === null || _container$MARK === void 0 ? void 0 : _container$MARK.unmount();
+            delete container[MARK];
+          }));
+        case 1:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function modernUnmount(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var legacyUnmount = function legacyUnmount(container) {
+  unmountComponentAtNode(container);
+};
+var ReactUnmount = function ReactUnmount(container) {
+  if (createRoot !== undefined) {
+    return modernUnmount(container);
+  }
+  legacyUnmount(container);
+};
+exports.ReactUnmount = ReactUnmount;

package/esm/utils/render.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { KeygenType } from '../common/type';
+export declare type renderFunc<T extends any[]> = (...args: T) => React.ReactNode;
+export declare const render: <T extends any[]>(r: string | renderFunc<T> | undefined, ...args: T) => any;
+export declare function getKey<T>(gen: KeygenType<T> | undefined, d: T, index?: number): string | number;
+//# sourceMappingURL=render.d.ts.map

package/esm/utils/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAE5C,oBAAY,UAAU,CAAC,CAAC,SAAS,GAAG,EAAE,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,KAAK,CAAC,SAAS,CAAC;AAE1E,eAAO,MAAM,MAAM,6EAIlB,CAAC;AASF,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,mBAM7E"}

package/esm/utils/render.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getKey = getKey;
+exports.render = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var render = function render(r) {
+  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    args[_key - 1] = arguments[_key];
+  }
+  if (typeof r === 'function') return r.apply(void 0, args);
+  if (typeof r === 'string' && args[0]) return args[0][r];
+  return args[0];
+};
+exports.render = render;
+function $getKey(gen, d, index) {
+  if (gen === true) return d;
+  if (typeof gen === 'string') return d[gen];
+  if (typeof gen === 'function') return gen(d, index);
+  return index;
+}
+function getKey(gen, d, index) {
+  var key = $getKey(gen, d, index);
+  if (typeof key !== 'string' && typeof key !== 'number') {
+    console.error(new Error("keygen result expect a string or a number, get '".concat((0, _typeof2.default)(key), "'")));
+  }
+  return key;
+}

package/esm/utils/rule/index.d.ts

@@ -0,0 +1,3 @@
+export { default, default as Rule } from './rule';
+export type { ValidFunc, RuleParams, FormItemRule } from './rule.type';
+//# sourceMappingURL=index.d.ts.map

package/esm/utils/rule/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,QAAQ,CAAC;AAClD,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC"}

package/esm/utils/rule/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Rule", {
+  enumerable: true,
+  get: function get() {
+    return _rule.default;
+  }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function get() {
+    return _rule.default;
+  }
+});
+var _rule = _interopRequireDefault(require("./rule"));

package/esm/utils/rule/length.d.ts

@@ -0,0 +1,11 @@
+import { ObjectType } from '../../common/type';
+import { MessageType } from './rule.type';
+export declare const lengthMessage: {
+    max: (props: ObjectType) => string;
+    min: (props: ObjectType) => string;
+};
+declare const _default: (key: 'min' | 'max', { message }?: {
+    message?: MessageType | undefined;
+}) => (len: number, msg?: MessageType) => ObjectType<any> | null;
+export default _default;
+//# sourceMappingURL=length.d.ts.map

package/esm/utils/rule/length.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"length.d.ts","sourceRoot":"","sources":["length.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAqB1C,eAAO,MAAM,aAAa;iBAnB4B,UAAU;iBAAV,UAAU;CAsB/D,CAAC;8BAEmB,KAAK,GAAG,KAAK;;YAC1B,MAAM,QAAQ,WAAW;AADjC,wBAWI"}

package/esm/utils/rule/length.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.lengthMessage = exports.default = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+require("core-js/modules/es.array.concat.js");
+var _object = require("../object");
+var createMessage = function createMessage(key) {
+  return function (props) {
+    var lt = '';
+    switch (props.type) {
+      case 'integer':
+      case 'number':
+        lt = 'number';
+        break;
+      case 'array':
+        lt = 'array';
+        break;
+      default:
+        lt = 'string';
+    }
+    return "$rules.length.".concat(key, ".").concat(lt);
+  };
+};
+var options = {
+  skipUndefined: true
+};
+var lengthMessage = {
+  max: createMessage('max'),
+  min: createMessage('min')
+};
+exports.lengthMessage = lengthMessage;
+var _default = function _default(key) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    message = _ref.message;
+  return function (len, msg) {
+    if (typeof len !== 'number') {
+      console.error(new Error("Rule \"".concat(key, "\" param expect a number, get ").concat((0, _typeof2.default)(len))));
+      return null;
+    }
+    return (0, _object.deepMerge)({
+      message: lengthMessage[key]
+    }, (0, _object.deepMerge)((0, _defineProperty2.default)({
+      message: message
+    }, key, len), {
+      message: msg
+    }, options), options);
+  };
+};
+exports.default = _default;

package/esm/utils/rule/regexp.d.ts

@@ -0,0 +1,6 @@
+import { MessageType } from './rule.type';
+declare const _default: ({ message }?: {
+    message?: MessageType | undefined;
+}) => (regExp: string | RegExp, msg?: MessageType) => import("../..").ObjectType<any> | null;
+export default _default;
+//# sourceMappingURL=regexp.d.ts.map

package/esm/utils/rule/regexp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regexp.d.ts","sourceRoot":"","sources":["regexp.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;;;eAK/B,MAAM,GAAG,MAAM,QAAQ,WAAW;AAD7C,wBAaI"}

package/esm/utils/rule/regexp.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+require("core-js/modules/es.regexp.constructor.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.regexp.to-string.js");
+var _object = require("../object");
+var options = {
+  skipUndefined: true
+};
+var _default = function _default() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    message = _ref.message;
+  return function (regExp, msg) {
+    if (typeof regExp !== 'string' && !(regExp instanceof RegExp)) {
+      console.error(new Error("Rule \"reg\" param expect a RegExp object or a string, get ".concat((0, _typeof2.default)(regExp))));
+      return null;
+    }
+    return (0, _object.deepMerge)({
+      message: '$rules.reg'
+    }, (0, _object.deepMerge)({
+      message: message,
+      regExp: regExp
+    }, {
+      message: msg
+    }, options), options);
+  };
+};
+exports.default = _default;