@aura3d/input 1.4.0 → 1.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aura3d/input",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "type": "module",
   "exports": {
     ".": {
@@ -11,7 +11,39 @@
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "dependencies": {
-    "@aura3d/math": "1.4.0",
-    "@aura3d/scene": "1.4.0"
-  }
+    "@aura3d/math": "1.4.2",
+    "@aura3d/scene": "1.4.2"
+  },
+  "description": "Keyboard, pointer, gamepad, gesture, action-map, picking-ray, interaction, and camera-control runtime contracts for Aura3D.",
+  "keywords": [
+    "aura3d",
+    "3d",
+    "browser-3d",
+    "web-3d",
+    "typescript",
+    "input",
+    "keyboard",
+    "pointer",
+    "gamepad",
+    "gestures",
+    "action-map",
+    "camera-controls"
+  ],
+  "homepage": "https://aura3d.auraone.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/auraoneai/aura3d.git",
+    "directory": "packages/input"
+  },
+  "bugs": {
+    "url": "https://github.com/auraoneai/aura3d/issues"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "README.md",
+    "dist"
+  ]
 }

package/src/ActionMap.ts

@@ -1,94 +0,0 @@
-import { InputSnapshot } from "./InputSnapshot";
-
-export type ActionBinding =
-  | { readonly type: "keyboard"; readonly code: string }
-  | { readonly type: "keyboard-chord"; readonly codes: readonly string[] }
-  | { readonly type: "pointer"; readonly button: number }
-  | { readonly type: "gamepad-button"; readonly gamepad?: number; readonly button: number };
-
-export type AxisBinding =
-  | { readonly type: "keyboard-axis"; readonly negative: string; readonly positive: string; readonly scale?: number }
-  | { readonly type: "pointer-axis"; readonly axis: "x" | "y" | "wheelX" | "wheelY"; readonly scale?: number }
-  | { readonly type: "gamepad-axis"; readonly gamepad?: number; readonly axis: number; readonly scale?: number };
-
-export class ActionMap {
-  private readonly actions = new Map<string, readonly ActionBinding[]>();
-  private readonly axes = new Map<string, readonly AxisBinding[]>();
-  private snapshot = new InputSnapshot();
-
-  bind(name: string, bindings: readonly ActionBinding[]): void {
-    this.actions.set(name, [...bindings]);
-  }
-
-  bindAxis(name: string, bindings: readonly AxisBinding[]): void {
-    this.axes.set(name, [...bindings]);
-  }
-
-  useSnapshot(snapshot: InputSnapshot): void {
-    this.snapshot = snapshot;
-  }
-
-  down(name: string, snapshot = this.snapshot): boolean {
-    return this.evaluate(name, snapshot, "down");
-  }
-
-  pressed(name: string, snapshot = this.snapshot): boolean {
-    return this.evaluate(name, snapshot, "pressed");
-  }
-
-  released(name: string, snapshot = this.snapshot): boolean {
-    return this.evaluate(name, snapshot, "released");
-  }
-
-  axis(name: string, snapshot = this.snapshot): number {
-    let value = 0;
-
-    for (const binding of this.axes.get(name) ?? []) {
-      const scale = binding.scale ?? 1;
-      if (binding.type === "keyboard-axis") {
-        value += (snapshot.key(binding.positive).down ? 1 : 0) * scale;
-        value -= (snapshot.key(binding.negative).down ? 1 : 0) * scale;
-      } else if (binding.type === "pointer-axis") {
-        const pointerValue =
-          binding.axis === "x"
-            ? snapshot.pointer.deltaX
-            : binding.axis === "y"
-              ? snapshot.pointer.deltaY
-              : snapshot.pointer[binding.axis];
-        value += pointerValue * scale;
-      } else {
-        const gamepad = snapshot.gamepads.find((pad) => pad.index === (binding.gamepad ?? 0));
-        value += (gamepad?.axes[binding.axis] ?? 0) * scale;
-      }
-    }
-
-    return value;
-  }
-
-  private evaluate(name: string, snapshot: InputSnapshot, field: "down" | "pressed" | "released"): boolean {
-    return (this.actions.get(name) ?? []).some((binding) => {
-      if (binding.type === "keyboard") {
-        return snapshot.key(binding.code)[field];
-      }
-      if (binding.type === "keyboard-chord") {
-        return evaluateChord(binding.codes, snapshot, field);
-      }
-      if (binding.type === "pointer") {
-        return snapshot.button(binding.button)[field];
-      }
-      return snapshot.gamepadButton(binding.gamepad ?? 0, binding.button)[field];
-    });
-  }
-}
-
-function evaluateChord(codes: readonly string[], snapshot: InputSnapshot, field: "down" | "pressed" | "released"): boolean {
-  if (codes.length === 0) return false;
-  const states = codes.map((code) => snapshot.key(code));
-  if (field === "down") {
-    return states.every((state) => state.down);
-  }
-  if (field === "pressed") {
-    return states.every((state) => state.down) && states.some((state) => state.pressed);
-  }
-  return states.some((state) => state.released);
-}

