@bifrostui/utils 0.0.5

package/es/hooks/useSize.js

@@ -0,0 +1,29 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+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 _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import React from 'react';
+import useDomReady from "./useDomReady";
+import getBoundingClientRect from "../getBoundingClientRect";
+import { getTargetElement } from "../domTarget";
+function useSize(target) {
+  var _React$useState = React.useState({}),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    state = _React$useState2[0],
+    setState = _React$useState2[1];
+  useDomReady(function () {
+    var el = getTargetElement(target);
+    if (el) {
+      getBoundingClientRect(el).then(function (res) {
+        setState({
+          width: res.width,
+          height: res.height
+        });
+      });
+    }
+  });
+  return state;
+}
+export default useSize;

package/es/hooks/useTouchEmulator.d.ts

@@ -0,0 +1 @@
+export default function useTouchEmulator(dom?: HTMLElement | Window): void;

package/es/hooks/useTouchEmulator.js

@@ -0,0 +1,146 @@
+/**
+ * Emulate touch event
+ * Source：https://github.com/hammerjs/touchemulator
+ */
+import { useEffect } from 'react';
+var eventTarget;
+
+/**
+ * create an touch point
+ * @constructor
+ * @param target
+ * @param identifier
+ * @param pos
+ * @param deltaX
+ * @param deltaY
+ * @returns {Object} touchPoint
+ */
+var Touch = function Touch(target, identifier, pos, deltaX, deltaY) {
+  deltaX = deltaX || 0;
+  deltaY = deltaY || 0;
+  this.identifier = identifier;
+  this.target = target;
+  this.clientX = pos.clientX + deltaX;
+  this.clientY = pos.clientY + deltaY;
+  this.screenX = pos.screenX + deltaX;
+  this.screenY = pos.screenY + deltaY;
+  this.pageX = pos.pageX + deltaX;
+  this.pageY = pos.pageY + deltaY;
+};
+
+/**
+ * create empty touchlist with the methods
+ * @constructor
+ * @returns touchList
+ */
+function TouchList() {
+  var _this = this;
+  var touchList = [];
+  touchList.item = function (index) {
+    return _this[index] || null;
+  };
+
+  // specified by Mozilla
+  touchList.identifiedTouch = function (id) {
+    return _this[id + 1] || null;
+  };
+  return touchList;
+}
+
+/**
+ * only trigger touches when the left mousebutton has been pressed
+ * @param touchType
+ * @returns {Function}
+ */
+
+var initiated = false;
+function onMouse(touchType) {
+  return function (ev) {
+    // prevent mouse events
+
+    if (ev.type === 'mousedown') {
+      initiated = true;
+    }
+    if (ev.type === 'mouseup') {
+      initiated = false;
+    }
+    if (ev.type === 'mousemove' && !initiated) {
+      return;
+    }
+
+    // The EventTarget on which the touch point started when it was first placed on the surface,
+    // even if the touch point has since moved outside the interactive area of that element.
+    // also, when the target doesnt exist anymore, we update it
+    if (ev.type === 'mousedown' || !eventTarget || eventTarget && !eventTarget.dispatchEvent) {
+      eventTarget = ev.target;
+    }
+    triggerTouch(touchType, ev);
+
+    // reset
+    if (ev.type === 'mouseup') {
+      eventTarget = null;
+    }
+  };
+}
+
+/**
+ * trigger a touch event
+ * @param eventName
+ * @param mouseEv
+ */
+function triggerTouch(eventName, mouseEv) {
+  var touchEvent = document.createEvent('Event');
+  touchEvent.initEvent(eventName, true, false);
+  touchEvent.altKey = mouseEv.altKey;
+  touchEvent.ctrlKey = mouseEv.ctrlKey;
+  touchEvent.metaKey = mouseEv.metaKey;
+  touchEvent.shiftKey = mouseEv.shiftKey;
+  touchEvent.touches = getActiveTouches(mouseEv);
+  touchEvent.targetTouches = getActiveTouches(mouseEv);
+  touchEvent.changedTouches = createTouchList(mouseEv);
+  eventTarget.dispatchEvent(touchEvent);
+}
+
+/**
+ * create a touchList based on the mouse event
+ * @param mouseEv
+ * @returns {TouchList}
+ */
+function createTouchList(mouseEv) {
+  var touchList = TouchList();
+  touchList.push(new Touch(eventTarget, 1, mouseEv, 0, 0));
+  return touchList;
+}
+
+/**
+ * receive all active touches
+ * @param mouseEv
+ * @returns {TouchList}
+ */
+function getActiveTouches(mouseEv) {
+  // empty list
+  if (mouseEv.type === 'mouseup') {
+    return TouchList();
+  }
+  return createTouchList(mouseEv);
+}
+export default function useTouchEmulator() {
+  var dom = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window;
+  var touchStart = onMouse('touchstart');
+  var touchMove = onMouse('touchmove');
+  var touchEnd = onMouse('touchend');
+  useEffect(function () {
+    if (dom) {
+      dom.addEventListener('mousedown', touchStart, true);
+      dom.addEventListener('mousemove', touchMove, true);
+      dom.addEventListener('mouseup', touchEnd, true);
+    }
+    return function () {
+      if (dom) {
+        dom.removeEventListener('mousedown', touchStart, true);
+        dom.removeEventListener('mousemove', touchMove, true);
+        dom.removeEventListener('mouseup', touchEnd, true);
+      }
+    };
+  }, [dom]);
+}

