antd-mobile 5.17.0 → 5.18.0

package/2x/es/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/es/utils/native-props.js

@@ -0,0 +1,27 @@
+import React from 'react';
+import classNames from 'classnames';
+export function withNativeProps(props, element) {
+  const p = Object.assign({}, element.props);
+
+  if (props.className) {
+    p.className = classNames(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.cloneElement(element, p);
+}

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+export const noop = () => {};

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

@@ -0,0 +1,36 @@
+import { Globals } from '@react-spring/web';
+import { useSyncExternalStore } from 'use-sync-external-store/shim';
+let reduced = false;
+const subscribers = new Set();
+
+function notify() {
+  subscribers.forEach(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;
+}
+export function useMotionReduced() {
+  return useSyncExternalStore(onStoreChange => {
+    subscribers.add(onStoreChange);
+    return () => {
+      subscribers.delete(onStoreChange);
+    };
+  }, isMotionReduced);
+}

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

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

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

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

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

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

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

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

@@ -0,0 +1,77 @@
+import { __awaiter } from "tslib";
+import * as ReactDOM from 'react-dom'; // 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;
+}
+
+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* () {
+    // 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];
+    });
+  });
+}
+
+export function unmount(container) {
+  if (createRoot) {
+    return concurrentUnmount(container);
+  }
+
+  return legacyUnmount(container);
+}

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

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

package/2x/es/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 {};

package/2x/es/utils/should-render.js

@@ -0,0 +1,12 @@
+import { useInitialized } from './use-initialized';
+export const ShouldRender = props => {
+  const shouldRender = useShouldRender(props.active, props.forceRender, props.destroyOnClose);
+  return shouldRender ? props.children : null;
+};
+export function useShouldRender(active, forceRender, destroyOnClose) {
+  const initialized = useInitialized(active);
+  if (forceRender) return true;
+  if (active) return true;
+  if (!initialized) return false;
+  return !destroyOnClose;
+}

package/2x/es/utils/shuffle.d.ts

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

package/2x/es/utils/shuffle.js

@@ -0,0 +1,15 @@
+/**
+ * 数组打乱
+ * @param array 任意数组
+ * @returns any[] 打乱后的数组
+ */
+export function shuffle(array) {
+  const result = [...array];
+
+  for (let i = result.length; i > 0; i--) {
+    const j = Math.floor(Math.random() * i);
+    [result[i - 1], result[j]] = [result[j], result[i - 1]];
+  }
+
+  return result;
+}

package/2x/es/utils/sleep.d.ts

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

package/2x/es/utils/sleep.js

@@ -0,0 +1 @@
+export const sleep = time => new Promise(resolve => setTimeout(resolve, time));

package/2x/es/utils/supports-passive.d.ts

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

package/2x/es/utils/supports-passive.js

@@ -0,0 +1,15 @@
+import { canUseDom } from './can-use-dom';
+export let supportsPassive = false;
+
+if (canUseDom) {
+  try {
+    const opts = {};
+    Object.defineProperty(opts, 'passive', {
+      get() {
+        supportsPassive = true;
+      }
+
+    });
+    window.addEventListener('test-passive', null, opts);
+  } catch (e) {}
+}

package/2x/es/utils/to-css-length.d.ts

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

package/2x/es/utils/to-css-length.js

@@ -0,0 +1,3 @@
+export function toCSSLength(val) {
+  return typeof val === 'number' ? `${val}px` : val;
+}

package/2x/es/utils/traverse-react-node.d.ts

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

package/2x/es/utils/traverse-react-node.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { isFragment } from 'react-is';
+export function traverseReactNode(children, fn) {
+  let i = 0;
+
+  function handle(target) {
+    React.Children.forEach(target, child => {
+      if (!isFragment(child)) {
+        fn(child, i);
+        i += 1;
+      } else {
+        handle(child.props.children);
+      }
+    });
+  }
+
+  handle(children);
+}

package/2x/es/utils/tree.d.ts

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

package/2x/es/utils/tree.js

@@ -0,0 +1,16 @@
+// 找到树的深度
+export function getTreeDeep(treeData, childrenName = 'children') {
+  const walker = tree => {
+    let deep = 0;
+    tree.forEach(item => {
+      if (item[childrenName]) {
+        deep = Math.max(deep, walker(item[childrenName]) + 1);
+      } else {
+        deep = Math.max(deep, 1);
+      }
+    });
+    return deep;
+  };
+
+  return walker(treeData);
+}

