midiwire 0.1.0

package/src/utils/sysex.test.js

@@ -0,0 +1,222 @@
+import { describe, expect, it } from "vitest"
+import { createSysEx, decode7Bit, encode7Bit, isSysEx, parseSysEx } from "./sysex.js"
+
+describe("SysEx Utils", () => {
+  describe("parseSysEx", () => {
+    it("should parse valid SysEx messages", () => {
+      const data = [0xf0, 0x41, 0x10, 0x20, 0x30, 0xf7]
+      const result = parseSysEx(data)
+      expect(result).toEqual({
+        manufacturerId: 0x41,
+        payload: [0x10, 0x20, 0x30],
+        raw: data,
+      })
+    })
+
+    it("should return null for non-SysEx messages", () => {
+      expect(parseSysEx([0x90, 0x40, 0x7f])).toBeNull() // Note on
+      expect(parseSysEx([0xb0, 0x01, 0x40])).toBeNull() // CC
+      expect(parseSysEx([0xf0, 0x41, 0x10])).toBeNull() // Missing F7
+      expect(parseSysEx([0x41, 0x10, 0xf7])).toBeNull() // Missing F0
+    })
+
+    it("should handle empty payload", () => {
+      const data = [0xf0, 0xf7]
+      expect(parseSysEx(data)).toEqual({
+        manufacturerId: 0xf7,
+        payload: [],
+        raw: data,
+      })
+    })
+
+    it("should handle long SysEx messages", () => {
+      const payload = new Array(100).fill(0x40)
+      const data = [0xf0, 0x41, ...payload, 0xf7]
+      const result = parseSysEx(data)
+      expect(result.payload.length).toBe(100)
+      expect(result.payload.every((byte) => byte === 0x40)).toBe(true)
+    })
+  })
+
+  describe("createSysEx", () => {
+    it("should create valid SysEx messages", () => {
+      const result = createSysEx(0x41, [0x10, 0x20, 0x30])
+      expect(result).toEqual([0xf0, 0x41, 0x10, 0x20, 0x30, 0xf7])
+    })
+
+    it("should handle empty payload", () => {
+      expect(createSysEx(0x41, [])).toEqual([0xf0, 0x41, 0xf7])
+    })
+
+    it("should handle single byte payload", () => {
+      expect(createSysEx(0x41, [0x7f])).toEqual([0xf0, 0x41, 0x7f, 0xf7])
+    })
+  })
+
+  describe("isSysEx", () => {
+    it("should identify SysEx messages", () => {
+      expect(isSysEx([0xf0, 0x41, 0x10, 0xf7])).toBe(true)
+      expect(isSysEx([0xf0, 0xf7])).toBe(true)
+    })
+
+    it("should reject non-SysEx messages", () => {
+      expect(isSysEx([0x90, 0x40, 0x7f])).toBe(false) // Note on
+      expect(isSysEx([0xb0, 0x01, 0x40])).toBe(false) // CC
+      expect(isSysEx([0xf0, 0x41, 0x10])).toBe(false) // Missing F7
+      expect(isSysEx([0x41, 0x10, 0xf7])).toBe(false) // Missing F0
+      expect(isSysEx([])).toBe(false) // Empty
+      expect(isSysEx([0xf0])).toBe(false) // Too short
+    })
+  })
+
+  describe("encode7Bit", () => {
+    it("should encode 8-bit data to 7-bit MIDI format", () => {
+      // 7 bytes of 8-bit data should encode to 8 bytes of 7-bit data
+      const data = [0x80, 0x40, 0x20, 0x7f, 0xff, 0x00, 0x01]
+      const result = encode7Bit(data)
+
+      // Should be exactly 8 bytes (1 header + 7 data)
+      expect(result.length).toBe(8)
+
+      // All bytes should be 7-bit values (<= 0x7f)
+      expect(result.every((byte) => byte <= 0x7f)).toBe(true)
+
+      // First byte is header with packed MSBs: bytes 0 and 4 have MSB=1
+      // Bits: 0b0010001 = 0x11 (bits 0 and 4 set)
+      expect(result[0]).toBe(0x11)
+
+      // Remaining bytes are lower 7 bits of each input byte
+      expect(result.slice(1)).toEqual([0x00, 0x40, 0x20, 0x7f, 0x7f, 0x00, 0x01])
+    })
+
+    it("should handle single byte encoding", () => {
+      // Single byte should still work but creates a group
+      expect(encode7Bit([0x80])).toEqual([0x01, 0x00])
+      expect(encode7Bit([0x40])).toEqual([0x00, 0x40])
+      expect(encode7Bit([0x7f])).toEqual([0x00, 0x7f])
+    })
+
+    it("should handle empty data", () => {
+      expect(encode7Bit([])).toEqual([])
+    })
+
+    it("should handle multiple groups", () => {
+      // 14 bytes should encode to 16 bytes (2 groups of 8)
+      const data = [
+        0x80, 0x40, 0x20, 0x7f, 0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+      ]
+      const result = encode7Bit(data)
+
+      expect(result.length).toBe(16)
+      expect(result.every((byte) => byte <= 0x7f)).toBe(true)
+
+      // First group header (bytes 0 and 4 have MSB set)
+      expect(result[0]).toBe(0x11)
+      // First group data bytes
+      expect(result.slice(1, 8)).toEqual([0x00, 0x40, 0x20, 0x7f, 0x7f, 0x00, 0x01])
+
+      // Second group header (no bytes have MSB set)
+      expect(result[8]).toBe(0x00)
+      // Second group data bytes
+      expect(result.slice(9, 16)).toEqual([0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08])
+    })
+
+    it("should handle partial last group", () => {
+      // 5 bytes should encode to 6 bytes (header + 5 data)
+      const data = [0x80, 0x40, 0x20, 0x7f, 0xff]
+      const result = encode7Bit(data)
+
+      expect(result.length).toBe(6)
+      expect(result.every((byte) => byte <= 0x7f)).toBe(true)
+      expect(result[0]).toBe(0x11) // Header: bytes 0 and 3 have MSB set
+    })
+
+    it("should handle all values from 0x00 to 0xff", () => {
+      // Test with values that have various bit patterns
+      const data = [0x00, 0x01, 0x7f, 0x80, 0xff]
+      const result = encode7Bit(data)
+
+      expect(result.length).toBe(6)
+      expect(result.every((byte) => byte <= 0x7f)).toBe(true)
+
+      // Check specific values
+      expect(result[0]).toBe(0x18) // Header: 0x80 and 0xff have MSB set
+      expect(result[1]).toBe(0x00) // 0x00 & 0x7f
+      expect(result[2]).toBe(0x01) // 0x01 & 0x7f
+      expect(result[3]).toBe(0x7f) // 0x7f & 0x7f
+      expect(result[4]).toBe(0x00) // 0x80 & 0x7f
+      expect(result[5]).toBe(0x7f) // 0xff & 0x7f
+    })
+  })
+
+  describe("decode7Bit", () => {
+    it("should decode 7-bit format to 8-bit data", () => {
+      // Decode the 8-byte encoded data back to original 7 bytes
+      const encoded = [0x11, 0x00, 0x40, 0x20, 0x7f, 0x7f, 0x00, 0x01]
+      const decoded = decode7Bit(encoded)
+
+      // Should reconstruct the original 7 bytes
+      expect(decoded).toEqual([0x80, 0x40, 0x20, 0x7f, 0xff, 0x00, 0x01])
+    })
+
+    it("should handle single byte decoding", () => {
+      // Single byte encoded
+      const result = decode7Bit([0x01, 0x00])
+      expect(result).toEqual([0x80])
+    })
+
+    it("should handle empty data", () => {
+      expect(decode7Bit([])).toEqual([])
+    })
+
+    it("should round-trip correctly", () => {
+      const testData = [
+        [0x00],
+        [0x00, 0x01, 0x7f],
+        [0x80, 0x40, 0x20, 0x7f, 0xff, 0x00, 0x01],
+        [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff],
+        new Array(14).fill(0x42),
+        [0x00, 0x01, 0x02, 0x03, 0x04, 0x05],
+      ]
+
+      testData.forEach((original) => {
+        const encoded = encode7Bit(original)
+        const decoded = decode7Bit(encoded)
+        expect(decoded).toEqual(original)
+      })
+    })
+
+    it("should handle multiple groups", () => {
+      // Two groups of 8 bytes each
+      const encoded = [
+        0x11,
+        0x00,
+        0x40,
+        0x20,
+        0x7f,
+        0x7f,
+        0x00,
+        0x01, // First group
+        0x00,
+        0x02,
+        0x03,
+        0x04,
+        0x05,
+        0x06,
+        0x07,
+        0x08, // Second group
+      ]
+      const decoded = decode7Bit(encoded)
+      expect(decoded.length).toBe(14)
+      expect(decoded.slice(0, 7)).toEqual([0x80, 0x40, 0x20, 0x7f, 0xff, 0x00, 0x01])
+      expect(decoded.slice(7)).toEqual([0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08])
+    })
+
+    it("should handle partial last group", () => {
+      // Partial group with 5 data bytes
+      const encoded = [0x11, 0x00, 0x40, 0x20, 0x7f, 0x7f]
+      const decoded = decode7Bit(encoded)
+      expect(decoded).toEqual([0x80, 0x40, 0x20, 0x7f, 0xff])
+    })
+  })
+})