package/src/GamepadDevice.ts

@@ -1,48 +0,0 @@
-import type { ButtonState, GamepadSnapshot } from "./InputSnapshot";
-
-export interface GamepadButtonLike {
-  readonly pressed: boolean;
-  readonly value: number;
-}
-
-export interface GamepadLike {
-  readonly id: string;
-  readonly index: number;
-  readonly connected: boolean;
-  readonly axes: readonly number[];
-  readonly buttons: readonly GamepadButtonLike[];
-}
-
-export class GamepadDevice {
-  private previousButtons = new Map<string, readonly boolean[]>();
-
-  poll(gamepads: readonly (GamepadLike | null | undefined)[], deadZone = 0.1): readonly GamepadSnapshot[] {
-    const snapshots: GamepadSnapshot[] = [];
-
-    for (const gamepad of gamepads) {
-      if (!gamepad?.connected) {
-        continue;
-      }
-
-      const key = `${gamepad.index}:${gamepad.id}`;
-      const previous = this.previousButtons.get(key) ?? [];
-      const buttons: ButtonState[] = gamepad.buttons.map((button, index) => {
-        const down = button.pressed || button.value > 0.5;
-        const wasDown = previous[index] ?? false;
-        return Object.freeze({ down, pressed: down && !wasDown, released: !down && wasDown });
-      });
-
-      snapshots.push(
-        Object.freeze({
-          id: gamepad.id,
-          index: gamepad.index,
-          axes: Object.freeze(gamepad.axes.map((axis) => (Math.abs(axis) < deadZone ? 0 : axis))),
-          buttons: Object.freeze(buttons)
-        })
-      );
-      this.previousButtons.set(key, buttons.map((button) => button.down));
-    }
-
-    return snapshots;
-  }
-}

package/src/GamepadInput.ts

@@ -1,2 +0,0 @@
-export { GamepadDevice as GamepadInput } from "./GamepadDevice";
-export type { GamepadButtonLike, GamepadLike } from "./GamepadDevice";

package/src/GestureControls.ts

@@ -1,2 +0,0 @@
-export { GestureRecognizer as GestureControls } from "./GestureRecognizer";
-export type { Gesture } from "./GestureRecognizer";

package/src/GestureHapticsFixtures.ts

