@trionesdev/antd-taro-react 0.0.1-beta.3

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

@@ -0,0 +1,81 @@
+import { useEffect } from 'react';
+import { getScrollParent } from "./get-scroll-parent";
+import { supportsPassive } from "./supports-passive";
+import { useTouch } from "./use-touch";
+var totalLockCount = 0;
+var BODY_LOCK_CLASS = 'triones-antm-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 onTouchMove(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 _el$getBoundingClient = el.getBoundingClientRect(),
+      height = _el$getBoundingClient.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 lock() {
+    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 unlock() {
+    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/dist/utils/use-mutation-effect.d.ts

@@ -0,0 +1,3 @@
+import { RefObject } from 'react';
+export declare function observe(element: HTMLElement | null, options: MutationObserverInit, callback: VoidFunction): () => void;
+export declare function useMutationEffect(effect: () => void, targetRef: RefObject<HTMLElement>, options: MutationObserverInit): void;

package/dist/utils/use-mutation-effect.js

@@ -0,0 +1,26 @@
+import { useMemoizedFn } from 'ahooks';
+import { useEffect } from 'react';
+export function observe(element, options, callback) {
+  if (element && typeof MutationObserver !== 'undefined') {
+    var observer = new MutationObserver(function () {
+      callback();
+    });
+    observer.observe(element, options);
+
+    // Return cleanup function
+    return function () {
+      if (observer) {
+        observer.disconnect();
+        observer = null;
+      }
+    };
+  }
+  return function () {};
+}
+export function useMutationEffect(effect, targetRef, options) {
+  var fn = useMemoizedFn(effect);
+  useEffect(function () {
+    var cleanup = observe(targetRef.current, options, fn);
+    return cleanup;
+  }, [targetRef]);
+}

package/dist/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, (this: unknown, v: SetStateAction<T>, forceTrigger?: boolean | undefined) => void];
+export {};

package/dist/utils/use-props-value.js

@@ -0,0 +1,22 @@
+import { useMemoizedFn, useUpdate } from 'ahooks';
+import { useRef } from 'react';
+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) {
+    var forceTrigger = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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/dist/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/dist/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;
+      var observer = new ResizeObserver(function () {
+        animationFrame = window.requestAnimationFrame(function () {
+          return fn(target);
+        });
+      });
+      observer.observe(target);
+      return function () {
+        window.cancelAnimationFrame(animationFrame);
+        observer.disconnect();
+      };
+    } else {
+      fn(target);
+    }
+  }, [targetRef]);
+}

package/dist/utils/use-touch.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+type Direction = '' | 'vertical' | 'horizontal';
+export declare function useTouch(): {
+    move: EventListener;
+    start: EventListener;
+    reset: () => void;
+    startX: import("react").MutableRefObject<number>;
+    startY: import("react").MutableRefObject<number>;
+    deltaX: import("react").MutableRefObject<number>;
+    deltaY: import("react").MutableRefObject<number>;
+    offsetX: import("react").MutableRefObject<number>;
+    offsetY: import("react").MutableRefObject<number>;
+    direction: import("react").MutableRefObject<Direction>;
+    isVertical: () => boolean;
+    isHorizontal: () => boolean;
+};
+export {};

package/dist/utils/use-touch.js

@@ -0,0 +1,63 @@
+import { useRef } from 'react';
+var MIN_DISTANCE = 10;
+function getDirection(x, y) {
+  if (x > y && x > MIN_DISTANCE) {
+    return 'horizontal';
+  }
+  if (y > x && y > MIN_DISTANCE) {
+    return 'vertical';
+  }
+  return '';
+}
+export function useTouch() {
+  var startX = useRef(0);
+  var startY = useRef(0);
+  var deltaX = useRef(0);
+  var deltaY = useRef(0);
+  var offsetX = useRef(0);
+  var offsetY = useRef(0);
+  var direction = useRef('');
+  var isVertical = function isVertical() {
+    return direction.current === 'vertical';
+  };
+  var isHorizontal = function isHorizontal() {
+    return direction.current === 'horizontal';
+  };
+  var reset = function reset() {
+    deltaX.current = 0;
+    deltaY.current = 0;
+    offsetX.current = 0;
+    offsetY.current = 0;
+    direction.current = '';
+  };
+  var start = function start(event) {
+    reset();
+    startX.current = event.touches[0].clientX;
+    startY.current = event.touches[0].clientY;
+  };
+  var move = function move(event) {
+    var touch = event.touches[0];
+    // Fix: Safari back will set clientX to negative number
+    deltaX.current = touch.clientX < 0 ? 0 : touch.clientX - startX.current;
+    deltaY.current = touch.clientY - startY.current;
+    offsetX.current = Math.abs(deltaX.current);
+    offsetY.current = Math.abs(deltaY.current);
+    if (!direction.current) {
+      direction.current = getDirection(offsetX.current, offsetY.current);
+    }
+  };
+  return {
+    move: move,
+    start: start,
+    reset: reset,
+    startX: startX,
+    startY: startY,
+    deltaX: deltaX,
+    deltaY: deltaY,
+    offsetX: offsetX,
+    offsetY: offsetY,
+    direction: direction,
+    isVertical: isVertical,
+    isHorizontal: isHorizontal
+  };
+}

