eli-video-interview 1.2.35 → 1.2.36-alpha.0

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = require("react");
+function useInitial(callback) {
+    var current = (0, react_1.useRef)({ sign: false, fn: undefined }).current;
+    if (!current.sign) {
+        current.sign = true;
+        current.fn = callback();
+    }
+    return current.fn;
+}
+exports.default = useInitial;

package/lib/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/lib/components/react-photo-view/hooks/useIsomorphicLayoutEffect.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = require("react");
+var isSSR = typeof window === 'undefined' || /ServerSideRendering/.test(navigator && navigator.userAgent);
+exports.default = isSSR ? react_1.useEffect : react_1.useLayoutEffect;

package/lib/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/lib/components/react-photo-view/hooks/useMethods.js

@@ -0,0 +1,38 @@
+"use strict";
+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));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = require("react");
+/**
+ * Hook of persistent methods
+ */
+function useMethods(fn) {
+    var current = (0, react_1.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;
+}
+exports.default = useMethods;

package/lib/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/lib/components/react-photo-view/hooks/useMountedRef.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = require("react");
+var useMountedRef = function () {
+    var mountedRef = (0, react_1.useRef)(false);
+    (0, react_1.useEffect)(function () {
+        mountedRef.current = true;
+        return function () {
+            mountedRef.current = false;
+        };
+    }, []);
+    return mountedRef;
+};
+exports.default = useMountedRef;

package/lib/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/lib/components/react-photo-view/hooks/useScrollPosition.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var edgeHandle_1 = require("../utils/edgeHandle");
+var getPositionOnMoveOrScale_1 = __importDefault(require("../utils/getPositionOnMoveOrScale"));
+var getRotateSize_1 = __importDefault(require("../utils/getRotateSize"));
+var variables_1 = require("../variables");
+var useMethods_1 = __importDefault(require("./useMethods"));
+// 触边运动反馈
+var rebound = function (start, bound, callback) {
+    return easeOutMove(start, bound, callback, variables_1.defaultSpeed / 4, function (t) { return t; }, function () { return easeOutMove(bound, start, callback); });
+};
+/**
+ * 物理滚动到具体位置
+ */
+function useScrollPosition(callbackX, callbackY, callbackS) {
+    var callback = (0, useMethods_1.default)({
+        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 = (0, getRotateSize_1.default)(rotate, width, height), currentWidth = _a[0], currentHeight = _a[1];
+        // 开始状态下边缘触发状态
+        var _b = (0, edgeHandle_1.computePositionEdge)(x, safeScale, currentWidth, window.innerWidth), beginEdgeX = _b[0], beginX = _b[1];
+        var _c = (0, edgeHandle_1.computePositionEdge)(y, safeScale, currentHeight, window.innerHeight), beginEdgeY = _c[0], beginY = _c[1];
+        var moveTime = Date.now() - touchedTime;
+        // 时间过长、超出安全范围的情况下不执行滚动逻辑，恢复安全范围
+        if (moveTime >= variables_1.maxTouchTime || safeScale !== scale || Math.abs(lastScale - scale) > 1) {
+            // 计算中心缩放点
+            var _d = (0, getPositionOnMoveOrScale_1.default)(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 = (0, edgeHandle_1.computePositionEdge)(nextX, scale, currentWidth, window.innerWidth), isEdgeX = _a[0], currentX = _a[1];
+            var _b = (0, edgeHandle_1.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;
+        });
+    };
+}
+exports.default = useScrollPosition;
+// 加速度
+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 = variables_1.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/lib/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/lib/components/react-photo-view/hooks/useSetState.js

@@ -0,0 +1,18 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = require("react");
+function useSetState(initialState) {
+    return (0, react_1.useReducer)(function (state, action) { return (__assign(__assign({}, state), (typeof action === 'function' ? action(state) : action))); }, initialState);
+}
+exports.default = useSetState;

package/lib/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];

package/lib/components/react-photo-view/hooks/useTargetScale.js

@@ -0,0 +1,76 @@
+"use strict";
+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 (_) 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 };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = require("react");
+var useDebounceCallback_1 = __importDefault(require("./useDebounceCallback"));
+var useIsomorphicLayoutEffect_1 = __importDefault(require("./useIsomorphicLayoutEffect"));
+var useSetState_1 = __importDefault(require("./useSetState"));
+/**
+ * 目标缩放延迟处理
+ */
+function useTargetScale(realWidth, realHeight, realScale, speed, updateEasing) {
+    var _this = this;
+    var execRef = (0, react_1.useRef)(false);
+    var _a = (0, useSetState_1.default)({ lead: true, scale: realScale }), _b = _a[0], lead = _b.lead, scale = _b.scale, updateState = _a[1];
+    var moveScale = (0, useDebounceCallback_1.default)(function (current) { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            updateEasing(true);
+            updateState({ lead: false, scale: current });
+            return [2 /*return*/];
+        });
+    }); }, { wait: speed });
+    (0, useIsomorphicLayoutEffect_1.default)(function () {
+        if (!execRef.current) {
+            execRef.current = true;
+            return;
+        }
+        updateEasing(false);
+        updateState({ lead: true });
+        moveScale(realScale);
+    }, [realScale]);
+    // 运动开始
+    if (lead) {
+        return [realWidth * scale, realHeight * scale, realScale / scale];
+    }
+    // 运动结束
+    return [realWidth * realScale, realHeight * realScale, 1];
+}
+exports.default = useTargetScale;