package/es/hooks/useValue.d.ts

@@ -0,0 +1,12 @@
+import { ChangeEvent } from 'react';
+type Options<T> = {
+    value?: T;
+    defaultValue: T;
+    onChange?: (e: ChangeEvent<HTMLElement>, data: Record<string, any>) => void;
+    config?: {
+        name?: string;
+        state?: string;
+    };
+};
+export default function useValue<T>(options: Options<T>): readonly [T, (e: any, val: any) => void];
+export {};

package/es/hooks/useValue.js

@@ -0,0 +1,36 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+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 _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { useCallback, useRef, useState, useEffect } from 'react';
+export default function useValue(options) {
+  var value = options.value,
+    defaultValue = options.defaultValue,
+    onChange = options.onChange,
+    _options$config = options.config,
+    config = _options$config === void 0 ? {} : _options$config;
+  var state = config.state,
+    name = config.name;
+  var _useState = useState(defaultValue),
+    _useState2 = _slicedToArray(_useState, 2),
+    internalValue = _useState2[0],
+    setInternalValue = _useState2[1];
+  var initialDefaultValue = useRef(defaultValue);
+  var isControlled = value !== undefined;
+
+  // 异常情况
+  useEffect(function () {
+    if (!isControlled && JSON.stringify(defaultValue) !== JSON.stringify(initialDefaultValue.current) && state && name) {
+      console.error(["BUI: A component is changing the default ".concat(state, " state of an uncontrolled ").concat(name, " after being initialized. ") + "To suppress this warning opt to use a controlled ".concat(name, ".")].join('\n'));
+    }
+  }, [defaultValue]);
+  var triggerChange = useCallback(function (e, val) {
+    setInternalValue(val);
+    onChange === null || onChange === void 0 || onChange(e, {
+      value: val
+    });
+  }, [onChange]);
+  return [isControlled ? value : internalValue, triggerChange];
+}

package/es/index.d.ts

@@ -0,0 +1,12 @@
+export { default as debounce } from './debounce';
+export { default as convertHexToRGBA } from './hex2rgba';
+export { useDidMountEffect, useEventCallback, useForkRef, useTouchEmulator, useValue, useDomReady, useSize, useDomCss, } from './hooks';
+export { default as isDev } from './isDev';
+export { isMini, isWeapp, isAlipay } from './isMini';
+export { default as setRef } from './setRef';
+export { default as throttle } from './throttle';
+export { default as toArray } from './toArray';
+export { default as blockTouch } from './touchBlocker';
+export { easing, duration, getTransitionProps, createTransitions, } from './transitions';
+export { default as getBoundingClientRect } from './getBoundingClientRect';
+export * from './isType';

