@nayan-ui/engine 0.0.0-stage → 1.0.0-beta.4

package/lib/module/input/keyboard.js

@@ -0,0 +1,250 @@
+"use strict";
+
+export const PRIMARY_INPUT_EVENT = 'nayan-engine-primary-action';
+/** Browser keyboard adapter. Reuses pointer input, including engine gestures and raw contact surfaces. */
+export function createKeyboardInput(surface, options = {}) {
+  const mode = options.mode ?? 'pointer';
+  const keys = new Set();
+  const directions = {
+    ArrowLeft: [-1, 0],
+    KeyA: [-1, 0],
+    ArrowRight: [1, 0],
+    KeyD: [1, 0],
+    ArrowUp: [0, -1],
+    KeyW: [0, -1],
+    ArrowDown: [0, 1],
+    KeyS: [0, 1]
+  };
+  let point = {
+    x: surface.clientWidth / 2,
+    y: surface.clientHeight / 2
+  };
+  let held;
+  let frame = 0;
+  let last = 0;
+  let disposed = false;
+  const cursor = document.createElement('div');
+  cursor.setAttribute('aria-hidden', 'true');
+  cursor.dataset.engineKeyboardCursor = '';
+  Object.assign(cursor.style, {
+    position: 'absolute',
+    width: '22px',
+    height: '22px',
+    border: '2px solid white',
+    borderRadius: '50%',
+    boxShadow: '0 0 0 2px #17122b, 0 2px 8px #000a',
+    background: '#6f3ef460',
+    pointerEvents: 'none',
+    zIndex: '20',
+    display: 'none',
+    transform: 'translate(-50%, -50%)'
+  });
+  surface.appendChild(cursor);
+  const show = () => {
+    point.x = Math.max(2, Math.min(surface.clientWidth - 2, point.x));
+    point.y = Math.max(2, Math.min(surface.clientHeight - 2, point.y));
+    cursor.style.display = 'block';
+    cursor.style.left = `${point.x}px`;
+    cursor.style.top = `${point.y}px`;
+  };
+  const target = () => {
+    const rect = surface.getBoundingClientRect();
+    const element = document.elementFromPoint(rect.left + point.x, rect.top + point.y);
+    return element && surface.contains(element) ? element : null;
+  };
+  const dispatch = (element, type, id) => {
+    const rect = surface.getBoundingClientRect();
+    element.dispatchEvent(new PointerEvent(type, {
+      bubbles: true,
+      cancelable: true,
+      pointerId: id,
+      pointerType: 'mouse',
+      isPrimary: id === -1,
+      button: 0,
+      buttons: type === 'pointerup' || type === 'pointercancel' ? 0 : 1,
+      clientX: rect.left + point.x,
+      clientY: rect.top + point.y
+    }));
+  };
+  const down = () => {
+    const element = target();
+    if (!element || held) return;
+    held = {
+      target: element,
+      id: -1
+    };
+    dispatch(element, 'pointerdown', -1);
+  };
+  const up = (cancelled = false) => {
+    if (!held) return;
+    dispatch(held.target, cancelled ? 'pointercancel' : 'pointerup', held.id);
+    held = undefined;
+  };
+  const tap = (id = -2) => {
+    const element = target();
+    if (!element) return;
+    dispatch(element, 'pointerdown', id);
+    dispatch(element, 'pointerup', id);
+  };
+  const cancel = () => {
+    cancelAnimationFrame(frame);
+    frame = 0;
+    keys.clear();
+    up(true);
+    cursor.style.display = 'none';
+  };
+  const vector = () => {
+    let x = 0,
+      y = 0;
+    for (const key of keys) {
+      const direction = directions[key];
+      if (direction) {
+        x += direction[0];
+        y += direction[1];
+      }
+    }
+    const length = Math.max(1, Math.hypot(x, y));
+    return {
+      x: x / length,
+      y: y / length
+    };
+  };
+  const tick = now => {
+    frame = 0;
+    if (disposed || options.enabled?.() === false) {
+      cancel();
+      return;
+    }
+    const dt = Math.min(0.05, Math.max(0, (now - last) / 1000));
+    last = now;
+    const direction = vector();
+    point.x = Math.max(2, Math.min(surface.clientWidth - 2, point.x + direction.x * 420 * dt));
+    point.y = Math.max(2, Math.min(surface.clientHeight - 2, point.y + direction.y * 420 * dt));
+    show();
+    if (held) dispatch(held.target, 'pointermove', held.id);
+    if (keys.size) frame = requestAnimationFrame(tick);
+  };
+  const editable = event => {
+    const element = event.target;
+    return element instanceof Element && !!element.closest('input,textarea,select,button,a,[role=button],[role=switch],[contenteditable=true]');
+  };
+  const keyDown = event => {
+    if (event.altKey || event.ctrlKey || event.metaKey || event.defaultPrevented || editable(event)) return;
+    if (options.enabled?.() === false) {
+      cancel();
+      return;
+    }
+    const focused = document.activeElement;
+    if (focused && focused !== document.body && focused !== document.documentElement && !surface.contains(focused)) return;
+    const direction = directions[event.code];
+    if (!direction && event.code !== 'Space' && event.code !== 'Enter') return;
+    event.preventDefault();
+    if (event.code === 'Enter') {
+      if (!event.repeat) {
+        cancel();
+        const action = new CustomEvent(PRIMARY_INPUT_EVENT, {
+          bubbles: true,
+          cancelable: true
+        });
+        if (!(surface.querySelector('canvas') ?? surface).dispatchEvent(action)) return;
+        const previous = point;
+        point = options.primary?.() ?? point;
+        tap();
+        point = previous;
+      }
+      return;
+    }
+    if (event.code === 'Space') {
+      if (event.repeat) return;
+      show();
+      if (mode === 'pointer') down();else {
+        const resume = !!held;
+        up();
+        tap();
+        if (resume) down();
+      }
+      return;
+    }
+    if (mode === 'swipe') {
+      const previous = point;
+      point = {
+        x: surface.clientWidth / 2,
+        y: surface.clientHeight / 2
+      };
+      down();
+      point = {
+        x: point.x + direction[0] * 80,
+        y: point.y + direction[1] * 80
+      };
+      if (held) dispatch(held.target, 'pointermove', held.id);
+      up();
+      point = previous;
+      return;
+    }
+    if (!keys.size && mode === 'drag') {
+      point = {
+        x: surface.clientWidth / 2,
+        y: surface.clientHeight / 2
+      };
+      down();
+    }
+    keys.add(event.code);
+    show();
+    if (!frame) {
+      last = performance.now();
+      frame = requestAnimationFrame(tick);
+    }
+  };
+  const keyUp = event => {
+    if (event.code === 'Space' && mode === 'pointer') up();
+    if (!keys.delete(event.code)) return;
+    if (!keys.size) {
+      cancelAnimationFrame(frame);
+      frame = 0;
+      if (mode === 'drag') up();
+    }
+  };
+  const pointer = event => {
+    if (!event.isTrusted) return;
+    if (event.type === 'pointerdown') {
+      cancel();
+      const control = event.target instanceof Element && event.target.closest('input,textarea,select,button,a,[role=button],[role=switch],[contenteditable=true]');
+      if (!control) surface.focus({
+        preventScroll: true
+      });
+    }
+    // Keep the keyboard cursor independent of mouse clicks on HUD controls.
+    if (!held) cursor.style.display = 'none';
+  };
+  const visibility = () => {
+    if (document.hidden) cancel();
+  };
+  const focus = () => {
+    const element = document.activeElement;
+    if (element && element !== document.body && (!surface.contains(element) || element.closest('input,textarea,select,button,a,[role=button],[role=switch],[contenteditable=true]'))) cancel();
+  };
+  window.addEventListener('keydown', keyDown);
+  window.addEventListener('keyup', keyUp);
+  window.addEventListener('blur', cancel);
+  document.addEventListener('visibilitychange', visibility);
+  document.addEventListener('focusin', focus);
+  surface.addEventListener('pointerdown', pointer, true);
+  surface.addEventListener('pointermove', pointer, true);
+  return {
+    cancel,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      cancel();
+      window.removeEventListener('keydown', keyDown);
+      window.removeEventListener('keyup', keyUp);
+      window.removeEventListener('blur', cancel);
+      document.removeEventListener('visibilitychange', visibility);
+      document.removeEventListener('focusin', focus);
+      surface.removeEventListener('pointerdown', pointer, true);
+      surface.removeEventListener('pointermove', pointer, true);
+      cursor.remove();
+    }
+  };
+}
+//# sourceMappingURL=keyboard.js.map

