@arco-design/mobile-react 2.19.0

package/umd/count-down/hooks.js

@@ -0,0 +1,148 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "react", "../_helpers", "./singleton", "./util"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("react"), require("../_helpers"), require("./singleton"), require("./util"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.react, global._helpers, global.singleton, global.util);
+    global.hooks = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _react, _helpers, _singleton, _util) {
+  "use strict";
+
+  _exports.__esModule = true;
+  _exports.useCountDown = void 0;
+
+  var useCountDown = function useCountDown(options) {
+    var taskIdRef = (0, _react.useRef)(0);
+    var endTimeRef = (0, _react.useRef)();
+    var countingRef = (0, _react.useRef)();
+
+    var _useRefState = (0, _helpers.useRefState)(options.time),
+        remain = _useRefState[0],
+        remainRef = _useRefState[1],
+        setRemain = _useRefState[2];
+
+    var _useState = (0, _react.useState)((0, _util.parseTime)(options.time)),
+        current = _useState[0],
+        setCurrent = _useState[1];
+
+    var taskType = options.millisecond ? 'micro' : 'macro'; // 暂停
+    // @en Pause
+
+    var pause = function pause() {
+      countingRef.current = false;
+      (0, _singleton.stopTask)(taskType, taskIdRef.current);
+    }; // 计算当前剩余时间，以毫秒为单位
+    // @en Calculate the current remaining time in milliseconds
+
+
+    var getCurrentRemain = function getCurrentRemain() {
+      var leftTime = Math.max(endTimeRef.current - Date.now(), 0);
+
+      if (options.millisecond) {
+        return leftTime;
+      }
+
+      return Math.round(leftTime / 1000) * 1000;
+    };
+
+    var setRemainCallback = function setRemainCallback(value) {
+      setRemain(value);
+      var time = (0, _util.parseTime)(value);
+
+      if (options.onChange && value !== options.time) {
+        options.onChange(time, value);
+      }
+
+      if (value === 0) {
+        setCurrent(time);
+        pause();
+        options.onFinish == null ? void 0 : options.onFinish();
+      }
+    }; // 开启任务
+    // @en start tasks
+
+
+    var tick = function tick() {
+      taskIdRef.current = (0, _singleton.startTask)(taskType, function () {
+        if (countingRef.current) {
+          setRemainCallback(getCurrentRemain());
+          return remainRef.current > 0;
+        }
+
+        return false;
+      });
+    }; // 开始
+    // @en Start
+
+
+    var start = function start(reStart) {
+      if (reStart === void 0) {
+        reStart = false;
+      }
+
+      if (!countingRef.current) {
+        if (reStart) {
+          endTimeRef.current = Date.now() + options.time;
+        } else {
+          endTimeRef.current = Date.now() + remainRef.current;
+        }
+
+        countingRef.current = true;
+        tick();
+      }
+    }; // 重置
+    // @en Reset
+
+
+    var reset = function reset() {
+      var totalTime = options.time;
+      endTimeRef.current = Date.now() + totalTime;
+      pause();
+      setRemainCallback(totalTime);
+
+      if (options.autoStart) {
+        start(true);
+      }
+    };
+
+    (0, _react.useEffect)(function () {
+      // ummounted时如果正在运行倒计时则暂停
+      // @en Pause if the countdown is running when ummounted
+      return function () {
+        if (countingRef.current) {
+          pause();
+        }
+      };
+    }, []); // 设置自动开始倒计时时自动启动
+    // @en Set to start automatically when the countdown starts automatically
+
+    (0, _react.useEffect)(function () {
+      if (options.autoStart) {
+        start();
+      }
+    }, [options.autoStart]); // 倒计时设置变化时重新计时
+    // @en Re-time when countdown settings change
+
+    (0, _react.useEffect)(function () {
+      reset();
+    }, [options.time]); // remain变化时同步current 即把毫秒转化为TimeDataType类型
+    // @en Synchronize current when remain changes, that is, convert milliseconds to TimeDataType
+
+    (0, _react.useEffect)(function () {
+      setCurrent((0, _util.parseTime)(remain));
+    }, [remain]);
+    return {
+      start: start,
+      pause: pause,
+      reset: reset,
+      current: current
+    };
+  };
+
+  _exports.useCountDown = useCountDown;
+});

