@ebscn/ui 0.0.10 → 1.0.0

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

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

@@ -0,0 +1,10 @@
+import type { 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/es/utils/should-render.js

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

package/es/utils/shuffle.d.ts

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

package/es/utils/shuffle.js

@@ -0,0 +1,23 @@
+/**
+ * 数组打乱
+ * @param array 任意数组
+ * @returns any[] 打乱后的数组
+ */
+var __spreadArray = this && this.__spreadArray || function (to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
+export function shuffle(array) {
+  var _a;
+  var result = __spreadArray([], array, true);
+  for (var i = result.length; i > 0; i--) {
+    var j = Math.floor(Math.random() * i);
+    _a = [result[j], result[i - 1]], result[i - 1] = _a[0], result[j] = _a[1];
+  }
+  return result;
+}

package/es/utils/sleep.d.ts

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

package/es/utils/sleep.js

@@ -0,0 +1,5 @@
+export var sleep = function (time) {
+  return new Promise(function (resolve) {
+    return setTimeout(resolve, time);
+  });
+};

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

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

package/es/utils/supports-passive.js

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

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

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

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

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

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

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

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

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

package/es/utils/tree.d.ts

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

package/es/utils/tree.js

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

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

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

package/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/es/utils/use-drag-and-pinch.js

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

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

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

package/es/utils/use-initialized.js

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,78 @@
+import { useTouch } from './use-touch';
+import { useEffect } from 'react';
+import { getScrollParent } from './get-scroll-parent';
+import { supportsPassive } from './supports-passive';
+var totalLockCount = 0;
+var BODY_LOCK_CLASS = 'adm-overflow-hidden';
+function getScrollableElement(el) {
+  var current = el === null || el === void 0 ? void 0 : el.parentElement;
+  while (current) {
+    if (current.clientHeight < current.scrollHeight) {
+      return current;
+    }
+    current = current.parentElement;
+  }
+  return null;
+}
+// 移植自vant：https://github.com/youzan/vant/blob/HEAD/src/composables/use-lock-scroll.ts
+export function useLockScroll(rootRef, shouldLock) {
+  var touch = useTouch();
+  var onTouchMove = function (event) {
+    touch.move(event);
+    var direction = touch.deltaY.current > 0 ? '10' : '01';
+    var el = getScrollParent(event.target, rootRef.current);
+    if (!el) return;
+    // This has perf cost but we have to compatible with iOS 12
+    if (shouldLock === 'strict') {
+      var scrollableParent = getScrollableElement(event.target);
+      if (scrollableParent === document.body || scrollableParent === document.documentElement) {
+        event.preventDefault();
+        return;
+      }
+    }
+    var scrollHeight = el.scrollHeight,
+      offsetHeight = el.offsetHeight,
+      scrollTop = el.scrollTop;
+    var height = el.getBoundingClientRect().height;
+    var status = '11';
+    if (scrollTop === 0) {
+      status = offsetHeight >= scrollHeight ? '00' : '01';
+    } else if (scrollHeight <= Math.round(height + scrollTop)) {
+      status = '10';
+    }
+    if (status !== '11' && touch.isVertical() && !(parseInt(status, 2) & parseInt(direction, 2))) {
+      if (event.cancelable && supportsPassive) {
+        // https://github.com/ant-design/ant-design-mobile/issues/6282
+        event.preventDefault();
+      }
+    }
+  };
+  var lock = function () {
+    document.addEventListener('touchstart', touch.start);
+    document.addEventListener('touchmove', onTouchMove, supportsPassive ? {
+      passive: false
+    } : false);
+    if (!totalLockCount) {
+      document.body.classList.add(BODY_LOCK_CLASS);
+    }
+    totalLockCount++;
+  };
+  var unlock = function () {
+    if (totalLockCount) {
+      document.removeEventListener('touchstart', touch.start);
+      document.removeEventListener('touchmove', onTouchMove);
+      totalLockCount--;
+      if (!totalLockCount) {
+        document.body.classList.remove(BODY_LOCK_CLASS);
+      }
+    }
+  };
+  useEffect(function () {
+    if (shouldLock) {
+      lock();
+      return function () {
+        unlock();
+      };
+    }
+  }, [shouldLock]);
+}

package/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/es/utils/use-mutation-effect.js

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

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

@@ -0,0 +1,8 @@
+import { SetStateAction } from 'react';
+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/es/utils/use-props-value.js

@@ -0,0 +1,24 @@
+import { useRef } from 'react';
+import { useMemoizedFn, useUpdate } from 'ahooks';
+export function usePropsValue(options) {
+  var value = options.value,
+    defaultValue = options.defaultValue,
+    onChange = options.onChange;
+  var update = useUpdate();
+  var stateRef = useRef(value !== undefined ? value : defaultValue);
+  if (value !== undefined) {
+    stateRef.current = value;
+  }
+  var setState = useMemoizedFn(function (v, forceTrigger) {
+    if (forceTrigger === void 0) {
+      forceTrigger = false;
+    }
+    // `forceTrigger` means trigger `onChange` even if `v` is the same as `stateRef.current`
+    var 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/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/es/utils/use-ref-state.js

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

package/es/utils/use-resize-effect.d.ts

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

package/es/utils/use-resize-effect.js

@@ -0,0 +1,23 @@
+import { useIsomorphicLayoutEffect, useMemoizedFn } from 'ahooks';
+export function useResizeEffect(effect, targetRef) {
+  var fn = useMemoizedFn(effect);
+  useIsomorphicLayoutEffect(function () {
+    var target = targetRef.current;
+    if (!target) return;
+    if (window.ResizeObserver) {
+      var animationFrame_1;
+      var observer_1 = new ResizeObserver(function () {
+        animationFrame_1 = window.requestAnimationFrame(function () {
+          return fn(target);
+        });
+      });
+      observer_1.observe(target);
+      return function () {
+        window.cancelAnimationFrame(animationFrame_1);
+        observer_1.disconnect();
+      };
+    } else {
+      fn(target);
+    }
+  }, [targetRef]);
+}

package/es/utils/use-tab-list-scroll.d.ts

@@ -0,0 +1,5 @@
+import { RefObject } from 'react';
+export declare const useTabListScroll: (targetRef: RefObject<HTMLElement>, activeIndex: number | undefined) => {
+    scrollLeft: import("@react-spring/core").SpringValue<number>;
+    animate: (immediate?: boolean) => void;
+};