eli-video-interview 1.2.39 → 1.2.40-alpha.2

package/esm/components/react-photo-view/components/Spinner.js

@@ -0,0 +1,29 @@
+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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './Spinner.css';
+function Spinner(_a) {
+    var className = _a.className, props = __rest(_a, ["className"]);
+    return (_jsx("div", __assign({ className: "PhotoView__Spinner ".concat(className) }, props, { children: _jsxs("svg", __assign({ viewBox: "0 0 32 32", width: "36", height: "36", fill: "white" }, { children: [_jsx("path", { opacity: ".25", d: "M16 0 A16 16 0 0 0 16 32 A16 16 0 0 0 16 0 M16 4 A12 12 0 0 1 16 28 A12 12 0 0 1 16 4" }), _jsx("path", { d: "M16 0 A16 16 0 0 1 32 16 L28 16 A12 12 0 0 0 16 4z" })] })) })));
+}
+export default Spinner;

package/esm/components/react-photo-view/hooks/useAdjacentImages.d.ts

@@ -0,0 +1,5 @@
+import type { DataType } from '../types';
+/**
+ * 截取相邻三张图片
+ */
+export default function useAdjacentImages(images: DataType[], index: number, loop: boolean): DataType[];

package/esm/components/react-photo-view/hooks/useAdjacentImages.js

@@ -0,0 +1,14 @@
+import { useMemo } from 'react';
+/**
+ * 截取相邻三张图片
+ */
+export default function useAdjacentImages(images, index, loop) {
+    return useMemo(function () {
+        var imageLength = images.length;
+        if (loop) {
+            var connected = images.concat(images).concat(images);
+            return connected.slice(imageLength + index - 1, imageLength + index + 2);
+        }
+        return images.slice(Math.max(index - 1, 0), Math.min(index + 2, imageLength + 1));
+    }, [images, index, loop]);
+}

package/esm/components/react-photo-view/hooks/useAnimationOrigin.d.ts

@@ -0,0 +1,6 @@
+import type { MutableRefObject } from 'react';
+import type { EasingMode, OriginRectType } from '../types';
+export default function useAnimationOrigin(visible: boolean | undefined, originRef: MutableRefObject<HTMLElement | null> | undefined, loaded: boolean, speed: number, updateEasing: (pause: boolean) => void): [
+    easingMode: EasingMode,
+    originRect: OriginRectType
+];

package/esm/components/react-photo-view/hooks/useAnimationOrigin.js

@@ -0,0 +1,72 @@
+import { useEffect, useRef, useState } from 'react';
+import { maxWaitAnimationTime } from '../variables';
+import useMethods from './useMethods';
+var initialRect = {
+    T: 0,
+    L: 0,
+    W: 0,
+    H: 0,
+    // 图像填充方式
+    FIT: undefined,
+};
+export default function useAnimationOrigin(visible, originRef, loaded, speed, updateEasing) {
+    var _a = useState(initialRect), originRect = _a[0], updateOriginRect = _a[1];
+    // 动画状态
+    var _b = useState(0), easingMode = _b[0], updateEasingMode = _b[1];
+    var initialTime = useRef();
+    var fn = useMethods({
+        OK: function () { return visible && updateEasingMode(4); },
+    });
+    useEffect(function () {
+        // 记录初始打开的时间
+        if (!initialTime.current) {
+            initialTime.current = Date.now();
+        }
+        if (!loaded) {
+            return;
+        }
+        handleUpdateOrigin(originRef, updateOriginRect);
+        // 打开动画处理
+        if (visible) {
+            // 小于最大允许动画时间，则执行缩放动画
+            if (Date.now() - initialTime.current < maxWaitAnimationTime) {
+                updateEasingMode(1);
+                // 延时执行动画，保持 transition 生效
+                requestAnimationFrame(function () {
+                    updateEasingMode(2);
+                    requestAnimationFrame(function () { return handleToShape(3); });
+                });
+                setTimeout(fn.OK, speed);
+                return;
+            }
+            // 超出则不执行
+            updateEasingMode(4);
+            return;
+        }
+        // 关闭动画处理
+        handleToShape(5);
+    }, [visible, loaded]);
+    function handleToShape(currentShape) {
+        updateEasing(false);
+        updateEasingMode(currentShape);
+    }
+    return [easingMode, originRect];
+}
+/**
+ * 更新缩略图位置信息
+ */
+function handleUpdateOrigin(originRef, updateOriginRect) {
+    var element = originRef && originRef.current;
+    if (element && element.nodeType === 1) {
+        // 获取触发时节点位置
+        var _a = element.getBoundingClientRect(), top_1 = _a.top, left = _a.left, width = _a.width, height = _a.height;
+        var isImage = element.tagName === 'IMG';
+        updateOriginRect({
+            T: top_1,
+            L: left,
+            W: width,
+            H: height,
+            FIT: isImage ? getComputedStyle(element).objectFit : undefined,
+        });
+    }
+}

