node-osc 11.1.0 → 11.2.0

package/types/Server.d.mts

@@ -0,0 +1,98 @@
+export default Server;
+/**
+ * OSC Server for receiving messages and bundles over UDP.
+ *
+ * Emits the following events:
+ * - 'listening': Emitted when the server starts listening
+ * - 'message': Emitted when an OSC message is received (receives msg array and rinfo object)
+ * - 'bundle': Emitted when an OSC bundle is received (receives bundle object and rinfo object)
+ * - 'error': Emitted when a socket error or decoding error occurs (receives error and rinfo)
+ * - Address-specific events: Emitted for each message address (e.g., '/test')
+ *
+ * @class
+ * @extends EventEmitter
+ *
+ * @fires Server#listening
+ * @fires Server#message
+ * @fires Server#bundle
+ * @fires Server#error
+ *
+ * @example
+ * // Create and listen for messages
+ * const server = new Server(3333, '0.0.0.0', () => {
+ *   console.log('Server is listening');
+ * });
+ *
+ * server.on('message', (msg, rinfo) => {
+ *   console.log('Message:', msg);
+ *   console.log('From:', rinfo.address, rinfo.port);
+ * });
+ *
+ * @example
+ * // Using async/await with events.once
+ * import { once } from 'node:events';
+ *
+ * const server = new Server(3333, '0.0.0.0');
+ * await once(server, 'listening');
+ *
+ * server.on('message', (msg) => {
+ *   console.log('Message:', msg);
+ * });
+ *
+ * @example
+ * // Listen for specific OSC addresses
+ * server.on('/note', (msg) => {
+ *   const [address, pitch, velocity] = msg;
+ *   console.log(`Note: ${pitch}, Velocity: ${velocity}`);
+ * });
+ */
+declare class Server extends EventEmitter<[never]> {
+    /**
+     * Create an OSC Server.
+     *
+     * @param {number} port - The port to listen on.
+     * @param {string} [host='127.0.0.1'] - The host address to bind to. Use '0.0.0.0' to listen on all interfaces.
+     * @param {Function} [cb] - Optional callback function called when server starts listening.
+     *
+     * @example
+     * // Basic server
+     * const server = new Server(3333);
+     *
+     * @example
+     * // Server on all interfaces with callback
+     * const server = new Server(3333, '0.0.0.0', () => {
+     *   console.log('Server started');
+     * });
+     *
+     * @example
+     * // Host parameter can be omitted, callback as second parameter
+     * const server = new Server(3333, () => {
+     *   console.log('Server started on 127.0.0.1');
+     * });
+     */
+    constructor(port: number, host?: string, cb?: Function);
+    port: number;
+    host: string;
+    _sock: import("dgram").Socket;
+    /**
+     * Close the server socket.
+     *
+     * This method can be used with either a callback or as a Promise.
+     *
+     * @param {Function} [cb] - Optional callback function called when socket is closed.
+     * @returns {Promise<void>|undefined} Returns a Promise if no callback is provided.
+     *
+     * @example
+     * // With callback
+     * server.close((err) => {
+     *   if (err) console.error(err);
+     * });
+     *
+     * @example
+     * // With async/await
+     * await server.close();
+     */
+    close(cb?: Function): Promise<void> | undefined;
+}
+import { EventEmitter } from 'node:events';
+//# sourceMappingURL=Server.d.mts.map

package/types/Server.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Server.d.mts","sourceRoot":"","sources":["../lib/Server.mjs"],"names":[],"mappings":";AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH;IACE;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,kBApBW,MAAM,SACN,MAAM,iBAqEhB;IA1CC,aAAgB;IAChB,aAAgB;IAChB,8BAGE;IAsCJ;;;;;;;;;;;;;;;;;OAiBG;IACH,sBAZa,OAAO,CAAC,IAAI,CAAC,GAAC,SAAS,CAuBnC;CACF;6BA5J4B,aAAa"}

