@holoscript/engine 6.0.3 → 6.0.4

package/dist/chunk-U6KMTGQJ.js

@@ -0,0 +1,632 @@
+import {
+  __export
+} from "./chunk-AKLW2MUS.js";
+
+// src/input/index.ts
+var input_exports = {};
+__export(input_exports, {
+  GestureRecognizer: () => GestureRecognizer,
+  InputBindings: () => InputBindings,
+  InputManager: () => InputManager
+});
+
+// src/input/GestureRecognizer.ts
+var _gestureSubId = 0;
+var DEFAULT_CONFIG = {
+  tapMaxDuration: 300,
+  tapMaxDistance: 10,
+  doubleTapWindow: 400,
+  longPressMinDuration: 500,
+  swipeMinDistance: 50,
+  swipeMinVelocity: 0.3,
+  pinchMinScale: 0.05
+};
+var GestureRecognizer = class {
+  config;
+  activeTouches = /* @__PURE__ */ new Map();
+  touchStarts = /* @__PURE__ */ new Map();
+  // Original positions
+  subscribers = /* @__PURE__ */ new Map();
+  lastTapTime = 0;
+  lastTapPosition = { x: 0, y: 0 };
+  longPressTimer = null;
+  gestureHistory = [];
+  initialPinchDistance = 0;
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  // ---------------------------------------------------------------------------
+  // Subscription
+  // ---------------------------------------------------------------------------
+  on(types, callback) {
+    const id = `gsub_${_gestureSubId++}`;
+    const typeArr = Array.isArray(types) ? types : [types];
+    this.subscribers.set(id, { types: typeArr, callback });
+    return id;
+  }
+  off(subscriptionId) {
+    this.subscribers.delete(subscriptionId);
+  }
+  // ---------------------------------------------------------------------------
+  // Touch Events
+  // ---------------------------------------------------------------------------
+  touchStart(id, x, y) {
+    const now = Date.now();
+    this.activeTouches.set(id, { id, x, y, timestamp: now });
+    this.touchStarts.set(id, { id, x, y, timestamp: now });
+    if (this.activeTouches.size === 1) {
+      this.longPressTimer = setTimeout(() => {
+        const touch = this.activeTouches.get(id);
+        if (touch) {
+          this.emit({
+            type: "longPress",
+            position: { x: touch.x, y: touch.y },
+            timestamp: Date.now()
+          });
+        }
+      }, this.config.longPressMinDuration);
+    }
+    if (this.activeTouches.size === 2) {
+      this.cancelLongPress();
+      const points = [...this.activeTouches.values()];
+      this.initialPinchDistance = this.distance(points[0], points[1]);
+    }
+  }
+  touchMove(id, x, y) {
+    const touch = this.activeTouches.get(id);
+    if (!touch) return;
+    const dx = x - touch.x;
+    const dy = y - touch.y;
+    if (Math.sqrt(dx * dx + dy * dy) > this.config.tapMaxDistance) {
+      this.cancelLongPress();
+    }
+    if (this.activeTouches.size === 1) {
+      this.emit({
+        type: "pan",
+        position: { x, y },
+        timestamp: Date.now(),
+        deltaX: x - touch.x,
+        deltaY: y - touch.y
+      });
+    }
+    if (this.activeTouches.size === 2) {
+      const oldX = touch.x, oldY = touch.y;
+      touch.x = x;
+      touch.y = y;
+      const points = [...this.activeTouches.values()];
+      const currentDist = this.distance(points[0], points[1]);
+      if (this.initialPinchDistance > 0) {
+        const scale = currentDist / this.initialPinchDistance;
+        if (Math.abs(scale - 1) >= this.config.pinchMinScale) {
+          this.emit({
+            type: "pinch",
+            position: {
+              x: (points[0].x + points[1].x) / 2,
+              y: (points[0].y + points[1].y) / 2
+            },
+            timestamp: Date.now(),
+            scale
+          });
+        }
+      }
+      touch.x = oldX;
+      touch.y = oldY;
+    }
+    touch.x = x;
+    touch.y = y;
+  }
+  touchEnd(id, x, y) {
+    const touch = this.activeTouches.get(id);
+    const startTouch = this.touchStarts.get(id);
+    if (!touch || !startTouch) return;
+    this.cancelLongPress();
+    const now = Date.now();
+    const duration = Math.max(1, now - startTouch.timestamp);
+    const totalDx = x - startTouch.x;
+    const totalDy = y - startTouch.y;
+    const totalDist = Math.sqrt(totalDx * totalDx + totalDy * totalDy);
+    this.activeTouches.delete(id);
+    this.touchStarts.delete(id);
+    if (totalDist >= this.config.swipeMinDistance) {
+      const velocity = totalDist / duration;
+      if (velocity >= this.config.swipeMinVelocity) {
+        this.emit({
+          type: "swipe",
+          position: { x, y },
+          timestamp: now,
+          direction: this.getSwipeDirection(totalDx, totalDy),
+          velocity,
+          distance: totalDist
+        });
+        return;
+      }
+    }
+    if (duration <= this.config.tapMaxDuration && totalDist <= this.config.tapMaxDistance) {
+      const timeSinceLastTap = now - this.lastTapTime;
+      const distFromLastTap = Math.sqrt(
+        (x - this.lastTapPosition.x) ** 2 + (y - this.lastTapPosition.y) ** 2
+      );
+      if (timeSinceLastTap <= this.config.doubleTapWindow && distFromLastTap <= this.config.tapMaxDistance * 2) {
+        this.emit({ type: "doubleTap", position: { x, y }, timestamp: now });
+        this.lastTapTime = 0;
+      } else {
+        this.emit({ type: "tap", position: { x, y }, timestamp: now });
+        this.lastTapTime = now;
+        this.lastTapPosition = { x, y };
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  emit(event) {
+    this.gestureHistory.push(event);
+    if (this.gestureHistory.length > 100) this.gestureHistory.shift();
+    for (const sub of this.subscribers.values()) {
+      if (sub.types.includes(event.type) || sub.types.includes("custom")) {
+        sub.callback(event);
+      }
+    }
+  }
+  cancelLongPress() {
+    if (this.longPressTimer) {
+      clearTimeout(this.longPressTimer);
+      this.longPressTimer = null;
+    }
+  }
+  getSwipeDirection(dx, dy) {
+    if (Math.abs(dx) > Math.abs(dy)) {
+      return dx > 0 ? "right" : "left";
+    }
+    return dy > 0 ? "down" : "up";
+  }
+  distance(a, b) {
+    return Math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2);
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getActiveTouchCount() {
+    return this.activeTouches.size;
+  }
+  getGestureHistory() {
+    return [...this.gestureHistory];
+  }
+  getRecentGestures(count) {
+    return this.gestureHistory.slice(-count);
+  }
+  clearHistory() {
+    this.gestureHistory = [];
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  setConfig(config) {
+    Object.assign(this.config, config);
+  }
+};
+
+// src/input/InputBindings.ts
+var _bindingId = 0;
+var _chordId = 0;
+var InputBindings = class {
+  profiles = /* @__PURE__ */ new Map();
+  activeProfileId = null;
+  constructor() {
+    this.createProfile("default", "Default");
+    this.activeProfileId = "default";
+    const p = this.profiles.get("default");
+    p.bindings.push({
+      id: `bind_${_bindingId++}`,
+      action: "VoicePushToTalk",
+      source: "key",
+      code: "KeyV"
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Profile Management
+  // ---------------------------------------------------------------------------
+  createProfile(id, name) {
+    const profile = { id, name, bindings: [], composites: [], chords: [] };
+    this.profiles.set(id, profile);
+    return profile;
+  }
+  deleteProfile(id) {
+    if (this.activeProfileId === id) return false;
+    return this.profiles.delete(id);
+  }
+  setActiveProfile(id) {
+    if (!this.profiles.has(id)) return false;
+    this.activeProfileId = id;
+    return true;
+  }
+  getActiveProfile() {
+    if (!this.activeProfileId) return null;
+    return this.profiles.get(this.activeProfileId) ?? null;
+  }
+  getProfile(id) {
+    return this.profiles.get(id);
+  }
+  getProfileCount() {
+    return this.profiles.size;
+  }
+  // ---------------------------------------------------------------------------
+  // Binding Management
+  // ---------------------------------------------------------------------------
+  bind(action, source, code, modifiers, scale) {
+    const profile = this.getActiveProfile();
+    if (!profile) return null;
+    const binding = {
+      id: `bind_${_bindingId++}`,
+      action,
+      source,
+      code,
+      modifiers: modifiers ?? [],
+      scale: scale ?? 1
+    };
+    profile.bindings.push(binding);
+    return binding;
+  }
+  unbind(bindingId) {
+    const profile = this.getActiveProfile();
+    if (!profile) return false;
+    const idx = profile.bindings.findIndex((b) => b.id === bindingId);
+    if (idx < 0) return false;
+    profile.bindings.splice(idx, 1);
+    return true;
+  }
+  unbindAction(action) {
+    const profile = this.getActiveProfile();
+    if (!profile) return 0;
+    const before = profile.bindings.length;
+    profile.bindings = profile.bindings.filter((b) => b.action !== action);
+    return before - profile.bindings.length;
+  }
+  getBindingsForAction(action) {
+    const profile = this.getActiveProfile();
+    if (!profile) return [];
+    return profile.bindings.filter((b) => b.action === action);
+  }
+  // ---------------------------------------------------------------------------
+  // Composite Axes
+  // ---------------------------------------------------------------------------
+  addCompositeAxis(name, positive, negative) {
+    const profile = this.getActiveProfile();
+    if (!profile) return;
+    profile.composites.push({ name, positive, negative });
+  }
+  getCompositeAxes() {
+    return this.getActiveProfile()?.composites ?? [];
+  }
+  /**
+   * Resolve a composite axis value from key states.
+   */
+  resolveComposite(name, keyStates) {
+    const profile = this.getActiveProfile();
+    if (!profile) return 0;
+    const comp = profile.composites.find((c) => c.name === name);
+    if (!comp) return 0;
+    const pos = keyStates.get(comp.positive) ? 1 : 0;
+    const neg = keyStates.get(comp.negative) ? 1 : 0;
+    return pos - neg;
+  }
+  // ---------------------------------------------------------------------------
+  // Chord Bindings
+  // ---------------------------------------------------------------------------
+  addChord(action, keys, order = "any") {
+    const profile = this.getActiveProfile();
+    const chord = { id: `chord_${_chordId++}`, action, keys, order };
+    if (profile) profile.chords.push(chord);
+    return chord;
+  }
+  isChordActive(chordId, pressedKeys) {
+    const profile = this.getActiveProfile();
+    if (!profile) return false;
+    const chord = profile.chords.find((c) => c.id === chordId);
+    if (!chord) return false;
+    return chord.keys.every((k) => pressedKeys.has(k));
+  }
+  // ---------------------------------------------------------------------------
+  // Conflict Detection
+  // ---------------------------------------------------------------------------
+  detectConflicts() {
+    const profile = this.getActiveProfile();
+    if (!profile) return [];
+    const conflicts = [];
+    const bindingMap = /* @__PURE__ */ new Map();
+    for (const b of profile.bindings) {
+      const key = `${b.source}:${b.code}:${(b.modifiers ?? []).sort().join("+")}`;
+      if (!bindingMap.has(key)) bindingMap.set(key, []);
+      bindingMap.get(key).push(b.action);
+    }
+    for (const [binding, actions] of bindingMap) {
+      if (actions.length > 1) {
+        const unique = [...new Set(actions)];
+        for (let i = 0; i < unique.length; i++) {
+          for (let j = i + 1; j < unique.length; j++) {
+            conflicts.push({
+              action1: unique[i],
+              action2: unique[j],
+              binding,
+              severity: "warning"
+            });
+          }
+        }
+      }
+    }
+    return conflicts;
+  }
+  // ---------------------------------------------------------------------------
+  // Serialization
+  // ---------------------------------------------------------------------------
+  exportProfile(profileId) {
+    const profile = profileId ? this.profiles.get(profileId) : this.getActiveProfile();
+    if (!profile) return "{}";
+    return JSON.stringify(profile, null, 2);
+  }
+  importProfile(json) {
+    try {
+      const data = JSON.parse(json);
+      if (!data.id || !data.name) return null;
+      this.profiles.set(data.id, data);
+      return data;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/input/InputManager.ts
+var InputManager = class {
+  keys = /* @__PURE__ */ new Map();
+  prevKeys = /* @__PURE__ */ new Set();
+  mouse;
+  gamepads = /* @__PURE__ */ new Map();
+  actionMappings = /* @__PURE__ */ new Map();
+  // action -> [key bindings]
+  actions = /* @__PURE__ */ new Map();
+  defaultDeadZone = 0.15;
+  inputBuffer = [];
+  bufferDuration = 200;
+  // ms
+  constructor() {
+    this.mouse = {
+      x: 0,
+      y: 0,
+      deltaX: 0,
+      deltaY: 0,
+      scrollDelta: 0,
+      buttons: /* @__PURE__ */ new Map()
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Key Input
+  // ---------------------------------------------------------------------------
+  keyDown(key) {
+    const existing = this.keys.get(key);
+    if (!existing || !existing.pressed) {
+      this.keys.set(key, {
+        pressed: true,
+        justPressed: true,
+        justReleased: false,
+        heldDuration: 0
+      });
+    }
+  }
+  keyUp(key) {
+    const existing = this.keys.get(key);
+    if (existing) {
+      existing.pressed = false;
+      existing.justReleased = true;
+    } else {
+      this.keys.set(key, {
+        pressed: false,
+        justPressed: false,
+        justReleased: true,
+        heldDuration: 0
+      });
+    }
+  }
+  isKeyPressed(key) {
+    return this.keys.get(key)?.pressed ?? false;
+  }
+  isKeyJustPressed(key) {
+    return this.keys.get(key)?.justPressed ?? false;
+  }
+  isKeyJustReleased(key) {
+    return this.keys.get(key)?.justReleased ?? false;
+  }
+  getKeyHeldDuration(key) {
+    return this.keys.get(key)?.heldDuration ?? 0;
+  }
+  // ---------------------------------------------------------------------------
+  // Mouse Input
+  // ---------------------------------------------------------------------------
+  setMousePosition(x, y) {
+    this.mouse.deltaX = x - this.mouse.x;
+    this.mouse.deltaY = y - this.mouse.y;
+    this.mouse.x = x;
+    this.mouse.y = y;
+  }
+  mouseButtonDown(button) {
+    this.mouse.buttons.set(button, {
+      pressed: true,
+      justPressed: true,
+      justReleased: false,
+      heldDuration: 0
+    });
+  }
+  mouseButtonUp(button) {
+    const existing = this.mouse.buttons.get(button);
+    if (existing) {
+      existing.pressed = false;
+      existing.justReleased = true;
+    }
+  }
+  setScrollDelta(delta) {
+    this.mouse.scrollDelta = delta;
+  }
+  getMousePosition() {
+    return { x: this.mouse.x, y: this.mouse.y };
+  }
+  getMouseDelta() {
+    return { x: this.mouse.deltaX, y: this.mouse.deltaY };
+  }
+  isMouseButtonPressed(button) {
+    return this.mouse.buttons.get(button)?.pressed ?? false;
+  }
+  // ---------------------------------------------------------------------------
+  // Gamepad Input
+  // ---------------------------------------------------------------------------
+  connectGamepad(index, id, axisCount = 4) {
+    const axes = [];
+    for (let i = 0; i < axisCount; i++) {
+      axes.push({ value: 0, deadZone: this.defaultDeadZone });
+    }
+    this.gamepads.set(index, { connected: true, id, buttons: /* @__PURE__ */ new Map(), axes });
+  }
+  disconnectGamepad(index) {
+    const gp = this.gamepads.get(index);
+    if (gp) gp.connected = false;
+  }
+  setGamepadAxis(padIndex, axisIndex, value) {
+    const gp = this.gamepads.get(padIndex);
+    if (!gp || axisIndex >= gp.axes.length) return;
+    const axis = gp.axes[axisIndex];
+    axis.value = Math.abs(value) < axis.deadZone ? 0 : value;
+  }
+  getGamepadAxis(padIndex, axisIndex) {
+    const gp = this.gamepads.get(padIndex);
+    if (!gp || axisIndex >= gp.axes.length) return 0;
+    return gp.axes[axisIndex].value;
+  }
+  gamepadButtonDown(padIndex, button) {
+    const gp = this.gamepads.get(padIndex);
+    if (!gp) return;
+    gp.buttons.set(button, {
+      pressed: true,
+      justPressed: true,
+      justReleased: false,
+      heldDuration: 0
+    });
+  }
+  setDeadZone(value) {
+    this.defaultDeadZone = Math.max(0, Math.min(1, value));
+  }
+  // ---------------------------------------------------------------------------
+  // Action Mapping
+  // ---------------------------------------------------------------------------
+  mapAction(actionName, keys) {
+    this.actionMappings.set(actionName, keys);
+    if (!this.actions.has(actionName)) {
+      this.actions.set(actionName, {
+        name: actionName,
+        value: 0,
+        pressed: false,
+        justPressed: false,
+        justReleased: false
+      });
+    }
+  }
+  unmapAction(actionName) {
+    this.actionMappings.delete(actionName);
+    this.actions.delete(actionName);
+  }
+  getAction(actionName) {
+    return this.actions.get(actionName);
+  }
+  isActionPressed(actionName) {
+    return this.actions.get(actionName)?.pressed ?? false;
+  }
+  isActionJustPressed(actionName) {
+    return this.actions.get(actionName)?.justPressed ?? false;
+  }
+  // ---------------------------------------------------------------------------
+  // Input Buffer (fighting game style)
+  // ---------------------------------------------------------------------------
+  getBufferedAction(actionName, withinMs) {
+    const cutoff = Date.now() - (withinMs ?? this.bufferDuration);
+    return this.inputBuffer.some((e) => e.action === actionName && e.timestamp >= cutoff);
+  }
+  setBufferDuration(ms) {
+    this.bufferDuration = Math.max(0, ms);
+  }
+  // ---------------------------------------------------------------------------
+  // Update (call once per frame)
+  // ---------------------------------------------------------------------------
+  update(dt) {
+    const now = Date.now();
+    for (const [_key, state] of this.keys) {
+      if (state.pressed) state.heldDuration += dt;
+      state.justPressed = false;
+      state.justReleased = false;
+    }
+    this.mouse.deltaX = 0;
+    this.mouse.deltaY = 0;
+    this.mouse.scrollDelta = 0;
+    for (const state of this.mouse.buttons.values()) {
+      state.justPressed = false;
+      state.justReleased = false;
+      if (state.pressed) state.heldDuration += dt;
+    }
+    for (const gp of this.gamepads.values()) {
+      for (const state of gp.buttons.values()) {
+        state.justPressed = false;
+        state.justReleased = false;
+        if (state.pressed) state.heldDuration += dt;
+      }
+    }
+    for (const [actionName, bindings] of this.actionMappings) {
+      const action = this.actions.get(actionName);
+      if (!action) continue;
+      const wasPressed = action.pressed;
+      let isPressed = false;
+      for (const binding of bindings) {
+        if (this.keys.get(binding)?.pressed) {
+          isPressed = true;
+          break;
+        }
+      }
+      action.pressed = isPressed;
+      action.justPressed = isPressed && !wasPressed;
+      action.justReleased = !isPressed && wasPressed;
+      action.value = isPressed ? 1 : 0;
+      if (action.justPressed) {
+        this.inputBuffer.push({ action: actionName, timestamp: now });
+      }
+    }
+    const cutoff = now - this.bufferDuration * 2;
+    this.inputBuffer = this.inputBuffer.filter((e) => e.timestamp > cutoff);
+  }
+  // ---------------------------------------------------------------------------
+  // Snapshot
+  // ---------------------------------------------------------------------------
+  getSnapshot() {
+    return {
+      timestamp: Date.now(),
+      keys: new Map(this.keys),
+      mouse: { ...this.mouse, buttons: new Map(this.mouse.buttons) },
+      gamepads: new Map(this.gamepads),
+      actions: new Map(this.actions)
+    };
+  }
+  reset() {
+    this.keys.clear();
+    this.mouse = { x: 0, y: 0, deltaX: 0, deltaY: 0, scrollDelta: 0, buttons: /* @__PURE__ */ new Map() };
+    this.gamepads.clear();
+    this.inputBuffer = [];
+    for (const action of this.actions.values()) {
+      action.pressed = false;
+      action.justPressed = false;
+      action.justReleased = false;
+      action.value = 0;
+    }
+  }
+};
+
+export {
+  GestureRecognizer,
+  InputBindings,
+  InputManager,
+  input_exports
+};