package/2x/es/utils/undefined-fallback.d.ts

@@ -0,0 +1,3 @@
+export declare function undefinedFallback<T>(a: T | undefined, b: T): T;
+export declare function undefinedFallback<T>(a: T | undefined, b: T | undefined, c: T): T;
+export declare function undefinedFallback<T>(a: T | undefined, b: T | undefined, c: T | undefined, d: T): T;

package/2x/es/utils/undefined-fallback.js

@@ -0,0 +1,9 @@
+export function undefinedFallback(...items) {
+  let i;
+
+  for (i = 0; i < items.length; i++) {
+    if (items[i] !== undefined) break;
+  }
+
+  return items[i];
+}

package/2x/es/utils/use-drag-and-pinch.d.ts

@@ -0,0 +1 @@
+export declare const useDragAndPinch: <Config extends import("@use-gesture/react").UserGestureConfig = import("@use-gesture/react").UserGestureConfig>(_handlers: Partial<import("@use-gesture/react").NativeHandlers<import("@use-gesture/react").EventTypes> & import("@use-gesture/react").UserHandlers<import("@use-gesture/react").EventTypes>>, _config?: Config | undefined) => Config["target"] extends object ? void : (...args: any[]) => import("@use-gesture/react/dist/declarations/src/types").ReactDOMAttributes;

package/2x/es/utils/use-drag-and-pinch.js

@@ -0,0 +1,2 @@
+import { createUseGesture, dragAction, pinchAction } from '@use-gesture/react';
+export const useDragAndPinch = createUseGesture([dragAction, pinchAction]);

package/2x/es/utils/use-initialized.d.ts

@@ -0,0 +1 @@
+export declare function useInitialized(check?: boolean): boolean;

package/2x/es/utils/use-initialized.js

@@ -0,0 +1,10 @@
+import { useRef } from 'react';
+export function useInitialized(check) {
+  const initializedRef = useRef(check);
+
+  if (check) {
+    initializedRef.current = true;
+  }
+
+  return !!initializedRef.current;
+}

package/2x/es/utils/use-inner-visible.d.ts

@@ -0,0 +1 @@
+export declare function useInnerVisible(outerVisible: boolean): boolean;

package/2x/es/utils/use-inner-visible.js

@@ -0,0 +1,9 @@
+import { useState } from 'react';
+import { useIsomorphicLayoutEffect } from 'ahooks';
+export function useInnerVisible(outerVisible) {
+  const [innerVisible, setInnerVisible] = useState(outerVisible);
+  useIsomorphicLayoutEffect(() => {
+    setInnerVisible(outerVisible);
+  }, [outerVisible]);
+  return innerVisible;
+}

package/2x/es/utils/use-isomorphic-update-layout-effect.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const useIsomorphicUpdateLayoutEffect: typeof import("react").useEffect | typeof import("react").useLayoutEffect;

package/2x/es/utils/use-isomorphic-update-layout-effect.js

@@ -0,0 +1,2 @@
+import { createUpdateEffect, useIsomorphicLayoutEffect } from 'ahooks';
+export const useIsomorphicUpdateLayoutEffect = createUpdateEffect(useIsomorphicLayoutEffect);

package/2x/es/utils/use-lock-scroll.d.ts

@@ -0,0 +1,2 @@
+import { RefObject } from 'react';
+export declare function useLockScroll(rootRef: RefObject<HTMLElement>, shouldLock: boolean): void;

package/2x/es/utils/use-lock-scroll.js