package/lib/components/react-photo-view/index.d.ts

@@ -0,0 +1,4 @@
+import PhotoProvider from './PhotoProvider';
+import PhotoSlider from './PhotoSlider';
+import PhotoView from './PhotoView';
+export { PhotoProvider, PhotoView, PhotoSlider };

package/lib/components/react-photo-view/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhotoSlider = exports.PhotoView = exports.PhotoProvider = void 0;
+var PhotoProvider_1 = __importDefault(require("./PhotoProvider"));
+exports.PhotoProvider = PhotoProvider_1.default;
+var PhotoSlider_1 = __importDefault(require("./PhotoSlider"));
+exports.PhotoSlider = PhotoSlider_1.default;
+var PhotoView_1 = __importDefault(require("./PhotoView"));
+exports.PhotoView = PhotoView_1.default;

package/lib/components/react-photo-view/photo-context.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import type { DataType } from './types';
+export declare type UpdateItemType = (dataType: DataType) => void;
+export interface PhotoContextType {
+    show: (key: number) => void;
+    update: UpdateItemType;
+    remove: (key: number) => void;
+    nextId: () => number;
+}
+declare const _default: import("react").Context<PhotoContextType>;
+export default _default;

package/lib/components/react-photo-view/photo-context.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = require("react");
+exports.default = (0, react_1.createContext)(undefined);

package/lib/components/react-photo-view/types.d.ts

@@ -0,0 +1,196 @@
+import type React from 'react';
+/**
+ * 资源数据类型
+ */
+export interface DataType {
+    /**
+     * 唯一标识
+     */
+    key: number | string;
+    /**
+     * 资源地址
+     */
+    src?: string;
+    /**
+     * 自定义渲染，优先级比 src 低
+     */
+    render?: (props: PhotoRenderParams) => React.ReactNode;
+    /**
+     * 自定义覆盖节点
+     */
+    overlay?: React.ReactNode;
+    /**
+     * 指定渲染节点宽度
+     */
+    width?: number;
+    /**
+     * 指定渲染节点高度
+     */
+    height?: number;
+    /**
+     * 触发 ref
+     */
+    originRef?: React.MutableRefObject<HTMLElement | null>;
+}
+export interface PhotoProviderBase {
+    /**
+     * 是否循环预览，达到该数量则启用
+     * @defaultValue 3
+     */
+    loop?: boolean | number;
+    /**
+     * 动画速度
+     * @defaultValue 400
+     */
+    speed?: (type: ActiveAnimationType) => number;
+    /**
+     * 动画函数
+     * @defaultValue 'cubic-bezier(0.25, 0.8, 0.25, 1)'
+     */
+    easing?: (type: ActiveAnimationType) => string;
+    /**
+     * 图片点击是否可关闭
+     */
+    photoClosable?: boolean;
+    /**
+     * 背景点击是否可关闭
+     * @defaultValue true
+     */
+    maskClosable?: boolean;
+    /**
+     * 默认背景透明度
+     * 设置 null 背景不响应下拉变化
+     * @defaultValue 1
+     */
+    maskOpacity?: number | null;
+    /**
+     * 下拉是否可关闭
+     * @defaultValue true
+     */
+    pullClosable?: boolean;
+    /**
+     * 导航条 visible
+     * @defaultValue true
+     */
+    bannerVisible?: boolean;
+    /**
+     * 自定义渲染覆盖物
+     */
+    overlayRender?: (overlayProps: OverlayRenderProps) => React.ReactNode;
+    /**
+     * 自定义渲染工具栏
+     */
+    toolbarRender?: (overlayProps: OverlayRenderProps) => React.ReactNode;
+    className?: string;
+    maskClassName?: string;
+    photoWrapClassName?: string;
+    photoClassName?: string;
+    /**
+     * 自定义 loading
+     */
+    loadingElement?: JSX.Element;
+    /**
+     * 自定义加载失败渲染
+     */
+    brokenElement?: JSX.Element | ((photoProps: BrokenElementParams) => JSX.Element);
+    /**
+     * @defaultValue document.body
+     */
+    portalContainer?: HTMLElement;
+}
+export declare type PhotoRenderParams = {
+    /**
+     * 自定义渲染 DOM 属性
+     */
+    attrs: Partial<React.HTMLAttributes<HTMLElement>>;
+    scale: number;
+    rotate: number;
+};
+/**
+ * brokenElement 函数参数
+ */
+export interface BrokenElementParams {
+    src: string;
+}
+export interface OverlayRenderProps {
+    /**
+     * 图片列表
+     */
+    images: DataType[];
+    /**
+     * 当前索引
+     */
+    index: number;
+    /**
+     * 索引改变回调
+     */
+    onIndexChange: (index: number) => void;
+    /**
+     * 是否可见
+     */
+    visible: boolean;
+    /**
+     * 关闭事件回调
+     */
+    onClose: (evt?: React.MouseEvent | React.TouchEvent) => void;
+    /**
+     * 覆盖物是否可见
+     */
+    overlayVisible: boolean;
+    /**
+     * 自定义覆盖节点
+     */
+    overlay?: React.ReactNode;
+    /**
+     * 当前旋转角度
+     */
+    rotate: number;
+    /**
+     * 旋转事件回调
+     */
+    onRotate: (rotate: number) => void;
+    /**
+     * 当前缩放
+     */
+    scale: number;
+    /**
+     * 缩放事件回调
+     */
+    onScale: (scale: number) => void;
+}
+export interface ExposedProperties {
+    scale?: number;
+    rotate?: number;
+    onScale?: (scale: number) => void;
+    onRotate?: (rotate: number) => void;
+}
+export declare type ReachMoveFunction = (reachPosition: ReachType, clientX: number, clientY: number, scale?: number) => void;
+export declare type ReachFunction = (clientX: number, clientY: number) => void;
+export declare type PhotoTapFunction = (clientX: number, clientY: number) => void;
+/**
+ * 边缘超出状态
+ */
+export declare type CloseEdgeType = 1 | 2 | 3 | undefined;
+/**
+ * 边缘触发状态
+ */
+export declare type ReachType = 'x' | 'y' | undefined;
+/**
+ * 初始响应状态
+ */
+export declare type TouchStartType = 0 | 1 | 2 | 3;
+export declare type OriginRectType = {
+    T: number;
+    L: number;
+    W: number;
+    H: number;
+    FIT: 'contain' | 'cover' | 'fill' | undefined;
+};
+/**
+ * 动画状态
+ */
+export declare type EasingMode = 0 | 1 | 2 | 3 | 4 | 5;
+/**
+ * 进行中的动画
+ */
+export declare type ActiveAnimationType = 0 | 1 | 2 | 3;