package/src/utils/validators.js

@@ -0,0 +1,88 @@
+/**
+ * Validate MIDI channel number
+ * @param {number} channel - Channel number
+ * @returns {boolean}
+ */
+export function isValidChannel(channel) {
+  return Number.isInteger(channel) && channel >= 1 && channel <= 16
+}
+
+/**
+ * Validate MIDI CC number
+ * @param {number} cc - CC number
+ * @returns {boolean}
+ */
+export function isValidCC(cc) {
+  return Number.isInteger(cc) && cc >= 0 && cc <= 127
+}
+
+/**
+ * Validate 14-bit MIDI CC number (0-31 for MSB)
+ * @param {number} cc - CC number
+ * @returns {boolean}
+ */
+export function isValid14BitCC(cc) {
+  return Number.isInteger(cc) && cc >= 0 && cc <= 31
+}
+
+/**
+ * Validate MIDI value (0-127)
+ * @param {number} value - MIDI value
+ * @returns {boolean}
+ */
+export function isValidMIDIValue(value) {
+  return Number.isInteger(value) && value >= 0 && value <= 127
+}
+
+/**
+ * Validate MIDI note number
+ * @param {number} note - Note number
+ * @returns {boolean}
+ */
+export function isValidNote(note) {
+  return Number.isInteger(note) && note >= 0 && note <= 127
+}
+
+/**
+ * Validate note velocity
+ * @param {number} velocity - Velocity value
+ * @returns {boolean}
+ */
+export function isValidVelocity(velocity) {
+  return Number.isInteger(velocity) && velocity >= 0 && velocity <= 127
+}
+
+/**
+ * Validate MIDI program change number
+ * @param {number} program - Program number
+ * @returns {boolean}
+ */
+export function isValidProgramChange(program) {
+  return Number.isInteger(program) && program >= 0 && program <= 127
+}
+
+/**
+ * Validate pitch bend value (14-bit)
+ * @param {number} value - Pitch bend value (0-16383, where 8192 is center)
+ * @returns {boolean}
+ */
+export function isValidPitchBend(value) {
+  return Number.isInteger(value) && value >= 0 && value <= 16383
+}
+
+/**
+ * Validate pitch bend MSB and LSB separately
+ * @param {number} msb - Most significant byte (0-127)
+ * @param {number} lsb - Least significant byte (0-127)
+ * @returns {boolean}
+ */
+export function isValidPitchBendBytes(msb, lsb) {
+  return (
+    Number.isInteger(msb) &&
+    msb >= 0 &&
+    msb <= 127 &&
+    Number.isInteger(lsb) &&
+    lsb >= 0 &&
+    lsb <= 127
+  )
+}

