antd-mobile 5.17.0 → 5.18.0

package/2x/cjs/utils/create-icon-component.d.ts

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

package/2x/cjs/utils/create-icon-component.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createIconComponent = createIconComponent;
+
+function createIconComponent(svg) {
+  const Icon = () => {
+    return svg;
+  };
+
+  return Icon;
+}

package/2x/cjs/utils/dev-log.d.ts

@@ -0,0 +1,2 @@
+export declare function devWarning(component: string, message: string): void;
+export declare function devError(component: string, message: string): void;

package/2x/cjs/utils/dev-log.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.devError = devError;
+exports.devWarning = devWarning;
+
+var _isDev = require("./is-dev");
+
+function devWarning(component, message) {
+  if (_isDev.isDev) {
+    console.warn(`[antd-mobile: ${component}] ${message}`);
+  }
+}
+
+function devError(component, message) {
+  if (_isDev.isDev) {
+    console.error(`[antd-mobile: ${component}] ${message}`);
+  }
+}

package/2x/cjs/utils/generate-int-array.d.ts

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

package/2x/cjs/utils/generate-int-array.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateIntArray = generateIntArray;
+
+function generateIntArray(from, to) {
+  const array = [];
+
+  for (let i = from; i <= to; i++) {
+    array.push(i);
+  }
+
+  return array;
+}

package/2x/cjs/utils/get-container.d.ts

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

package/2x/cjs/utils/get-container.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveContainer = resolveContainer;
+
+function resolveContainer(getContainer) {
+  const container = typeof getContainer === 'function' ? getContainer() : getContainer;
+  return container || document.body;
+}

package/2x/cjs/utils/get-scroll-parent.d.ts

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

package/2x/cjs/utils/get-scroll-parent.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getScrollParent = getScrollParent;
+
+var _canUseDom = require("./can-use-dom");
+
+const defaultRoot = _canUseDom.canUseDom ? window : undefined;
+const overflowStylePatterns = ['scroll', 'auto', 'overlay'];
+
+function isElement(node) {
+  const ELEMENT_NODE_TYPE = 1;
+  return node.nodeType === ELEMENT_NODE_TYPE;
+}
+
+function getScrollParent(el, root = defaultRoot) {
+  let node = el;
+
+  while (node && node !== root && isElement(node)) {
+    if (node === document.body) {
+      return root;
+    }
+
+    const {
+      overflowY
+    } = window.getComputedStyle(node);
+
+    if (overflowStylePatterns.includes(overflowY) && node.scrollHeight > node.clientHeight) {
+      return node;
+    }
+
+    node = node.parentNode;
+  }
+
+  return root;
+}

package/2x/cjs/utils/is-dev.d.ts

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

package/2x/cjs/utils/is-dev.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isDev = void 0;
+const isDev = process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test';
+exports.isDev = isDev;

package/2x/cjs/utils/is-node-with-content.d.ts

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

package/2x/cjs/utils/is-node-with-content.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isNodeWithContent = isNodeWithContent;
+
+function isNodeWithContent(node) {
+  return node !== undefined && node !== null && node !== false;
+}

package/2x/cjs/utils/measure-css-length.d.ts

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

package/2x/cjs/utils/measure-css-length.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.measureCSSLength = measureCSSLength;
+
+var _isDev = require("./is-dev");
+
+var _devLog = require("./dev-log");
+
+function measureCSSLength(raw) {
+  if (raw === null || raw === undefined || raw === '') {
+    if (_isDev.isDev) {
+      (0, _devLog.devError)('Global', 'Seems like the you will encounter a style messed problem. Please check the browser environment to make sure it supports CSS variables.');
+    }
+
+    return 0;
+  }
+
+  const 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.isDev) {
+      (0, _devLog.devError)('Global', `You are using a not supported CSS unit in \`${raw}\`. Only \`px\` \`rem\` and \`vw\` are supported.`);
+    }
+
+    return 0;
+  }
+}

package/2x/cjs/utils/merge-locale.d.ts

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

package/2x/cjs/utils/merge-locale.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeLocale = mergeLocale;
+
+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;
+    }
+
+    const result = {};
+
+    for (const key in a) {
+      if (a.hasOwnProperty(key)) {
+        result[key] = merge(a[key], b[key]);
+      }
+    }
+
+    return result;
+  }
+
+  return merge(base, patch);
+}

package/2x/cjs/utils/native-props.d.ts

@@ -0,0 +1,8 @@
+import React, { AriaAttributes } from 'react';
+import type { CSSProperties, ReactElement } from 'react';
+export declare 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/2x/cjs/utils/native-props.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withNativeProps = withNativeProps;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function withNativeProps(props, element) {
+  const p = Object.assign({}, element.props);
+
+  if (props.className) {
+    p.className = (0, _classnames.default)(element.props.className, props.className);
+  }
+
+  if (props.style) {
+    p.style = Object.assign(Object.assign({}, p.style), props.style);
+  }
+
+  if (props.tabIndex !== undefined) {
+    p.tabIndex = props.tabIndex;
+  }
+
+  for (const key in props) {
+    if (!props.hasOwnProperty(key)) continue;
+
+    if (key.startsWith('data-') || key.startsWith('aria-')) {
+      p[key] = props[key];
+    }
+  }
+
+  return _react.default.cloneElement(element, p);
+}