package/lib/module/media/audio-worklet.js

@@ -0,0 +1,34 @@
+"use strict";
+
+// Runs on the audio rendering thread. PCM is produced by the shared Rust mixer on the main thread.
+class NayanMixer extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.blocks = [];
+    this.offset = 0;
+    this.port.onmessage = ({
+      data
+    }) => {
+      if (this.blocks.length < 8) this.blocks.push(data);
+    };
+  }
+  process(_inputs, outputs) {
+    const channels = outputs[0];
+    for (let i = 0; i < channels[0].length; i++) {
+      const block = this.blocks[0];
+      channels[0][i] = block ? block[this.offset] : 0;
+      channels[1][i] = block ? block[this.offset + 1] : 0;
+      if (block) {
+        this.offset += 2;
+        if (this.offset >= block.length) {
+          this.blocks.shift();
+          this.offset = 0;
+          this.port.postMessage(null);
+        }
+      }
+    }
+    return true;
+  }
+}
+registerProcessor('nayan-mixer', NayanMixer);
+//# sourceMappingURL=audio-worklet.js.map

package/lib/module/media/audio.js

@@ -0,0 +1,97 @@
+"use strict";
+
+import { AssetLoader } from "../assets/AssetLoader.js";
+// Sound, played by the Rust core's mixer (no Expo or other native audio dependency).
+
+import NativeEngine from '../native/NativeNayanEngine';
+
+/** A decoded sound in the core's mixer. */
+
+/** A playing instance of a sound (for `audio.stop`). */
+
+/** A `require("./file.wav")` asset, or a URI. WAV, PCM or float, mono or stereo. */
+
+const loader = new AssetLoader('audio');
+function loadSound(source) {
+  return loader.load(source, (native, bytes) => {
+    const finish = id => {
+      if (id < 0) throw new Error(native.loadError() || 'not a supported WAV file');
+      return id;
+    };
+    // Decoded on a background native thread where the app's build supports it.
+    return typeof native.audioLoadAsync === 'function' ? native.audioLoadAsync(bytes).then(finish) : finish(native.audioLoad(bytes));
+  }).catch(error => {
+    console.warn(error instanceof Error ? error.message : String(error));
+    return null;
+  });
+}
+
+/** Named sounds. Plays are ignored until `ready` resolves (usually a few milliseconds). */
+export class SoundBank {
+  /** Resolves when every sound has loaded (failures are logged and skipped). */
+
+  ids = {};
+  constructor(sources) {
+    this.ready = Promise.all(Object.keys(sources).map(async name => {
+      const id = await loadSound(sources[name]);
+      if (id !== null) this.ids[name] = id;
+    })).then(() => undefined);
+  }
+
+  /** The sound, once loaded (e.g. for an entity's `impact.sound`). */
+  get(name) {
+    return this.ids[name];
+  }
+  play(name, options) {
+    const id = this.ids[name];
+    return id === undefined ? null : audio.play(id, options);
+  }
+}
+let muted = false;
+let volume = 1;
+export const audio = {
+  /** Initializes the engine and loads named sounds into its mixer. Each asset decodes once per session. */
+  load(sources) {
+    return new SoundBank(sources);
+  },
+  /** Plays a sound (low latency: mixed in Rust on the audio thread). Returns null if it couldn't play. */
+  play(sound, {
+    volume: v = 1,
+    pan = 0,
+    pitch = 1,
+    loop = false
+  } = {}) {
+    const voice = NativeEngine?.audioPlay(sound, v, pan, pitch, loop) ?? 0;
+    return voice > 0 ? voice : null;
+  },
+  stop(voice) {
+    if (voice) NativeEngine?.audioStop(voice);
+  },
+  get muted() {
+    return muted;
+  },
+  /** The inverse of `muted`, matching `haptics.enabled` (e.g. `audio.enabled = settings.enableSounds`). */
+  get enabled() {
+    return !muted;
+  },
+  set enabled(value) {
+    this.muted = !value;
+  },
+  set muted(value) {
+    muted = value;
+    NativeEngine?.audioSetMuted(value);
+  },
+  /** Master volume, 0..2. */
+  get volume() {
+    return volume;
+  },
+  set volume(value) {
+    volume = value;
+    NativeEngine?.audioSetVolume(value);
+  },
+  /** True once the device's audio output is running. */
+  get running() {
+    return NativeEngine?.audioIsRunning() ?? false;
+  }
+};
+//# sourceMappingURL=audio.js.map

