@ebscn/ui 0.0.10 → 1.0.0

package/es/utils/bound.d.ts

@@ -0,0 +1 @@
+export declare function bound(position: number, min: number | undefined, max: number | undefined): number;

package/es/utils/bound.js

@@ -0,0 +1,10 @@
+export function bound(position, min, max) {
+  var ret = position;
+  if (min !== undefined) {
+    ret = Math.max(position, min);
+  }
+  if (max !== undefined) {
+    ret = Math.min(ret, max);
+  }
+  return ret;
+}

package/es/utils/can-use-dom.d.ts

@@ -0,0 +1 @@
+export declare const canUseDom: boolean;

package/es/utils/can-use-dom.js

@@ -0,0 +1 @@
+export var canUseDom = !!(typeof window !== 'undefined' && typeof document !== 'undefined' && window.document && window.document.createElement);

package/es/utils/convert-px.d.ts

@@ -0,0 +1 @@
+export declare function convertPx(px: number): number;

package/es/utils/convert-px.js

@@ -0,0 +1,27 @@
+import { canUseDom } from './can-use-dom';
+import { isDev } from './is-dev';
+import { devError } from './dev-log';
+var tenPxTester = null;
+var tester = null;
+if (canUseDom) {
+  tenPxTester = document.createElement('div');
+  tenPxTester.className = 'adm-px-tester';
+  tenPxTester.style.setProperty('--size', '10');
+  document.body.appendChild(tenPxTester);
+  tester = document.createElement('div');
+  tester.className = 'adm-px-tester';
+  document.body.appendChild(tester);
+  if (isDev) {
+    if (window.getComputedStyle(tester).position !== 'fixed') {
+      devError('Global', 'The px tester is not rendering properly. Please make sure you have imported `antd-mobile/es/global`.');
+    }
+  }
+}
+export function convertPx(px) {
+  if (tenPxTester === null || tester === null) return px;
+  if (tenPxTester.getBoundingClientRect().height === 10) {
+    return px;
+  }
+  tester.style.setProperty('--size', px.toString());
+  return tester.getBoundingClientRect().height;
+}

package/es/utils/create-icon-component.d.ts

@@ -0,0 +1,2 @@
+import type { FC, ReactElement } from 'react';
+export declare function createIconComponent(svg: ReactElement): FC;

package/es/utils/create-icon-component.js

@@ -0,0 +1,6 @@
+export function createIconComponent(svg) {
+  var Icon = function () {
+    return svg;
+  };
+  return Icon;
+}

package/es/utils/dev-log.d.ts

@@ -0,0 +1,3 @@
+export declare function devWarning(component: string, message: string): void;
+export declare function devError(component: string, message: string): void;
+export declare function devPrint(...message: any[]): void;

package/es/utils/dev-log.js

@@ -0,0 +1,37 @@
+import { isDev } from './is-dev';
+export function devWarning(component, message) {
+  if (isDev) {
+    console.warn("[antd-mobile: ".concat(component, "] ").concat(message));
+  }
+}
+export function devError(component, message) {
+  if (isDev) {
+    console.error("[antd-mobile: ".concat(component, "] ").concat(message));
+  }
+}
+var infoBox;
+export function devPrint() {
+  var message = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    message[_i] = arguments[_i];
+  }
+  if (isDev) {
+    if (!infoBox) {
+      infoBox = document.createElement('textarea');
+      document.body.append(infoBox);
+      infoBox.style.position = 'fixed';
+      infoBox.style.top = '0';
+      infoBox.style.left = '0';
+      infoBox.style.width = '100vw';
+      infoBox.style.height = '100vh';
+      infoBox.style.zIndex = '999999';
+      infoBox.style.fontSize = '12px';
+      // infoBox.style.opacity = '0.85'
+      infoBox.style.pointerEvents = 'none';
+      infoBox.style.background = 'transparent';
+      infoBox.style.textShadow = '-1px -1px 0 #FFF, -1px 1px 0 #FFF, 1px -1px 0 #FFF, 1px 1px 0 #FFF';
+    }
+    infoBox.value = "".concat(infoBox.value, "\n").concat(message.join(' ')).trim();
+    infoBox.scrollTop = infoBox.scrollHeight;
+  }
+}

package/es/utils/generate-int-array.d.ts

@@ -0,0 +1 @@
+export declare function generateIntArray(from: number, to: number): number[];

package/es/utils/generate-int-array.js

@@ -0,0 +1,7 @@
+export function generateIntArray(from, to) {
+  var array = [];
+  for (var i = from; i <= to; i++) {
+    array.push(i);
+  }
+  return array;
+}

package/es/utils/get-container.d.ts

@@ -0,0 +1,2 @@
+export type GetContainer = () => HTMLElement;
+export declare function resolveContainer(getContainer: HTMLElement | GetContainer | undefined | null): HTMLElement;

package/es/utils/get-container.js

@@ -0,0 +1,4 @@
+export function resolveContainer(getContainer) {
+  var container = typeof getContainer === 'function' ? getContainer() : getContainer;
+  return container || document.body;
+}

package/es/utils/get-scroll-parent.d.ts

@@ -0,0 +1,3 @@
+type ScrollElement = HTMLElement | Window;
+export declare function getScrollParent(el: Element, root?: ScrollElement | null | undefined): Window | Element | null | undefined;
+export {};

package/es/utils/get-scroll-parent.js

@@ -0,0 +1,24 @@
+import { canUseDom } from './can-use-dom';
+var defaultRoot = canUseDom ? window : undefined;
+var overflowStylePatterns = ['scroll', 'auto', 'overlay'];
+function isElement(node) {
+  var ELEMENT_NODE_TYPE = 1;
+  return node.nodeType === ELEMENT_NODE_TYPE;
+}
+export function getScrollParent(el, root) {
+  if (root === void 0) {
+    root = defaultRoot;
+  }
+  var node = el;
+  while (node && node !== root && isElement(node)) {
+    if (node === document.body) {
+      return root;
+    }
+    var overflowY = window.getComputedStyle(node).overflowY;
+    if (overflowStylePatterns.includes(overflowY) && node.scrollHeight > node.clientHeight) {
+      return node;
+    }
+    node = node.parentNode;
+  }
+  return root;
+}

package/es/utils/is-dev.d.ts

@@ -0,0 +1 @@
+export declare const isDev: boolean;

package/es/utils/is-dev.js

@@ -0,0 +1 @@
+export var isDev = process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test';

package/es/utils/is-node-with-content.d.ts

@@ -0,0 +1,4 @@
+import type { ReactNode } from 'react';
+type Regulated<T> = T extends null | undefined | false ? never : T;
+export declare function isNodeWithContent(node: ReactNode): node is Regulated<ReactNode>;
+export {};

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 {};