package/umd/count-down/index.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { CountDownProps, CountDownRef } from './type';
+export * from './type';
+/**
+ * 倒计时组件
+ * @en Countdown Component
+ * @name 倒计时
+ * @name_en CountDown
+ * @type 数据展示
+ * @type_en Data Display
+ */
+declare const CountDown: React.ForwardRefExoticComponent<CountDownProps & React.RefAttributes<CountDownRef>>;
+export default CountDown;

package/umd/count-down/index.js

@@ -0,0 +1,94 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "react", "./util", "./hooks", "../context-provider", "./type"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("react"), require("./util"), require("./hooks"), require("../context-provider"), require("./type"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.react, global.util, global.hooks, global.contextProvider, global.type);
+    global.index = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _react, _util, _hooks, _contextProvider, _type) {
+  "use strict";
+
+  _exports.__esModule = true;
+  var _exportNames = {};
+  _exports.default = void 0;
+  _react = _interopRequireWildcard(_react);
+  Object.keys(_type).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in _exports && _exports[key] === _type[key]) return;
+    _exports[key] = _type[key];
+  });
+
+  function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(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; }
+
+  /**
+   * 倒计时组件
+   * @en Countdown Component
+   * @name 倒计时
+   * @name_en CountDown
+   * @type 数据展示
+   * @type_en Data Display
+   */
+  var CountDown = /*#__PURE__*/(0, _react.forwardRef)(function (props, ref) {
+    var _props$className = props.className,
+        className = _props$className === void 0 ? '' : _props$className,
+        _props$style = props.style,
+        style = _props$style === void 0 ? {} : _props$style,
+        _props$time = props.time,
+        time = _props$time === void 0 ? 0 : _props$time,
+        _props$format = props.format,
+        format = _props$format === void 0 ? 'HH:mm:ss' : _props$format,
+        _props$autoStart = props.autoStart,
+        autoStart = _props$autoStart === void 0 ? true : _props$autoStart,
+        _props$millisecond = props.millisecond,
+        millisecond = _props$millisecond === void 0 ? false : _props$millisecond,
+        onFinish = props.onFinish,
+        onChange = props.onChange,
+        renderChild = props.renderChild;
+    var domRef = (0, _react.useRef)(null); // 传入倒计时等变量得到开始暂停启动三个方法以及目前所剩时间current(TimeDataType格式)
+    // @en get start, pause, reset methods and the current remaining time —— current (TimeDataType format) by inputing variables such as countdown
+
+    var _useCountDown = (0, _hooks.useCountDown)({
+      time: typeof time === 'number' ? time : (0, _util.unParseTime)(time),
+      millisecond: millisecond,
+      onChange: onChange,
+      onFinish: onFinish,
+      autoStart: autoStart
+    }),
+        start = _useCountDown.start,
+        pause = _useCountDown.pause,
+        reset = _useCountDown.reset,
+        current = _useCountDown.current; // 导出dom以及start,pause,reset三个方法
+    // @en Export dom and three methods of start, pause and reset
+
+
+    (0, _react.useImperativeHandle)(ref, function () {
+      return {
+        dom: domRef.current,
+        start: start,
+        pause: pause,
+        reset: reset
+      };
+    });
+    var currentStr = (0, _react.useMemo)(function () {
+      return (0, _util.parseFormat)(format, current);
+    }, [format, current]);
+    return /*#__PURE__*/_react.default.createElement(_contextProvider.ContextLayout, null, function (_ref) {
+      var prefixCls = _ref.prefixCls;
+      return /*#__PURE__*/_react.default.createElement("div", {
+        className: prefixCls + "-count-down " + className,
+        style: style,
+        ref: domRef
+      }, renderChild ? renderChild(current) : currentStr);
+    });
+  });
+  var _default = CountDown;
+  _exports.default = _default;
+});

