@ebscn/ui 0.0.11 → 1.0.0

package/cjs/utils/render-imperatively.js

@@ -0,0 +1,207 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderImperatively = renderImperatively;
+var _react = _interopRequireWildcard(require("react"));
+var _renderToBody = require("./render-to-body");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var __assign = void 0 && (void 0).__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+var __awaiter = void 0 && (void 0).__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __generator = void 0 && (void 0).__generator || function (thisArg, body) {
+  var _ = {
+      label: 0,
+      sent: function () {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      },
+      trys: [],
+      ops: []
+    },
+    f,
+    y,
+    t,
+    g;
+  return g = {
+    next: verb(0),
+    "throw": verb(1),
+    "return": verb(2)
+  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+    return this;
+  }), g;
+  function verb(n) {
+    return function (v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op[0] && (_ = 0)), _) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return {
+            value: op[1],
+            done: false
+          };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
+    };
+  }
+};
+function renderImperatively(element) {
+  var _this = this;
+  var Wrapper = _react.default.forwardRef(function (_, ref) {
+    var _a = (0, _react.useState)(false),
+      visible = _a[0],
+      setVisible = _a[1];
+    var closedRef = (0, _react.useRef)(false);
+    var _b = (0, _react.useState)(element),
+      elementToRender = _b[0],
+      setElementToRender = _b[1];
+    var keyRef = (0, _react.useRef)(0);
+    (0, _react.useEffect)(function () {
+      if (!closedRef.current) {
+        setVisible(true);
+      } else {
+        afterClose();
+      }
+    }, []);
+    function onClose() {
+      var _a, _b;
+      closedRef.current = true;
+      setVisible(false);
+      (_b = (_a = elementToRender.props).onClose) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    function afterClose() {
+      var _a, _b;
+      unmount();
+      (_b = (_a = elementToRender.props).afterClose) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    (0, _react.useImperativeHandle)(ref, function () {
+      return {
+        close: onClose,
+        replace: function (element) {
+          var _a, _b;
+          keyRef.current++;
+          (_b = (_a = elementToRender.props).afterClose) === null || _b === void 0 ? void 0 : _b.call(_a);
+          setElementToRender(element);
+        }
+      };
+    });
+    return _react.default.cloneElement(elementToRender, __assign(__assign({}, elementToRender.props), {
+      key: keyRef.current,
+      visible: visible,
+      onClose: onClose,
+      afterClose: afterClose
+    }));
+  });
+  var wrapperRef = _react.default.createRef();
+  var unmount = (0, _renderToBody.renderToBody)(_react.default.createElement(Wrapper, {
+    ref: wrapperRef
+  }));
+  return {
+    close: function () {
+      return __awaiter(_this, void 0, void 0, function () {
+        var _a;
+        return __generator(this, function (_b) {
+          if (!wrapperRef.current) {
+            // it means the wrapper is not mounted yet, call `unmount` directly
+            unmount();
+          } else {
+            (_a = wrapperRef.current) === null || _a === void 0 ? void 0 : _a.close();
+          }
+          return [2 /*return*/];
+        });
+      });
+    },
+    replace: function (element) {
+      var _a;
+      (_a = wrapperRef.current) === null || _a === void 0 ? void 0 : _a.replace(element);
+    }
+  };
+}

package/cjs/utils/render-to-body.d.ts

@@ -0,0 +1,2 @@
+import type { ReactElement } from 'react';
+export declare function renderToBody(element: ReactElement): () => void;

package/cjs/utils/render-to-body.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderToBody = renderToBody;
+var _render = require("./render");
+function renderToBody(element) {
+  var container = document.createElement('div');
+  document.body.appendChild(container);
+  function unmount() {
+    var unmountResult = (0, _render.unmount)(container);
+    if (unmountResult && container.parentNode) {
+      container.parentNode.removeChild(container);
+    }
+  }
+  (0, _render.render)(element, container);
+  return unmount;
+}

package/cjs/utils/render-to-container.d.ts

@@ -0,0 +1,3 @@
+import type { ReactElement } from 'react';
+export type GetContainer = HTMLElement | (() => HTMLElement) | null;
+export declare function renderToContainer(getContainer: GetContainer, node: ReactElement): ReactElement<any, string | import("react").JSXElementConstructor<any>>;

package/cjs/utils/render-to-container.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderToContainer = renderToContainer;
+var _reactDom = require("react-dom");
+var _getContainer = require("./get-container");
+var _canUseDom = require("./can-use-dom");
+function renderToContainer(getContainer, node) {
+  if (_canUseDom.canUseDom && getContainer) {
+    var container = (0, _getContainer.resolveContainer)(getContainer);
+    return (0, _reactDom.createPortal)(node, container);
+  }
+  return node;
+}

package/cjs/utils/render.d.ts

@@ -0,0 +1,9 @@
+import type { ReactElement } from 'react';
+import type { Root } from 'react-dom/client';
+declare const MARK = "__antd_mobile_root__";
+type ContainerType = (Element | DocumentFragment) & {
+    [MARK]?: Root;
+};
+export declare function render(node: ReactElement, container: ContainerType): void;
+export declare function unmount(container: ContainerType): boolean | Promise<void>;
+export {};

package/cjs/utils/render.js

@@ -0,0 +1,196 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.render = render;
+exports.unmount = unmount;
+var ReactDOM = _interopRequireWildcard(require("react-dom"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var __assign = void 0 && (void 0).__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+var __awaiter = void 0 && (void 0).__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __generator = void 0 && (void 0).__generator || function (thisArg, body) {
+  var _ = {
+      label: 0,
+      sent: function () {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      },
+      trys: [],
+      ops: []
+    },
+    f,
+    y,
+    t,
+    g;
+  return g = {
+    next: verb(0),
+    "throw": verb(1),
+    "return": verb(2)
+  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+    return this;
+  }), g;
+  function verb(n) {
+    return function (v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op[0] && (_ = 0)), _) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return {
+            value: op[1],
+            done: false
+          };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
+    };
+  }
+};
+// Let compiler not to search module usage
+var fullClone = __assign({}, ReactDOM);
+var version = fullClone.version,
+  reactRender = fullClone.render,
+  unmountComponentAtNode = fullClone.unmountComponentAtNode;
+var createRoot;
+try {
+  var mainVersion = Number((version || '').split('.')[0]);
+  if (mainVersion >= 18 && fullClone.createRoot) {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    createRoot = fullClone.createRoot;
+  }
+} catch (e) {
+  // Do nothing;
+}
+function toggleWarning(skip) {
+  var __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = fullClone.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+  if (__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED && typeof __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED === 'object') {
+    __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.usingClientEntryPoint = skip;
+  }
+}
+var MARK = '__antd_mobile_root__';
+function legacyRender(node, container) {
+  reactRender(node, container);
+}
+function concurrentRender(node, container) {
+  toggleWarning(true);
+  var root = container[MARK] || createRoot(container);
+  toggleWarning(false);
+  root.render(node);
+  container[MARK] = root;
+}
+function render(node, container) {
+  if (createRoot) {
+    concurrentRender(node, container);
+    return;
+  }
+  legacyRender(node, container);
+}
+// ========================== Unmount =========================
+function legacyUnmount(container) {
+  return unmountComponentAtNode(container);
+}
+function concurrentUnmount(container) {
+  return __awaiter(this, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+      // Delay to unmount to avoid React 18 sync warning
+      return [2 /*return*/, Promise.resolve().then(function () {
+        var _a;
+        (_a = container[MARK]) === null || _a === void 0 ? void 0 : _a.unmount();
+        delete container[MARK];
+      })];
+    });
+  });
+}
+function unmount(container) {
+  if (createRoot) {
+    return concurrentUnmount(container);
+  }
+  return legacyUnmount(container);
+}