package/esm/components/react-photo-view/hooks/useAnimationPosition.d.ts

@@ -0,0 +1,2 @@
+import type { MutableRefObject } from 'react';
+export default function useAnimationPosition(visible: boolean | undefined, originRef: MutableRefObject<HTMLElement | null> | undefined, loaded: boolean, x: number, y: number, width: number, height: number, scale: number, speed: number, updateEasing: (pause: boolean) => void): readonly [number, number, number, number, number, 0 | 1, import("../types").EasingMode, "fill" | "contain" | "cover" | undefined];

package/esm/components/react-photo-view/hooks/useAnimationPosition.js

@@ -0,0 +1,28 @@
+import useAnimationOrigin from './useAnimationOrigin';
+import useTargetScale from './useTargetScale';
+export default function useAnimationPosition(visible, originRef, loaded, x, y, width, height, scale, speed, updateEasing) {
+    // 延迟更新 width/height
+    var _a = useTargetScale(width, height, scale, speed, updateEasing), autoWidth = _a[0], autoHeight = _a[1], autoScale = _a[2];
+    // 动画源处理
+    var _b = useAnimationOrigin(visible, originRef, loaded, speed, updateEasing), easingMode = _b[0], originRect = _b[1];
+    // 计算动画位置
+    var T = originRect.T, L = originRect.L, W = originRect.W, H = originRect.H, FIT = originRect.FIT;
+    // 偏移量，x: 0, y: 0 居中为初始
+    var centerWidth = window.innerWidth / 2;
+    var centerHeight = window.innerHeight / 2;
+    var offsetX = centerWidth - (width * scale) / 2;
+    var offsetY = centerHeight - (height * scale) / 2;
+    // 缩略图状态
+    var miniMode = easingMode < 3 || easingMode > 4;
+    // 有缩略图时，则为缩略图的位置，否则居中
+    var translateX = miniMode ? (W ? L : centerWidth) : x + offsetX;
+    var translateY = miniMode ? (W ? T : centerHeight) : y + offsetY;
+    // 最小值缩放
+    var minScale = W / (width * scale) || 0.01;
+    // 适应 objectFit 保持缩略图宽高比
+    var currentHeight = miniMode && FIT ? autoWidth * (H / W) : autoHeight;
+    // 初始加载情况无缩放
+    var currentScale = easingMode === 0 ? autoScale : miniMode ? minScale : autoScale;
+    var opacity = miniMode ? (FIT ? 1 : 0) : 1;
+    return [translateX, translateY, autoWidth, currentHeight, currentScale, opacity, easingMode, FIT];
+}

package/esm/components/react-photo-view/hooks/useAnimationVisible.d.ts

@@ -0,0 +1,6 @@
+import type { ActiveAnimationType } from '../types';
+/**
+ * 动画关闭处理真实关闭状态
+ * 通过 onAnimationEnd 回调实现 leaveCallback
+ */
+export default function useAnimationVisible(visible: boolean | undefined, afterClose?: () => void): [realVisible: boolean | undefined, activeAnimation: ActiveAnimationType, onAnimationEnd: () => void];

package/esm/components/react-photo-view/hooks/useAnimationVisible.js