package/umd/count-down/singleton.d.ts

@@ -0,0 +1,15 @@
+export interface TaskQueueItem {
+    id: number;
+    callback: () => boolean;
+}
+export declare type TaskQueueType = 'micro' | 'macro';
+export declare const taskCount: {
+    micro: number;
+    macro: number;
+};
+export declare const taskQueue: Record<TaskQueueType, TaskQueueItem[]>;
+export declare function startTask(type: TaskQueueType, callback: TaskQueueItem['callback']): number;
+export declare function execMicroTask(): void;
+export declare function execMacroTask(): void;
+export declare function execTask(type: TaskQueueType): void;
+export declare function stopTask(type: TaskQueueType, id: number): void;

package/umd/count-down/singleton.js

@@ -0,0 +1,86 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./util"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./util"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.util);
+    global.singleton = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _util) {
+  "use strict";
+
+  _exports.__esModule = true;
+  _exports.execMacroTask = execMacroTask;
+  _exports.execMicroTask = execMicroTask;
+  _exports.execTask = execTask;
+  _exports.startTask = startTask;
+  _exports.stopTask = stopTask;
+  _exports.taskQueue = _exports.taskCount = void 0;
+  var timeoutId = null;
+  var rafId = null;
+  var taskCount = {
+    micro: 0,
+    macro: 0
+  };
+  _exports.taskCount = taskCount;
+  var taskQueue = {
+    micro: [],
+    macro: []
+  };
+  _exports.taskQueue = taskQueue;
+
+  function startTask(type, callback) {
+    taskCount[type] += 1;
+    taskQueue[type].push({
+      id: taskCount[type],
+      callback: callback
+    }); // 超过1个任务说明定时任务已建，执行时取最新queue即可
+
+    if (taskQueue[type].length <= 1) {
+      type === 'micro' ? execMicroTask() : execMacroTask();
+    }
+
+    return taskCount[type];
+  }
+
+  function execMicroTask() {
+    rafId && (0, _util.cancelRaf)(rafId);
+    rafId = (0, _util.raf)(function () {
+      execTask('micro');
+      taskQueue.micro.length && execMicroTask();
+    });
+  }
+
+  function execMacroTask() {
+    timeoutId && clearTimeout(timeoutId);
+    timeoutId = window.setTimeout(function () {
+      execTask('macro');
+      taskQueue.macro.length && execMacroTask();
+    }, 1000);
+  }
+
+  function execTask(type) {
+    taskQueue[type].forEach(function (item) {
+      var needContinue = item.callback();
+
+      if (!needContinue) {
+        stopTask(type, item.id);
+      }
+    });
+  }
+
+  function stopTask(type, id) {
+    var queue = taskQueue[type];
+    var index = queue.findIndex(function (val) {
+      return val.id === id;
+    });
+
+    if (index >= 0) {
+      taskQueue[type].splice(index, 1);
+    }
+  }
+});

package/umd/count-down/style/css/index.css

@@ -0,0 +1,5 @@
+.arco-count-down {
+  font-size:  0.32rem ;
+  line-height:  0.44rem ;
+  color:  #1d2129 ;
+}

package/umd/count-down/style/css/index.d.ts

@@ -0,0 +1,2 @@
+import '../../../../style/css/public.css';
+import './index.css';

package/umd/count-down/style/css/index.js