@@ -1,179 +0,0 @@
-export type GestureHapticsGestureType = "tap" | "pan" | "pinch" | "swipe" | "rotate";
-export type GestureHapticsPatternName = "tap" | "impact" | "damage" | "success" | "engine";
-
-export interface GestureHapticsFixtureOptions {
-  readonly seed?: number;
-  readonly pointerDeltaX?: number;
-  readonly pointerDeltaY?: number;
-  readonly pinchStartDistance?: number;
-  readonly pinchEndDistance?: number;
-  readonly rotateDegrees?: number;
-  readonly gamepadConnected?: boolean;
-}
-
-export interface GestureHapticsFixture {
-  readonly source: "origin-master-input-gesture-rumble-adapted";
-  readonly gestures: readonly {
-    readonly type: GestureHapticsGestureType;
-    readonly state: "possible" | "began" | "changed" | "ended";
-    readonly touchCount: number;
-    readonly center: readonly [number, number];
-    readonly distance?: number;
-    readonly velocity?: readonly [number, number];
-    readonly scale?: number;
-    readonly rotationDegrees?: number;
-  }[];
-  readonly gestureSummary: {
-    readonly tapDetected: boolean;
-    readonly panDistance: number;
-    readonly pinchScale: number;
-    readonly swipeDirection: "left" | "right" | "up" | "down";
-    readonly rotateDegrees: number;
-  };
-  readonly haptics: {
-    readonly gamepadConnected: boolean;
-    readonly hapticsClaimed: false;
-    readonly patterns: readonly {
-      readonly name: GestureHapticsPatternName;
-      readonly steps: number;
-      readonly totalDurationMs: number;
-      readonly peakWeak: number;
-      readonly peakStrong: number;
-      readonly loop: boolean;
-    }[];
-    readonly queuedPatterns: number;
-    readonly totalDurationMs: number;
-    readonly intensityMultiplier: number;
-  };
-  readonly productionReadiness: {
-    readonly gestureTelemetry: true;
-    readonly swipeRotateTelemetry: true;
-    readonly hapticPatternTelemetry: true;
-    readonly hapticClaimBoundaryTelemetry: true;
-  };
-  readonly blockedClaims: readonly string[];
-  readonly claimBoundary: string;
-  readonly hash: string;
-}
-
-export function sampleGestureHapticsFixture(options: GestureHapticsFixtureOptions = {}): GestureHapticsFixture {
-  const seed = normalizeSeed(options.seed ?? 0x9e57);
-  const pointerDeltaX = finite(options.pointerDeltaX ?? 84, "pointerDeltaX");
-  const pointerDeltaY = finite(options.pointerDeltaY ?? 18, "pointerDeltaY");
-  const pinchStartDistance = positive(options.pinchStartDistance ?? 42, "pinchStartDistance");
-  const pinchEndDistance = positive(options.pinchEndDistance ?? 76, "pinchEndDistance");
-  const rotateDegrees = finite(options.rotateDegrees ?? 28, "rotateDegrees");
-  const panDistance = Number(Math.hypot(pointerDeltaX, pointerDeltaY).toFixed(3));
-  const pinchScale = Number((pinchEndDistance / pinchStartDistance).toFixed(3));
-  const swipeDirection = Math.abs(pointerDeltaX) >= Math.abs(pointerDeltaY)
-    ? pointerDeltaX >= 0 ? "right" : "left"
-    : pointerDeltaY >= 0 ? "down" : "up";
-  const patterns = [
-    hapticPattern("tap", [{ weak: 0.3, strong: 0.2, duration: 50 }], false),
-    hapticPattern("impact", [{ weak: 0.7, strong: 0.8, duration: 100 }], false),
-    hapticPattern("damage", [
-      { weak: 0.8, strong: 0.9, duration: 80 },
-      { weak: 0, strong: 0, duration: 40 },
-      { weak: 0.6, strong: 0.7, duration: 60 }
-    ], false),
-    hapticPattern("success", [
-      { weak: 0.3, strong: 0.3, duration: 80 },
-      { weak: 0, strong: 0, duration: 50 },
-      { weak: 0.4, strong: 0.4, duration: 100 }
-    ], false),
-    hapticPattern("engine", [
-      { weak: 0.3, strong: 0.2, duration: 50 },
-      { weak: 0.35, strong: 0.25, duration: 50 }
-    ], true)
-  ] as const;
-  const fixture: Omit<GestureHapticsFixture, "hash"> = {
-    source: "origin-master-input-gesture-rumble-adapted",
-    gestures: [
-      { type: "tap", state: "ended", touchCount: 1, center: [16, 22] },
-      { type: "pan", state: "changed", touchCount: 1, center: [42, 38], distance: panDistance, velocity: [pointerDeltaX, pointerDeltaY] },
-      { type: "pinch", state: "changed", touchCount: 2, center: [64, 64], distance: pinchEndDistance, scale: pinchScale },
-      { type: "swipe", state: "ended", touchCount: 1, center: [120, 64], distance: panDistance, velocity: [pointerDeltaX * 8, pointerDeltaY * 8] },
-      { type: "rotate", state: "changed", touchCount: 2, center: [64, 64], rotationDegrees: Number(rotateDegrees.toFixed(3)) }
-    ],
-    gestureSummary: {
-      tapDetected: true,
-      panDistance,
-      pinchScale,
-      swipeDirection,
-      rotateDegrees: Number(rotateDegrees.toFixed(3))
-    },
-    haptics: {
-      gamepadConnected: options.gamepadConnected ?? true,
-      hapticsClaimed: false,
-      patterns,
-      queuedPatterns: 3 + Math.floor(seededUnit(seed) * 2),
-      totalDurationMs: patterns.reduce((sum, pattern) => sum + pattern.totalDurationMs, 0),
-      intensityMultiplier: Number((0.65 + seededUnit(seed ^ 0x54c) * 0.25).toFixed(3))
-    },
-    productionReadiness: {
-      gestureTelemetry: true,
-      swipeRotateTelemetry: true,
-      hapticPatternTelemetry: true,
-      hapticClaimBoundaryTelemetry: true
-    },
-    blockedClaims: [
-      "native mobile gesture recognizer parity",
-      "gamepad haptic actuator delivery guarantee",
-      "platform vibration permission handling",
-      "Unity Input System haptics parity",
-      "Unreal Enhanced Input haptics parity"
-    ],
-    claimBoundary: "This fixture ports old swipe/rotate gesture and rumble-pattern concepts into deterministic local input telemetry. It does not vibrate hardware, guarantee platform haptic delivery, or claim Unity Input System or Unreal Enhanced Input parity."
-  };
-  return {
-    ...fixture,
-    hash: stableHash(JSON.stringify(fixture))
-  };
-}
-
-function hapticPattern(
-  name: GestureHapticsPatternName,
-  steps: readonly { readonly weak: number; readonly strong: number; readonly duration: number }[],
-  loop: boolean
-): GestureHapticsFixture["haptics"]["patterns"][number] {
-  return {
-    name,
-    steps: steps.length,
-    totalDurationMs: steps.reduce((sum, step) => sum + step.duration, 0),
-    peakWeak: Math.max(...steps.map((step) => step.weak)),
-    peakStrong: Math.max(...steps.map((step) => step.strong)),
-    loop
-  };
-}
-
-function normalizeSeed(seed: number): number {
-  if (!Number.isInteger(seed) || seed < 0) throw new Error("seed must be a non-negative integer.");
-  return seed >>> 0;
-}
-
-function finite(value: number, name: string): number {
-  if (!Number.isFinite(value)) throw new Error(`${name} must be finite.`);
-  return value;
-}
-
-function positive(value: number, name: string): number {
-  if (!Number.isFinite(value) || value <= 0) throw new Error(`${name} must be positive.`);
-  return value;
-}
-
-function seededUnit(seed: number): number {
-  let value = seed >>> 0;
-  value ^= value << 13;
-  value ^= value >>> 17;
-  value ^= value << 5;
-  return (value >>> 0) / 0xffffffff;
-}
-
-function stableHash(value: string): string {
-  let hash = 2166136261;
-  for (let index = 0; index < value.length; index += 1) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}