package/lib/module/media/haptics.js

@@ -0,0 +1,82 @@
+"use strict";
+
+// Haptics, driven by the Rust core (Core Haptics on iOS).
+import NativeEngine from '../native/NativeNayanEngine';
+const PATTERNS = {
+  success: [{
+    time: 0,
+    intensity: 0.55,
+    sharpness: 0.5
+  }, {
+    time: 0.1,
+    intensity: 1,
+    sharpness: 0.7
+  }],
+  warning: [{
+    time: 0,
+    intensity: 0.8,
+    sharpness: 0.4
+  }, {
+    time: 0.16,
+    intensity: 0.8,
+    sharpness: 0.4
+  }],
+  error: [{
+    time: 0,
+    intensity: 1,
+    sharpness: 0.8
+  }, {
+    time: 0.09,
+    intensity: 0.9,
+    sharpness: 0.8
+  }, {
+    time: 0.18,
+    intensity: 0.7,
+    sharpness: 0.8
+  }]
+};
+
+/** One throttled tap (collisions call this often): a reused [time, intensity, sharpness] array. */
+const single = [0, 0, 0];
+function playTap(intensity, sharpness) {
+  if (!haptics.enabled || !NativeEngine) return;
+  single[1] = intensity;
+  single[2] = sharpness;
+  NativeEngine.hapticsPlay(single, true);
+}
+
+/** Flattened patterns, built once per tap list (presets are constant; custom lists by identity). */
+const flattened = new WeakMap();
+function playTaps(taps, throttle) {
+  if (!haptics.enabled || !NativeEngine) return;
+  let flat = flattened.get(taps);
+  if (!flat) {
+    flat = taps.flatMap(t => [t.time, t.intensity, t.sharpness]);
+    flattened.set(taps, flat);
+  }
+  NativeEngine.hapticsPlay(flat, throttle);
+}
+export const haptics = {
+  /** Set false to silence all haptics (e.g. a settings toggle). */
+  enabled: true,
+  /** True if the device has a haptic actuator (false on simulators). */
+  get supported() {
+    return NativeEngine?.hapticsSupported() ?? false;
+  },
+  /** A single tap. Rapid repeats (< 35 ms apart) are dropped so collisions don't buzz. */
+  impact(intensity = 0.6, sharpness = 0.5) {
+    playTap(intensity, sharpness);
+  },
+  /** A light, crisp tick for UI selection. */
+  selection() {
+    playTap(0.35, 0.9);
+  },
+  notify(type) {
+    playTaps(PATTERNS[type], false);
+  },
+  /** Any sequence of taps. */
+  play(taps) {
+    playTaps(taps, false);
+  }
+};
+//# sourceMappingURL=haptics.js.map

