@predy-js/render-interface 0.3.4-beta.10 → 0.3.4-beta.13

package/dist/index.mjs

@@ -2,7 +2,7 @@
  * Name: @predy-js/render-interface
  * Description: undefined
  * Author: undefined
- * Version: v0.3.4-beta.10
+ * Version: v0.3.4-beta.13
  */
 
 /******************************************************************************
@@ -19,7 +19,7 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+/* global Reflect, Promise, SuppressedError, Symbol */
 
 var extendStatics = function(d, b) {
     extendStatics = Object.setPrototypeOf ||
@@ -170,6 +170,83 @@ var TextureSourceType;
 
 var GPUBufferOptionsMemoryShared = 1 << 1;
 
+var EventSystemEnv;
+(function (EventSystemEnv) {
+    EventSystemEnv[EventSystemEnv["web"] = 0] = "web";
+    EventSystemEnv[EventSystemEnv["h5"] = 1] = "h5";
+    EventSystemEnv[EventSystemEnv["rn"] = 2] = "rn";
+    EventSystemEnv[EventSystemEnv["ios"] = 3] = "ios";
+    EventSystemEnv[EventSystemEnv["android"] = 4] = "android";
+    EventSystemEnv[EventSystemEnv["harmony"] = 5] = "harmony";
+})(EventSystemEnv || (EventSystemEnv = {}));
+var RecognizerState;
+(function (RecognizerState) {
+    RecognizerState[RecognizerState["UNDETERMINED"] = 0] = "UNDETERMINED";
+    RecognizerState[RecognizerState["FAILED"] = 1] = "FAILED";
+    RecognizerState[RecognizerState["BEGAN"] = 2] = "BEGAN";
+    RecognizerState[RecognizerState["CANCELLED"] = 3] = "CANCELLED";
+    RecognizerState[RecognizerState["ACTIVE"] = 4] = "ACTIVE";
+    RecognizerState[RecognizerState["END"] = 5] = "END";
+})(RecognizerState || (RecognizerState = {}));
+var EVENT_TYPE_CLICK = 'click';
+var EVENT_TYPE_TOUCH_START = 'touchstart';
+var EVENT_TYPE_TOUCH_MOVE = 'touchmove';
+var EVENT_TYPE_TOUCH_END = 'touchend';
+var EVENT_TYPE_TOUCH_CANCEL = 'touchcancel';
+// // 扩展事件类型
+// export enum EVENT_TYPE {
+//   // 基础事件
+//   START = 'start',
+//   MOVE = 'move',
+//   END = 'end',
+//   CANCEL = 'cancel',
+//   // 手势事件
+//   PINCH_START = 'pinchstart',
+//   PINCH_MOVE = 'pinchmove',
+//   PINCH_END = 'pinchend',
+//   PINCH = 'pinch',
+//   ROTATE_START = 'rotatestart',
+//   ROTATE_MOVE = 'rotatemove',
+//   ROTATE_END = 'rotateend',
+//   ROTATE = 'rotate',
+//   PAN_START = 'panstart',
+//   PAN_MOVE = 'panmove',
+//   PAN_END = 'panend',
+//   PAN = 'pan',
+//   SWIPE = 'swipe',
+//   TAP = 'tap',
+// }
+// export type PredyGestureEventArg = {
+//   type: EVENT_TYPE,
+//   touches: PredyTouch[], // 当前所有触点
+//   center: vec2,       // 手势中心点
+//   scale?: number,     // 当前缩放比例（相对于初始）
+//   rotation?: number,  // 旋转角度（弧度，相对于初始）
+//   velocityX?: number,  // 移动速度
+//   velocityY?: number,  // 移动速度
+//   deltaX?: number,    // X轴位移
+//   deltaY?: number,    // Y轴位移
+//   timestamp: number,  // 时间戳
+//   originEvent: Event, // 原始事件
+// };
+// 方向枚举
+var GESTURE_DIRECTION;
+(function (GESTURE_DIRECTION) {
+    GESTURE_DIRECTION[GESTURE_DIRECTION["NONE"] = 0] = "NONE";
+    GESTURE_DIRECTION[GESTURE_DIRECTION["ANY"] = 1] = "ANY";
+    // 滑动方向
+    GESTURE_DIRECTION[GESTURE_DIRECTION["UP"] = 2] = "UP";
+    GESTURE_DIRECTION[GESTURE_DIRECTION["DOWN"] = 3] = "DOWN";
+    GESTURE_DIRECTION[GESTURE_DIRECTION["LEFT"] = 4] = "LEFT";
+    GESTURE_DIRECTION[GESTURE_DIRECTION["RIGHT"] = 5] = "RIGHT";
+    // 缩放方向
+    GESTURE_DIRECTION[GESTURE_DIRECTION["IN"] = 6] = "IN";
+    GESTURE_DIRECTION[GESTURE_DIRECTION["OUT"] = 7] = "OUT";
+    // 旋转方向
+    GESTURE_DIRECTION[GESTURE_DIRECTION["CLOCKWISE"] = 8] = "CLOCKWISE";
+    GESTURE_DIRECTION[GESTURE_DIRECTION["COUNTERCLOCKWISE"] = 9] = "COUNTERCLOCKWISE";
+})(GESTURE_DIRECTION || (GESTURE_DIRECTION = {}));
+
 var _a$6, _b$3;
 // @ts-expect-error safe to assign
 var constants = {};
@@ -5909,7 +5986,616 @@ var MarsSharedGeometry = /** @class */ (function (_super) {
     return MarsSharedGeometry;
 }(MarsGeometry));
 
-consoleLog('version: ' + "0.3.4-beta.10");
+var WebHandler = /** @class */ (function () {
+    function WebHandler(system) {
+        var _this = this;
+        this.system = system;
+        this.isPointerDown = false;
+        this.handleStart = function (e) {
+            _this.isPointerDown = true;
+            _this.handleEvent(EVENT_TYPE_TOUCH_START, e);
+        };
+        this.handleMove = function (e) {
+            if (_this.isPointerDown) {
+                _this.handleEvent(EVENT_TYPE_TOUCH_MOVE, e);
+            }
+        };
+        this.handleEnd = function (e) {
+            _this.handleEvent(EVENT_TYPE_TOUCH_END, e);
+            _this.isPointerDown = false;
+        };
+        this.pointers = new Map();
+        this.timeOrigin = Date.now();
+    }
+    Object.defineProperty(WebHandler.prototype, "timeStamp", {
+        get: function () {
+            return Date.now() - this.timeOrigin;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    WebHandler.prototype.setup = function () {
+        var target = this.system.target;
+        target.addEventListener('pointerdown', this.handleStart);
+        target.addEventListener('pointermove', this.handleMove);
+        target.addEventListener('pointerup', this.handleEnd);
+    };
+    WebHandler.prototype.teardown = function () {
+        var target = this.system.target;
+        target.removeEventListener('pointerdown', this.handleStart);
+        target.removeEventListener('pointermove', this.handleMove);
+        target.removeEventListener('pointerup', this.handleEnd);
+    };
+    WebHandler.prototype.getNormalizedPos = function (e) {
+        var rect = e.target.getBoundingClientRect();
+        return [
+            ((e.clientX - rect.left) / rect.width) * 2 - 1,
+            ((e.clientY - rect.top) / rect.height) * -2 + 1,
+        ];
+    };
+    WebHandler.prototype.handleEvent = function (type, e) {
+        e.preventDefault();
+        var np = this.getNormalizedPos(e);
+        var pointer = {
+            id: e.pointerId,
+            x: np[0],
+            y: np[1],
+            clientX: e.clientX,
+            clientY: e.clientY,
+            force: 1,
+            ts: this.timeStamp,
+        };
+        // 更新触点集合
+        if (type === EVENT_TYPE_TOUCH_END) {
+            this.pointers.delete(e.pointerId);
+        }
+        else {
+            this.pointers.set(e.pointerId, pointer);
+        }
+        // 封装基础事件
+        var event = {
+            type: type,
+            timestamp: this.timeStamp,
+            target: e.target,
+            touches: Array.from(this.pointers.values()),
+            changedTouches: [pointer],
+            preventDefault: function () { return e.preventDefault(); },
+            stopPropagation: function () { return e.stopPropagation(); },
+            nativeEvent: e,
+        };
+        this.system.handleBaseEvent(event);
+    };
+    return WebHandler;
+}());
+
+var RNHandler = /** @class */ (function () {
+    function RNHandler(system) {
+        this.system = system;
+        this.timeOrigin = Date.now();
+    }
+    Object.defineProperty(RNHandler.prototype, "timeStamp", {
+        get: function () {
+            return Date.now() - this.timeOrigin;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RNHandler.prototype.setup = function () {
+        throw new Error('Method not implemented.');
+    };
+    RNHandler.prototype.teardown = function () {
+        throw new Error('Method not implemented.');
+    };
+    return RNHandler;
+}());
+
+var H5Handler = /** @class */ (function () {
+    function H5Handler(system) {
+        var _this = this;
+        this.system = system;
+        this.handleTouch = function (type, e) {
+            e.preventDefault();
+            // 封装基础事件
+            var event = {
+                type: type,
+                timestamp: _this.timeStamp,
+                target: e.target,
+                touches: _this.encapsulate(e.targetTouches),
+                changedTouches: _this.encapsulate(e.changedTouches),
+                preventDefault: function () { return e.preventDefault(); },
+                stopPropagation: function () { return e.stopPropagation(); },
+                nativeEvent: e,
+            };
+            _this.system.handleBaseEvent(event);
+        };
+        this.handleStart = function (e) { return _this.handleTouch(EVENT_TYPE_TOUCH_START, e); };
+        this.handleMove = function (e) { return _this.handleTouch(EVENT_TYPE_TOUCH_MOVE, e); };
+        this.handleEnd = function (e) { return _this.handleTouch(EVENT_TYPE_TOUCH_END, e); };
+        this.timeOrigin = Date.now();
+    }
+    Object.defineProperty(H5Handler.prototype, "timeStamp", {
+        get: function () {
+            return Date.now() - this.timeOrigin;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    H5Handler.prototype.setup = function () {
+        var target = this.system.target;
+        target.addEventListener('touchstart', this.handleStart);
+        target.addEventListener('touchmove', this.handleMove);
+        target.addEventListener('touchend', this.handleEnd);
+        target.addEventListener('touchcancel', this.handleEnd);
+    };
+    H5Handler.prototype.teardown = function () {
+        var target = this.system.target;
+        target.removeEventListener('touchstart', this.handleStart);
+        target.removeEventListener('touchmove', this.handleMove);
+        target.removeEventListener('touchend', this.handleEnd);
+        target.removeEventListener('touchcancel', this.handleEnd);
+    };
+    H5Handler.prototype.getNormalizedPos = function (e) {
+        var rect = e.target.getBoundingClientRect();
+        return [
+            ((e.clientX - rect.left) / rect.width) * 2 - 1,
+            ((e.clientY - rect.top) / rect.height) * -2 + 1,
+        ];
+    };
+    H5Handler.prototype.encapsulate = function (list) {
+        var touches = [];
+        for (var i = 0; i < list.length; i++) {
+            var touch = list[i];
+            var _a = this.getNormalizedPos(touch), x = _a[0], y = _a[1];
+            touches.push({
+                id: touch.identifier,
+                x: x,
+                y: y,
+                clientX: touch.clientX,
+                clientY: touch.clientY,
+                force: 1,
+                ts: this.timeStamp,
+            });
+        }
+        return touches;
+    };
+    return H5Handler;
+}());
+
+var PredyEventSystem = /** @class */ (function () {
+    function PredyEventSystem(target, env) {
+        this._handlerMap = new Map();
+        this._enabled = true;
+        this.target = target;
+        this._platformHandler = this.createPlatformHandler(env);
+        this._platformHandler.setup();
+        this.setRecognizer(new BaseRecognizer());
+    }
+    Object.defineProperty(PredyEventSystem.prototype, "enabled", {
+        get: function () {
+            return this._enabled;
+        },
+        set: function (value) {
+            this._enabled = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PredyEventSystem.prototype.createPlatformHandler = function (env) {
+        switch (env) {
+            case EventSystemEnv.web:
+                return new WebHandler(this);
+            case EventSystemEnv.rn:
+                return new RNHandler(this);
+            case EventSystemEnv.h5:
+                return new H5Handler(this);
+            default:
+                throw new Error("Unsupported platform ".concat(env));
+        }
+    };
+    PredyEventSystem.prototype.setRecognizer = function (recognizer) {
+        recognizer._callback = this.dispatch.bind(this);
+        this.recognizer = recognizer;
+    };
+    // 事件分发入口
+    PredyEventSystem.prototype.handleBaseEvent = function (event) {
+        if (!this.enabled) {
+            return;
+        }
+        // 识别手势
+        var gestureType = this.recognizer.detect(event);
+        if (gestureType) {
+            this.dispatch(gestureType, event);
+        }
+        if (event.touches.length === 0) {
+            this.recognizer.reset();
+        }
+    };
+    PredyEventSystem.prototype.dispatch = function (type, event) {
+        var _a;
+        (_a = this._handlerMap.get(type)) === null || _a === void 0 ? void 0 : _a.forEach(function (fn) { return fn(event); });
+    };
+    PredyEventSystem.prototype.addEventListener = function (type, handler) {
+        var _this = this;
+        var set = this._handlerMap.get(type) || new Set();
+        set.add(handler);
+        this._handlerMap.set(type, set);
+        return function () { return _this.removeEventListener(type, handler); };
+    };
+    PredyEventSystem.prototype.removeEventListener = function (type, handler) {
+        var _a;
+        (_a = this._handlerMap.get(type)) === null || _a === void 0 ? void 0 : _a.delete(handler);
+    };
+    PredyEventSystem.prototype.destroy = function () {
+        this._platformHandler.teardown();
+        this._handlerMap.clear();
+    };
+    return PredyEventSystem;
+}());
+var BaseRecognizer = /** @class */ (function () {
+    function BaseRecognizer() {
+    }
+    BaseRecognizer.prototype.detect = function (event) {
+        return event.type;
+    };
+    BaseRecognizer.prototype.reset = function () { };
+    return BaseRecognizer;
+}());
+
+var UniversalRecognizer = /** @class */ (function () {
+    function UniversalRecognizer(options) {
+        this._state = RecognizerState.UNDETERMINED;
+        this.trackedTouches = new Map(); // 跟踪所有触点
+        this.gestureStartTime = 0;
+        this.startPositions = [];
+        this.lastEventTs = 0;
+        // 缩放/旋转专用缓存
+        this.initialCenter = [0, 0];
+        this.validateOptions(options);
+        this.options = options;
+    }
+    Object.defineProperty(UniversalRecognizer.prototype, "state", {
+        get: function () {
+            return this._state;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    UniversalRecognizer.prototype.detect = function (event) {
+        this.lastEventTs = event.timestamp;
+        switch (event.type) {
+            case 'touchstart':
+                return this.handleStart(event);
+            case 'touchmove':
+                return this.handleMove(event);
+            case 'touchend':
+            case 'touchcancel':
+                return this.handleEnd(event);
+        }
+    };
+    UniversalRecognizer.prototype.trigger = function (event) {
+        var _a;
+        var type = this.getGestureName();
+        (_a = this._callback) === null || _a === void 0 ? void 0 : _a.call(this, type, event);
+    };
+    UniversalRecognizer.prototype.handleStart = function (event) {
+        var _this = this;
+        if (this.state !== RecognizerState.UNDETERMINED) {
+            return;
+        }
+        // 验证触点数量
+        if (event.touches.length !== this.options.touchCount) {
+            this.reset();
+            return;
+        }
+        // 初始化跟踪数据
+        this.gestureStartTime = event.timestamp;
+        this.trackedTouches.clear();
+        event.touches.forEach(function (t) { return _this.trackedTouches.set(t.id, t); });
+        this.startPositions = event.touches.map(function (t) { return [t.clientX, t.clientY]; });
+        // 初始化多指手势数据
+        if (this.options.touchCount > 1) {
+            this.initialCenter = this.calculateCenter(event.touches);
+        }
+        this.setState(RecognizerState.BEGAN);
+        return this.getGestureName('start');
+    };
+    UniversalRecognizer.prototype.handleMove = function (event) {
+        if (![RecognizerState.BEGAN, RecognizerState.ACTIVE].includes(this.state)) {
+            return;
+        }
+        // 验证触点数量一致性
+        if (event.touches.length !== this.options.touchCount) {
+            this.reset();
+            return;
+        }
+        // 核心验证逻辑
+        if (!this.validateGesture(event)) {
+            this.handleFailure();
+            return;
+        }
+        // 更新状态为持续活动
+        if (this.state === RecognizerState.BEGAN) {
+            this.setState(RecognizerState.ACTIVE);
+            // return this.getGestureName('start');
+        }
+        return this.getGestureName('move');
+    };
+    UniversalRecognizer.prototype.handleEnd = function (event) {
+        if (![RecognizerState.BEGAN, RecognizerState.ACTIVE].includes(this.state)) {
+            return;
+        }
+        // 最终验证（例如点击的持续时间）
+        var isValid = this.validateFinalConditions(event);
+        if (isValid) {
+            this.setState(RecognizerState.END);
+            if (this.validateThreshold(event)) {
+                this.trigger(event);
+            }
+            return this.getGestureName('end');
+        }
+        else {
+            this.handleFailure();
+        }
+    };
+    /**
+     * 手势识别核心算法
+     */
+    UniversalRecognizer.prototype.validateGesture = function (event) {
+        // 基础验证
+        if (!this.validateTouchCount(event)) {
+            return false;
+        }
+        if (!this.validateDuration(event)) {
+            return false;
+        }
+        if (!this.validateDistance(event)) {
+            return false;
+        }
+        // 方向/路径验证
+        if (this.options.direction !== undefined) {
+            if (!this.validateDirection(event)) {
+                return false;
+            }
+        }
+        // 高级手势验证
+        return true;
+    };
+    UniversalRecognizer.prototype.validateTouchCount = function (event) {
+        return event.touches.length === this.options.touchCount;
+    };
+    UniversalRecognizer.prototype.validateDuration = function (event) {
+        var duration = event.timestamp - this.gestureStartTime;
+        if (this.options.minDuration && duration < this.options.minDuration) {
+            return false;
+        }
+        if (this.options.maxDuration && duration > this.options.maxDuration) {
+            return false;
+        }
+        return true;
+    };
+    UniversalRecognizer.prototype.validateDistance = function (event) {
+        var currentCenter = this.calculateCenter(event.touches);
+        var startCenter = [0, 0];
+        this.startPositions.forEach(function (pos) {
+            startCenter[0] += pos[0];
+            startCenter[1] += pos[1];
+        });
+        startCenter[0] /= this.startPositions.length;
+        startCenter[1] /= this.startPositions.length;
+        var distance = Math.hypot(currentCenter[0] - startCenter[0], currentCenter[1] - startCenter[1]);
+        if (this.options.minDistance && distance < this.options.minDistance) {
+            return false;
+        }
+        if (this.options.maxDistance && distance > this.options.maxDistance) {
+            return false;
+        }
+        return true;
+    };
+    UniversalRecognizer.prototype.validateDirection = function (event) {
+        return true;
+    };
+    UniversalRecognizer.prototype.validateThreshold = function (event) {
+        var delta = this.calculateOverallDelta(event);
+        switch (this.options.direction) {
+            case GESTURE_DIRECTION.LEFT:
+                return delta[0] < -this.options.minDistance;
+            case GESTURE_DIRECTION.RIGHT:
+                return delta[0] > this.options.minDistance;
+            case GESTURE_DIRECTION.UP:
+                return delta[1] < -this.options.minDistance;
+            case GESTURE_DIRECTION.DOWN:
+                return delta[1] > this.options.minDistance;
+            case GESTURE_DIRECTION.IN:
+                return this.calculateScale(event.touches) < (1 - this.options.scaleThreshold);
+            case GESTURE_DIRECTION.OUT:
+                return this.calculateScale(event.touches) > (1 + this.options.scaleThreshold);
+            case GESTURE_DIRECTION.CLOCKWISE:
+                return this.calculateRotation(event.touches) > this.options.rotationThreshold;
+            case GESTURE_DIRECTION.COUNTERCLOCKWISE:
+                return this.calculateRotation(event.touches) < -this.options.rotationThreshold;
+            default:
+                return true;
+        }
+    };
+    UniversalRecognizer.prototype.validateFinalConditions = function (event) {
+        // 验证时间区间
+        var duration = event.timestamp - this.gestureStartTime;
+        if (this.options.minDuration && duration < this.options.minDuration) {
+            return false;
+        }
+        if (this.options.maxDuration && duration > this.options.maxDuration) {
+            return false;
+        }
+        // 验证点击次数（需要外部状态管理）
+        // 此处需要结合外部计数器实现双击等逻辑
+        return true;
+    };
+    UniversalRecognizer.prototype.calculateOverallDelta = function (event) {
+        var _this = this;
+        // 计算多点触控的平均移动量
+        var totalDelta = [0, 0];
+        event.touches.forEach(function (t, idx) {
+            totalDelta[0] += t.clientX - _this.startPositions[idx][0];
+            totalDelta[1] += t.clientY - _this.startPositions[idx][1];
+        });
+        return [totalDelta[0] / event.touches.length, totalDelta[1] / event.touches.length];
+    };
+    /**
+     * 计算聚合缩放比例（基于各触点到中心点的距离变化）
+     */
+    UniversalRecognizer.prototype.calculateScale = function (touches) {
+        var _this = this;
+        var currentCentroid = this.calculateCenter(touches);
+        // 计算所有触点到中心点的平均距离
+        var currentDistances = touches.map(function (t) {
+            return Math.hypot(t.clientX - currentCentroid[0], t.clientY - currentCentroid[1]);
+        });
+        var currentAvgDistance = currentDistances.reduce(function (a, b) { return a + b; }) / touches.length;
+        // 初始平均距离（从startPositions计算）
+        var initialDistances = this.startPositions.map(function (pos) {
+            return Math.hypot(pos[0] - _this.initialCenter[0], pos[1] - _this.initialCenter[1]);
+        });
+        var initialAvgDistance = initialDistances.reduce(function (a, b) { return a + b; }) / touches.length;
+        return initialAvgDistance > 0 ? currentAvgDistance / initialAvgDistance : 1;
+    };
+    /**
+     * 计算聚合旋转角度（基于各触点相对于中心点的角度变化）
+     */
+    UniversalRecognizer.prototype.calculateRotation = function (touches) {
+        var _this = this;
+        var currentCentroid = this.calculateCenter(touches);
+        var totalAngleChange = 0;
+        touches.forEach(function (t, index) {
+            // 当前触点角度
+            var currentAngle = Math.atan2(t.clientY - currentCentroid[1], t.clientX - currentCentroid[0]);
+            // 初始触点角度
+            var initialPos = _this.startPositions[index];
+            var initialAngle = Math.atan2(initialPos[1] - _this.initialCenter[1], initialPos[0] - _this.initialCenter[0]);
+            // 累加角度变化（处理360°边界）
+            var angleChange = currentAngle - initialAngle;
+            if (angleChange > Math.PI) {
+                angleChange -= 2 * Math.PI;
+            }
+            if (angleChange < -Math.PI) {
+                angleChange += 2 * Math.PI;
+            }
+            totalAngleChange += angleChange;
+        });
+        // 转换为角度制并返回平均值
+        return (totalAngleChange * 180 / Math.PI) / touches.length;
+    };
+    // 工具方法
+    UniversalRecognizer.prototype.calculateCenter = function (touchList) {
+        var pointersLength = touchList.length;
+        if (pointersLength === 1) {
+            return [touchList[0].clientX, touchList[0].clientY];
+        }
+        var x = 0;
+        var y = 0;
+        var i = 0;
+        while (i < pointersLength) {
+            x += touchList[i].clientX;
+            y += touchList[i].clientY;
+            i++;
+        }
+        return [x / pointersLength, y / pointersLength];
+    };
+    UniversalRecognizer.prototype.getGestureName = function (phase) {
+        return phase ? "".concat(this.options.name).concat(phase) : this.options.name;
+    };
+    UniversalRecognizer.prototype.handleFailure = function () {
+        this.setState(RecognizerState.FAILED);
+        this.reset();
+    };
+    /**
+     * 重置所有状态
+     */
+    UniversalRecognizer.prototype.reset = function () {
+        this.trackedTouches.clear();
+        this.startPositions = [];
+        this.setState(RecognizerState.UNDETERMINED);
+    };
+    UniversalRecognizer.prototype.setState = function (s) {
+        this._state = s;
+    };
+    /**
+     * 验证选项合规性，抛出详细错误信息
+     */
+    UniversalRecognizer.prototype.validateOptions = function (options) {
+        var errors = [];
+        // 1. 基础必填字段检查
+        if (!options.name || typeof options.name !== 'string') {
+            errors.push('Missing or invalid `name`: must be a non-empty string');
+        }
+        if (typeof options.touchCount !== 'number' ||
+            options.touchCount < 1 ||
+            options.touchCount > 5 ||
+            !Number.isInteger(options.touchCount)) {
+            errors.push('Invalid `touchCount`: must be an integer of [1, 5]');
+        }
+        // 2. 方向相关检查
+        if (options.direction !== undefined) {
+            if (!Object.values(GESTURE_DIRECTION).includes(options.direction)) {
+                errors.push("Invalid `moveDirection`: ".concat(options.direction, " is not a valid GESTURE_DIRECTION enum"));
+            }
+            // 当方向为NONE时，必须检查点击次数
+            if (options.direction === GESTURE_DIRECTION.NONE) {
+                if (options.clickCount === undefined) {
+                    errors.push('Missing `clickCount` when direction is NONE');
+                }
+                else if (typeof options.clickCount !== 'number' || options.clickCount < 1) {
+                    errors.push('Invalid `clickCount`: must be a positive integer');
+                }
+            }
+        }
+        // 3. 时间区间检查
+        this.validateRange('duration', options.minDuration, options.maxDuration, 'Time duration range invalid', errors);
+        // 4. 距离区间检查
+        this.validateRange('distance', options.minDistance, options.maxDistance, 'Distance range invalid', errors);
+        // 5. 高级参数检查
+        if (options.scaleThreshold !== undefined) {
+            if (options.touchCount < 2) {
+                errors.push('`scaleThreshold` requires touchCount>=2');
+            }
+            else if (options.scaleThreshold <= 0) {
+                errors.push('`scaleThreshold` must be positive');
+            }
+        }
+        if (options.rotationThreshold !== undefined) {
+            if (options.touchCount < 2) {
+                errors.push('`rotationThreshold` requires touchCount>=2');
+            }
+            else if (options.rotationThreshold <= 0) {
+                errors.push('`rotationThreshold` must be positive');
+            }
+        }
+        // 6. 互斥参数检查
+        if (options.direction !== undefined && options.customPath !== undefined) {
+            errors.push('`moveDirection` and `customPath` cannot coexist');
+        }
+        // 抛出所有错误
+        if (errors.length > 0) {
+            throw new Error("Invalid options for \"".concat(options.name, "\":\n- ").concat(errors.join('\n- ')));
+        }
+    };
+    /**
+     * 通用区间验证工具
+     */
+    UniversalRecognizer.prototype.validateRange = function (field, min, max, errorMsg, errors) {
+        if (min !== undefined && min < 0) {
+            errors.push("Invalid `min".concat(field, "`: must be non-negative"));
+        }
+        if (max !== undefined && max < 0) {
+            errors.push("Invalid `max".concat(field, "`: must be non-negative"));
+        }
+        if (min !== undefined && max !== undefined && min > max) {
+            errors.push("".concat(errorMsg, ": min (").concat(min, ") > max (").concat(max, ")"));
+        }
+    };
+    return UniversalRecognizer;
+}());
+
+consoleLog('version: ' + "0.3.4-beta.13");
 var ModuleMsg = 'RI Package: @predy-js/render-interface';
 
 var RI = /*#__PURE__*/Object.freeze({
@@ -5930,6 +6616,8 @@ var RI = /*#__PURE__*/Object.freeze({
     getDefaultTextureFactory: getDefaultTextureFactory,
     setDefaultTextureFactory: setDefaultTextureFactory,
     MarsTextureFactory: MarsTextureFactory,
+    EventSystem: PredyEventSystem,
+    PredyUniversalRecognizer: UniversalRecognizer,
     get DestroyOptions () { return DestroyOptions; },
     get PredyTextEncoding () { return PredyTextEncoding; },
     get PredyVideoCodec () { return PredyVideoCodec; },
@@ -5944,6 +6632,14 @@ var RI = /*#__PURE__*/Object.freeze({
     get RenderPassMeshOrder () { return RenderPassMeshOrder; },
     get TextureSourceType () { return TextureSourceType; },
     GPUBufferOptionsMemoryShared: GPUBufferOptionsMemoryShared,
+    get EventSystemEnv () { return EventSystemEnv; },
+    get RecognizerState () { return RecognizerState; },
+    EVENT_TYPE_CLICK: EVENT_TYPE_CLICK,
+    EVENT_TYPE_TOUCH_START: EVENT_TYPE_TOUCH_START,
+    EVENT_TYPE_TOUCH_MOVE: EVENT_TYPE_TOUCH_MOVE,
+    EVENT_TYPE_TOUCH_END: EVENT_TYPE_TOUCH_END,
+    EVENT_TYPE_TOUCH_CANCEL: EVENT_TYPE_TOUCH_CANCEL,
+    get GESTURE_DIRECTION () { return GESTURE_DIRECTION; },
     get ShaderCompileResultStatus () { return ShaderCompileResultStatus; },
     ShaderLibraryEmpty: ShaderLibraryEmpty
 });
@@ -5955,5 +6651,5 @@ else if (typeof global === 'object') {
     global.PredyRI = RI;
 }
 
-export { DestroyOptions, GPUBufferOptionsMemoryShared, MarsGeometry as Geometry, MarsInstancedMesh as InstancedMesh, MarsTextureFactory, MarsMaterial as Material, MarsMaterialDataBlock as MaterialDataBlock, MarsMesh as Mesh, ModuleMsg, PredyResourceCacheStatus, PredyTextEncoding, PredyVideoCodec, MarsRenderFrame as RenderFrame, MarsRenderPass as RenderPass, RenderPassAttachmentStorageType, RenderPassDestroyAttachmentType, RenderPassMeshOrder, RenderPassPriorityNormal, RenderPassPriorityPostprocess, RenderPassPriorityPrepare, MarsRenderer as Renderer, ShaderCompileResultStatus, ShaderLibraryEmpty, MarsSharedGeometry as SharedGeometry, MarsTexture as Texture, TextureLoadAction, TextureSourceType, TextureStoreAction, constants, getDefaultGPUCapability, getDefaultTextureFactory, setDefaultTextureFactory };
+export { DestroyOptions, EVENT_TYPE_CLICK, EVENT_TYPE_TOUCH_CANCEL, EVENT_TYPE_TOUCH_END, EVENT_TYPE_TOUCH_MOVE, EVENT_TYPE_TOUCH_START, PredyEventSystem as EventSystem, EventSystemEnv, GESTURE_DIRECTION, GPUBufferOptionsMemoryShared, MarsGeometry as Geometry, MarsInstancedMesh as InstancedMesh, MarsTextureFactory, MarsMaterial as Material, MarsMaterialDataBlock as MaterialDataBlock, MarsMesh as Mesh, ModuleMsg, PredyResourceCacheStatus, PredyTextEncoding, UniversalRecognizer as PredyUniversalRecognizer, PredyVideoCodec, RecognizerState, MarsRenderFrame as RenderFrame, MarsRenderPass as RenderPass, RenderPassAttachmentStorageType, RenderPassDestroyAttachmentType, RenderPassMeshOrder, RenderPassPriorityNormal, RenderPassPriorityPostprocess, RenderPassPriorityPrepare, MarsRenderer as Renderer, ShaderCompileResultStatus, ShaderLibraryEmpty, MarsSharedGeometry as SharedGeometry, MarsTexture as Texture, TextureLoadAction, TextureSourceType, TextureStoreAction, constants, getDefaultGPUCapability, getDefaultTextureFactory, setDefaultTextureFactory };
 //# sourceMappingURL=index.mjs.map