@@ -0,0 +1,49 @@
+import { useReducer, useRef } from 'react';
+import useForkedVariable from './useForkedVariable';
+/**
+ * 动画关闭处理真实关闭状态
+ * 通过 onAnimationEnd 回调实现 leaveCallback
+ */
+export default function useAnimationVisible(visible, afterClose) {
+    var _a = useReducer(function (c) { return !c; }, false), handleRender = _a[1];
+    var activeAnimation = useRef(0);
+    // 可见状态分支
+    var _b = useForkedVariable(visible, function (modify) {
+        // 可见状态：设置进入动画
+        if (visible) {
+            modify(visible);
+            activeAnimation.current = 1;
+        }
+        else {
+            activeAnimation.current = 2;
+        }
+    }), realVisible = _b[0], modifyRealVisible = _b[1];
+    function onAnimationEnd() {
+        // 动画结束后触发渲染
+        handleRender();
+        // 结束动画：设置隐藏状态
+        if (activeAnimation.current === 2) {
+            modifyRealVisible(false);
+            // 触发隐藏回调
+            if (afterClose) {
+                afterClose();
+            }
+        }
+        // 重置状态
+        activeAnimation.current = 0;
+    }
+    return [
+        /**
+         * 真实可见状态
+         */
+        realVisible,
+        /**
+         * 正在进行的动画
+         */
+        activeAnimation.current,
+        /**
+         * 动画结束后回调
+         */
+        onAnimationEnd,
+    ];
+}

package/esm/components/react-photo-view/hooks/useContinuousTap.d.ts

@@ -0,0 +1,8 @@
+export declare type TapFuncType<T> = (...args: T[]) => void;
+/**
+ * 单击和双击事件处理
+ * @param singleTap - 单击事件
+ * @param doubleTap - 双击事件
+ * @return invokeTap
+ */
+export default function useContinuousTap<T>(singleTap: TapFuncType<T>, doubleTap: TapFuncType<T>): TapFuncType<T>;

package/esm/components/react-photo-view/hooks/useContinuousTap.js

@@ -0,0 +1,36 @@
+import { useRef } from 'react';
+import useDebounceCallback from './useDebounceCallback';
+/**
+ * 单击和双击事件处理
+ * @param singleTap - 单击事件
+ * @param doubleTap - 双击事件
+ * @return invokeTap
+ */
+export default function useContinuousTap(singleTap, doubleTap) {
+    // 当前连续点击次数
+    var continuousClick = useRef(0);
+    var debounceTap = useDebounceCallback(function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        continuousClick.current = 0;
+        singleTap.apply(void 0, args);
+    }, {
+        wait: 300,
+    });
+    return function invokeTap() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        continuousClick.current += 1;
+        debounceTap.apply(void 0, args);
+        // 双击
+        if (continuousClick.current >= 2) {
+            debounceTap.cancel();
+            continuousClick.current = 0;
+            doubleTap.apply(void 0, args);
+        }
+    };
+}

package/esm/components/react-photo-view/hooks/useDebounceCallback.d.ts

@@ -0,0 +1,10 @@
+interface DebounceCallback<CallbackArguments extends any[]> {
+    (...args: CallbackArguments): void;
+    cancel: () => void;
+}
+export default function useDebounceCallback<CallbackArguments extends any[]>(callback: (...args: CallbackArguments) => void, { leading, maxWait, wait, }: {
+    leading?: boolean;
+    maxWait?: number;
+    wait?: number;
+}): DebounceCallback<CallbackArguments>;
+export {};

package/esm/components/react-photo-view/hooks/useDebounceCallback.js

@@ -0,0 +1,48 @@
+import { useCallback, useRef } from 'react';
+export default function useDebounceCallback(callback, _a) {
+    var _b = _a.leading, leading = _b === void 0 ? false : _b, maxWait = _a.maxWait, _c = _a.wait, wait = _c === void 0 ? maxWait || 0 : _c;
+    var callbackRef = useRef(callback);
+    callbackRef.current = callback;
+    var prev = useRef(0);
+    var trailingTimeout = useRef();
+    var clearTrailing = function () { return trailingTimeout.current && clearTimeout(trailingTimeout.current); };
+    var fn = useCallback(function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var now = Date.now();
+        function call() {
+            prev.current = now;
+            clearTrailing();
+            callbackRef.current.apply(null, args);
+        }
+        var last = prev.current;
+        var offset = now - last;
+        // leading
+        if (last === 0) {
+            if (leading) {
+                call();
+            }
+            prev.current = now;
+        }
+        // body
+        if (maxWait !== undefined) {
+            if (offset > maxWait) {
+                call();
+                return;
+            }
+        }
+        else if (offset < wait) {
+            prev.current = now;
+        }
+        // trailing
+        clearTrailing();
+        trailingTimeout.current = setTimeout(function () {
+            call();
+            prev.current = 0;
+        }, wait);
+    }, [wait, maxWait, leading]);
+    fn.cancel = clearTrailing;
+    return fn;
+}

