antd-mobile 0.0.0-dev-626cbf51f

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/render-imperatively.d.ts

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

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

@@ -0,0 +1,68 @@
+"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);
+    (0, _react.useEffect)(() => {
+      if (!closedRef.current) {
+        setVisible(true);
+      } else {
+        afterClose();
+      }
+    }, []);
+
+    function onClose() {
+      var _a, _b;
+
+      closedRef.current = true;
+      setVisible(false);
+      (_b = (_a = element.props).onClose) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+
+    function afterClose() {
+      var _a, _b;
+
+      unmount();
+      (_b = (_a = element.props).afterClose) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+
+    (0, _react.useImperativeHandle)(ref, () => ({
+      close: onClose
+    }));
+    return _react.default.cloneElement(element, Object.assign(Object.assign({}, element.props), {
+      visible,
+      onClose,
+      afterClose
+    }));
+  });
+
+  const wrapperRef = _react.default.createRef();
+
+  const unmount = (0, _renderToBody.renderToBody)(_react.default.createElement(Wrapper, {
+    ref: wrapperRef
+  }));
+
+  function close() {
+    var _a;
+
+    (_a = wrapperRef.current) === null || _a === void 0 ? void 0 : _a.close();
+  }
+
+  return {
+    close
+  };
+}

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,80 @@
+"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) {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    createRoot = require('react-dom/client').createRoot;
+  }
+} catch (e) {// Do nothing;
+}
+
+const MARK = '__antd_mobile_root__';
+
+function legacyRender(node, container) {
+  reactRender(node, container);
+}
+
+function concurrentRender(node, container) {
+  const root = container[MARK] || createRoot(container);
+  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 {};

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

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

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

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

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

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.shuffle = shuffle;
+
+/**
+ * 数组打乱
+ * @param array 任意数组
+ * @returns any[] 打乱后的数组
+ */
+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/cjs/utils/sleep.d.ts

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

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

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

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

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

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

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

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

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

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

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

package/2x/cjs/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/cjs/utils/traverse-react-node.js

@@ -0,0 +1,29 @@
+"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) {
+  let i = 0;
+
+  function handle(target) {
+    _react.default.Children.forEach(target, child => {
+      if (!(0, _reactIs.isFragment)(child)) {
+        fn(child, i);
+        i += 1;
+      } else {
+        handle(child.props.children);
+      }
+    });
+  }
+
+  handle(children);
+}

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

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

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

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTreeDeep = getTreeDeep;
+
+// 找到树的深度
+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/cjs/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/cjs/utils/undefined-fallback.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.undefinedFallback = undefinedFallback;
+
+function undefinedFallback(...items) {
+  let i;
+
+  for (i = 0; i < items.length; i++) {
+    if (items[i] !== undefined) break;
+  }
+
+  return items[i];
+}

package/2x/cjs/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").ReactDOMAttributes;

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

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useDragAndPinch = void 0;
+
+var _react = require("@use-gesture/react");
+
+const useDragAndPinch = (0, _react.createUseGesture)([_react.dragAction, _react.pinchAction]);
+exports.useDragAndPinch = useDragAndPinch;

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

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

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

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useInitialized = useInitialized;
+
+var _react = require("react");
+
+function useInitialized(check) {
+  const initializedRef = (0, _react.useRef)(check);
+
+  if (check) {
+    initializedRef.current = true;
+  }
+
+  return !!initializedRef.current;
+}

package/2x/cjs/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/cjs/utils/use-isomorphic-update-layout-effect.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useIsomorphicUpdateLayoutEffect = void 0;
+
+var _ahooks = require("ahooks");
+
+const useIsomorphicUpdateLayoutEffect = (0, _ahooks.createUpdateEffect)(_ahooks.useIsomorphicLayoutEffect);
+exports.useIsomorphicUpdateLayoutEffect = useIsomorphicUpdateLayoutEffect;

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

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