package/src/utils/validators.test.js

@@ -0,0 +1,300 @@
+import { describe, expect, it } from "vitest"
+import {
+  isValid14BitCC,
+  isValidCC,
+  isValidChannel,
+  isValidMIDIValue,
+  isValidNote,
+  isValidPitchBend,
+  isValidPitchBendBytes,
+  isValidProgramChange,
+  isValidVelocity,
+} from "./validators.js"
+
+describe("Validators - Complete Tests", () => {
+  describe("isValidChannel", () => {
+    const validChannels = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
+    const invalidChannels = [
+      0,
+      17,
+      -1,
+      100,
+      1.5,
+      0.5,
+      NaN,
+      Infinity,
+      -Infinity,
+      null,
+      "",
+      "1",
+      undefined,
+    ]
+
+    it("should validate all valid channels 1-16", () => {
+      validChannels.forEach((channel) => {
+        expect(isValidChannel(channel)).toBe(true)
+      })
+    })
+
+    it("should reject invalid channels", () => {
+      invalidChannels.forEach((channel) => {
+        expect(isValidChannel(channel)).toBe(false)
+      })
+    })
+
+    it("should only accept integers", () => {
+      expect(isValidChannel(1)).toBe(true)
+      expect(isValidChannel(1.0)).toBe(true)
+      expect(isValidChannel(1.5)).toBe(false)
+      expect(isValidChannel(Number.EPSILON)).toBe(false)
+    })
+  })
+
+  describe("isValidCC", () => {
+    it("should validate all valid CC numbers 0-127", () => {
+      for (let cc = 0; cc <= 127; cc++) {
+        expect(isValidCC(cc)).toBe(true)
+      }
+    })
+
+    it("should reject invalid CC numbers", () => {
+      const invalid = [-1, 128, 200, 1.5, 63.7, NaN, Infinity, -Infinity, null, "", "1", undefined]
+      invalid.forEach((cc) => {
+        expect(isValidCC(cc)).toBe(false)
+      })
+    })
+
+    it("should only accept integers", () => {
+      expect(isValidCC(64)).toBe(true)
+      expect(isValidCC(64.0)).toBe(true)
+      expect(isValidCC(64.1)).toBe(false)
+    })
+  })
+
+  describe("isValidMIDIValue", () => {
+    it("should validate all valid MIDI values 0-127", () => {
+      for (let value = 0; value <= 127; value++) {
+        expect(isValidMIDIValue(value)).toBe(true)
+      }
+    })
+
+    it("should reject invalid values", () => {
+      const invalid = [-1, 128, 200, 1.5, NaN, Infinity, -Infinity, null, "", "1", undefined]
+      invalid.forEach((value) => {
+        expect(isValidMIDIValue(value)).toBe(false)
+      })
+    })
+
+    it("should only accept integers", () => {
+      expect(isValidMIDIValue(100)).toBe(true)
+      expect(isValidMIDIValue(100.0)).toBe(true)
+      expect(isValidMIDIValue(100.5)).toBe(false)
+    })
+  })
+
+  describe("isValidNote", () => {
+    it("should validate all valid note numbers 0-127", () => {
+      for (let note = 0; note <= 127; note++) {
+        expect(isValidNote(note)).toBe(true)
+      }
+    })
+
+    it("should reject invalid note numbers", () => {
+      const invalid = [-1, 128, 200, 1.5, 60.5, NaN, Infinity, -Infinity, null, "", "60", undefined]
+      invalid.forEach((note) => {
+        expect(isValidNote(note)).toBe(false)
+      })
+    })
+
+    it("should only accept integers", () => {
+      expect(isValidNote(60)).toBe(true)
+      expect(isValidNote(60.0)).toBe(true)
+      expect(isValidNote(60.5)).toBe(false)
+    })
+  })
+
+  describe("isValidVelocity", () => {
+    it("should validate all valid velocities 0-127", () => {
+      for (let velocity = 0; velocity <= 127; velocity++) {
+        expect(isValidVelocity(velocity)).toBe(true)
+      }
+    })
+
+    it("should reject invalid velocities", () => {
+      const invalid = [-1, 128, 200, 1.5, 64.7, NaN, Infinity, -Infinity, null, "", "64", undefined]
+      invalid.forEach((velocity) => {
+        expect(isValidVelocity(velocity)).toBe(false)
+      })
+    })
+
+    it("should only accept integers", () => {
+      expect(isValidVelocity(100)).toBe(true)
+      expect(isValidVelocity(100.0)).toBe(true)
+      expect(isValidVelocity(100.5)).toBe(false)
+    })
+
+    it("should validate common velocity values", () => {
+      expect(isValidVelocity(0)).toBe(true) // Note off
+      expect(isValidVelocity(64)).toBe(true) // Medium
+      expect(isValidVelocity(100)).toBe(true) // Strong
+      expect(isValidVelocity(127)).toBe(true) // Maximum
+    })
+  })
+
+  describe("isValid14BitCC", () => {
+    it("should validate all valid 14-bit CC numbers 0-31", () => {
+      for (let cc = 0; cc <= 31; cc++) {
+        expect(isValid14BitCC(cc)).toBe(true)
+      }
+    })
+
+    it("should reject invalid 14-bit CC numbers", () => {
+      const invalid = [
+        -1,
+        32,
+        100,
+        127,
+        128,
+        1.5,
+        NaN,
+        Infinity,
+        -Infinity,
+        null,
+        "",
+        "1",
+        undefined,
+      ]
+      invalid.forEach((cc) => {
+        expect(isValid14BitCC(cc)).toBe(false)
+      })
+    })
+
+    it("should only accept integers", () => {
+      expect(isValid14BitCC(15)).toBe(true)
+      expect(isValid14BitCC(15.0)).toBe(true)
+      expect(isValid14BitCC(15.5)).toBe(false)
+    })
+
+    it("should validate common 14-bit CC values", () => {
+      expect(isValid14BitCC(0)).toBe(true) // CC 0 (MSB for bank select)
+      expect(isValid14BitCC(6)).toBe(true) // Data entry MSB
+      expect(isValid14BitCC(16)).toBe(true) // General purpose 1 MSB
+      expect(isValid14BitCC(31)).toBe(true) // Maximum valid 14-bit CC
+    })
+  })
+
+  describe("isValidProgramChange", () => {
+    it("should validate all valid program numbers 0-127", () => {
+      for (let program = 0; program <= 127; program++) {
+        expect(isValidProgramChange(program)).toBe(true)
+      }
+    })
+
+    it("should reject invalid program numbers", () => {
+      const invalid = [-1, 128, 200, 1.5, NaN, Infinity, null, "", "64", undefined]
+      invalid.forEach((program) => {
+        expect(isValidProgramChange(program)).toBe(false)
+      })
+    })
+
+    it("should only accept integers", () => {
+      expect(isValidProgramChange(64)).toBe(true)
+      expect(isValidProgramChange(64.0)).toBe(true)
+      expect(isValidProgramChange(64.5)).toBe(false)
+    })
+  })
+
+  describe("isValidPitchBend", () => {
+    it("should validate 14-bit pitch bend range 0-16383", () => {
+      expect(isValidPitchBend(0)).toBe(true) // Max down
+      expect(isValidPitchBend(8192)).toBe(true) // Center
+      expect(isValidPitchBend(16383)).toBe(true) // Max up
+    })
+
+    it("should reject out-of-range values", () => {
+      expect(isValidPitchBend(-1)).toBe(false)
+      expect(isValidPitchBend(16384)).toBe(false)
+      expect(isValidPitchBend(20000)).toBe(false)
+    })
+
+    it("should reject non-integers", () => {
+      expect(isValidPitchBend(8192.5)).toBe(false)
+      expect(isValidPitchBend(NaN)).toBe(false)
+      expect(isValidPitchBend(Infinity)).toBe(false)
+      expect(isValidPitchBend("8192")).toBe(false)
+    })
+  })
+
+  describe("isValidPitchBendBytes", () => {
+    it("should validate valid MSB/LSB combinations", () => {
+      expect(isValidPitchBendBytes(0, 0)).toBe(true) // 0
+      expect(isValidPitchBendBytes(64, 0)).toBe(true) // 8192 (center)
+      expect(isValidPitchBendBytes(127, 127)).toBe(true) // 16383
+    })
+
+    it("should reject invalid MSB or LSB", () => {
+      expect(isValidPitchBendBytes(-1, 0)).toBe(false)
+      expect(isValidPitchBendBytes(0, 128)).toBe(false)
+      expect(isValidPitchBendBytes(128, 0)).toBe(false)
+      expect(isValidPitchBendBytes(64.5, 0)).toBe(false)
+    })
+  })
+
+  describe("validator edge cases", () => {
+    it("should handle boundary values correctly", () => {
+      // Valid boundaries
+      expect(isValidChannel(1)).toBe(true)
+      expect(isValidChannel(16)).toBe(true)
+      expect(isValidCC(0)).toBe(true)
+      expect(isValidCC(127)).toBe(true)
+      expect(isValidMIDIValue(0)).toBe(true)
+      expect(isValidMIDIValue(127)).toBe(true)
+      expect(isValidNote(0)).toBe(true)
+      expect(isValidNote(127)).toBe(true)
+      expect(isValidVelocity(0)).toBe(true)
+      expect(isValidVelocity(127)).toBe(true)
+      expect(isValid14BitCC(0)).toBe(true)
+      expect(isValid14BitCC(31)).toBe(true)
+
+      // Invalid boundaries
+      expect(isValidChannel(0)).toBe(false)
+      expect(isValidChannel(17)).toBe(false)
+      expect(isValidCC(-1)).toBe(false)
+      expect(isValidCC(128)).toBe(false)
+      expect(isValidMIDIValue(-1)).toBe(false)
+      expect(isValidMIDIValue(128)).toBe(false)
+      expect(isValidNote(-1)).toBe(false)
+      expect(isValidNote(128)).toBe(false)
+      expect(isValidVelocity(-1)).toBe(false)
+      expect(isValidVelocity(128)).toBe(false)
+      expect(isValid14BitCC(-1)).toBe(false)
+      expect(isValid14BitCC(32)).toBe(false)
+    })
+
+    it("should handle all zero edge cases", () => {
+      expect(isValidChannel(0)).toBe(false) // Channel 0 is not valid
+      expect(isValidCC(0)).toBe(true) // CC 0 is valid
+      expect(isValidMIDIValue(0)).toBe(true) // Value 0 is valid
+      expect(isValidNote(0)).toBe(true) // Note 0 is valid
+      expect(isValidVelocity(0)).toBe(true) // Velocity 0 is valid
+      expect(isValid14BitCC(0)).toBe(true) // 14-bit CC 0 is valid
+      expect(isValidProgramChange(0)).toBe(true) // Program 0 is valid
+      expect(isValidPitchBend(0)).toBe(true) // Pitch bend 0 is valid (max down)
+      expect(isValidPitchBendBytes(0, 0)).toBe(true) // Pitch bend bytes 0, 0 is valid
+    })
+
+    it("should handle non-numeric inputs", () => {
+      const nonNumeric = ["1", "", null, undefined, {}, []]
+      nonNumeric.forEach((value) => {
+        expect(isValidChannel(value)).toBe(false)
+        expect(isValidCC(value)).toBe(false)
+        expect(isValidMIDIValue(value)).toBe(false)
+        expect(isValidNote(value)).toBe(false)
+        expect(isValidVelocity(value)).toBe(false)
+        expect(isValid14BitCC(value)).toBe(false)
+        expect(isValidProgramChange(value)).toBe(false)
+        expect(isValidPitchBend(value)).toBe(false)
+      })
+    })
+  })
+})