package/types/index.d.mts

@@ -0,0 +1,6 @@
+export { default as Message } from "./Message.mjs";
+export { default as Bundle } from "./Bundle.mjs";
+export { default as Server } from "./Server.mjs";
+export { default as Client } from "./Client.mjs";
+export { encode, decode } from "./osc.mjs";
+//# sourceMappingURL=index.d.mts.map

package/types/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../lib/index.mjs"],"names":[],"mappings":""}

package/types/internal/decode.d.mts

@@ -0,0 +1,4 @@
+export default decodeAndSanitize;
+declare function decodeAndSanitize(data: any, customDecode?: typeof decode): any;
+import { decode } from '../osc.mjs';
+//# sourceMappingURL=decode.d.mts.map

package/types/internal/decode.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode.d.mts","sourceRoot":"","sources":["../../lib/internal/decode.mjs"],"names":[],"mappings":";AAmBA,iFAWC;uBA9BsB,YAAY"}

package/types/osc.d.mts

@@ -0,0 +1,66 @@
+/**
+ * Encode an OSC message or bundle to a Buffer.
+ *
+ * This low-level function converts OSC messages and bundles into binary format
+ * for transmission or storage. Useful for sending OSC over custom transports
+ * (WebSocket, TCP, HTTP), storing to files, or implementing custom OSC routers.
+ *
+ * @param {Object} message - OSC message or bundle object with oscType property
+ * @returns {Buffer} The encoded OSC data ready for transmission
+ *
+ * @example
+ * // Encode a message
+ * import { Message, encode } from 'node-osc';
+ *
+ * const message = new Message('/oscillator/frequency', 440);
+ * const buffer = encode(message);
+ * console.log('Encoded bytes:', buffer.length);
+ *
+ * @example
+ * // Encode a bundle
+ * import { Bundle, encode } from 'node-osc';
+ *
+ * const bundle = new Bundle(['/one', 1], ['/two', 2]);
+ * const buffer = encode(bundle);
+ *
+ * @example
+ * // Send over WebSocket
+ * const buffer = encode(message);
+ * websocket.send(buffer);
+ */
+export function encode(message: any): Buffer;
+/**
+ * Decode a Buffer containing OSC data into a message or bundle object.
+ *
+ * This low-level function parses binary OSC data back into JavaScript objects.
+ * Useful for receiving OSC over custom transports, reading from files,
+ * or implementing custom OSC routers.
+ *
+ * @param {Buffer} buffer - The Buffer containing OSC data
+ * @returns {Object} The decoded OSC message or bundle. Messages have
+ *   {oscType: 'message', address: string, args: Array}, bundles have
+ *   {oscType: 'bundle', timetag: number, elements: Array}
+ * @throws {Error} If the buffer contains malformed OSC data
+ *
+ * @example
+ * // Decode received data
+ * import { decode } from 'node-osc';
+ *
+ * const decoded = decode(buffer);
+ * if (decoded.oscType === 'message') {
+ *   console.log('Address:', decoded.address);
+ *   console.log('Arguments:', decoded.args);
+ * }
+ *
+ * @example
+ * // Round-trip encode/decode
+ * import { Message, encode, decode } from 'node-osc';
+ *
+ * const original = new Message('/test', 42, 'hello');
+ * const buffer = encode(original);
+ * const decoded = decode(buffer);
+ * console.log(decoded.address); // '/test'
+ */
+export function decode(buffer: Buffer): any;
+import { Buffer } from 'node:buffer';
+//# sourceMappingURL=osc.d.mts.map

package/types/osc.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"osc.d.mts","sourceRoot":"","sources":["../lib/osc.mjs"],"names":[],"mappings":"AA+MA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,sCAtBa,MAAM,CA4BlB;AA6CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,+BAzBW,MAAM,OAgChB;uBAlUsB,aAAa"}