@@ -0,0 +1,15 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["../../../../style/css/public.css", "./index.css"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(require("../../../../style/css/public.css"), require("./index.css"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(global._public, global.index);
+    global.index = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_public, _index) {
+  "use strict";
+});

package/umd/count-down/style/index.d.ts

@@ -0,0 +1,2 @@
+import '../../../style/public.less';
+import './index.less';

package/umd/count-down/style/index.js

@@ -0,0 +1,15 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["../../../style/public.less", "./index.less"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(require("../../../style/public.less"), require("./index.less"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(global._public, global.index);
+    global.index = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_public, _index) {
+  "use strict";
+});

package/umd/count-down/style/index.less

@@ -0,0 +1,7 @@
+@import "../../../style/mixin.less";
+
+.@{prefix}-count-down {
+    .use-var(font-size, count-down-font-size);
+    .use-var(line-height, count-down-line-height);
+    .use-var(color, count-down-color);
+}

package/umd/count-down/type.d.ts

@@ -0,0 +1,112 @@
+import { ReactNode } from 'react';
+export interface TimeDataType {
+    /**
+     * 天数
+     * @en Days
+     */
+    days: number;
+    /**
+     * 小时
+     * @en Hour
+     * */
+    hours: number;
+    /**
+     * 分钟
+     * @en minute
+     * */
+    minutes: number;
+    /**
+     * 秒数
+     * @en second
+     * */
+    seconds: number;
+    /**
+     * 毫秒
+     * @en millisecond
+     * */
+    milliseconds: number;
+}
+export interface CountDownProps {
+    /**
+     * 自定义类名
+     * @en Custom classname
+     */
+    className?: string;
+    /**
+     * 自定义样式
+     * @en Custom stylesheet
+     */
+    style?: React.CSSProperties;
+    /**
+     * 倒计时时长，单位毫秒
+     * @en Countdown time in milliseconds
+     * @default 0
+     */
+    time?: number | TimeDataType;
+    /**
+     * 自定义格式
+     * D:天数 DD:天数（个位数补0）
+     * H:小时 HH:小时（个位数补0）
+     * m:分钟 mm:分钟（个位数补0）
+     * s:秒数 ss:秒数（个位数补0）
+     * S:毫秒（1 位）SS:毫秒（2 位）SSS:毫秒（3 位）
+     * @en Custom format
+     * D: Days DD: Days (1 digit with 0)
+     * H: Hours HH: Hours (1 digit with 0)
+     * m: Minutes mm: Minutes (1 digit with 0)
+     * s: Seconds ss: Seconds (1 digit with 0)
+     * S: Milliseconds (1 digit) SS: Milliseconds (2 digits) SSS: Milliseconds (3 digits)
+     *
+     * @default HH:mm:ss
+     */
+    format?: string;
+    /**
+     * 是否自动开始倒计时
+     * @en Whether to automatically start the countdown
+     * @default true
+     */
+    autoStart?: boolean;
+    /**
+     * 是否开启毫秒级渲染
+     * @en Whether to enable millisecond rendering
+     * @default false
+     */
+    millisecond?: boolean;
+    /**
+     * 倒计时结束时触发
+     * @en Callback when the countdown ends
+     */
+    onFinish?: () => void;
+    /**
+     * 倒计时变化时触发
+     * @en Callback when the countdown changes
+     */
+    onChange?: (val: TimeDataType, ts: number) => void;
+    /**
+     * 自定义内容
+     * @en Custom content
+     */
+    renderChild?: (val: TimeDataType) => ReactNode;
+}
+export interface CountDownRef {
+    /**
+     * 最外层元素 DOM
+     * @en The outermost element DOM
+     */
+    dom: HTMLDivElement | null;
+    /**
+     * 开始
+     * @en Start
+     */
+    start: () => void;
+    /**
+     * 暂停
+     * @en Pause
+     */
+    pause: () => void;
+    /**
+     * 重置
+     * @en Reset
+     * */
+    reset: () => void;
+}

package/umd/count-down/type.js

@@ -0,0 +1,17 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports);
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports);
+    global.type = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports) {
+  "use strict";
+
+  _exports.__esModule = true;
+});

package/umd/count-down/util.d.ts

@@ -0,0 +1,8 @@
+import { TimeDataType } from './index';
+export declare function parseTime(time: number): TimeDataType;
+export declare function unParseTime(time: TimeDataType): number;
+export declare const inBrowser: boolean;
+export declare function cancelRaf(id: number): void;
+export declare function raf(fn: FrameRequestCallback): number;
+export declare function padZero(num: number | string, targetLength?: number): string;
+export declare function parseFormat(formatArg: string, currentTime: TimeDataType): string;