package/es/index.js

@@ -0,0 +1,12 @@
+export { default as debounce } from "./debounce";
+export { default as convertHexToRGBA } from "./hex2rgba";
+export { useDidMountEffect, useEventCallback, useForkRef, useTouchEmulator, useValue, useDomReady, useSize, useDomCss } from "./hooks";
+export { default as isDev } from "./isDev";
+export { isMini, isWeapp, isAlipay } from "./isMini";
+export { default as setRef } from "./setRef";
+export { default as throttle } from "./throttle";
+export { default as toArray } from "./toArray";
+export { default as blockTouch } from "./touchBlocker";
+export { easing, duration, getTransitionProps, createTransitions } from "./transitions";
+export { default as getBoundingClientRect } from "./getBoundingClientRect";
+export * from "./isType";

package/es/isDev.d.ts

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

package/es/isDev.js

@@ -0,0 +1,2 @@
+var isDev = process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test';
+export default isDev;

package/es/isMini.d.ts

@@ -0,0 +1,4 @@
+declare const isMini: boolean;
+declare const isWeapp: boolean;
+declare const isAlipay: boolean;
+export { isMini, isWeapp, isAlipay };

package/es/isMini.js

@@ -0,0 +1,4 @@
+var isMini = typeof process.env.TARO_ENV === 'string';
+var isWeapp = process.env.TARO_ENV === 'weapp';
+var isAlipay = process.env.TARO_ENV === 'alipay';
+export { isMini, isWeapp, isAlipay };

package/es/isType.d.ts

@@ -0,0 +1 @@
+export declare const isFunction: (fn: any) => boolean;

package/es/isType.js

@@ -0,0 +1,4 @@
+// eslint-disable-next-line import/prefer-default-export
+export var isFunction = function isFunction(fn) {
+  return fn && {}.toString.call(fn) === '[object Function]';
+};

package/es/setRef.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function setRef<T>(ref: React.MutableRefObject<T | null> | ((instance: T | null) => void) | null | undefined, value: T | null): void;

package/es/setRef.js

@@ -0,0 +1,7 @@
+export default function setRef(ref, value) {
+  if (typeof ref === 'function') {
+    ref(value);
+  } else if (ref) {
+    ref.current = value;
+  }
+}

package/es/throttle.d.ts

@@ -0,0 +1,6 @@
+interface OptionsThrottle {
+    leading?: boolean;
+    trailing?: boolean;
+}
+export default function throttle(fn: any, interval?: number, options?: OptionsThrottle): (...args: any[]) => void;
+export {};

package/es/throttle.js

@@ -0,0 +1,49 @@
+export default function throttle(fn) {
+  var interval = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 200;
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+    leading: true,
+    trailing: false
+  };
+  // 1.记录上一次的开始时间
+  var _options$leading = options.leading,
+    leading = _options$leading === void 0 ? true : _options$leading,
+    _options$trailing = options.trailing,
+    trailing = _options$trailing === void 0 ? false : _options$trailing;
+  var lastTime = 0;
+  var timer = null;
+
+  // 2.事件触发时, 真正执行的函数
+  /* eslint no-underscore-dangle: 0 */
+  var _throttle = function _throttle() {
+    var _this = this;
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    // 2.1.获取当前事件触发时的时间
+    var nowTime = new Date().getTime();
+    if (!lastTime && !leading) lastTime = nowTime;
+
+    // 2.2.使用当前触发的时间和之前的时间间隔以及上一次开始的时间, 计算出还剩余多长事件需要去触发函数
+    var remainTime = interval - (nowTime - lastTime);
+    if (remainTime <= 0) {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+
+      // 2.3.真正触发函数
+      fn.apply(this, args);
+      // 2.4.保留上次触发的时间
+      lastTime = nowTime;
+      return;
+    }
+    if (trailing && !timer) {
+      timer = setTimeout(function () {
+        timer = null;
+        lastTime = !leading ? 0 : new Date().getTime();
+        fn.apply(_this, args);
+      }, remainTime);
+    }
+  };
+  return _throttle;
+}