@@ -0,0 +1,69 @@
+import { useTouch } from './use-touch';
+import { useEffect } from 'react';
+import { getScrollParent } from './get-scroll-parent';
+import { supportsPassive } from './supports-passive';
+let totalLockCount = 0;
+const BODY_LOCK_CLASS = 'adm-overflow-hidden'; // 移植自vant：https://github.com/youzan/vant/blob/HEAD/src/composables/use-lock-scroll.ts
+
+export function useLockScroll(rootRef, shouldLock) {
+  const touch = useTouch();
+
+  const onTouchMove = event => {
+    touch.move(event);
+    const direction = touch.deltaY.current > 0 ? '10' : '01';
+    const el = getScrollParent(event.target, rootRef.current);
+    if (!el) return;
+    const {
+      scrollHeight,
+      offsetHeight,
+      scrollTop
+    } = el;
+    let status = '11';
+
+    if (scrollTop === 0) {
+      status = offsetHeight >= scrollHeight ? '00' : '01';
+    } else if (scrollTop + offsetHeight >= scrollHeight) {
+      status = '10';
+    }
+
+    if (status !== '11' && touch.isVertical() && !(parseInt(status, 2) & parseInt(direction, 2))) {
+      if (event.cancelable) {
+        event.preventDefault();
+      }
+    }
+  };
+
+  const lock = () => {
+    document.addEventListener('touchstart', touch.start);
+    document.addEventListener('touchmove', onTouchMove, supportsPassive ? {
+      passive: false
+    } : false);
+
+    if (!totalLockCount) {
+      document.body.classList.add(BODY_LOCK_CLASS);
+    }
+
+    totalLockCount++;
+  };
+
+  const unlock = () => {
+    if (totalLockCount) {
+      document.removeEventListener('touchstart', touch.start);
+      document.removeEventListener('touchmove', onTouchMove);
+      totalLockCount--;
+
+      if (!totalLockCount) {
+        document.body.classList.remove(BODY_LOCK_CLASS);
+      }
+    }
+  };
+
+  useEffect(() => {
+    if (shouldLock) {
+      lock();
+      return () => {
+        unlock();
+      };
+    }
+  }, [shouldLock]);
+}

package/2x/es/utils/use-mutation-effect.d.ts

@@ -0,0 +1,2 @@
+import { RefObject } from 'react';
+export declare function useMutationEffect(effect: () => void, targetRef: RefObject<HTMLElement>, options: MutationObserverInit): void;

package/2x/es/utils/use-mutation-effect.js

@@ -0,0 +1,15 @@
+import { useEffect } from 'react';
+import { useMemoizedFn } from 'ahooks';
+export function useMutationEffect(effect, targetRef, options) {
+  const fn = useMemoizedFn(effect);
+  useEffect(() => {
+    const observer = new MutationObserver(() => {
+      fn();
+    });
+    if (!targetRef.current) return;
+    observer.observe(targetRef.current, options);
+    return () => {
+      observer.disconnect();
+    };
+  }, [targetRef]);
+}

package/2x/es/utils/use-props-value.d.ts

@@ -0,0 +1,8 @@
+import { SetStateAction } from 'react';
+declare type Options<T> = {
+    value?: T;
+    defaultValue: T;
+    onChange?: (v: T) => void;
+};
+export declare function usePropsValue<T>(options: Options<T>): readonly [T, (v: SetStateAction<T>, forceTrigger?: boolean) => void];
+export {};

package/2x/es/utils/use-props-value.js

@@ -0,0 +1,25 @@
+import { useRef } from 'react';
+import { useMemoizedFn, useUpdate } from 'ahooks';
+export function usePropsValue(options) {
+  const {
+    value,
+    defaultValue,
+    onChange
+  } = options;
+  const update = useUpdate();
+  const stateRef = useRef(value !== undefined ? value : defaultValue);
+
+  if (value !== undefined) {
+    stateRef.current = value;
+  }
+
+  const setState = useMemoizedFn((v, forceTrigger = false) => {
+    // `forceTrigger` means trigger `onChange` even if `v` is the same as `stateRef.current`
+    const nextValue = typeof v === 'function' ? v(stateRef.current) : v;
+    if (!forceTrigger && nextValue === stateRef.current) return;
+    stateRef.current = nextValue;
+    update();
+    return onChange === null || onChange === void 0 ? void 0 : onChange(nextValue);
+  });
+  return [stateRef.current, setState];
+}

package/2x/es/utils/use-ref-state.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare function useRefState<T>(initialState: T | (() => T)): readonly [T, import("react").Dispatch<import("react").SetStateAction<T>>, import("react").MutableRefObject<T>];

package/2x/es/utils/use-ref-state.js

@@ -0,0 +1,9 @@
+import { useEffect, useRef, useState } from 'react';
+export function useRefState(initialState) {
+  const [state, setState] = useState(initialState);
+  const ref = useRef(state);
+  useEffect(() => {
+    ref.current = state;
+  }, [state]);
+  return [state, setState, ref];
+}