three-base 2.0.137 → 2.0.145

package/ThreeMouse.ts

@@ -0,0 +1,472 @@
+//
+//
+//
+//
+//
+//  启动鼠标事件
+import { Camera, InstancedMesh, Intersection, Mesh, Object3D, Raycaster, Scene, Vector2, WebGLRenderer } from "three";
+import { debounce } from "lodash";
+import { computeBoundsTree, acceleratedRaycast } from "three-mesh-bvh";
+import type InstancedGroup from "./instanced/InstancedGroup";
+
+/** 安全地分发事件到 Object3D 对象 */
+function dispatchObjectEvent<T extends { type: string }>(object: Object3D, event: T): void {
+    // 使用双重断言来安全地传递事件对象
+    object.dispatchEvent(event as unknown as Parameters<Object3D["dispatchEvent"]>[0]);
+}
+
+/** Patch Mesh.raycast with BVH acceleration. Call once before using ThreeMouse. */
+export function initBVHRaycast(): void {
+    if (Mesh.prototype.raycast !== acceleratedRaycast) {
+        Mesh.prototype.raycast = acceleratedRaycast;
+    }
+}
+
+export { computeBoundsTree, acceleratedRaycast };
+
+export interface ThreeMouseEvent extends Intersection {
+    e: MouseEvent;
+    renderer: WebGLRenderer;
+    camera: Camera;
+    type: string;
+    offsetX: number;
+    offsetY: number;
+    x: number;
+    y: number;
+}
+
+export type MouseEventType = "leftclick" | "rightclick" | "click" | "dbclick" | "mouseenter" | "mouseleave" | "mousemove" | "mousedown" | "mouseup";
+
+/**
+ *  js 专用的鼠标拾取模型对象
+ */
+export default class ThreeMouse {
+    constructor(renderer: WebGLRenderer, camera: Camera, scene: Scene) {
+        this._renderer = renderer;
+        this._camera = camera;
+        this._scene = scene;
+        this._frame = this._renderer.info.render.frame;
+        this._renderer.domElement.addEventListener("mouseenter", () => {
+            this._mouseInRenderer = true;
+        }, true); //鼠标进入开启拾取
+        this._renderer.domElement.addEventListener("mouseleave", this._mouseleave, true); //鼠标离开停止拾取
+        this._renderer.domElement.addEventListener("mousemove", this._mousemove, true); //鼠标移动监听事件
+        this._renderer.domElement.addEventListener("pointerdown", this._mousedown, true); //鼠标按下监听事件
+        this._renderer.domElement.addEventListener("pointerup", this._mouseup, true); //鼠标弹起监听事件
+    }
+    // 渲染器
+    _renderer: WebGLRenderer;
+    _camera: Camera;
+    _scene: Scene;
+    // 固定的实例化分组器（由 ThreeBase 注入），用于把 InstancedMesh 命中路由到 InstancedChild
+    instancedGroup?: InstancedGroup;
+    // 鼠标在渲染器上面的位置
+    _mosePosition: Vector2 = new Vector2(0, 0);
+    // 鼠标按下的位置 如果和鼠标弹起的位置相同 才算一次有效的点击事件
+    _mouseDownPosition: Vector2 = new Vector2(0, 0);
+    //当前鼠标指针上的对象
+    _mesh_on?: Object3D;
+    //鼠标按下的对象
+    _mesh_Down?: Object3D;
+    //射线拾取器
+    _raycaster: Raycaster = new Raycaster();
+    // 当前渲染的帧数 ( 鼠标滑动事件 一帧只需要执行费一次即可 )
+    _frame: number = 0;
+    //鼠标是否在渲染器上
+    _mouseInRenderer: boolean = false;
+    // 鼠标滑动的事件
+    _mousemoveEvent?: MouseEvent | PointerEvent;
+    // 鼠标事件
+    _mouseEvent?: MouseEvent | PointerEvent;
+    // 需要被拾取的对象数组
+    _object3ds: Object3D[] = [];
+    // 点击次数
+    _click_num: number = 0;
+    // 获取拾取到的对象
+    _getSelected(object3ds: Object3D[]): Intersection | undefined {
+        let intersection: Intersection | undefined;
+        if (object3ds.length) {
+            intersection = this._raycaster.intersectObjects(object3ds, false)[0];
+        }
+        return intersection;
+    }
+    // 判断对象上面是否有事件
+    hasEvent(object?: Object3D, types: Array<MouseEventType> = []): boolean {
+        if (!object) {
+            return false;
+        }
+        // 如果 启用事件为关闭的话就不执行事件
+        if (object["userData"] && object["userData"]["enableEvent"] === false) {
+            return false;
+        }
+        // 注意：three 的 hasEventListener(type, null) 因 indexOf(null) 永远 -1 而恒返回 false，
+        // 无法用来判断"是否存在任意监听器"。改为直接读取私有 _listeners 表判断该类型是否有监听。
+        const listeners = (object as unknown as { _listeners?: Record<string, unknown[]> })._listeners;
+        const hasevent = types.some((type) => {
+            return !!(listeners && listeners[type] && listeners[type].length > 0);
+        });
+        return hasevent;
+    }
+    // 判断对象上是否有鼠标样式
+    hasCursor(object?: Object3D): boolean | undefined {
+        if (!object) {
+            return false;
+        }
+        // 如果 启用事件为关闭的话就不执行事件
+        if (object["userData"] && object["userData"]["enableEvent"] === false) {
+            return false;
+        }
+        if (object["userData"] && object["userData"]["cursor"]) {
+            return true;
+        }
+    }
+    // 把命中的对象解析为事件派发目标：若命中 InstancedMesh 且属于某个 batch，
+    // 则路由到对应的 InstancedChild（逻辑实例），使实例成为透明事件接收端。
+    private resolveTarget(object: Object3D, instanceId?: number): Object3D {
+        if (object instanceof InstancedMesh && this.instancedGroup) {
+            const child = this.instancedGroup.resolveInstance(object, instanceId);
+            if (child) {
+                return child;
+            }
+        }
+        return object;
+    }
+    // 分发鼠标拾取事件
+    dispatchEvent(): void {
+        // 提取有事件的对象
+        const meshs: Object3D[] = [];
+        this._scene.traverseVisible((mesh: Object3D) => {
+            // 逻辑实例节点（InstancedChild）自身不渲染、无几何，跳过收集（命中由 InstancedMesh 路由回来）
+            if ((mesh as unknown as { userData?: { __instancedChild?: boolean } }).userData?.__instancedChild) {
+                return;
+            }
+            // 判断对象是否有指定的事件
+            if (this.hasCursor(mesh) ||
+                this.hasEvent(mesh, [
+                    "leftclick",
+                    "rightclick",
+                    "click",
+                    "dbclick",
+                    "mouseenter",
+                    "mouseleave",
+                    "mousemove",
+                    "mousedown",
+                    "mouseup",
+                ])) {
+                if (mesh instanceof Mesh &&
+                    !mesh.geometry.boundsTree &&
+                    mesh.geometry.attributes.position &&
+                    mesh.geometry.attributes.position.count > 0) {
+                    computeBoundsTree.apply(mesh.geometry);
+                    //   disposeBoundsTree.apply((mesh as Mesh).geometry);
+                }
+                meshs.push(mesh);
+            }
+        });
+        this._object3ds = meshs;
+        // 收集可拾取的 InstancedMesh（仅含注册了监听的已就绪 batch）
+        if (this.instancedGroup) {
+            this.instancedGroup.collectPickable(meshs);
+        }
+        // 没有鼠标事件就不往下执行了
+        if (!this._mousemoveEvent || !this._mouseInRenderer) {
+            return;
+        }
+        // 拾取模型
+        let intersection = this._getSelected(meshs);
+        if (intersection) {
+            const { face, object } = intersection;
+            // face && face.normal.applyMatrix4(object.matrixWorld);
+            const MouseEvent: ThreeMouseEvent = Object.assign(intersection, {
+                // 将来可能用到的对象
+                e: this._mousemoveEvent,
+                renderer: this._renderer,
+                camera: this._camera,
+                object: intersection.object,
+                type: this._mousemoveEvent.type,
+                offsetX: this._mousemoveEvent.offsetX,
+                offsetY: this._mousemoveEvent.offsetY,
+                x: this._mousemoveEvent.x,
+                y: this._mousemoveEvent.y,
+            });
+            // 命中 InstancedMesh 时，把派发目标重定向到对应的 InstancedChild
+            const _target = this.resolveTarget(intersection.object, intersection.instanceId);
+            if (_target) (MouseEvent as unknown as { object: Object3D }).object = _target;
+            // 触发滑动事件
+            if (this._mesh_on === MouseEvent.object) {
+                if (this.hasEvent(MouseEvent.object, ["mousemove"])) {
+                    MouseEvent.type = "mousemove";
+                    dispatchObjectEvent(MouseEvent.object, MouseEvent);
+                }
+                // 鼠标划入滑出事件
+            }
+            else if (this._mesh_on !== MouseEvent.object) {
+                if (this.hasEvent(this._mesh_on, ["mouseleave"])) {
+                    MouseEvent.type = "mouseleave";
+                    dispatchObjectEvent(this._mesh_on!, MouseEvent);
+                }
+                if (this.hasEvent(MouseEvent.object, ["mouseenter"])) {
+                    MouseEvent.type = "mouseenter";
+                    dispatchObjectEvent(MouseEvent.object, MouseEvent);
+                }
+            }
+            this._mesh_on = MouseEvent.object || undefined; // 设置为当前鼠标上的对象
+            // 鼠标样式
+            if (this._mesh_on &&
+                this._mesh_on.userData &&
+                this._mesh_on.userData.cursor) {
+                this._renderer.domElement.style.cursor = this._mesh_on.userData.cursor;
+            }
+            else {
+                this._renderer.domElement.style.cursor = "auto";
+            }
+        }
+        else {
+            if (this.hasEvent(this._mesh_on, ["mouseleave"])) {
+                // 鼠标离开事件
+                dispatchObjectEvent(this._mesh_on!, {
+                    e: this._mouseEvent,
+                    renderer: this._renderer,
+                    camera: this._camera,
+                    object: this._mesh_on,
+                    type: "mouseleave",
+                    offsetX: this._mousemoveEvent!.offsetX,
+                    offsetY: this._mousemoveEvent!.offsetY,
+                    x: this._mousemoveEvent!.x,
+                    y: this._mousemoveEvent!.y,
+                });
+            }
+            // 置空当前鼠标上面的对象
+            this._mesh_on = undefined;
+            this._renderer.domElement.style.cursor = "auto"; // 鼠标样式
+        }
+    }
+    // 鼠标离开事件
+    _mouseleave = (e: MouseEvent): void => {
+        this._mouseEvent = e;
+        this._mouseInRenderer = false;
+        // 鼠标离开事件
+        if (this._mousemoveEvent && this.hasEvent(this._mesh_on, ["mouseleave"])) {
+            dispatchObjectEvent(this._mesh_on!, {
+                e: this._mouseEvent,
+                renderer: this._renderer,
+                camera: this._camera,
+                object: this._mesh_on,
+                type: "mouseleave",
+                offsetX: this._mousemoveEvent.offsetX,
+                offsetY: this._mousemoveEvent.offsetY,
+                x: this._mousemoveEvent.x,
+                y: this._mousemoveEvent.y,
+            });
+        }
+        // 置空当前鼠标上面的对象
+        this._mesh_on = undefined;
+        this._renderer.domElement.style.cursor = "auto"; // 鼠标样式
+    };
+    // 鼠标滑动 设置鼠标位置
+    _mousemove = (e: MouseEvent): void => {
+        this._mousemoveEvent = e;
+        this._frame = this._renderer.info.render.frame;
+        if (document.pointerLockElement) {
+            // 如果当前有元素 锁住了鼠标
+            this._mosePosition.set(0, 0); // 鼠标就指向canvas 的正中心
+        }
+        else {
+            this._mosePosition.x = (e.offsetX / this._renderer.domElement.offsetWidth) * 2 - 1;
+            this._mosePosition.y = -(e.offsetY / this._renderer.domElement.offsetHeight) * 2 + 1;
+        }
+        this._raycaster.setFromCamera(this._mosePosition, this._camera); // 设置射线拾取的参数
+    };
+    // 鼠标按下事件
+    _mousedown = (e: PointerEvent): void => {
+        this._mouseEvent = e;
+        // 记录按下的位置
+        this._mouseDownPosition.set(e.offsetX, e.offsetY);
+        this._mousemove(e);
+        let intersection = this._getSelected(this._object3ds);
+        if (!intersection || !this._mousemoveEvent) {
+            return;
+        }
+        // 命中 InstancedMesh 时把派发目标重定向到 InstancedChild，并改写 intersection.object
+        this._mesh_Down = this._mesh_on = this.resolveTarget(intersection.object, intersection.instanceId);
+        (intersection as unknown as { object: Object3D }).object = this._mesh_Down;
+        // 触发鼠标按下事件
+        if (this.hasEvent(this._mesh_Down, ["mousedown"])) {
+            dispatchObjectEvent(this._mesh_Down, {
+                e: this._mouseEvent,
+                ...intersection,
+                renderer: this._renderer,
+                camera: this._camera,
+                object: intersection.object,
+                type: "mousedown",
+                offsetX: this._mousemoveEvent!.offsetX,
+                offsetY: this._mousemoveEvent!.offsetY,
+                x: this._mousemoveEvent!.x,
+                y: this._mousemoveEvent!.y,
+            });
+        }
+    };
+    // 鼠标弹起事件
+    _mouseup = debounce(async (e: PointerEvent) => {
+        this._mouseEvent = e;
+        // 提取有事件的对象
+        const meshs: Object3D[] = [];
+        let intersection = this._getSelected(this._object3ds);
+        if (!intersection || !this._mousemoveEvent) {
+            return;
+        }
+        // 命中 InstancedMesh 时把派发目标重定向到 InstancedChild，并改写 intersection.object
+        this._mesh_on = this.resolveTarget(intersection.object, intersection.instanceId);
+        (intersection as unknown as { object: Object3D }).object = this._mesh_on;
+        if (this.hasEvent(this._mesh_on, ["mouseup"])) {
+            dispatchObjectEvent(this._mesh_on, {
+                e: this._mouseEvent,
+                ...intersection,
+                renderer: this._renderer,
+                camera: this._camera,
+                object: intersection.object,
+                type: "mouseup",
+                offsetX: this._mousemoveEvent!.offsetX,
+                offsetY: this._mousemoveEvent!.offsetY,
+                x: this._mousemoveEvent!.x,
+                y: this._mousemoveEvent!.y,
+            });
+        }
+        // 触发鼠标弹起事件
+        if (this._mesh_Down &&
+            this._mesh_Down === this._mesh_on &&
+            Math.abs(this._mouseDownPosition.x - e.offsetX) < 5 &&
+            Math.abs(this._mouseDownPosition.y - e.offsetY) < 5) {
+            // 是否有双击事件
+            if (this.hasEvent(this._mesh_Down, ["dbclick"])) {
+                this._click_num++;
+                await new Promise((resolve) => setTimeout(resolve, 200));
+                // 只点击了一次
+                if (this._click_num === 1) {
+                    if (this.hasEvent(this._mesh_Down, ["click"])) {
+                        dispatchObjectEvent(this._mesh_Down, {
+                            e: this._mouseEvent,
+                            ...intersection,
+                            renderer: this._renderer,
+                            camera: this._camera,
+                            object: intersection.object,
+                            type: "click",
+                            offsetX: this._mousemoveEvent!.offsetX,
+                            offsetY: this._mousemoveEvent!.offsetY,
+                            x: this._mousemoveEvent!.x,
+                            y: this._mousemoveEvent!.y,
+                        });
+                    }
+                    if (this.hasEvent(this._mesh_Down, ["leftclick"]) && e.button === 0) {
+                        dispatchObjectEvent(this._mesh_Down, {
+                            e: this._mouseEvent,
+                            ...intersection,
+                            renderer: this._renderer,
+                            camera: this._camera,
+                            object: intersection.object,
+                            type: "leftclick",
+                            offsetX: this._mousemoveEvent!.offsetX,
+                            offsetY: this._mousemoveEvent!.offsetY,
+                            x: this._mousemoveEvent!.x,
+                            y: this._mousemoveEvent!.y,
+                        });
+                    }
+                    if (this.hasEvent(this._mesh_Down, ["rightclick"]) &&
+                        e.button === 2) {
+                        dispatchObjectEvent(this._mesh_Down, {
+                            e: this._mouseEvent,
+                            ...intersection,
+                            renderer: this._renderer,
+                            camera: this._camera,
+                            object: intersection.object,
+                            type: "rightclick",
+                            offsetX: this._mousemoveEvent!.offsetX,
+                            offsetY: this._mousemoveEvent!.offsetY,
+                            x: this._mousemoveEvent!.x,
+                            y: this._mousemoveEvent!.y,
+                        });
+                    }
+                }
+                else if (this._click_num > 1) {
+                    if (this.hasEvent(this._mesh_Down, ["dbclick"]) &&
+                        new Date().valueOf() - this._click_num > 1 &&
+                        e.button === 0) {
+                        dispatchObjectEvent(this._mesh_Down, {
+                            e: this._mouseEvent,
+                            ...intersection,
+                            renderer: this._renderer,
+                            camera: this._camera,
+                            object: intersection.object,
+                            type: "dbclick",
+                            offsetX: this._mousemoveEvent!.offsetX,
+                            offsetY: this._mousemoveEvent!.offsetY,
+                            x: this._mousemoveEvent!.x,
+                            y: this._mousemoveEvent!.y,
+                        });
+                    }
+                }
+            }
+            else {
+                if (this.hasEvent(this._mesh_Down, ["click"])) {
+                    dispatchObjectEvent(this._mesh_Down, {
+                        e: this._mouseEvent,
+                        ...intersection,
+                        renderer: this._renderer,
+                        camera: this._camera,
+                        object: intersection.object,
+                        type: "click",
+                        offsetX: this._mousemoveEvent!.offsetX,
+                        offsetY: this._mousemoveEvent!.offsetY,
+                        x: this._mousemoveEvent!.x,
+                        y: this._mousemoveEvent!.y,
+                    });
+                }
+                if (this.hasEvent(this._mesh_Down, ["leftclick"]) && e.button === 0) {
+                    dispatchObjectEvent(this._mesh_Down, {
+                        e: this._mouseEvent,
+                        ...intersection,
+                        renderer: this._renderer,
+                        camera: this._camera,
+                        object: intersection.object,
+                        type: "leftclick",
+                        offsetX: this._mousemoveEvent!.offsetX,
+                        offsetY: this._mousemoveEvent!.offsetY,
+                        x: this._mousemoveEvent!.x,
+                        y: this._mousemoveEvent!.y,
+                    });
+                }
+                if (this.hasEvent(this._mesh_Down, ["rightclick"]) && e.button === 2) {
+                    dispatchObjectEvent(this._mesh_Down, {
+                        e: this._mouseEvent,
+                        ...intersection,
+                        renderer: this._renderer,
+                        camera: this._camera,
+                        object: intersection.object,
+                        type: "rightclick",
+                        offsetX: this._mousemoveEvent!.offsetX,
+                        offsetY: this._mousemoveEvent!.offsetY,
+                        x: this._mousemoveEvent!.x,
+                        y: this._mousemoveEvent!.y,
+                    });
+                }
+            }
+            this._click_num = 0;
+        }
+    });
+
+    /** 设置 Points（点云）拾取阈值（世界单位），数值越大越容易点中。
+     *  全景纹理标记改用 Points 后，通过它调节点击命中范围。 */
+    setPointsThreshold(threshold: number): void {
+        this._raycaster.params.Points.threshold = threshold;
+    }
+
+    /** 移除 canvas 上的所有鼠标/指针事件监听（渲染器销毁时调用）。
+     *  注：mouseenter 为内联匿名监听，销毁时 canvas 已脱离 DOM，无需显式移除。 */
+    dispose(): void {
+        const dom = this._renderer.domElement;
+        dom.removeEventListener("mouseleave", this._mouseleave, true);
+        dom.removeEventListener("mousemove", this._mousemove, true);
+        dom.removeEventListener("pointerdown", this._mousedown, true);
+        dom.removeEventListener("pointerup", this._mouseup, true);
+    }
+}