package/lib/module/media/output.web.js

@@ -0,0 +1,66 @@
+"use strict";
+
+/** The Rust mixer remains the source of all audio, including native collision feedback. */
+export function installAudioOutput(core) {
+  if (typeof window === 'undefined') return () => false;
+  let context;
+  let pending;
+  const start = () => {
+    if (pending) {
+      void context?.resume().catch(() => {});
+      return;
+    }
+    let release;
+    pending = (async () => {
+      context = new AudioContext({
+        sampleRate: 48000
+      });
+      await context.audioWorklet.addModule(new URL('./audio-worklet.js', import.meta.url));
+      const output = new AudioWorkletNode(context, 'nayan-mixer', {
+        numberOfInputs: 0,
+        numberOfOutputs: 1,
+        outputChannelCount: [2]
+      });
+      const allocate = core.engine_web_alloc;
+      const free = core.engine_web_free;
+      const render = core.engine_web_audio_render;
+      const floats = 2048;
+      const pointer = allocate(floats * 4);
+      const current = context;
+      const visibility = () => {
+        void (document.hidden ? current.suspend() : current.resume()).catch(() => {});
+      };
+      release = () => {
+        document.removeEventListener('visibilitychange', visibility);
+        output.port.onmessage = null;
+        output.disconnect();
+        free(pointer, floats * 4);
+      };
+      const send = () => {
+        render(pointer, floats);
+        const samples = new Float32Array(core.memory.buffer, pointer, floats).slice();
+        output.port.postMessage(samples, [samples.buffer]);
+      };
+      output.port.onmessage = send;
+      send();
+      send();
+      send();
+      output.connect(context.destination);
+      document.addEventListener('visibilitychange', visibility);
+      await context.resume();
+    })().catch(() => {
+      release?.();
+      void context?.close().catch(() => {});
+      context = undefined;
+      pending = undefined; // retry on the next gesture if audio is unavailable or blocked
+    });
+  };
+  window.addEventListener('pointerdown', start, {
+    capture: true
+  });
+  window.addEventListener('keydown', start, {
+    capture: true
+  });
+  return () => context?.state === 'running';
+}
+//# sourceMappingURL=output.web.js.map