package/cjs/utils/replace-message.d.ts

@@ -0,0 +1 @@
+export declare function replaceMessage(template: string, kv: Record<string, string>): string;

package/cjs/utils/replace-message.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.replaceMessage = replaceMessage;
+// 移植自 field-form https://github.com/react-component/field-form/blob/master/src/utils/validateUtil.ts#L21
+function replaceMessage(template, kv) {
+  return template.replace(/\$\{\w+\}/g, function (str) {
+    var key = str.slice(2, -1);
+    return kv[key];
+  });
+}

package/cjs/utils/rubberband.d.ts

@@ -0,0 +1,2 @@
+export declare function rubberband(distance: number, dimension: number, constant: number): number;
+export declare function rubberbandIfOutOfBounds(position: number, min: number, max: number, dimension: number, constant?: number): number;

package/cjs/utils/rubberband.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.rubberband = rubberband;
+exports.rubberbandIfOutOfBounds = rubberbandIfOutOfBounds;
+var _bound = require("./bound");
+function rubberband(distance, dimension, constant) {
+  return distance * dimension * constant / (dimension + constant * distance);
+}
+function rubberbandIfOutOfBounds(position, min, max, dimension, constant) {
+  if (constant === void 0) {
+    constant = 0.15;
+  }
+  if (constant === 0) return (0, _bound.bound)(position, min, max);
+  if (position < min) return -rubberband(min - position, dimension, constant) + min;
+  if (position > max) return +rubberband(position - max, dimension, constant) + max;
+  return position;
+}

package/cjs/utils/should-render.d.ts

