bump @jwetzell/osc to v1.4.0

fix bundle minimum size check

package-lock.json

@@ -3651,7 +3651,7 @@
     },
     "packages/osc": {
       "name": "@jwetzell/osc",
-      "version": "1.3.0",
+      "version": "1.4.0",
       "license": "MIT",
       "devDependencies": {
         "@types/node": "22.7.5",

packages/osc/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jwetzell/osc",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

packages/osc/src/bundle.ts

@@ -3,7 +3,7 @@ import { OSCBundle } from './models';
 import { oscTypeConverterMap } from './osc-types';
 
 export function bundleFromBuffer(bytes: Uint8Array): [OSCBundle | undefined, Uint8Array | undefined] {
-  if (bytes.length < 8) {
+  if (bytes.length < 20) {
     throw new Error('bundle has to be at least 20 bytes');
   }
 

packages/osc/src/message.ts

@@ -28,28 +28,32 @@ function argsToBuffer(args: OSCArg[]) {
 }
 
 export function messageToBuffer(message: OSCMessage): Uint8Array {
+  if (!message.address.startsWith('/')) {
+    throw new Error('osc message must start with a /');
+  }
+
   const addressBuffer = oscTypeConverterMap.s.toBuffer(message.address);
   if (addressBuffer === undefined) {
     throw new Error('problem encoding address');
   }
 
-  let typeString = ','
+  let typeString = ',';
 
-  const flatOSCArgs: OSCArg[] = []
+  const flatOSCArgs: OSCArg[] = [];
 
-  message.args.forEach((oscArg)=> {
+  message.args.forEach((oscArg) => {
-    if(Array.isArray(oscArg)){
+    if (Array.isArray(oscArg)) {
-      typeString += '['
+      typeString += '[';
-      oscArg.forEach((oscArg)=>{
+      oscArg.forEach((oscArg) => {
-        typeString += oscArg.type
+        typeString += oscArg.type;
-        flatOSCArgs.push(oscArg)
+        flatOSCArgs.push(oscArg);
-      })
+      });
-      typeString += ']'
+      typeString += ']';
-    }else {
+    } else {
-      typeString += oscArg.type
+      typeString += oscArg.type;
-      flatOSCArgs.push(oscArg)
+      flatOSCArgs.push(oscArg);
     }
-  })
+  });
 
   const typesBuffer = oscTypeConverterMap.s.toBuffer(typeString);
   if (typesBuffer === undefined) {
@@ -72,6 +76,17 @@ export function messageFromBuffer(bytes: Uint8Array): [OSCMessage | undefined, U
 
   const [address, bytesAfterAddress] = oscTypeConverterMap.s.fromBuffer(bytes);
   if (typeof address === 'string') {
+    if (bytesAfterAddress.length === 0) {
+      // NOTE(jwetzell): OSC 1.0 spec says that messages without a type string should be allowed
+      return [
+        {
+          address,
+          args: [],
+        },
+        bytesAfterAddress,
+      ];
+    }
+
     let [typeString, bytesAfterType] = oscTypeConverterMap.s.fromBuffer(bytesAfterAddress);
     if (typeof typeString === 'string') {
       if (!typeString.startsWith(',')) {
@@ -83,18 +98,18 @@ export function messageFromBuffer(bytes: Uint8Array): [OSCMessage | undefined, U
       for (let index = 1; index < typeString.length; index++) {
         const argType = typeString.charAt(index) as OSCType;
 
-        if (argType === '['){
+        if (argType === '[') {
-          if (insideArgArray){
+          if (insideArgArray) {
-            throw new Error('osc arg array opened without closing previous arg array')
+            throw new Error('osc arg array opened without closing previous arg array');
           }
           oscArrayArg = [];
           insideArgArray = true;
           continue;
         }
 
-        if (argType === ']'){
+        if (argType === ']') {
-          if (!insideArgArray){
+          if (!insideArgArray) {
-            throw new Error('osc arg array closed without opening arg array')
+            throw new Error('osc arg array closed without opening arg array');
           }
           oscArgs.push(oscArrayArg);
           oscArrayArg = [];
@@ -112,9 +127,9 @@ export function messageFromBuffer(bytes: Uint8Array): [OSCMessage | undefined, U
             type: argType,
             value: value,
           };
-          if(insideArgArray){
+          if (insideArgArray) {
-            oscArrayArg.push(arg)
+            oscArrayArg.push(arg);
-          }else {
+          } else {
             oscArgs.push(arg);
           }
         }

packages/osc/tests/bundle-decode.test.js

@@ -1,8 +1,8 @@
-const { deepEqual, equal } = require('assert');
+const { deepEqual, equal, throws } = require('assert');
 const { describe, it } = require('node:test');
 const osc = require('../dist/index');
 
-const tests = [
+const goodTests = [
   {
     description: 'simple contents single message',
     bytes: new Uint8Array([
@@ -20,6 +20,34 @@ const tests = [
       contents: [{ address: '/oscillator/4/frequency', args: [{ type: 'f', value: 440 }] }],
     },
   },
+  {
+    description: 'simple contents single bundle',
+    bytes: new Uint8Array([
+      ...new TextEncoder().encode('#bundle'),
+      ...new Uint8Array([0x00]),
+      ...new Uint8Array([0, 0, 0, 32, 0, 0, 0, 0]),
+      ...new Uint8Array([0x00, 0x00, 0x00, 0x34]),
+      ...new Uint8Array([
+        ...new TextEncoder().encode('#bundle'),
+        ...new Uint8Array([0x00]),
+        ...new Uint8Array([0, 0, 0, 32, 0, 0, 0, 0]),
+        ...new Uint8Array([0x00, 0x00, 0x00, 0x20]),
+        ...new Uint8Array([
+          0x2f, 0x6f, 0x73, 0x63, 0x69, 0x6c, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x2f, 0x34, 0x2f, 0x66, 0x72, 0x65, 0x71,
+          0x75, 0x65, 0x6e, 0x63, 0x79, 0x00, 0x2c, 0x66, 0x00, 0x00, 0x43, 0xdc, 0x00, 0x00,
+        ]),
+      ]),
+    ]),
+    expected: {
+      timeTag: [32, 0],
+      contents: [
+        {
+          timeTag: [32, 0],
+          contents: [{ address: '/oscillator/4/frequency', args: [{ type: 'f', value: 440 }] }],
+        },
+      ],
+    },
+  },
   {
     description: 'resolume bundle example',
     bytes: new Uint8Array([
@@ -88,8 +116,71 @@ const tests = [
   },
 ];
 
-describe('OSC Bundle Decoding', () => {
+const badTests = [
-  tests.forEach((bundleTest) => {
+  {
+    description: 'bad bundle header',
+    bytes: new Uint8Array([
+      ...new TextEncoder().encode('bundle'),
+      ...new Uint8Array([0x00]),
+      ...new Uint8Array([0, 0, 0, 32, 0, 0, 0, 0]),
+      ...new Uint8Array([0x00, 0x00, 0x00, 0x20]),
+      ...new Uint8Array([
+        0x2f, 0x6f, 0x73, 0x63, 0x69, 0x6c, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x2f, 0x34, 0x2f, 0x66, 0x72, 0x65, 0x71,
+        0x75, 0x65, 0x6e, 0x63, 0x79, 0x00, 0x2c, 0x66, 0x00, 0x00, 0x43, 0xdc, 0x00, 0x00,
+      ]),
+    ]),
+    throwsMessage: {
+      name: /^Error$/,
+      message: 'bundle must start with #bundle',
+    },
+  },
+  {
+    description: 'incomplete bundle',
+    bytes: new Uint8Array([
+      ...new TextEncoder().encode('#bundle'),
+      ...new Uint8Array([0x00]),
+      ...new Uint8Array([0, 0, 0, 32, 0, 0, 0, 0]),
+    ]),
+    throwsMessage: {
+      name: /^Error$/,
+      message: 'bundle has to be at least 20 bytes',
+    },
+  },
+  {
+    description: 'bundle not enough bytes',
+    bytes: new Uint8Array([
+      ...new TextEncoder().encode('#bundle'),
+      ...new Uint8Array([0x00]),
+      ...new Uint8Array([0, 0, 0, 32, 0, 0, 0, 0]),
+      ...new Uint8Array([0x00, 0x00, 0x00, 0x20]),
+      ...new Uint8Array([0x2f, 0x6f, 0x73, 0x63, 0x69, 0x6c, 0x6c, 0x61]),
+    ]),
+    throwsMessage: {
+      name: /^Error$/,
+      message: 'bundle does not contain enough data',
+    },
+  },
+  {
+    description: 'bad bundle contents',
+    bytes: new Uint8Array([
+      ...new TextEncoder().encode('#bundle'),
+      ...new Uint8Array([0x00]),
+      ...new Uint8Array([0, 0, 0, 32, 0, 0, 0, 0]),
+      ...new Uint8Array([0x00, 0x00, 0x00, 0x20]),
+      ...new Uint8Array([
+        0x2a, 0x6f, 0x73, 0x63, 0x69, 0x6c, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x2f, 0x34, 0x2f, 0x66, 0x72, 0x65, 0x71,
+        0x75, 0x65, 0x6e, 0x63, 0x79, 0x00, 0x2c, 0x66, 0x00, 0x00, 0x43, 0xdc, 0x00, 0x00,
+      ]),
+    ]),
+    throwsMessage: {
+      name: /^Error$/,
+      message: 'bundle contents does not look like a OSC message or bundle',
+    },
+  },
+];
+
+describe('OSC Bundle Decoding Pass', () => {
+  goodTests.forEach((bundleTest) => {
     it(bundleTest.description, () => {
       const [encoded, remainingBytes] = osc.bundleFromBuffer(bundleTest.bytes);
       equal(remainingBytes.length, 0);
@@ -97,3 +188,13 @@ describe('OSC Bundle Decoding', () => {
     });
   });
 });
+
+describe('OSC Bundle Decoding Throws', () => {
+  badTests.forEach((bundleTest) => {
+    it(bundleTest.description, () => {
+      throws(() => {
+        osc.bundleFromBuffer(bundleTest.bytes);
+      }, bundleTest.throwsMessage);
+    });
+  });
+});

packages/osc/tests/message-decode.test.js

@@ -2,7 +2,7 @@ const { deepEqual, throws, equal } = require('assert');
 const { describe, it } = require('node:test');
 const osc = require('../dist/index');
 
-const tests = [
+const goodTests = [
   {
     description: 'simple address no args',
     bytes: new Uint8Array([47, 104, 101, 108, 108, 111, 0, 0, 44, 0, 0, 0]),
@@ -68,9 +68,26 @@ const tests = [
   {
     description: 'simple address array arg',
     bytes: new Uint8Array([
-      47, 104, 101, 108, 108, 111, 0, 0, 44, 91, 100, 105, 93, 0, 0, 0, 0x40, 0x29, 0x87, 0xec, 0x82, 0x74, 0xb9, 0xe6, 0, 0, 3, 232
+      47, 104, 101, 108, 108, 111, 0, 0, 44, 91, 100, 105, 93, 0, 0, 0, 0x40, 0x29, 0x87, 0xec, 0x82, 0x74, 0xb9, 0xe6,
+      0, 0, 3, 232,
     ]),
-    expected: { address: '/hello', args: [[{ type: 'd', value: 12.7654763 }, { type: 'i', value: 1000}]] },
+    expected: {
+      address: '/hello',
+      args: [
+        [
+          { type: 'd', value: 12.7654763 },
+          { type: 'i', value: 1000 },
+        ],
+      ],
+    },
+  },
+  {
+    description: 'simple address no type string',
+    bytes: new Uint8Array([47, 104, 101, 108, 108, 111, 0, 0]),
+    expected: {
+      address: '/hello',
+      args: [],
+    },
   },
   {
     description: 'osc 1.0 spec example 1',
@@ -100,83 +117,78 @@ const tests = [
   },
 ];
 
-describe('OSC Message Decoding', () => {
+const badTests = [
-  tests.forEach((messageTest) => {
+  {
+    description: 'bad address',
+    bytes: new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x66, 0x00, 0x00, 0x42, 0x0a, 0x00, 0x00]),
+    throwsMessage: { name: /^Error$/, message: /must start with/ },
+  },
+
+  {
+    description: 'bad type string',
+    bytes: new Uint8Array([0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x66, 0x00, 0x00, 0x00, 0x42, 0x0a, 0x00]),
+    throwsMessage: { name: /^Error$/, message: /type string must start with/ },
+  },
+  {
+    description: 'unknown type',
+    bytes: new Uint8Array([
+      0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x7a, 0x00, 0x00, 0x42, 0x0a, 0x00, 0x00,
+    ]),
+    throwsMessage: { name: /^Error$/, message: /unknown/ },
+  },
+  {
+    description: 'float arg missing bytes',
+    bytes: new Uint8Array([0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x66, 0x00, 0x00, 0x42, 0x0a, 0x00]),
+    throwsMessage: { name: /^Error$/, message: /not enough bytes/ },
+  },
+  {
+    description: 'int arg missing bytes',
+    bytes: new Uint8Array([0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x69, 0x00, 0x00, 0x00, 0x00, 0x00]),
+    throwsMessage: { name: /^Error$/, message: /not enough bytes/ },
+  },
+  {
+    description: 'blob bytes too small',
+    bytes: new Uint8Array([
+      0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x62, 0x6c, 0x6f,
+    ]),
+    throwsMessage: { name: /^Error$/, message: /not enough bytes/ },
+  },
+  {
+    description: 'float64 missing bytes',
+    bytes: new Uint8Array([
+      47, 104, 101, 108, 108, 111, 0, 0, 44, 100, 0, 0, 0x40, 0x29, 0x87, 0xec, 0x82, 0x74, 0xb9,
+    ]),
+    throwsMessage: { name: /^Error$/, message: /not enough bytes/ },
+  },
+  {
+    description: 'int64 missing bytes',
+    bytes: new Uint8Array([47, 104, 101, 108, 108, 111, 0, 0, 44, 104, 0, 0, 0, 0, 255, 255, 255, 255, 255]),
+    throwsMessage: { name: /^Error$/, message: /must be at least/ },
+  },
+  {
+    description: 'color missing bytes',
+    bytes: new Uint8Array([47, 104, 101, 108, 108, 111, 0, 0, 44, 114, 0, 0, 20, 21, 22]),
+    throwsMessage: { name: /^Error$/, message: /must be at least/ },
+  },
+  
+];
+
+describe('OSC Message Decoding Pass', () => {
+  goodTests.forEach((messageTest) => {
     it(messageTest.description, () => {
       const [decoded, remainingBytes] = osc.messageFromBuffer(messageTest.bytes);
       equal(remainingBytes.length, 0);
       deepEqual(decoded, messageTest.expected);
     });
   });
+});
 
-  it('bad address', () => {
+describe('OSC Message Decoding Throws', () => {
-    throws(
+  badTests.forEach((messageTest) => {
-      () => {
+    it(messageTest.description, () => {
-        osc.messageFromBuffer(
+      throws(() => {
-          new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x66, 0x00, 0x00, 0x42, 0x0a, 0x00, 0x00])
+        osc.messageFromBuffer(messageTest.bytes);
-        );
+      }, messageTest.throwsMessage);
-      },
+    });
-      { name: /^Error$/, message: /must start with/ }
-    );
-  });
-
-  it('bad type string', () => {
-    throws(
-      () => {
-        osc.messageFromBuffer(
-          new Uint8Array([0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x66, 0x00, 0x00, 0x00, 0x42, 0x0a, 0x00])
-        );
-      },
-      { name: /^Error$/, message: /type string must start with/ }
-    );
-  });
-
-  it('unknown type', () => {
-    throws(
-      () => {
-        osc.messageFromBuffer(
-          new Uint8Array([
-            0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x7a, 0x00, 0x00, 0x42, 0x0a, 0x00, 0x00,
-          ])
-        );
-      },
-      { name: /^Error$/, message: /unknown/ }
-    );
-  });
-
-  it('float arg missing bytes', () => {
-    throws(
-      () => {
-        osc.messageFromBuffer(
-          new Uint8Array([0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x66, 0x00, 0x00, 0x42, 0x0a, 0x00])
-        );
-      },
-      { name: /^Error$/, message: /not enough bytes/ }
-    );
-  });
-
-  it('int arg missing bytes', () => {
-    throws(
-      () => {
-        osc.messageFromBuffer(
-          new Uint8Array([0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x69, 0x00, 0x00, 0x00, 0x00, 0x00])
-        );
-      },
-      { name: /^Error$/, message: /not enough bytes/ }
-    );
-  });
-
-  it('blob bytes too small', () => {
-    throws(
-      () => {
-        osc.messageFromBuffer(
-          new Uint8Array([
-            0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x62, 0x6c,
-            0x6f,
-          ])
-        );
-      },
-      { name: /^Error$/, message: /not enough bytes/ }
-    );
   });
 });

packages/osc/tests/message-encode.test.js

@@ -2,7 +2,7 @@ const { deepEqual, throws } = require('assert');
 const { describe, it } = require('node:test');
 const osc = require('../dist/index');
 
-const tests = [
+const goodTests = [
   {
     description: 'simple address no args',
     message: { address: '/hello', args: [] },
@@ -62,9 +62,18 @@ const tests = [
   },
   {
     description: 'simple address array arg',
-    message: { address: '/hello', args: [[{ type: 'd', value: 12.7654763 }, { type: 'i', value: 1000}]] },
+    message: {
+      address: '/hello',
+      args: [
+        [
+          { type: 'd', value: 12.7654763 },
+          { type: 'i', value: 1000 },
+        ],
+      ],
+    },
     expected: new Uint8Array([
-      47, 104, 101, 108, 108, 111, 0, 0, 44, 91, 100, 105, 93, 0, 0, 0, 0x40, 0x29, 0x87, 0xec, 0x82, 0x74, 0xb9, 0xe6, 0, 0, 3, 232
+      47, 104, 101, 108, 108, 111, 0, 0, 44, 91, 100, 105, 93, 0, 0, 0, 0x40, 0x29, 0x87, 0xec, 0x82, 0x74, 0xb9, 0xe6,
+      0, 0, 3, 232,
     ]),
   },
   {
@@ -95,55 +104,58 @@ const tests = [
   },
 ];
 
-describe('OSC Message Encoding', () => {
+const badTests = [
-  tests.forEach((messageTest) => {
+  {
+    description: 'bad string arg',
+    message: { address: '/address', args: [{ type: 's', value: 123 }] },
+    throwsMessage: { name: /^TypeError$/, message: /non string/ },
+  },
+
+  {
+    description: 'bad integer arg',
+    message: { address: '/address', args: [{ type: 'i', value: 'hi' }] },
+    throwsMessage: { name: /^TypeError$/, message: /non number/ },
+  },
+  {
+    description: 'bad float arg',
+    message: { address: '/address', args: [{ type: 'f', value: 'hi' }] },
+    throwsMessage: { name: /^TypeError$/, message: /non number/ },
+  },
+  {
+    description: 'bad blob arg',
+    message: { address: '/address', args: [{ type: 'b', value: 123 }] },
+    throwsMessage: { name: /^TypeError$/, message: /non Uint8Array/ },
+  },
+  {
+    description: 'unknown arg type',
+    message: { address: '/address', args: [{ type: 'z', value: 123 }] },
+    throwsMessage: { name: /^TypeError$/, message: /unknown type z/ },
+  },
+  {
+    description: 'address that does not start with / should throw',
+    message: { address: 'address', args: [] },
+    throwsMessage: {
+      name: /^Error$/,
+      message: 'osc message must start with a /',
+    },
+  },
+];
+
+describe('OSC Message Encoding Pass', () => {
+  goodTests.forEach((messageTest) => {
     it(messageTest.description, () => {
       const encoded = osc.messageToBuffer(messageTest.message);
       deepEqual(encoded, messageTest.expected);
     });
   });
-  it('bad string arg', () => {
+});
-    throws(
-      () => {
-        osc.messageToBuffer({ address: '/address', args: [{ type: 's', value: 123 }] });
-      },
-      { name: /^TypeError$/ }
-    );
-  });
 
-  it('bad integer arg', () => {
+describe('OSC Message Encoding Throws', () => {
-    throws(
+  badTests.forEach((messageTest) => {
-      () => {
+    it(messageTest.description, () => {
-        osc.messageToBuffer({ address: '/address', args: [{ type: 'i', value: 'hi' }] });
+      throws(() => {
-      },
+        osc.messageToBuffer(messageTest.message);
-      { name: /^TypeError$/ }
+      }, messageTest.throwsMessage);
-    );
+    });
-  });
-
-  it('bad float arg', () => {
-    throws(
-      () => {
-        osc.messageToBuffer({ address: '/address', args: [{ type: 'f', value: 'hi' }] });
-      },
-      { name: /^TypeError$/ }
-    );
-  });
-
-  it('bad blob arg', () => {
-    throws(
-      () => {
-        osc.messageToBuffer({ address: '/address', args: [{ type: 'b', value: 123 }] });
-      },
-      { name: /^TypeError$/ }
-    );
-  });
-
-  it('unknown arg type', () => {
-    throws(
-      () => {
-        osc.messageToBuffer({ address: '/address', args: [{ type: 'z', value: 123 }] });
-      },
-      { name: /^TypeError$/ }
-    );
   });
 });