package/es/toArray.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface Option {
+    keepEmpty?: boolean;
+}
+export default function toArray(children: React.ReactNode, option?: Option): React.ReactElement[];
+export {};

package/es/toArray.js

@@ -0,0 +1,19 @@
+import React from 'react';
+import { isFragment } from 'react-is';
+export default function toArray(children) {
+  var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var ret = [];
+  React.Children.forEach(children, function (child) {
+    if ((child === undefined || child === null) && !option.keepEmpty) {
+      return;
+    }
+    if (Array.isArray(child)) {
+      ret = ret.concat(toArray(child));
+    } else if (isFragment(child) && child.props) {
+      ret = ret.concat(toArray(child.props.children, option));
+    } else {
+      ret.push(child);
+    }
+  });
+  return ret;
+}

package/es/touchBlocker.d.ts

@@ -0,0 +1,11 @@
+/**
+ * author: 辉宇
+ * 为一个DOM元素添加滑动穿透防护
+ * 返回一个函数，调用可解除滑动穿透防护
+ *
+ * **这里滑动穿透防护的定义为不允许root外部的元素被touch类事件滑动（overflow）**
+ *
+ * @param root: HTMLElement
+ * @returns {(function(): void)|*}
+ */
+export default function blockTouch(root: any): () => void;

package/es/touchBlocker.js

@@ -0,0 +1,90 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+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 _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+/**
+ * author: 辉宇
+ * 为一个DOM元素添加滑动穿透防护
+ * 返回一个函数，调用可解除滑动穿透防护
+ *
+ * **这里滑动穿透防护的定义为不允许root外部的元素被touch类事件滑动（overflow）**
+ *
+ * @param root: HTMLElement
+ * @returns {(function(): void)|*}
+ */
+export default function blockTouch(root) {
+  var lastTouch;
+  var moveDirection;
+  var moveAxis;
+  var onTouchStart = function onTouchStart(e) {
+    var _e$touches = _slicedToArray(e.touches, 1);
+    lastTouch = _e$touches[0];
+  };
+  var shouldPrevent = function shouldPrevent(targetElement, axis, delta) {
+    var el = targetElement;
+    var needPrevent = true;
+    while (el) {
+      var _window$getComputedSt = window.getComputedStyle(el),
+        overflowY = _window$getComputedSt.overflowY,
+        overflowX = _window$getComputedSt.overflowX;
+      if (axis === 'y' && (overflowY === 'scroll' || overflowY === 'auto')) {
+        var dir = moveDirection || delta;
+        if (moveDirection === undefined) moveDirection = dir;
+        if (el.scrollTop !== 0 && dir < 0) {
+          needPrevent = false;
+          break;
+        }
+        // 当内部滚动元素高度有小数时，可能会出现小于号左右差1的情况导致算法失效
+        if (el.scrollTop + el.offsetHeight + 1 < el.scrollHeight && dir > 0) {
+          needPrevent = false;
+          break;
+        }
+      }
+      if (axis === 'x' && (overflowX === 'scroll' || overflowX === 'auto')) {
+        var _dir = moveDirection || delta;
+        if (moveDirection === undefined) moveDirection = _dir;
+        if (el.scrollLeft !== 0 && _dir < 0) {
+          needPrevent = false;
+          break;
+        }
+        if (el.scrollLeft + el.offsetWidth < el.scrollWidth && _dir > 0) {
+          needPrevent = false;
+          break;
+        }
+      }
+      if (el === root) break;
+      el = el.parentNode;
+    }
+    return needPrevent;
+  };
+  var onTouchMove = function onTouchMove(e) {
+    var currentTouch = e.touches[0];
+    if (!moveAxis) {
+      if (Math.abs(lastTouch.screenY - currentTouch.screenY) > Math.abs(lastTouch.screenX - currentTouch.screenX)) moveAxis = 'y';
+      if (Math.abs(lastTouch.screenY - currentTouch.screenY) < Math.abs(lastTouch.screenX - currentTouch.screenX)) moveAxis = 'x';
+    }
+    if (shouldPrevent(e.target, moveAxis, moveAxis === 'x' ? lastTouch.screenX - currentTouch.screenX : lastTouch.screenY - currentTouch.screenY) && !e.cancelable === false) e.preventDefault();
+    // setLastTouch(e.touches[0]);
+  };
+  var onTouchEnd = function onTouchEnd() {
+    lastTouch = undefined;
+    moveDirection = undefined;
+    moveAxis = undefined;
+  };
+  var onScroll = function onScroll(e) {
+    if (shouldPrevent(e.target, Math.abs(e.deltaX) > Math.abs(e.deltaY) ? 'x' : 'y', Math.abs(e.deltaX) > Math.abs(e.deltaY) ? e.deltaX : e.deltaY) && !e.cancelable === false) e.preventDefault();
+    moveDirection = undefined;
+  };
+  root.addEventListener('touchstart', onTouchStart);
+  root.addEventListener('touchmove', onTouchMove);
+  root.addEventListener('touchend', onTouchEnd);
+  root.addEventListener('wheel', onScroll);
+  return function () {
+    root.removeEventListener('touchstart', onTouchStart);
+    root.removeEventListener('touchmove', onTouchMove);
+    root.removeEventListener('touchend', onTouchEnd);
+    root.removeEventListener('wheel', onScroll);
+  };
+}

