@ebscn/ui 0.0.11 → 1.0.0-beta.0

package/es/utils/is-node-with-content.js

@@ -0,0 +1,3 @@
+export function isNodeWithContent(node) {
+  return node !== undefined && node !== null && node !== false;
+}

package/es/utils/matrix.d.ts

@@ -0,0 +1,10 @@
+export type Matrix = readonly [number, number, number, number, number, number];
+export declare const create: () => Matrix;
+export declare const getTranslateX: (m: Matrix) => number;
+export declare const getTranslateY: (m: Matrix) => number;
+export declare const getScaleX: (m: Matrix) => number;
+export declare const getScaleY: (m: Matrix) => number;
+export declare const translate: (m: Matrix, x: number, y: number) => Matrix;
+export declare const scale: (m: Matrix, scaleX: number, scaleY?: number) => Matrix;
+export declare const apply: (m: Matrix, [ox, oy]: [number, number]) => [number, number];
+export declare const multiply: (m1: Matrix, m2: Matrix) => Matrix;

package/es/utils/matrix.js

@@ -0,0 +1,32 @@
+export var create = function () {
+  return [1, 0, 0, 1, 0, 0];
+};
+export var getTranslateX = function (m) {
+  return m[4];
+};
+export var getTranslateY = function (m) {
+  return m[5];
+};
+export var getScaleX = function (m) {
+  return m[0];
+};
+export var getScaleY = function (m) {
+  return m[3];
+};
+export var translate = function (m, x, y) {
+  return multiply([1, 0, 0, 1, x, y], m);
+};
+export var scale = function (m, scaleX, scaleY) {
+  if (scaleY === void 0) {
+    scaleY = scaleX;
+  }
+  return multiply([scaleX, 0, 0, scaleY, 0, 0], m);
+};
+export var apply = function (m, _a) {
+  var ox = _a[0],
+    oy = _a[1];
+  return [m[0] * ox + m[2] * oy + m[4], m[1] * ox + m[3] * oy + m[5]];
+};
+export var multiply = function (m1, m2) {
+  return [m1[0] * m2[0] + m1[2] * m2[1], m1[1] * m2[0] + m1[3] * m2[1], m1[0] * m2[2] + m1[2] * m2[3], m1[1] * m2[2] + m1[3] * m2[3], m1[0] * m2[4] + m1[2] * m2[5] + m1[4], m1[1] * m2[4] + m1[3] * m2[5] + m1[5]];
+};

package/es/utils/measure-css-length.d.ts

@@ -0,0 +1 @@
+export declare function measureCSSLength(raw: string | undefined | null): number;

package/es/utils/measure-css-length.js

@@ -0,0 +1,23 @@
+import { isDev } from './is-dev';
+import { devError } from './dev-log';
+export function measureCSSLength(raw) {
+  if (raw === null || raw === undefined || raw === '') {
+    if (isDev) {
+      devError('Global', 'Something went wrong when calculating CSS length. Please report an issue at https://github.com/ant-design/ant-design-mobile/issues/new/choose');
+    }
+    return 0;
+  }
+  var withUnit = raw.trim();
+  if (withUnit.endsWith('px')) {
+    return parseFloat(withUnit);
+  } else if (withUnit.endsWith('rem')) {
+    return parseFloat(withUnit) * parseFloat(window.getComputedStyle(document.documentElement).fontSize);
+  } else if (withUnit.endsWith('vw')) {
+    return parseFloat(withUnit) * window.innerWidth / 100;
+  } else {
+    if (isDev) {
+      devError('Global', "You are using a not supported CSS unit in `".concat(raw, "`. Only `px` `rem` and `vw` are supported."));
+    }
+    return 0;
+  }
+}

package/es/utils/merge-locale.d.ts

@@ -0,0 +1 @@
+export declare function mergeLocale<T extends object, P extends object>(base: T, patch: P): T;

package/es/utils/merge-locale.js

@@ -0,0 +1,15 @@
+export function mergeLocale(base, patch) {
+  function merge(a, b) {
+    if (typeof a !== 'object' || typeof b !== 'object' || Array.isArray(a) || Array.isArray(b)) {
+      return b !== undefined ? b : a;
+    }
+    var result = {};
+    for (var key in a) {
+      if (a.hasOwnProperty(key)) {
+        result[key] = merge(a[key], b[key]);
+      }
+    }
+    return result;
+  }
+  return merge(base, patch);
+}

package/es/utils/native-props.d.ts

@@ -0,0 +1,8 @@
+import React, { AriaAttributes } from 'react';
+import type { CSSProperties, ReactElement } from 'react';
+export type NativeProps<S extends string = never> = {
+    className?: string;
+    style?: CSSProperties & Partial<Record<S, string>>;
+    tabIndex?: number;
+} & AriaAttributes;
+export declare function withNativeProps<P extends NativeProps>(props: P, element: ReactElement): React.ReactElement<any, string | React.JSXElementConstructor<any>>;

package/es/utils/native-props.js

@@ -0,0 +1,31 @@
+var __assign = this && this.__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);
+};
+import React from 'react';
+import classNames from 'classnames';
+export function withNativeProps(props, element) {
+  var p = __assign({}, element.props);
+  if (props.className) {
+    p.className = classNames(element.props.className, props.className);
+  }
+  if (props.style) {
+    p.style = __assign(__assign({}, p.style), props.style);
+  }
+  if (props.tabIndex !== undefined) {
+    p.tabIndex = props.tabIndex;
+  }
+  for (var key in props) {
+    if (!props.hasOwnProperty(key)) continue;
+    if (key.startsWith('data-') || key.startsWith('aria-')) {
+      p[key] = props[key];
+    }
+  }
+  return React.cloneElement(element, p);
+}

