initial commit

src/index.ts

@@ -0,0 +1,2 @@
+export * from './osc';
+export * from './models';

src/models.ts

@@ -0,0 +1,15 @@
+export type OSCType = 's' | 'i' | 'f' | 'b';
+export type OSCArg = {
+  type: OSCType;
+  value: string | number | Buffer;
+};
+
+export type OSCMessage = {
+  address: string;
+  args: OSCArg[];
+};
+
+export type OSCTypeConverter = {
+  toBuffer: (value: number | string | Buffer) => Buffer | undefined;
+  fromString: (string: string) => number | string | Buffer;
+};

src/osc.ts

@@ -0,0 +1,109 @@
+import { OSCType, OSCArg, OSCMessage, OSCTypeConverter } from './models';
+
+const oscTypeConverterMap: { [key in OSCType]: OSCTypeConverter } = {
+  s: {
+    toBuffer: (string) => {
+      if (typeof string === 'string') {
+        let oscString = `${string}\u0000`;
+        const padSize = 4 - (oscString.length % 4);
+        if (padSize < 4) {
+          oscString = oscString.padEnd(oscString.length + padSize, '\u0000');
+        }
+        return Buffer.from(oscString, 'ascii');
+      }
+      throw new Error('osc type s toBuffer called with non string value');
+    },
+    fromString: (string: string) => string,
+  },
+  f: {
+    toBuffer: (number) => {
+      if (typeof number === 'number') {
+        const buffer = Buffer.alloc(4);
+        buffer.writeFloatBE(number);
+        return buffer;
+      }
+      throw new Error('osc type f toBuffer called with non number value');
+    },
+    fromString: (string: string) => Number.parseFloat(string),
+  },
+  i: {
+    toBuffer: (number) => {
+      if (typeof number === 'number') {
+        const buffer = Buffer.alloc(4);
+        buffer.writeInt32BE(number);
+        return buffer;
+      }
+      throw new Error('osc type i toBuffer called with non number value');
+    },
+    fromString: (string: string) => Number.parseInt(string, 10),
+  },
+  b: {
+    toBuffer: (data) => {
+      if (Buffer.isBuffer(data)) {
+        const sizeBuffer = oscTypeConverterMap.i.toBuffer(data.length);
+        if (sizeBuffer) {
+          const padSize = 4 - (data.length % 4);
+          const padBuffer = Buffer.from(Array(padSize).fill(0));
+          return Buffer.concat([sizeBuffer, data, padBuffer]);
+        }
+      }
+      throw new Error('osc type b toBuffer called with non Buffer value');
+    },
+    fromString: (string: string) => Buffer.from(string, 'hex'),
+  },
+};
+
+function argsToBuffer(args: OSCArg[]) {
+  const argBuffers: Buffer[] = [];
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    const typeConverter = oscTypeConverterMap[arg.type];
+    if (typeConverter === undefined) {
+      throw new Error('osc type error: unknown type '.concat(arg.type));
+    }
+
+    if (typeConverter.fromString === undefined) {
+      throw new Error('osc type error: no string converter for type '.concat(arg.type));
+    }
+
+    const buffer = typeConverter.toBuffer(arg.value);
+    if (buffer !== undefined) {
+      argBuffers.push(buffer);
+    }
+  }
+  return Buffer.concat(argBuffers);
+}
+
+function toBuffer({ address, args }: OSCMessage) {
+  const addressBuffer = oscTypeConverterMap.s.toBuffer(address);
+  if (addressBuffer === undefined) {
+    throw new Error('problem encoding address');
+  }
+
+  const typeString = args.map((arg) => arg.type).join('');
+  const typesBuffer = oscTypeConverterMap.s.toBuffer(`,${typeString}`);
+  if (typesBuffer === undefined) {
+    throw new Error('problem encoding types');
+  }
+  const argsBuffer = argsToBuffer(args);
+  return Buffer.concat([addressBuffer, typesBuffer, argsBuffer]);
+}
+
+function stringArgToTypedArg(rawArg: string, type: OSCType = 's') {
+  const typeConverter = oscTypeConverterMap[type];
+  if (typeConverter === undefined) {
+    throw new Error('osc type error: unknown type '.concat(type));
+  }
+
+  if (typeConverter.fromString === undefined) {
+    throw new Error('osc type error: no string converter for type '.concat(type));
+  }
+
+  return typeConverter.fromString(rawArg);
+}
+
+export default {
+  toBuffer,
+  stringArgToTypedArg,
+};