package/dist/utils/validate.d.ts

@@ -0,0 +1 @@
+export declare function isPromise(obj: unknown): obj is Promise<unknown>;

package/dist/utils/validate.js

@@ -0,0 +1,4 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+export function isPromise(obj) {
+  return !!obj && _typeof(obj) === 'object' && typeof obj.then === 'function';
+}

package/dist/utils/with-default-props.d.ts

@@ -0,0 +1,9 @@
+export declare function mergeProps<A, B>(a: A, b: B): B & A;
+export declare function mergeProps<A, B, C>(a: A, b: B, c: C): C & B & A;
+export declare function mergeProps<A, B, C, D>(a: A, b: B, c: C, d: D): D & C & B & A;
+/**
+ * Merge props and return the first non-undefined value.
+ * The later has higher priority. e.g. (10, 1, 5) => 5 wins.
+ * This is useful with legacy props that have been deprecated.
+ */
+export declare function mergeProp<T, DefaultT extends T = T>(defaultProp: DefaultT, ...propList: T[]): T | undefined;

package/dist/utils/with-default-props.js

@@ -0,0 +1,33 @@
+export function mergeProps() {
+  var ret = {};
+  for (var _len = arguments.length, items = new Array(_len), _key = 0; _key < _len; _key++) {
+    items[_key] = arguments[_key];
+  }
+  items.forEach(function (item) {
+    if (item) {
+      Object.keys(item).forEach(function (key) {
+        if (item[key] !== undefined) {
+          ret[key] = item[key];
+        }
+      });
+    }
+  });
+  return ret;
+}
+
+/**
+ * Merge props and return the first non-undefined value.
+ * The later has higher priority. e.g. (10, 1, 5) => 5 wins.
+ * This is useful with legacy props that have been deprecated.
+ */
+export function mergeProp(defaultProp) {
+  for (var _len2 = arguments.length, propList = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+    propList[_key2 - 1] = arguments[_key2];
+  }
+  for (var i = propList.length - 1; i >= 0; i -= 1) {
+    if (propList[i] !== undefined) {
+      return propList[i];
+    }
+  }
+  return defaultProp;
+}

package/dist/utils/with-stop-propagation.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { ReactElement } from 'react';
+export type PropagationEvent = 'click' | 'touchstart';
+export declare function withStopPropagation(events: PropagationEvent[], element: ReactElement): React.ReactElement<any, string | React.JSXElementConstructor<any>>;

package/dist/utils/with-stop-propagation.js