package/src/GestureRecognizer.ts

@@ -1,43 +0,0 @@
-import type { InputSnapshot, PointerTouch } from "./InputSnapshot";
-
-export type Gesture =
-  | { readonly type: "tap"; readonly x: number; readonly y: number }
-  | { readonly type: "pan"; readonly deltaX: number; readonly deltaY: number }
-  | { readonly type: "pinch"; readonly scale: number };
-
-export class GestureRecognizer {
-  private previousTouches: readonly PointerTouch[] = [];
-  private downFrames = 0;
-
-  update(snapshot: InputSnapshot): readonly Gesture[] {
-    const gestures: Gesture[] = [];
-    const touches = snapshot.pointer.touches;
-
-    if (snapshot.button(0).down) {
-      this.downFrames += 1;
-      if (snapshot.pointer.deltaX !== 0 || snapshot.pointer.deltaY !== 0) {
-        gestures.push({ type: "pan", deltaX: snapshot.pointer.deltaX, deltaY: snapshot.pointer.deltaY });
-      }
-    }
-
-    if (snapshot.button(0).released && this.downFrames <= 12) {
-      gestures.push({ type: "tap", x: snapshot.pointer.x, y: snapshot.pointer.y });
-    }
-
-    if (touches.length >= 2 && this.previousTouches.length >= 2) {
-      const previousDistance = distance(this.previousTouches[0]!, this.previousTouches[1]!);
-      const currentDistance = distance(touches[0]!, touches[1]!);
-      if (previousDistance > 0) gestures.push({ type: "pinch", scale: currentDistance / previousDistance });
-    }
-
-    if (!snapshot.button(0).down) {
-      this.downFrames = 0;
-    }
-    this.previousTouches = touches;
-    return gestures;
-  }
-}
-
-function distance(a: PointerTouch, b: PointerTouch): number {
-  return Math.hypot(a.x - b.x, a.y - b.y);
-}