package/es/transitions.d.ts

@@ -0,0 +1,72 @@
+import React from 'react';
+interface IEasing {
+    easeInOut: string;
+    easeIn: string;
+    easeOut: string;
+    sharp: string;
+}
+interface IDuration {
+    shortest: number;
+    shorter: number;
+    short: number;
+    standard: number;
+    complex: number;
+    enteringScreen: number;
+    leavingScreen: number;
+}
+export declare const easing: IEasing;
+export declare const duration: IDuration;
+interface ComponentProps {
+    easing: string | {
+        enter?: string;
+        exit?: string;
+    } | undefined;
+    style: React.CSSProperties | undefined;
+    timeout: number | {
+        enter?: number;
+        exit?: number;
+    };
+    delay: number | {
+        enter?: number;
+        exit?: number;
+    };
+}
+interface Options {
+    mode: 'enter' | 'exit' | 'unmounted' | 'exited' | 'entering' | 'entered' | 'exiting';
+}
+interface TransitionOptions {
+    duration: string | number;
+    easing: string | undefined;
+    delay: string | number;
+}
+export declare function getTransitionProps(props: ComponentProps, options: Options): TransitionOptions;
+interface IInputTransition {
+    easing: IEasing;
+    duration: IDuration;
+    delay: number;
+}
+type ITransitionProps = string | string[];
+export declare function createTransitions(inputTransitions?: Partial<IInputTransition>): {
+    easing: {
+        easeInOut: string;
+        easeIn: string;
+        easeOut: string;
+        sharp: string;
+    };
+    duration: {
+        shortest: number;
+        shorter: number;
+        short: number;
+        standard: number;
+        complex: number;
+        enteringScreen: number;
+        leavingScreen: number;
+    };
+    delay?: number;
+    create: (props?: ITransitionProps, options?: Partial<{
+        duration: number | string;
+        easing: string;
+        delay: number | string;
+    }>) => string;
+};
+export {};

package/es/transitions.js