package/es/utils/nearest.d.ts

@@ -0,0 +1 @@
+export declare function nearest(arr: number[], target: number): number;

package/es/utils/nearest.js

@@ -0,0 +1,5 @@
+export function nearest(arr, target) {
+  return arr.reduce(function (pre, cur) {
+    return Math.abs(pre - target) < Math.abs(cur - target) ? pre : cur;
+  });
+}

package/es/utils/noop.d.ts

@@ -0,0 +1 @@
+export declare const noop: () => void;

package/es/utils/noop.js

@@ -0,0 +1 @@
+export var noop = function () {};

package/es/utils/reduce-and-restore-motion.d.ts

@@ -0,0 +1,4 @@
+export declare function reduceMotion(): void;
+export declare function restoreMotion(): void;
+export declare function isMotionReduced(): boolean;
+export declare function useMotionReduced(): boolean;

package/es/utils/reduce-and-restore-motion.js

@@ -0,0 +1,35 @@
+import { Globals } from '@react-spring/web';
+import { useSyncExternalStore } from 'use-sync-external-store/shim';
+var reduced = false;
+var subscribers = new Set();
+function notify() {
+  subscribers.forEach(function (subscriber) {
+    subscriber();
+  });
+}
+export function reduceMotion() {
+  reduced = true;
+  notify();
+  Globals.assign({
+    skipAnimation: true
+  });
+}
+export function restoreMotion() {
+  reduced = false;
+  notify();
+  Globals.assign({
+    skipAnimation: false
+  });
+}
+export function isMotionReduced() {
+  return reduced;
+}
+function subscribe(onStoreChange) {
+  subscribers.add(onStoreChange);
+  return function () {
+    subscribers.delete(onStoreChange);
+  };
+}
+export function useMotionReduced() {
+  return useSyncExternalStore(subscribe, isMotionReduced, isMotionReduced);
+}

package/es/utils/render-imperatively.d.ts

@@ -0,0 +1,13 @@
+import type { ReactElement } from 'react';
+type ImperativeProps = {
+    visible?: boolean;
+    onClose?: () => void;
+    afterClose?: () => void;
+};
+type TargetElement = ReactElement<ImperativeProps>;
+export type ImperativeHandler = {
+    close: () => void;
+    replace: (element: TargetElement) => void;
+};
+export declare function renderImperatively(element: TargetElement): ImperativeHandler;
+export {};

package/es/utils/render-imperatively.js

@@ -0,0 +1,199 @@
+var __assign = this && this.__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 = this && this.__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 = this && this.__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
+    };
+  }
+};
+import React, { useEffect, useImperativeHandle, useRef, useState } from 'react';
+import { renderToBody } from './render-to-body';
+export function renderImperatively(element) {
+  var _this = this;
+  var Wrapper = React.forwardRef(function (_, ref) {
+    var _a = useState(false),
+      visible = _a[0],
+      setVisible = _a[1];
+    var closedRef = useRef(false);
+    var _b = useState(element),
+      elementToRender = _b[0],
+      setElementToRender = _b[1];
+    var keyRef = useRef(0);
+    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);
+    }
+    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.cloneElement(elementToRender, __assign(__assign({}, elementToRender.props), {
+      key: keyRef.current,
+      visible: visible,
+      onClose: onClose,
+      afterClose: afterClose
+    }));
+  });
+  var wrapperRef = React.createRef();
+  var unmount = renderToBody(React.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/es/utils/render-to-body.d.ts

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

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

@@ -0,0 +1,13 @@
+import { render, unmount as reactUnmount } from './render';
+export function renderToBody(element) {
+  var container = document.createElement('div');
+  document.body.appendChild(container);
+  function unmount() {
+    var unmountResult = reactUnmount(container);
+    if (unmountResult && container.parentNode) {
+      container.parentNode.removeChild(container);
+    }
+  }
+  render(element, container);
+  return unmount;
+}

package/es/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/es/utils/render-to-container.js

@@ -0,0 +1,10 @@
+import { createPortal } from 'react-dom';
+import { resolveContainer } from './get-container';
+import { canUseDom } from './can-use-dom';
+export function renderToContainer(getContainer, node) {
+  if (canUseDom && getContainer) {
+    var container = resolveContainer(getContainer);
+    return createPortal(node, container);
+  }
+  return node;
+}

package/es/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/es/utils/render.js

@@ -0,0 +1,187 @@
+var __assign = this && this.__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 = this && this.__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 = this && this.__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
+    };
+  }
+};
+import * as ReactDOM from 'react-dom';
+// 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;
+}
+export 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];
+      })];
+    });
+  });
+}
+export function unmount(container) {
+  if (createRoot) {
+    return concurrentUnmount(container);
+  }
+  return legacyUnmount(container);
+}

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

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

package/es/utils/replace-message.js

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

package/es/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/es/utils/rubberband.js

@@ -0,0 +1,13 @@
+import { bound } from './bound';
+export function rubberband(distance, dimension, constant) {
+  return distance * dimension * constant / (dimension + constant * distance);
+}
+export function rubberbandIfOutOfBounds(position, min, max, dimension, constant) {
+  if (constant === void 0) {
+    constant = 0.15;
+  }
+  if (constant === 0) return 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;
+}