@@ -0,0 +1,38 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import React from 'react';
+var eventToPropRecord = {
+  'click': 'onClick',
+  'touchstart': 'onTouchStart'
+};
+export function withStopPropagation(events, element) {
+  var props = _objectSpread({}, element.props);
+  var _iterator = _createForOfIteratorHelper(events),
+    _step;
+  try {
+    var _loop = function _loop() {
+      var key = _step.value;
+      var prop = eventToPropRecord[key];
+      props[prop] = function (e) {
+        var _element$props$prop, _element$props;
+        e.stopPropagation();
+        (_element$props$prop = (_element$props = element.props)[prop]) === null || _element$props$prop === void 0 || _element$props$prop.call(_element$props, e);
+      };
+    };
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      _loop();
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return /*#__PURE__*/React.cloneElement(element, props);
+}

package/dist/utils/zIndex.d.ts

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

package/dist/utils/zIndex.js

@@ -0,0 +1,4 @@
+var zIndex = 1000;
+export function getNextZIndex() {
+  return ++zIndex;
+}

package/dist/utils/zindexContext.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const zIndexContext: React.Context<number | undefined>;
+export default zIndexContext;

package/dist/utils/zindexContext.js

@@ -0,0 +1,6 @@
+import React from 'react';
+var zIndexContext = /*#__PURE__*/React.createContext(undefined);
+if (process.env.NODE_ENV !== 'production') {
+  zIndexContext.displayName = 'zIndexContext';
+}
+export default zIndexContext;

package/package.json

@@ -0,0 +1,106 @@
+{
+  "name": "@trionesdev/antd-taro-react",
+  "version": "0.0.1-beta.3",
+  "description": "antd taro react ",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "start": "npm run dev",
+    "start-dev": "cross-env API_PARSER=true npm run dev",
+    "dev": "dumi dev",
+    "build": "father build",
+    "build:watch": "father dev",
+    "docs:build": "dumi build",
+    "docs:preview": "dumi preview",
+    "prepare": " dumi setup",
+    "doctor": "father doctor",
+    "lint": "npm run lint:es && npm run lint:css",
+    "lint:css": "stylelint \"{src,test}/**/*.{css,less}\"",
+    "lint:es": "eslint \"{src,test}/**/*.{js,jsx,ts,tsx}\"",
+    "prepublishOnly": "father doctor && npm run build"
+  },
+  "authors": [
+    "fengxiaotx@163.com"
+  ],
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "lint-staged": {
+    "*.{md,json}": [
+      "prettier --write --no-error-on-unmatched-pattern"
+    ],
+    "*.{css,less}": [
+      "stylelint --fix",
+      "prettier --write"
+    ],
+    "*.{js,jsx}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "*.{ts,tsx}": [
+      "eslint --fix",
+      "prettier --parser=typescript --write"
+    ]
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@tarojs/components": "^4.0.9",
+    "@tarojs/extend": "^4.0.9",
+    "@tarojs/react": "^4.0.9",
+    "@tarojs/taro": "^4.0.9",
+    "classnames": "^2.5.1",
+    "lodash": "^4.17.21",
+    "react": ">=16.9.0",
+    "react-dom": ">=16.9.0",
+    "staged-components": "^1.1.3"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^19.6.1",
+    "@commitlint/config-conventional": "^19.6.0",
+    "@tarojs/components": "4.0.9",
+    "@tarojs/extend": "^4.0.9",
+    "@tarojs/react": "4.0.9",
+    "@tarojs/taro": "4.0.9",
+    "@trionesdev/antd-taro-icons-react": "0.0.1-beta.0",
+    "@types/crypto-js": "^4.2.2",
+    "@types/lodash": "^4.17.14",
+    "@types/react": "^18.0.0",
+    "@types/react-dom": "^18.0.0",
+    "@umijs/lint": "^4.0.0",
+    "classnames": "^2.5.1",
+    "cross-env": "^7.0.3",
+    "dumi": "2.4.12",
+    "dumi-theme-mobile": "^2.3.5",
+    "eslint": "^8.23.0",
+    "father": "^4.5.1",
+    "husky": "^8.0.1",
+    "lint-staged": "^13.0.3",
+    "lodash": "^4.17.21",
+    "prettier": "^3.4.2",
+    "prettier-plugin-organize-imports": "^4.1.0",
+    "prettier-plugin-packagejson": "^2.5.6",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0",
+    "staged-components": "^1.1.3",
+    "stylelint": "^16.12.0"
+  },
+  "dependencies": {
+    "ahooks": "^3.8.4",
+    "crypto-js": "^4.2.0",
+    "rc-field-form": "^2.7.0",
+    "rc-util": "^5.44.3",
+    "runes2": "^1.1.4"
+  },
+  "optionalDependencies": {
+    "@trionesdev/antd-taro-icons-react": "^0.0.1-beta.1"
+  },
+  "gitHead": "e40c2363a9ec15795e0caea702f2a2bf46da2b59"
+}

package/readme.md

@@ -0,0 +1,43 @@
+# @trionesdev/antd-taro-react
+
+[![NPM version](https://img.shields.io/npm/v/@trionesdev/antd-taro-react.svg?style=flat)](https://npmjs.org/package/@trionesdev/antd-taro-react)
+[![NPM downloads](http://img.shields.io/npm/dm/@trionesdev/antd-taro-react.svg?style=flat)](https://npmjs.org/package/@trionesdev/antd-taro-react)
+
+antd taro react 
+
+## Usage
+
+TODO
+
+## Options
+
+TODO
+
+## Development
+
+```bash
+# install dependencies
+$ pnpm install
+
+# develop library by docs demo
+$ pnpm start
+
+# build library source code
+$ pnpm run build
+
+# build library source code in watch mode
+$ pnpm run build:watch
+
+# build docs
+$ pnpm run docs:build
+
+# Locally preview the production build.
+$ pnpm run docs:preview
+
+# check your project for potential problems
+$ pnpm run doctor
+```
+
+## LICENSE
+
+MIT