@kidlib/web-audio 0.1.0

package/dist/io.d.ts

@@ -0,0 +1,239 @@
+declare type AudioInputDevice = DeviceInfo & {
+    kind: 'audioinput';
+};
+
+declare type AudioOutputDevice = DeviceInfo & {
+    kind: 'audiooutput';
+};
+
+export declare const chromaticKeymap: KeyMap;
+
+export declare type ControlCallback = (value: number, event: ControlChangeEvent) => void;
+
+export declare type ControlChangeEvent = {
+    type: 'controlchange';
+    controller: number;
+    normalizedValue: number;
+    midiValue: number;
+    channel: number;
+    raw: any;
+};
+
+declare type ControlChangeHandler = (event: ControlChangeEvent) => void;
+
+export declare type ControlTarget = SimpleControlTarget | KnobControlTarget | DetailedControlTarget | ControlCallback;
+
+export declare const DEFAULT_KEYMAP_KEY: KeymapKey;
+
+/**
+ * Default keyboard-to-MIDI note mapping for audio input.
+ * Provides a piano-like layout across the QWERTY keyboard.
+ * Used by KeyboardInputManager to translate keyboard events to MIDI notes.
+ */
+export declare const defaultKeymap: KeyMap;
+
+export declare type DetailedControlTarget = {
+    onControlChange: (value: number, event: ControlChangeEvent) => void;
+};
+
+declare type DeviceInfo = {
+    deviceId: string;
+    label: string;
+    kind: MediaDeviceKind;
+};
+
+/**
+ * Generate a keymap from a base note and scale intervals.
+ * Each QWERTY row is mapped one octave above the previous (bottom row lowest).
+ */
+export declare function generateKeymap(config: {
+    baseNote: number;
+    scale: number[];
+}): KeyMap;
+
+export declare function getAudioInputDevices(): Promise<AudioInputDevice[]>;
+
+export declare function getAudioOutputDevices(): Promise<AudioOutputDevice[]>;
+
+export declare function getCamera(constraints?: MediaTrackConstraints): Promise<MediaStream>;
+
+export declare function getDevices(): Promise<DeviceInfo[]>;
+
+export declare function getMicrophone(constraints?: MediaTrackConstraints, deviceId?: string): Promise<MediaStream>;
+
+export declare function getMIDIAccess(): Promise<MIDIAccess>;
+
+/**
+ * Get browser-specific MIDI support information
+ */
+export declare function getMidiSupportInfo(): {
+    supported: boolean;
+    browserName: string;
+    message: string;
+};
+
+export declare function getVideoInputDevices(): Promise<VideoInputDevice[]>;
+
+export declare class InputController {
+    #private;
+    init(): Promise<boolean>;
+    onNoteOn(handler: NoteHandler): () => void;
+    onNoteOff(handler: NoteHandler): () => void;
+    onControlChange(handler: ControlChangeHandler): () => void;
+    onSustainPedal(handler: SustainPedalHandler): () => void;
+    registerNoteTarget(target: NoteTarget, channel?: number | 'all'): () => void;
+    /**
+     * Register one or more control targets to respond to MIDI CC messages.
+     *
+     * By default, passes normalized values (0-1) to targets. Use transformValue for custom behavior.
+     *
+     * Supports multiple target types for maximum flexibility:
+     *
+     * @example
+     * // Knobs - automatically calls setValueNormalized if available
+     * inputController.registerControlTarget(knobElement, { controller: 15 });
+     *
+     * @example
+     * // Simple callback function - cleanest for custom logic
+     * inputController.registerControlTarget(
+     *   (value, event) => console.log(`CC${event.controller}: ${value}`),
+     *   { controller: 15 }
+     * );
+     *
+     * @example
+     * // Multiple targets controlled by same CC
+     * inputController.registerControlTarget([knob1, knob2], { controller: 15 });
+     *
+     * @example
+     * // Raw MIDI values (0-127) instead of normalized (0-1)
+     * inputController.registerControlTarget(knobElement, {
+     *   controller: 15,
+     *   transformValue: (event) => event.midiValue
+     * });
+     *
+     * @example
+     * // Object with setValue method (sliders, etc.)
+     * inputController.registerControlTarget({ setValue: (v) => slider.value = v }, { controller: 15 });
+     */
+    registerControlTarget(target: ControlTarget | ControlTarget[], options: RegisterControlOptions): () => void;
+    registerSustainPedalTarget(target: SustainPedalTarget, channel?: number | 'all'): () => void;
+    get initialized(): boolean;
+    get midiSupported(): boolean;
+    get supportInfo(): {
+        supported: boolean;
+        browserName: string;
+        message: string;
+    };
+}
+
+export declare const inputController: InputController;
+
+export declare interface InputHandler {
+    onNoteOn: (midiNote: number, velocity: number, modifiers?: PressedModifiers) => void;
+    onNoteOff: (midiNote: number, modifiers: PressedModifiers) => void;
+    onBlur: () => void;
+    onModifierChange?: (modifiers: PressedModifiers) => void;
+}
+
+/**
+ * Check if Web MIDI API is supported in the current browser
+ */
+export declare function isMidiSupported(): boolean;
+
+export declare type KeyMap = Record<string, number>;
+
+export declare type KeymapKey = 'piano' | 'major' | 'minor' | 'pentatonic' | 'chromatic';
+
+export declare const keymaps: Record<KeymapKey, KeyMap>;
+
+export declare type KnobControlTarget = {
+    setValueNormalized?: (value: number) => void;
+    setValue?: (value: number) => void;
+};
+
+export declare const majorKeymap: KeyMap;
+
+export declare const minorKeymap: KeyMap;
+
+export declare type ModifierKey = 'space' | 'caps' | 'meta' | 'shift' | 'ctrl' | 'alt';
+
+/**
+ * MIDI Input Controller - Clean, Flexible API
+ *
+ * Supports multiple target types for maximum convenience:
+ * - Knob elements (auto-detects setValueNormalized/setValue methods)
+ * - Simple callback functions
+ * - Objects with setValue method
+ * - Objects with onControlChange method
+ *
+ * ControlChangeEvent provides both value formats:
+ * - event.normalizedValue: 0-1 range (default, most common)
+ * - event.midiValue: 0-127 range (raw MIDI spec)
+ *
+ * @example
+ * // Knobs - automatically calls the right method
+ * inputController.registerControlTarget(knobElement, { controller: 15 });
+ *
+ * @example
+ * // Simple callback - cleanest for custom logic
+ * inputController.registerControlTarget(
+ *   (value, event) => console.log(`CC${event.controller}: ${value}`),
+ *   { controller: 15 }
+ * );
+ *
+ * @example
+ * // Raw MIDI values instead of normalized
+ * inputController.registerControlTarget(knob, {
+ *   controller: 15,
+ *   transformValue: (event) => event.midiValue
+ * });
+ */
+export declare type NoteEvent = {
+    type: 'noteon' | 'noteoff';
+    note: number;
+    velocity: number;
+    channel: number;
+    raw: any;
+};
+
+declare type NoteHandler = (event: NoteEvent) => void;
+
+export declare type NoteTarget = {
+    play: (note: number, velocity?: number) => void;
+    release: (note: number) => void;
+};
+
+export declare function onDeviceChange(callback: () => void): () => void;
+
+export declare const pentatonicKeymap: KeyMap;
+
+export declare type PressedModifiers = Partial<Record<ModifierKey, boolean>>;
+
+declare type RegisterControlOptions = {
+    controller: number | number[];
+    channel?: number | 'all';
+    transformValue?: (event: ControlChangeEvent) => number;
+};
+
+export declare type SimpleControlTarget = {
+    setValue: (value: number) => void;
+};
+
+export declare type SustainPedalEvent = {
+    type: 'sustainpedal';
+    pressed: boolean;
+    channel: number;
+    raw: any;
+};
+
+declare type SustainPedalHandler = (event: SustainPedalEvent) => void;
+
+export declare type SustainPedalTarget = {
+    setSustainPedal: (pressed: boolean) => void;
+};
+
+declare type VideoInputDevice = DeviceInfo & {
+    kind: 'videoinput';
+};
+
+export { }