@@ -0,0 +1,10 @@
+import type { FC, ReactElement } from 'react';
+interface Props {
+    active: boolean;
+    forceRender?: boolean;
+    destroyOnClose?: boolean;
+    children: ReactElement;
+}
+export declare const ShouldRender: FC<Props>;
+export declare function useShouldRender(active: boolean, forceRender?: boolean, destroyOnClose?: boolean): boolean;
+export {};

package/cjs/utils/should-render.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ShouldRender = void 0;
+exports.useShouldRender = useShouldRender;
+var _useInitialized = require("./use-initialized");
+var ShouldRender = function (props) {
+  var shouldRender = useShouldRender(props.active, props.forceRender, props.destroyOnClose);
+  return shouldRender ? props.children : null;
+};
+exports.ShouldRender = ShouldRender;
+function useShouldRender(active, forceRender, destroyOnClose) {
+  var initialized = (0, _useInitialized.useInitialized)(active);
+  if (forceRender) return true;
+  if (active) return true;
+  if (!initialized) return false;
+  return !destroyOnClose;
+}

package/cjs/utils/shuffle.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 数组打乱
+ * @param array 任意数组
+ * @returns any[] 打乱后的数组
+ */
+export declare function shuffle(array: any[]): any[];

package/cjs/utils/shuffle.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.shuffle = shuffle;
+/**
+ * 数组打乱
+ * @param array 任意数组
+ * @returns any[] 打乱后的数组
+ */
+var __spreadArray = void 0 && (void 0).__spreadArray || function (to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
+function shuffle(array) {
+  var _a;
+  var result = __spreadArray([], array, true);
+  for (var i = result.length; i > 0; i--) {
+    var j = Math.floor(Math.random() * i);
+    _a = [result[j], result[i - 1]], result[i - 1] = _a[0], result[j] = _a[1];
+  }
+  return result;
+}

package/cjs/utils/sleep.d.ts

@@ -0,0 +1 @@
+export declare const sleep: (time: number) => Promise<unknown>;

package/cjs/utils/sleep.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sleep = void 0;
+var sleep = function (time) {
+  return new Promise(function (resolve) {
+    return setTimeout(resolve, time);
+  });
+};
+exports.sleep = sleep;

package/cjs/utils/supports-passive.d.ts

@@ -0,0 +1 @@
+export declare let supportsPassive: boolean;

package/cjs/utils/supports-passive.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.supportsPassive = void 0;
+var _canUseDom = require("./can-use-dom");
+var supportsPassive = exports.supportsPassive = false;
+if (_canUseDom.canUseDom) {
+  try {
+    var opts = {};
+    Object.defineProperty(opts, 'passive', {
+      get: function () {
+        exports.supportsPassive = supportsPassive = true;
+      }
+    });
+    window.addEventListener('test-passive', null, opts);
+  } catch (e) {}
+}

package/cjs/utils/to-css-length.d.ts

@@ -0,0 +1 @@
+export declare function toCSSLength(val: string | number): string;

package/cjs/utils/to-css-length.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toCSSLength = toCSSLength;
+function toCSSLength(val) {
+  return typeof val === 'number' ? "".concat(val, "px") : val;
+}

package/cjs/utils/traverse-react-node.d.ts

@@ -0,0 +1,2 @@
+import type { ReactNode } from 'react';
+export declare function traverseReactNode(children: ReactNode, fn: (child: ReactNode, index: number) => void): void;

package/cjs/utils/traverse-react-node.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.traverseReactNode = traverseReactNode;
+var _react = _interopRequireDefault(require("react"));
+var _reactIs = require("react-is");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function traverseReactNode(children, fn) {
+  var i = 0;
+  function handle(target) {
+    _react.default.Children.forEach(target, function (child) {
+      if (!(0, _reactIs.isFragment)(child)) {
+        fn(child, i);
+        i += 1;
+      } else {
+        handle(child.props.children);
+      }
+    });
+  }
+  handle(children);
+}

package/cjs/utils/tree.d.ts

@@ -0,0 +1 @@
+export declare function getTreeDeep(treeData: any[], childrenName?: string): number;

package/cjs/utils/tree.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTreeDeep = getTreeDeep;
+// 找到树的深度
+function getTreeDeep(treeData, childrenName) {
+  if (childrenName === void 0) {
+    childrenName = 'children';
+  }
+  var walker = function (tree) {
+    var deep = 0;
+    tree.forEach(function (item) {
+      if (item[childrenName]) {
+        deep = Math.max(deep, walker(item[childrenName]) + 1);
+      } else {
+        deep = Math.max(deep, 1);
+      }
+    });
+    return deep;
+  };
+  return walker(treeData);
+}