package/lib/components/react-photo-view/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/components/react-photo-view/utils/edgeHandle.d.ts

@@ -0,0 +1,15 @@
+import type { CloseEdgeType } from '../types';
+import type { ReachType, TouchStartType } from '../types';
+/**
+ * 获取接触边缘类型
+ */
+export declare const getReachType: (initialTouchState: TouchStartType, horizontalCloseEdge: CloseEdgeType, verticalCloseEdge: CloseEdgeType, reachPosition: ReachType) => ReachType;
+/**
+ * 计算接触边缘位置
+ * @param position - x/y
+ * @param scale
+ * @param size - width/height
+ * @param innerSize - innerWidth/innerHeight
+ * @return [CloseEdgeType, position]
+ */
+export declare const computePositionEdge: (position: number, scale: number, size: number, innerSize: number) => readonly [CloseEdgeType, number];

package/lib/components/react-photo-view/utils/edgeHandle.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computePositionEdge = exports.getReachType = void 0;
+/**
+ * 获取接触边缘类型
+ */
+var getReachType = function (initialTouchState, horizontalCloseEdge, verticalCloseEdge, reachPosition) {
+    if ((horizontalCloseEdge && initialTouchState === 1) || reachPosition === 'x') {
+        return 'x';
+    }
+    else if ((verticalCloseEdge && initialTouchState > 1) || reachPosition === 'y') {
+        return 'y';
+    }
+    return undefined;
+};
+exports.getReachType = getReachType;
+/**
+ * 计算接触边缘位置
+ * @param position - x/y
+ * @param scale
+ * @param size - width/height
+ * @param innerSize - innerWidth/innerHeight
+ * @return [CloseEdgeType, position]
+ */
+var computePositionEdge = function (position, scale, size, innerSize) {
+    var currentWidth = size * scale;
+    // 图片超出的宽度
+    var outOffset = (currentWidth - innerSize) / 2;
+    var closedEdge = undefined;
+    var current = position;
+    if (currentWidth <= innerSize) {
+        closedEdge = 1;
+        current = 0;
+    }
+    else if (position > 0 && outOffset - position <= 0) {
+        closedEdge = 2;
+        current = outOffset;
+    }
+    else if (position < 0 && outOffset + position <= 0) {
+        closedEdge = 3;
+        current = -outOffset;
+    }
+    return [closedEdge, current];
+};
+exports.computePositionEdge = computePositionEdge;

package/lib/components/react-photo-view/utils/getMultipleTouchPosition.d.ts

@@ -0,0 +1,5 @@
+import type React from 'react';
+/**
+ * 从 Touch 事件中获取两个触控中心位置
+ */
+export default function getMultipleTouchPosition(evt: TouchEvent | React.TouchEvent): [clientX: number, clientY: number, touchLength: number];