package/dist/io.js

@@ -0,0 +1,193 @@
+var M = (t) => {
+  throw TypeError(t);
+};
+var w = (t, e, r) => e.has(t) || M("Cannot " + r);
+var s = (t, e, r) => (w(t, e, "read from private field"), r ? r.call(t) : e.get(t)), d = (t, e, r) => e.has(t) ? M("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, r), S = (t, e, r, a) => (w(t, e, "write to private field"), a ? a.call(t, r) : e.set(t, r), r), f = (t, e, r) => (w(t, e, "access private method"), r);
+import { D as F, c as T, d as H, a as L, b as j, e as Y, f as _, h as $, i as q, g as B, j as G, k as R, m as J, l as Q, o as X, p as Z } from "./keymap-3lZMR1Ak.js";
+import { WebMidi as V } from "webmidi";
+function A() {
+  return typeof navigator < "u" && typeof navigator.requestMIDIAccess == "function";
+}
+function O() {
+  const t = navigator.userAgent, e = /Chrome/.test(t) && /Google Inc/.test(navigator.vendor || ""), r = /Edg/.test(t), a = /OPR/.test(t), n = /Safari/.test(t) && !/Chrome/.test(t), o = /Firefox/.test(t);
+  let u = "Unknown";
+  e ? u = "Chrome" : r ? u = "Edge" : a ? u = "Opera" : n ? u = "Safari" : o && (u = "Firefox");
+  const m = A();
+  let l = "";
+  return m || (n ? l = "Safari doesn't support Web MIDI API. Use Chrome, Edge, or Opera for MIDI functionality." : o ? l = "Firefox has limited Web MIDI API support. Use Chrome, Edge, or Opera for full MIDI functionality." : l = "Web MIDI API not supported in this browser."), { supported: m, browserName: u, message: l };
+}
+var y, b, I, h, p, i, E, D, P, z, C;
+class N {
+  constructor() {
+    d(this, i);
+    d(this, y, !1);
+    d(this, b, /* @__PURE__ */ new Set());
+    d(this, I, /* @__PURE__ */ new Set());
+    d(this, h, /* @__PURE__ */ new Set());
+    d(this, p, /* @__PURE__ */ new Set());
+  }
+  async init() {
+    if (s(this, y)) return !0;
+    if (!A()) {
+      const { browserName: e, message: r } = O();
+      return console.warn(`InputController: ${r} (Browser: ${e})`), !1;
+    }
+    try {
+      await V.enable();
+    } catch (e) {
+      return console.warn("InputController: WebMIDI enable failed", e), !1;
+    }
+    return V.enabled ? (S(this, y, !0), f(this, i, E).call(this), !0) : (console.warn("InputController: WebMIDI not enabled"), !1);
+  }
+  onNoteOn(e) {
+    return s(this, b).add(e), () => s(this, b).delete(e);
+  }
+  onNoteOff(e) {
+    return s(this, I).add(e), () => s(this, I).delete(e);
+  }
+  onControlChange(e) {
+    return s(this, h).add(e), () => s(this, h).delete(e);
+  }
+  onSustainPedal(e) {
+    return s(this, p).add(e), () => s(this, p).delete(e);
+  }
+  registerNoteTarget(e, r = "all") {
+    const a = this.onNoteOn((o) => {
+      f(this, i, C).call(this, r, o.channel) && e.play(o.note, o.velocity ?? 0);
+    }), n = this.onNoteOff((o) => {
+      f(this, i, C).call(this, r, o.channel) && e.release(o.note);
+    });
+    return () => {
+      a(), n();
+    };
+  }
+  /**
+   * Register one or more control targets to respond to MIDI CC messages.
+   *
+   * By default, passes normalized values (0-1) to targets. Use transformValue for custom behavior.
+   *
+   * Supports multiple target types for maximum flexibility:
+   *
+   * @example
+   * // Knobs - automatically calls setValueNormalized if available
+   * inputController.registerControlTarget(knobElement, { controller: 15 });
+   *
+   * @example
+   * // Simple callback function - cleanest for custom logic
+   * inputController.registerControlTarget(
+   *   (value, event) => console.log(`CC${event.controller}: ${value}`),
+   *   { controller: 15 }
+   * );
+   *
+   * @example
+   * // Multiple targets controlled by same CC
+   * inputController.registerControlTarget([knob1, knob2], { controller: 15 });
+   *
+   * @example
+   * // Raw MIDI values (0-127) instead of normalized (0-1)
+   * inputController.registerControlTarget(knobElement, {
+   *   controller: 15,
+   *   transformValue: (event) => event.midiValue
+   * });
+   *
+   * @example
+   * // Object with setValue method (sliders, etc.)
+   * inputController.registerControlTarget({ setValue: (v) => slider.value = v }, { controller: 15 });
+   */
+  registerControlTarget(e, r) {
+    const a = Array.isArray(e) ? e : [e], n = Array.isArray(r.controller) ? r.controller : [r.controller], o = r.channel ?? "all", u = r.transformValue ?? ((l) => l.normalizedValue);
+    return this.onControlChange((l) => {
+      if (!n.includes(l.controller) || !f(this, i, C).call(this, o, l.channel)) return;
+      const g = u(l);
+      a.forEach((c) => {
+        typeof c == "function" ? c(g, l) : "onControlChange" in c ? c.onControlChange(g, l) : "setValueNormalized" in c && c.setValueNormalized ? c.setValueNormalized(g) : "setValue" in c && c.setValue && c.setValue(g);
+      });
+    });
+  }
+  registerSustainPedalTarget(e, r = "all") {
+    return this.onSustainPedal((n) => {
+      f(this, i, C).call(this, r, n.channel) && e.setSustainPedal(n.pressed);
+    });
+  }
+  get initialized() {
+    return s(this, y);
+  }
+  get midiSupported() {
+    return A();
+  }
+  get supportInfo() {
+    return O();
+  }
+}
+y = new WeakMap(), b = new WeakMap(), I = new WeakMap(), h = new WeakMap(), p = new WeakMap(), i = new WeakSet(), E = function() {
+  V.inputs.forEach((e) => {
+    e && (e.addListener("noteon", (r) => {
+      f(this, i, D).call(this, s(this, b), r, "noteon");
+    }), e.addListener("noteoff", (r) => {
+      f(this, i, D).call(this, s(this, I), r, "noteoff");
+    }), e.addListener("controlchange", (r) => {
+      var n, o;
+      (((n = r.controller) == null ? void 0 : n.number) ?? ((o = r.controller) == null ? void 0 : o.value) ?? 0) === 64 ? f(this, i, z).call(this, r) : f(this, i, P).call(this, r);
+    }));
+  });
+}, D = function(e, r, a) {
+  var o, u, m, l;
+  if (!e.size) return;
+  const n = {
+    type: a,
+    note: ((o = r.note) == null ? void 0 : o.number) ?? 0,
+    velocity: ((u = r.note) == null ? void 0 : u.rawAttack) ?? (typeof r.velocity == "number" ? r.velocity : ((m = r.note) == null ? void 0 : m.attack) ?? 0),
+    channel: ((l = r.message) == null ? void 0 : l.channel) ?? 1,
+    raw: r
+  };
+  e.forEach((g) => g(n));
+}, P = function(e) {
+  var a, n, o;
+  if (!s(this, h).size) return;
+  const r = {
+    type: "controlchange",
+    controller: ((a = e.controller) == null ? void 0 : a.number) ?? ((n = e.controller) == null ? void 0 : n.value) ?? (typeof e.controller == "number" ? e.controller : 0),
+    // Provide both values explicitly
+    normalizedValue: typeof e.value == "number" ? e.value : typeof e.rawValue == "number" ? e.rawValue / 127 : 0,
+    midiValue: typeof e.rawValue == "number" ? e.rawValue : typeof e.value == "number" ? Math.round(e.value * 127) : 0,
+    channel: ((o = e.message) == null ? void 0 : o.channel) ?? 1,
+    raw: e
+  };
+  s(this, h).forEach((u) => u(r));
+}, z = function(e) {
+  var n;
+  if (!s(this, p).size) return;
+  const a = {
+    type: "sustainpedal",
+    pressed: (typeof e.rawValue == "number" ? e.rawValue : typeof e.value == "number" ? Math.round(e.value * 127) : 0) >= 64,
+    // MIDI standard: >= 64 is "on"
+    channel: ((n = e.message) == null ? void 0 : n.channel) ?? 1,
+    raw: e
+  };
+  s(this, p).forEach((o) => o(a));
+}, C = function(e, r) {
+  return e === "all" ? !0 : typeof r != "number" ? !1 : e === r;
+};
+const U = new N();
+export {
+  F as DEFAULT_KEYMAP_KEY,
+  N as InputController,
+  T as chromaticKeymap,
+  H as defaultKeymap,
+  L as generateKeymap,
+  j as getAudioInputDevices,
+  Y as getAudioOutputDevices,
+  _ as getCamera,
+  $ as getDevices,
+  q as getMIDIAccess,
+  B as getMicrophone,
+  O as getMidiSupportInfo,
+  G as getVideoInputDevices,
+  U as inputController,
+  A as isMidiSupported,
+  R as keymaps,
+  J as majorKeymap,
+  Q as minorKeymap,
+  X as onDeviceChange,
+  Z as pentatonicKeymap
+};

package/dist/keymap-3lZMR1Ak.js

@@ -0,0 +1,167 @@
+async function u() {
+  try {
+    return await navigator.mediaDevices.getUserMedia({ audio: !0, video: !0 }), (await navigator.mediaDevices.enumerateDevices()).map((a) => ({
+      deviceId: a.deviceId,
+      label: a.label,
+      kind: a.kind
+    }));
+  } catch (e) {
+    return console.error("Failed to enumerate devices:", e), [];
+  }
+}
+async function f() {
+  if (!navigator.requestMIDIAccess)
+    throw new Error("MIDI access not supported in this browser");
+  return navigator.requestMIDIAccess();
+}
+async function N(e = {
+  echoCancellation: !1,
+  noiseSuppression: !0,
+  // ?
+  autoGainControl: !0
+  // ?
+}, a = "") {
+  try {
+    return await navigator.mediaDevices.getUserMedia({
+      audio: a ? {
+        ...e,
+        deviceId: { exact: a }
+      } : e
+    });
+  } catch (t) {
+    if (a && t.name === "OverconstrainedError")
+      return console.warn(
+        "Requested audio input device unavailable, falling back to default"
+      ), navigator.mediaDevices.getUserMedia({ audio: e });
+    throw t;
+  }
+}
+async function w(e = {
+  width: 1280,
+  height: 720,
+  facingMode: "user"
+}) {
+  return navigator.mediaDevices.getUserMedia({
+    video: e
+  });
+}
+async function M() {
+  return (await u()).filter((a) => a.kind === "audioinput");
+}
+async function E() {
+  return (await u()).filter((a) => a.kind === "audiooutput");
+}
+async function I() {
+  return (await u()).filter((a) => a.kind === "videoinput");
+}
+function k(e) {
+  return navigator.mediaDevices.addEventListener("devicechange", e), () => navigator.mediaDevices.removeEventListener("devicechange", e);
+}
+const g = {
+  KeyZ: 48,
+  KeyS: 49,
+  KeyX: 50,
+  KeyD: 51,
+  KeyC: 52,
+  KeyV: 53,
+  KeyG: 54,
+  KeyB: 55,
+  KeyH: 56,
+  KeyN: 57,
+  KeyJ: 58,
+  KeyM: 59,
+  Comma: 60,
+  KeyL: 61,
+  Period: 62,
+  Semicolon: 63,
+  Slash: 64,
+  KeyQ: 60,
+  Digit2: 61,
+  KeyW: 62,
+  Digit3: 63,
+  KeyE: 64,
+  KeyR: 65,
+  Digit5: 66,
+  KeyT: 67,
+  Digit6: 68,
+  KeyY: 69,
+  Digit7: 70,
+  KeyU: 71,
+  KeyI: 72,
+  Digit9: 73,
+  KeyO: 74,
+  Digit0: 75,
+  KeyP: 76,
+  BracketLeft: 77,
+  Equal: 78,
+  BracketRight: 79,
+  // Numpad
+  Numpad1: 60,
+  Numpad2: 62,
+  Numpad3: 64,
+  Numpad4: 65,
+  Numpad5: 67,
+  Numpad6: 69,
+  Numpad7: 71,
+  Numpad8: 72,
+  Numpad9: 74
+};
+function n(e) {
+  const { baseNote: a, scale: t } = e;
+  if (t.length === 0)
+    throw new RangeError("scale must contain at least one interval");
+  const y = [
+    ["KeyZ", "KeyX", "KeyC", "KeyV", "KeyB", "KeyN", "KeyM", "Comma", "Period", "Slash"],
+    ["KeyA", "KeyS", "KeyD", "KeyF", "KeyG", "KeyH", "KeyJ", "KeyK", "KeyL", "Semicolon", "Quote", "Backslash"],
+    ["KeyQ", "KeyW", "KeyE", "KeyR", "KeyT", "KeyY", "KeyU", "KeyI", "KeyO", "KeyP", "BracketLeft", "BracketRight"],
+    ["Digit1", "Digit2", "Digit3", "Digit4", "Digit5", "Digit6", "Digit7", "Digit8", "Digit9", "Digit0", "Minus", "Equal"]
+  ], o = {};
+  return y.forEach((s, i) => {
+    const c = a + i * 12;
+    s.forEach((r, d) => {
+      const K = d % t.length, m = Math.floor(d / t.length);
+      o[r] = c + m * 12 + t[K];
+    });
+  }), ["Numpad1", "Numpad2", "Numpad3", "Numpad4", "Numpad5", "Numpad6", "Numpad7", "Numpad8", "Numpad9"].forEach((s, i) => {
+    const c = i % t.length, r = Math.floor(i / t.length);
+    o[s] = a + 36 + r * 12 + t[c];
+  }), o;
+}
+const p = n({
+  baseNote: 36,
+  scale: [0, 2, 4, 5, 7, 9, 11]
+}), v = n({
+  baseNote: 36,
+  scale: [0, 2, 3, 5, 7, 8, 10]
+}), l = n({
+  baseNote: 36,
+  scale: [0, 2, 4, 7, 9]
+  // Major pentatonic
+}), D = n({
+  baseNote: 48,
+  scale: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+}), b = "major", A = {
+  piano: g,
+  major: p,
+  minor: v,
+  pentatonic: l,
+  chromatic: D
+};
+export {
+  b as D,
+  n as a,
+  M as b,
+  D as c,
+  g as d,
+  E as e,
+  w as f,
+  N as g,
+  u as h,
+  f as i,
+  I as j,
+  A as k,
+  v as l,
+  p as m,
+  k as o,
+  l as p
+};