package/esm/components/react-photo-view/hooks/useEventListener.d.ts

@@ -0,0 +1 @@
+export default function useEventListener<K extends keyof WindowEventMap>(type: K | undefined, fn: (evt: WindowEventMap[K]) => void, options?: AddEventListenerOptions): void;

package/esm/components/react-photo-view/hooks/useEventListener.js

@@ -0,0 +1,18 @@
+import { useEffect, useRef } from 'react';
+export default function useEventListener(type, fn, options) {
+    var latest = useRef(fn);
+    latest.current = fn;
+    useEffect(function () {
+        function wrapper(evt) {
+            latest.current(evt);
+        }
+        if (type) {
+            window.addEventListener(type, wrapper, options);
+        }
+        return function () {
+            if (type) {
+                window.removeEventListener(type, wrapper);
+            }
+        };
+    }, [type]);
+}

package/esm/components/react-photo-view/hooks/useForkedVariable.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 逻辑分叉变量处理
+ * 此 hook 不触发额外渲染
+ */
+export default function useForkedVariable<T>(initial: T, updater: (modify: (variable: T) => void) => void): readonly [T, (next: T) => void];

package/esm/components/react-photo-view/hooks/useForkedVariable.js

@@ -0,0 +1,17 @@
+import { useMemo, useRef } from 'react';
+/**
+ * 逻辑分叉变量处理
+ * 此 hook 不触发额外渲染
+ */
+export default function useForkedVariable(initial, updater) {
+    // 初始分叉变量
+    var forkedRef = useRef(initial);
+    function modify(next) {
+        forkedRef.current = next;
+    }
+    useMemo(function () {
+        // 参数变化之后同步内部分叉变量
+        updater(modify);
+    }, [initial]);
+    return [forkedRef.current, modify];
+}

package/esm/components/react-photo-view/hooks/useInitial.d.ts

@@ -0,0 +1 @@
+export default function useInitial<T extends (...args: any) => any>(callback: T): ReturnType<T>;

package/esm/components/react-photo-view/hooks/useInitial.js

@@ -0,0 +1,9 @@
+import { useRef } from 'react';
+export default function useInitial(callback) {
+    var current = useRef({ sign: false, fn: undefined }).current;
+    if (!current.sign) {
+        current.sign = true;
+        current.fn = callback();
+    }
+    return current.fn;
+}

package/esm/components/react-photo-view/hooks/useIsomorphicLayoutEffect.d.ts

@@ -0,0 +1,3 @@
+import { useEffect } from 'react';
+declare const _default: typeof useEffect;
+export default _default;

package/esm/components/react-photo-view/hooks/useIsomorphicLayoutEffect.js

@@ -0,0 +1,3 @@
+import { useEffect, useLayoutEffect } from 'react';
+var isSSR = typeof window === 'undefined' || /ServerSideRendering/.test(navigator && navigator.userAgent);
+export default isSSR ? useEffect : useLayoutEffect;

package/esm/components/react-photo-view/hooks/useMethods.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Hook of persistent methods
+ */
+export default function useMethods<T extends Record<string, (...args: any[]) => any>>(fn: T): T;

package/esm/components/react-photo-view/hooks/useMethods.js

@@ -0,0 +1,35 @@
+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));
+};
+import { useRef } from 'react';
+/**
+ * Hook of persistent methods
+ */
+export default function useMethods(fn) {
+    var current = useRef({
+        fn: fn,
+        curr: undefined,
+    }).current;
+    current.fn = fn;
+    if (!current.curr) {
+        var curr_1 = Object.create(null);
+        Object.keys(fn).forEach(function (key) {
+            curr_1[key] = function () {
+                var _a;
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                return (_a = current.fn[key]).call.apply(_a, __spreadArray([current.fn], args, false));
+            };
+        });
+        current.curr = curr_1;
+    }
+    return current.curr;
+}