package/src/InputActionBindingFixtures.ts

@@ -1,121 +0,0 @@
-import { InputSnapshot } from "./InputSnapshot";
-
-export type InputValueProcessor =
-  | { readonly type: "deadzone"; readonly threshold: number }
-  | { readonly type: "scale"; readonly factor: number }
-  | { readonly type: "invert" }
-  | { readonly type: "clamp"; readonly min: number; readonly max: number }
-  | { readonly type: "exponential"; readonly exponent: number };
-
-export interface InputActionBindingFixture {
-  readonly source: "origin-master-input-action-binding-adapted";
-  readonly evidence: {
-    readonly oldCodebasePort: true;
-    readonly actionBindings: true;
-    readonly processors: true;
-    readonly holdTapDoubleTap: true;
-    readonly compositeAxis: true;
-    readonly modifierChord: true;
-  };
-  readonly actionCount: number;
-  readonly bindingCount: number;
-  readonly processorCount: number;
-  readonly processedAxis: number;
-  readonly deadzoneFilteredAxis: number;
-  readonly compositeX: number;
-  readonly compositeY: number;
-  readonly compositeMagnitude: number;
-  readonly holdTriggered: boolean;
-  readonly holdDurationSeconds: number;
-  readonly tapTriggered: boolean;
-  readonly doubleTapTriggered: boolean;
-  readonly modifierChordPressed: boolean;
-  readonly claimBoundary: string;
-}
-
-export function processInputValue(value: number, processors: readonly InputValueProcessor[], deltaSeconds = 1 / 60): number {
-  let result = finite(value, 0);
-  for (const processor of processors) {
-    if (processor.type === "deadzone") {
-      result = Math.abs(result) < Math.max(0, processor.threshold) ? 0 : result;
-    } else if (processor.type === "scale") {
-      result *= finite(processor.factor, 1);
-    } else if (processor.type === "invert") {
-      result *= -1;
-    } else if (processor.type === "clamp") {
-      result = clamp(result, processor.min, processor.max);
-    } else {
-      const sign = Math.sign(result);
-      result = sign * Math.pow(Math.abs(result), Math.max(0.01, finite(processor.exponent, 1))) * Math.max(0.001, deltaSeconds / (1 / 60));
-    }
-  }
-  return Number(result.toFixed(4));
-}
-
-export function sampleInputActionBindingFixture(): InputActionBindingFixture {
-  const activeSnapshot = new InputSnapshot({
-    keys: new Set(["ControlLeft", "KeyW", "KeyD"]),
-    previousKeys: new Set(["ControlLeft", "KeyW"]),
-    gamepads: [{
-      id: "fixture-pad",
-      index: 0,
-      axes: [0.42, -0.74],
-      buttons: [{ down: true, pressed: true, released: false }]
-    }]
-  });
-  const processedAxis = processInputValue(activeSnapshot.gamepads[0]?.axes[0] ?? 0, [
-    { type: "deadzone", threshold: 0.2 },
-    { type: "scale", factor: 1.8 },
-    { type: "clamp", min: -1, max: 1 }
-  ]);
-  const deadzoneFilteredAxis = processInputValue(0.08, [{ type: "deadzone", threshold: 0.2 }]);
-  const compositeX = (activeSnapshot.key("KeyD").down ? 1 : 0) - (activeSnapshot.key("KeyA").down ? 1 : 0);
-  const compositeY = (activeSnapshot.key("KeyW").down ? 1 : 0) - (activeSnapshot.key("KeyS").down ? 1 : 0);
-  const holdDurationSeconds = Number((5 * 0.12).toFixed(2));
-  const tapTriggered = evaluateTap(1.2, 1.34, 0.2);
-  const doubleTapTriggered = evaluateDoubleTap([1.2, 1.34], 0.25);
-  const modifierChordPressed = activeSnapshot.key("ControlLeft").down && activeSnapshot.key("KeyD").pressed;
-
-  return {
-    source: "origin-master-input-action-binding-adapted",
-    evidence: {
-      oldCodebasePort: true,
-      actionBindings: true,
-      processors: true,
-      holdTapDoubleTap: true,
-      compositeAxis: true,
-      modifierChord: true
-    },
-    actionCount: 4,
-    bindingCount: 8,
-    processorCount: 3,
-    processedAxis,
-    deadzoneFilteredAxis,
-    compositeX,
-    compositeY,
-    compositeMagnitude: Number(Math.hypot(compositeX, compositeY).toFixed(4)),
-    holdTriggered: holdDurationSeconds >= 0.5,
-    holdDurationSeconds,
-    tapTriggered,
-    doubleTapTriggered,
-    modifierChordPressed,
-    claimBoundary: "Bounded deterministic current-input evidence for old InputAction/InputBinding processors and interactions; this does not claim full input action asset, rebinding UI, or Unity Input System parity."
-  };
-}
-
-function evaluateTap(pressedAtSeconds: number, releasedAtSeconds: number, tapSpeedSeconds: number): boolean {
-  return releasedAtSeconds >= pressedAtSeconds && releasedAtSeconds - pressedAtSeconds <= tapSpeedSeconds;
-}
-
-function evaluateDoubleTap(pressTimesSeconds: readonly number[], maxIntervalSeconds: number): boolean {
-  return pressTimesSeconds.length >= 2 && (pressTimesSeconds.at(-1) ?? 0) - (pressTimesSeconds.at(-2) ?? 0) <= maxIntervalSeconds;
-}
-
-function finite(value: unknown, fallback: number): number {
-  const number = Number(value);
-  return Number.isFinite(number) ? number : fallback;
-}
-
-function clamp(value: number, min: number, max: number): number {
-  return Math.max(min, Math.min(max, value));
-}