package/Transition.d.ts

@@ -1,7 +1,7 @@
 export type TransitionParame = {
     [key: string]: number;
 };
-export default class Transition<T extends TransitionParame, K extends Extract<keyof T, string>> {
+export default class Transition<T extends TransitionParame, K extends Extract<keyof T, string> = Extract<keyof T, string>> {
     /**
      *Creates an instance of transition.
      * @param {{ [key: string]: number }} // 初始值
@@ -10,7 +10,7 @@ export default class Transition<T extends TransitionParame, K extends Extract<ke
      * @memberof transition
      */
     constructor(param: T, bezier?: [number, number, number, number], duration?: number);
-    _keys: Array<Extract<keyof T, string>>;
+    _keys: K[];
     _bezier: [number, number, number, number];
     _Xbezier: [number, number, number, number];
     _Ybezier: [number, number, number, number];
@@ -25,15 +25,20 @@ export default class Transition<T extends TransitionParame, K extends Extract<ke
     };
     private onChangeCall;
     private onDoneCall;
-    run({ timeTemp }: any): this;
-    runbindThis: any;
+    run({ timeTemp }: {
+        timeTemp: number;
+    }): this;
+    runbindThis: ((event: {
+        timeTemp: number;
+        accumulate: number;
+    }) => void);
     onChange(onChangeCall: (josn: T) => void): this;
     onDone(onDoneCall: (josn: T) => void): this;
-    get(key: Extract<keyof T, string>): T[K];
+    get(key: K): T[K];
     set(param: Partial<T>): Promise<this>;
     reset(param: Partial<T>): this;
-    getKeys(): Array<Extract<keyof T, string>>;
-    hasKey(key: Extract<keyof T, string>): boolean;
+    getKeys(): K[];
+    hasKey(key: K): boolean;
     getJson(): T;
     _isDone: boolean;
     isDone(): boolean;

package/Transition.js

@@ -47,9 +47,7 @@ export default class Transition {
     _delay = 0;
     // 设置过渡时间
     setDuration(duration = 500) {
-        setTimeout(() => {
-            this._duration = duration;
-        }, 0);
+        this._duration = duration;
         return this;
     }
     // 设置延时
@@ -87,11 +85,11 @@ export default class Transition {
     }
     // 计算当前 key 的值
     get(key) {
-        key = String(key);
-        if (this._keys.includes(key) && this.timeTemp < (this._[key + "_startTime"] + this._duration)) {
-            let start = this._[key + "_start"];
-            let end = this._[key + "_end"];
-            let timeProgress = Math.min(1, Math.max(0, (this.timeTemp - this._[key + "_startTime"]) / this._duration));
+        const keyStr = String(key);
+        if (this._keys.includes(keyStr) && this.timeTemp < (this._[`${keyStr}_startTime`] + this._duration)) {
+            let start = this._[`${keyStr}_start`];
+            let end = this._[`${keyStr}_end`];
+            let timeProgress = Math.min(1, Math.max(0, (this.timeTemp - this._[`${keyStr}_startTime`]) / this._duration));
             // 斜率
             let t = 0;
             // 微分法 求斜率t
@@ -111,36 +109,36 @@ export default class Transition {
             // 通过斜率求y值
             return (bezier(this._Ybezier, t) * (end - start)) + start;
         }
-        else if (this._keys.includes(key) && this.timeTemp >= (this._[key + "_startTime"] + this._duration)) {
-            return this._[key + "_end"];
+        else if (this._keys.includes(keyStr) && this.timeTemp >= (this._[`${keyStr}_startTime`] + this._duration)) {
+            return this._[`${keyStr}_end`];
         }
         // `没有 ${ key } 的值`;
         return 0;
     }
     async set(param) {
         let timetemp = performance.now() + this._delay;
-        ;
         for (let key in param) {
+            const keyStr = key;
             // 有就赋值
-            if (this._keys.includes(key) && Math.abs(param[key] - this._[key + "_end"]) > 0.0001) {
-                this._[key + "_start"] = this.get(key);
-                this._[key + "_end"] = param[key];
+            if (this._keys.includes(keyStr) && Math.abs(param[key] - this._[`${keyStr}_end`]) > 0.0001) {
+                this._[`${keyStr}_start`] = this.get(keyStr);
+                this._[`${keyStr}_end`] = param[key];
                 // 起始时间
-                this._[key + "_startTime"] = timetemp;
+                this._[`${keyStr}_startTime`] = timetemp;
                 // 执行状态未完成
                 this._isDone = false;
                 // 没有就添加一个
             }
-            else if (!this._keys.includes(key)) {
-                this._[key + "_start"] = param[key];
-                this._[key + "_end"] = param[key];
+            else if (!this._keys.includes(keyStr)) {
+                this._[`${keyStr}_start`] = param[key];
+                this._[`${keyStr}_end`] = param[key];
                 // 起始时间
-                this._[key + "_startTime"] = timetemp - this._duration;
+                this._[`${keyStr}_startTime`] = timetemp - this._duration;
                 // 执行状态未完成
                 this._isDone = false;
             }
-            if (!this._keys.includes(key)) {
-                this._keys.push(key);
+            if (!this._keys.includes(keyStr)) {
+                this._keys.push(keyStr);
             }
             // // 执行状态未完成
             // this._isDone = false;
@@ -156,12 +154,13 @@ export default class Transition {
     // 重置起始和终止位置
     reset(param) {
         for (let key in param) {
-            if (!this._keys.includes(key)) {
-                this._keys.push(key);
+            const keyStr = key;
+            if (!this._keys.includes(keyStr)) {
+                this._keys.push(keyStr);
             }
-            this._[key + "_start"] = param[key];
-            this._[key + "_end"] = param[key];
-            this._[key + "_startTime"] = -this._duration;
+            this._[`${keyStr}_start`] = param[key];
+            this._[`${keyStr}_end`] = param[key];
+            this._[`${keyStr}_startTime`] = -this._duration;
         }
         if (this.onChangeCall) {
             this.onChangeCall(this.getJson());
@@ -195,7 +194,7 @@ export default class Transition {
         }
         let isisDone = false;
         for (let i in this._keys) {
-            isisDone = this._[this._keys[i] + "_startTime"] + this._duration < this.timeTemp;
+            isisDone = this._[`${this._keys[i]}_startTime`] + this._duration < this.timeTemp;
             // 只要有一个没有完成 都算没有完成 过渡
             if (!isisDone) {
                 return false;