@@ -0,0 +1,65 @@
+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); }
+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 var easing = {
+  easeInOut: 'cubic-bezier(0.4, 0, 0.2, 1)',
+  easeOut: 'cubic-bezier(0.0, 0, 0.2, 1)',
+  easeIn: 'cubic-bezier(0.4, 0, 1, 1)',
+  sharp: 'cubic-bezier(0.4, 0, 0.6, 1)'
+};
+export var duration = {
+  shortest: 150,
+  shorter: 200,
+  short: 250,
+  /** 标准 */
+  standard: 300,
+  /** 用在复杂动画场景 */
+  complex: 375,
+  enteringScreen: 225,
+  leavingScreen: 195
+};
+export function getTransitionProps(props, options) {
+  var _style$transitionDura, _style$transitionTimi, _style$transitionDela;
+  var timeout = props.timeout,
+    easingProps = props.easing,
+    _props$style = props.style,
+    style = _props$style === void 0 ? {} : _props$style,
+    delay = props.delay;
+  var mode = options.mode;
+  if (mode !== 'enter' && mode !== 'exit') mode = mode === 'entering' || mode === 'entered' ? 'enter' : 'exit';
+  return {
+    duration: (_style$transitionDura = style.transitionDuration) !== null && _style$transitionDura !== void 0 ? _style$transitionDura : typeof timeout === 'number' ? timeout : timeout[mode] || 0,
+    easing: (_style$transitionTimi = style.transitionTimingFunction) !== null && _style$transitionTimi !== void 0 ? _style$transitionTimi : _typeof(easingProps) === 'object' ? easingProps[mode] : easingProps,
+    delay: (_style$transitionDela = style.transitionDelay) !== null && _style$transitionDela !== void 0 ? _style$transitionDela : typeof delay === 'number' ? delay : delay[mode] || 0
+  };
+}
+function formatMs(milliseconds) {
+  return "".concat(Math.round(milliseconds), "ms");
+}
+export function createTransitions() {
+  var inputTransitions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var mergedEasing = _objectSpread(_objectSpread({}, easing), inputTransitions.easing);
+  var mergedDuration = _objectSpread(_objectSpread({}, duration), inputTransitions.duration);
+  var create = function create() {
+    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['all'];
+    var options = arguments.length > 1 ? arguments[1] : undefined;
+    var _options$duration = options.duration,
+      durationOption = _options$duration === void 0 ? mergedDuration.standard : _options$duration,
+      _options$easing = options.easing,
+      easingOption = _options$easing === void 0 ? mergedEasing.easeInOut : _options$easing,
+      _options$delay = options.delay,
+      delay = _options$delay === void 0 ? 0 : _options$delay;
+    return (Array.isArray(props) ? props : [props]).map(function (animatedProp) {
+      return "".concat(animatedProp, " ").concat(typeof durationOption === 'string' ? durationOption : formatMs(durationOption), " ").concat(easingOption, " ").concat(typeof delay === 'string' ? delay : formatMs(delay));
+    }).join(',');
+  };
+  return _objectSpread(_objectSpread({
+    create: create
+  }, inputTransitions), {}, {
+    easing: mergedEasing,
+    duration: mergedDuration
+  });
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@bifrostui/utils",
+  "version": "0.0.5",
+  "description": "BUI React utilities for building components.",
+  "main": "dist/index.js",
+  "module": "es/index.js",
+  "sideEffects": false,
+  "files": [
+    "es",
+    "dist"
+  ],
+  "scripts": {
+    "build": "father build",
+    "test": "echo \"Error: run tests from root\" && exit 1"
+  },
+  "devDependencies": {
+    "father": "^4.1.8"
+  },
+  "dependencies": {
+    "react-is": "^18.0.0"
+  },
+  "peerDependencies": {
+    "@tarojs/taro": "^3.2.0",
+    "react": "^17.0.0 || ^18.0.0"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "gitHead": "f24f431d8291f7838d943eb887c970c7bb0ce5ec"
+}