package/esm/components/react-photo-view/hooks/useMountedRef.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const useMountedRef: () => import("react").MutableRefObject<boolean>;
+export default useMountedRef;

package/esm/components/react-photo-view/hooks/useMountedRef.js

@@ -0,0 +1,12 @@
+import { useEffect, useRef } from 'react';
+var useMountedRef = function () {
+    var mountedRef = useRef(false);
+    useEffect(function () {
+        mountedRef.current = true;
+        return function () {
+            mountedRef.current = false;
+        };
+    }, []);
+    return mountedRef;
+};
+export default useMountedRef;

package/esm/components/react-photo-view/hooks/useScrollPosition.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 物理滚动到具体位置
+ */
+export default function useScrollPosition<C extends (spatial: number) => boolean>(callbackX: C, callbackY: C, callbackS: C): (x: number, y: number, lastX: number, lastY: number, width: number, height: number, scale: number, safeScale: number, lastScale: number, rotate: number, touchedTime: number) => void;

package/esm/components/react-photo-view/hooks/useScrollPosition.js

@@ -0,0 +1,157 @@
+import { computePositionEdge } from '../utils/edgeHandle';
+import getPositionOnMoveOrScale from '../utils/getPositionOnMoveOrScale';
+import getRotateSize from '../utils/getRotateSize';
+import { defaultSpeed, maxTouchTime } from '../variables';
+import useMethods from './useMethods';
+// 触边运动反馈
+var rebound = function (start, bound, callback) {
+    return easeOutMove(start, bound, callback, defaultSpeed / 4, function (t) { return t; }, function () { return easeOutMove(bound, start, callback); });
+};
+/**
+ * 物理滚动到具体位置
+ */
+export default function useScrollPosition(callbackX, callbackY, callbackS) {
+    var callback = useMethods({
+        X: function (spatial) { return callbackX(spatial); },
+        Y: function (spatial) { return callbackY(spatial); },
+        S: function (spatial) { return callbackS(spatial); },
+    });
+    return function (x, y, lastX, lastY, width, height, scale, safeScale, lastScale, rotate, touchedTime) {
+        var _a = getRotateSize(rotate, width, height), currentWidth = _a[0], currentHeight = _a[1];
+        // 开始状态下边缘触发状态
+        var _b = computePositionEdge(x, safeScale, currentWidth, window.innerWidth), beginEdgeX = _b[0], beginX = _b[1];
+        var _c = computePositionEdge(y, safeScale, currentHeight, window.innerHeight), beginEdgeY = _c[0], beginY = _c[1];
+        var moveTime = Date.now() - touchedTime;
+        // 时间过长、超出安全范围的情况下不执行滚动逻辑，恢复安全范围
+        if (moveTime >= maxTouchTime || safeScale !== scale || Math.abs(lastScale - scale) > 1) {
+            // 计算中心缩放点
+            var _d = getPositionOnMoveOrScale(x, y, width, height, scale, safeScale), nextX = _d.x, nextY = _d.y;
+            var targetX = beginEdgeX ? beginX : nextX !== x ? nextX : null;
+            var targetY = beginEdgeY ? beginY : nextY !== y ? nextY : null;
+            if (targetX !== null) {
+                easeOutMove(x, targetX, callback.X);
+            }
+            if (targetY !== null) {
+                easeOutMove(y, targetY, callback.Y);
+            }
+            if (safeScale !== scale) {
+                easeOutMove(scale, safeScale, callback.S);
+            }
+            return;
+        }
+        // 初始速度
+        var speedX = (x - lastX) / moveTime;
+        var speedY = (y - lastY) / moveTime;
+        var speedT = Math.sqrt(Math.pow(speedX, 2) + Math.pow(speedY, 2));
+        // 是否接触到边缘
+        var edgeX = false;
+        var edgeY = false;
+        scrollMove(speedT, function (spatial) {
+            var nextX = x + spatial * (speedX / speedT);
+            var nextY = y + spatial * (speedY / speedT);
+            var _a = computePositionEdge(nextX, scale, currentWidth, window.innerWidth), isEdgeX = _a[0], currentX = _a[1];
+            var _b = computePositionEdge(nextY, scale, currentHeight, window.innerHeight), isEdgeY = _b[0], currentY = _b[1];
+            if (isEdgeX && !edgeX) {
+                edgeX = true;
+                if (beginEdgeX) {
+                    easeOutMove(nextX, currentX, callback.X);
+                }
+                else {
+                    rebound(currentX, nextX + (nextX - currentX), callback.X);
+                }
+            }
+            if (isEdgeY && !edgeY) {
+                edgeY = true;
+                if (beginEdgeY) {
+                    easeOutMove(nextY, currentY, callback.Y);
+                }
+                else {
+                    rebound(currentY, nextY + (nextY - currentY), callback.Y);
+                }
+            }
+            // 同时接触边缘的情况下停止滚动
+            if (edgeX && edgeY) {
+                return false;
+            }
+            var resultX = edgeX || callback.X(currentX);
+            var resultY = edgeY || callback.Y(currentY);
+            return resultX && resultY;
+        });
+    };
+}
+// 加速度
+var acceleration = -0.001;
+// 阻力
+var resistance = 0.0002;
+/**
+ * 通过速度滚动到停止
+ */
+function scrollMove(initialSpeed, callback) {
+    var v = initialSpeed;
+    var s = 0;
+    var lastTime = undefined;
+    var frameId = 0;
+    var calcMove = function (now) {
+        if (!lastTime) {
+            lastTime = now;
+        }
+        var dt = now - lastTime;
+        var direction = Math.sign(initialSpeed);
+        var a = direction * acceleration;
+        var f = Math.sign(-v) * Math.pow(v, 2) * resistance;
+        var ds = v * dt + ((a + f) * Math.pow(dt, 2)) / 2;
+        v = v + (a + f) * dt;
+        s = s + ds;
+        // move to s
+        lastTime = now;
+        if (direction * v <= 0) {
+            caf();
+            return;
+        }
+        if (callback(s)) {
+            raf();
+            return;
+        }
+        caf();
+    };
+    raf();
+    function raf() {
+        frameId = requestAnimationFrame(calcMove);
+    }
+    function caf() {
+        cancelAnimationFrame(frameId);
+    }
+}
+/**
+ * 缓动函数
+ */
+var easeOutQuart = function (x) { return 1 - Math.pow((1 - x), 4); };
+/**
+ * 缓动回调
+ */
+function easeOutMove(start, end, callback, speed, easing, complete) {
+    if (speed === void 0) { speed = defaultSpeed; }
+    if (easing === void 0) { easing = easeOutQuart; }
+    var distance = end - start;
+    if (distance === 0) {
+        return;
+    }
+    var startTime = Date.now();
+    var frameId = 0;
+    var calcMove = function () {
+        var time = Math.min(1, (Date.now() - startTime) / speed);
+        var result = callback(start + easing(time) * distance);
+        if (result && time < 1) {
+            raf();
+            return;
+        }
+        cancelAnimationFrame(frameId);
+        if (time >= 1 && complete) {
+            complete();
+        }
+    };
+    raf();
+    function raf() {
+        frameId = requestAnimationFrame(calcMove);
+    }
+}

package/esm/components/react-photo-view/hooks/useSetState.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export default function useSetState<S extends Record<string, any>>(initialState: S): [S & Partial<S>, import("react").Dispatch<Partial<S> | ((state: S) => Partial<S>)>];

package/esm/components/react-photo-view/hooks/useSetState.js

@@ -0,0 +1,15 @@
+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);
+};
+import { useReducer } from 'react';
+export default function useSetState(initialState) {
+    return useReducer(function (state, action) { return (__assign(__assign({}, state), (typeof action === 'function' ? action(state) : action))); }, initialState);
+}

package/esm/components/react-photo-view/hooks/useTargetScale.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 目标缩放延迟处理
+ */
+export default function useTargetScale(realWidth: number, realHeight: number, realScale: number, speed: number, updateEasing: (pause: boolean) => void): readonly [number, number, number];