package/2x/cjs/utils/nearest.d.ts

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

package/2x/cjs/utils/nearest.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.nearest = nearest;
+
+function nearest(arr, target) {
+  return arr.reduce((pre, cur) => {
+    return Math.abs(pre - target) < Math.abs(cur - target) ? pre : cur;
+  });
+}

package/2x/cjs/utils/noop.d.ts

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

package/2x/cjs/utils/noop.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.noop = void 0;
+
+const noop = () => {};
+
+exports.noop = noop;

package/2x/cjs/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/2x/cjs/utils/reduce-and-restore-motion.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isMotionReduced = isMotionReduced;
+exports.reduceMotion = reduceMotion;
+exports.restoreMotion = restoreMotion;
+exports.useMotionReduced = useMotionReduced;
+
+var _web = require("@react-spring/web");
+
+var _shim = require("use-sync-external-store/shim");
+
+let reduced = false;
+const subscribers = new Set();
+
+function notify() {
+  subscribers.forEach(subscriber => {
+    subscriber();
+  });
+}
+
+function reduceMotion() {
+  reduced = true;
+  notify();
+
+  _web.Globals.assign({
+    skipAnimation: true
+  });
+}
+
+function restoreMotion() {
+  reduced = false;
+  notify();
+
+  _web.Globals.assign({
+    skipAnimation: false
+  });
+}
+
+function isMotionReduced() {
+  return reduced;
+}
+
+function useMotionReduced() {
+  return (0, _shim.useSyncExternalStore)(onStoreChange => {
+    subscribers.add(onStoreChange);
+    return () => {
+      subscribers.delete(onStoreChange);
+    };
+  }, isMotionReduced);
+}

package/2x/cjs/utils/render-imperatively.d.ts

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

package/2x/cjs/utils/render-imperatively.js

@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderImperatively = renderImperatively;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _renderToBody = require("./render-to-body");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (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 renderImperatively(element) {
+  const Wrapper = _react.default.forwardRef((_, ref) => {
+    const [visible, setVisible] = (0, _react.useState)(false);
+    const closedRef = (0, _react.useRef)(false);
+    const [elementToRender, setElementToRender] = (0, _react.useState)(element);
+    const keyRef = (0, _react.useRef)(0);
+    (0, _react.useEffect)(() => {
+      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, () => ({
+      close: onClose,
+      replace: 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, Object.assign(Object.assign({}, elementToRender.props), {
+      key: keyRef.current,
+      visible,
+      onClose,
+      afterClose
+    }));
+  });
+
+  const wrapperRef = _react.default.createRef();
+
+  const unmount = (0, _renderToBody.renderToBody)(_react.default.createElement(Wrapper, {
+    ref: wrapperRef
+  }));
+  return {
+    close: () => {
+      var _a;
+
+      (_a = wrapperRef.current) === null || _a === void 0 ? void 0 : _a.close();
+    },
+    replace: element => {
+      var _a;
+
+      (_a = wrapperRef.current) === null || _a === void 0 ? void 0 : _a.replace(element);
+    }
+  };
+}

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

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

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

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

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

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

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

@@ -0,0 +1,21 @@
+"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) {
+    const container = (0, _getContainer.resolveContainer)(getContainer);
+    return (0, _reactDom.createPortal)(node, container);
+  }
+
+  return node;
+}

package/2x/cjs/utils/render.d.ts

@@ -0,0 +1,9 @@
+import { ReactElement } from 'react';
+import type { Root } from 'react-dom/client';
+declare const MARK = "__antd_mobile_root__";
+declare 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/2x/cjs/utils/render.js

@@ -0,0 +1,92 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.render = render;
+exports.unmount = unmount;
+
+var _tslib = require("tslib");
+
+var ReactDOM = _interopRequireWildcard(require("react-dom"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (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; }
+
+// Let compiler not to search module usage
+const fullClone = Object.assign({}, ReactDOM);
+const {
+  version,
+  render: reactRender,
+  unmountComponentAtNode
+} = fullClone;
+let createRoot;
+
+try {
+  const 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) {
+  const {
+    __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
+  } = fullClone;
+
+  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;
+  }
+}
+
+const MARK = '__antd_mobile_root__';
+
+function legacyRender(node, container) {
+  reactRender(node, container);
+}
+
+function concurrentRender(node, container) {
+  toggleWarning(true);
+  const 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 (0, _tslib.__awaiter)(this, void 0, void 0, function* () {
+    // Delay to unmount to avoid React 18 sync warning
+    return Promise.resolve().then(() => {
+      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/2x/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/2x/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 = 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/2x/cjs/utils/should-render.d.ts

@@ -0,0 +1,10 @@
+import { 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 {};