@blibliki/engine 0.3.8 → 0.3.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blibliki/engine",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "type": "module",
   "source": "src/index.ts",
   "main": "dist/index.cjs",
@@ -18,10 +18,10 @@
   },
   "dependencies": {
     "es-toolkit": "^1.41.0",
+    "jzz": "^1.9.6",
     "node-web-audio-api": "^1.0.3",
-    "webmidi": "^3.1.14",
-    "@blibliki/transport": "^0.3.8",
-    "@blibliki/utils": "^0.3.8"
+    "@blibliki/utils": "^0.3.9",
+    "@blibliki/transport": "^0.3.9"
   },
   "scripts": {
     "build": "tsup",

package/src/core/Note/index.ts

@@ -1,5 +1,5 @@
 import { Seconds } from "@blibliki/transport";
-import { Message } from "webmidi";
+import Message from "../midi/Message";
 import frequencyTable from "./frequencyTable";
 
 const Notes = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];

package/src/core/midi/Message.ts

@@ -0,0 +1,46 @@
+/**
+ * Simple wrapper around MIDI message data (Uint8Array)
+ * Replaces the webmidi Message class with native Web MIDI API data
+ */
+export default class Message {
+  public readonly data: Uint8Array;
+
+  constructor(data: Uint8Array) {
+    this.data = data;
+  }
+
+  /**
+   * Returns the data bytes (excluding the status byte)
+   */
+  get dataBytes(): number[] {
+    return Array.from(this.data.slice(1));
+  }
+
+  /**
+   * Returns the MIDI message type based on the status byte
+   */
+  get type(): string {
+    const statusByte = this.data[0];
+    const messageType = statusByte & 0xf0;
+
+    switch (messageType) {
+      case 0x90: // Note On
+        // Check if velocity is 0 (which is actually Note Off)
+        return this.data[2] === 0 ? "noteoff" : "noteon";
+      case 0x80: // Note Off
+        return "noteoff";
+      case 0xb0: // Control Change
+        return "controlchange";
+      case 0xe0: // Pitch Bend
+        return "pitchbend";
+      case 0xd0: // Channel Pressure (Aftertouch)
+        return "channelaftertouch";
+      case 0xa0: // Polyphonic Key Pressure
+        return "keyaftertouch";
+      case 0xc0: // Program Change
+        return "programchange";
+      default:
+        return "unknown";
+    }
+  }
+}

package/src/core/midi/MidiDevice.ts

@@ -1,6 +1,7 @@
 import { Context } from "@blibliki/utils";
-import { MessageEvent, Input } from "webmidi";
+import type { JZZMidiMessage, JZZPort } from "./jzz.types";
 import MidiEvent, { MidiEventType } from "./MidiEvent";
