Initial Commit

src/index.ts

@@ -0,0 +1,3 @@
+export * from './oscClient';
+export {OSCType} from 'osc-min'
+

src/oscClient.ts

@@ -0,0 +1,62 @@
+import * as dgram from 'dgram';
+import {OSCArgument, OSCType, toBuffer, fromBuffer, OSCArgumentType} from 'osc-min';
+import { EventEmitter } from 'events';
+
+
+interface OSCClientOptions {
+    outHost: string;
+    outPort: number;
+    inPort?: number;
+}
+
+interface ReceivedOSCMessage<T extends OSCType> {
+    address: string;
+    type: T;
+    value: OSCArgumentType<T>  
+}
+
+// declare types for events
+export declare interface OSCClient {
+    on(event: 'message', listener: (message: ReceivedOSCMessage<OSCType>) => void): this;
+}
+
+export class OSCClient extends EventEmitter{
+    private socket: dgram.Socket;
+    private options: OSCClientOptions;
+    constructor(options: OSCClientOptions){
+	super();
+	this.socket = dgram.createSocket({type: "udp4", reuseAddr: true});
+	this.options = options;
+
+	if(options.inPort){
+	    this.socket.bind(options.inPort);
+	}
+
+	this.socket.on('message', (msg)=>{
+	    const decoded = fromBuffer(msg)
+	    if(decoded.oscType === "message"){
+		decoded.args.forEach((arg)=>{
+		    this.emit('message', {
+			address: decoded.address,
+			type: arg.type,
+			value: arg.value
+		    })
+		})
+	    }
+	})
+    }
+
+    private sendPacket(packet: Buffer): void{
+	this.socket.send(packet, 0, packet.length, this.options.outPort, this.options.outHost)
+    }
+
+    public send<T extends OSCType>(address: string, type: T, value: OSCArgumentType<T>){
+	const arg: OSCArgument<T> = {
+	    type,
+	    value
+	}
+
+	const encoded = toBuffer(address, [arg]);
+	this.sendPacket(encoded);
+    }
+}

src/types/osc-min.d.ts

@@ -0,0 +1,59 @@
+declare module "osc-min" {
+    export const enum OSCType {
+	String = "string",
+	Float = "float",
+	Integer = "integer",
+	Blob = "blob",
+	True = "true",
+	False = "false",
+	Null = "null",
+	Bang = "bang",
+	Timetag = "timetag",
+	Array = "array"
+    }
+
+    export type OSCTimeTag = [number, number];
+
+    export interface OSCMessage {
+	oscType?: "message",
+	address: string,
+	args: Array<OSCArgument<OSCType>>
+    }
+
+    export interface OutgoingOSCMessage extends OSCMessage{
+	args: OutgoingOSCArgsTypes;
+    }
+
+    export type OutgoingOSCArgsTypes = Array<OSCArgument<OSCType> | Buffer | boolean | string | number>
+
+    export interface OSCBundle {
+	oscType: "bundle",
+	timetag: null | number | Date | OSCTimeTag,
+	elements: Array<OSCMessage | OSCBundle>
+    }
+
+    export type OSCArgumentType<T extends OSCType> = T extends OSCType.String ? string
+			    : T extends OSCType.Float | OSCType.Integer | OSCType.Timetag ? number
+			    : T extends OSCType.True ? true
+			    : T extends OSCType.False ? false
+			    : T extends OSCType.Blob ? Buffer
+			    : T extends OSCType.array ? Array<OSCArgument<OSCType>>
+			    : null;
+
+    export interface OSCArgument<T extends OSCType>{
+	type: T;
+	value: OSCArgumentType<T>;
+    }
+
+    type OSCPacket = OSCMessage | OSCBundle;
+
+    export function fromBuffer(buffer: Buffer, strict?: boolean): OSCPacket;
+    export function toBuffer(object: OutgoingOSCMessage, strict?: boolean): Buffer;
+    export function toBuffer(address: string, args: Array<OSCArgument<OSCType>>, strict?: boolean): Buffer;
+    export function applyMessageTransform(msg: Buffer, transform: (message: OSCMessage) => OSCMessage);
+    export function applyAddressTransform(msg: Buffer, transform: (address: string) => string);
+    export function timetagToDate(ntpTimeTag: OSCTimeTag): Date;
+    export function dateToTimetag(date: Date): OSCTimeTag; 
+    export function timetagToTimestamp(timeTag: OSCTimeTag): number;
+    export function timestampToTimetag(timestamp: number); OSCTimeTag;
+}