+import Message from "./Message";
 
 export enum MidiPortState {
   connected = "connected",
@@ -25,11 +26,12 @@ export default class MidiDevice implements IMidiDevice {
   eventListerCallbacks: EventListerCallback[] = [];
 
   private context: Readonly<Context>;
-  private input: Input;
+  private input: JZZPort;
+  private _state: MidiPortState = MidiPortState.connected;
 
-  constructor(input: Input, context: Context) {
-    this.id = input.id;
-    this.name = input.name || `Device ${input.id}`;
+  constructor(input: JZZPort, id: string, name: string, context: Context) {
+    this.id = id;
+    this.name = name || `Device ${id}`;
     this.input = input;
     this.context = context;
 
@@ -37,17 +39,19 @@ export default class MidiDevice implements IMidiDevice {
   }
 
   get state() {
-    return this.input.state as MidiPortState;
+    return this._state;
   }
 
   connect() {
-    this.input.addListener("midimessage", (e: MessageEvent) => {
-      this.processEvent(e);
+    // JZZ uses a callback function to receive MIDI messages
+    this.input.connect((msg: JZZMidiMessage) => {
+      this.processEvent(msg);
     });
   }
 
   disconnect() {
-    this.input.removeListener();
+    this.input.close();
+    this._state = MidiPortState.disconnected;
   }
 
   serialize() {
@@ -66,10 +70,16 @@ export default class MidiDevice implements IMidiDevice {
     );
   }
 
-  private processEvent(event: MessageEvent) {
+  private processEvent(msg: JZZMidiMessage) {
+    // Convert JZZ MIDI message to Uint8Array
+    const data = new Uint8Array(msg.slice());
+    const message = new Message(data);
+
+    // Use current time as timestamp since JZZ doesn't provide precise timestamps
+    const timestamp = performance.now();
     const midiEvent = new MidiEvent(
-      event.message,
-      this.context.browserToContextTime(event.timestamp),
+      message,
+      this.context.browserToContextTime(timestamp),
     );
 
     switch (midiEvent.type) {

package/src/core/midi/MidiDeviceManager.ts

@@ -1,5 +1,6 @@
 import { Context } from "@blibliki/utils";
-import { Input, Output, WebMidi } from "webmidi";
+import JZZ from "jzz";
+import type { JZZ as JZZType, JZZInputInfo, JZZPort } from "./jzz.types";
 import ComputerKeyboardDevice from "./ComputerKeyboardDevice";
 import MidiDevice from "./MidiDevice";
 
@@ -10,6 +11,7 @@ export default class MidiDeviceManager {
   private initialized = false;
   private listeners: ListenerCallback[] = [];
   private context: Readonly<Context>;
+  private jzz: JZZType | null = null;
 
   constructor(context: Context) {
     this.context = context;
@@ -39,15 +41,21 @@ export default class MidiDeviceManager {
     if (this.initialized) return;
 
     try {
-      await WebMidi.enable();
-
-      WebMidi.inputs.forEach((input) => {
-        if (!this.devices.has(input.id)) {
-          this.devices.set(input.id, new MidiDevice(input, this.context));
+      const jzz: JZZType = (await JZZ()) as unknown as JZZType;
+      this.jzz = jzz;
+      const info = jzz.info();
+
+      // Get all MIDI input devices
+      for (const inputInfo of info.inputs ?? []) {
+        const id: string = inputInfo.id ?? inputInfo.name;
+        if (!this.devices.has(id)) {
+          const port = (await jzz.openMidiIn(inputInfo.name)) as unknown as JZZPort;
+          const device = new MidiDevice(port, id, inputInfo.name, this.context);
+          this.devices.set(id, device);
         }
-      });
+      }
     } catch (err) {
-      console.error("Error enabling WebMidi:", err);
+      console.error("Error enabling JZZ MIDI:", err);
     }
   }
 
@@ -59,34 +67,54 @@ export default class MidiDeviceManager {
   }
 
   private listenChanges() {
-    WebMidi.addListener("connected", (event) => {
-      const port = event.port as Input | Output;
-      if (port instanceof Output) return;
-
-      if (this.devices.has(port.id)) return;
-
-      const device = new MidiDevice(port, this.context);
-      this.devices.set(device.id, device);
-
-      this.listeners.forEach((listener) => {
-        listener(device);
-      });
-    });
-
-    WebMidi.addListener("disconnected", (event) => {
-      const port = event.port as Input | Output;
-      if (port instanceof Output) return;
-
-      const device = this.devices.get(port.id);
-      if (!device) return;
-      if (device instanceof ComputerKeyboardDevice) return;
-
-      device.disconnect();
-      this.devices.delete(device.id);
-
-      this.listeners.forEach((listener) => {
-        listener(device);
-      });
+    if (!this.jzz) return;
+
+    // JZZ watch for MIDI device changes
+    this.jzz.onChange(() => {
+      if (!this.jzz) return;
+
+      const info = this.jzz.info();
+      const currentInputIds = new Set<string>(
+        (info.inputs ?? []).map((i: JZZInputInfo) => i.id ?? i.name),
+      );
+
+      // Check for new devices
+      for (const inputInfo of info.inputs ?? []) {
+        const id: string = inputInfo.id ?? inputInfo.name;
+        if (!this.devices.has(id)) {
+          // New device connected
+          void this.jzz
+            .openMidiIn(inputInfo.name)
+            .then((port: unknown) => {
+              const jzzPort = port as JZZPort;
+              const device = new MidiDevice(
+                jzzPort,
+                id,
+                inputInfo.name,
+                this.context,
+              );
+              this.devices.set(id, device);
+
+              this.listeners.forEach((listener) => {
+                listener(device);
+              });
+            });
+        }
+      }
+
+      // Check for removed devices
+      for (const [id, device] of this.devices) {
+        if (device instanceof ComputerKeyboardDevice) continue;
+        if (!currentInputIds.has(id)) {
+          // Device disconnected
+          device.disconnect();
+          this.devices.delete(id);
+
+          this.listeners.forEach((listener) => {
+            listener(device);
+          });
+        }
+      }
     });
   }
 }

package/src/core/midi/MidiEvent.ts

@@ -1,5 +1,5 @@
 import { ContextTime } from "@blibliki/transport";
-import { Message } from "webmidi";
+import Message from "./Message";
 import Note, { INote } from "../Note";
 
 export enum MidiEventType {

package/src/core/midi/jzz.types.ts

@@ -0,0 +1,51 @@
+/**
+ * Type definitions for JZZ MIDI library
+ */
+
+export interface JZZInputInfo {
+  id?: string;
+  name: string;
+  manufacturer?: string;
+  version?: string;
+  engine?: string;
+}
+
+export interface JZZOutputInfo {
+  id?: string;
+  name: string;
+  manufacturer?: string;
+  version?: string;
+  engine?: string;
+}
+
+export interface JZZInfo {
+  inputs?: JZZInputInfo[];
+  outputs?: JZZOutputInfo[];
+  version?: string;
+  engine?: string;
+}
+
+export interface JZZMidiMessage extends Array<number> {
+  slice(): number[];
+}
+
+export interface JZZPort {
+  connect(callback: (msg: JZZMidiMessage) => void): JZZPort;
+  close(): void;
+  disconnect(): void;
+}
+
+// JZZ uses a custom Promise-like type called Async
+export interface JZZAsync<T> {
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
+    onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null,
+  ): JZZAsync<TResult1 | TResult2>;
+}
+
+export interface JZZ {
+  info(): JZZInfo;
+  openMidiIn(name: string): JZZAsync<JZZPort>;
+  openMidiOut(name: string): JZZAsync<JZZPort>;
+  onChange(callback: () => void): void;
+}