@djodjonx/x32-simulator 0.0.2 → 0.0.4

package/src/domain/models/X32Address.ts

@@ -1,78 +0,0 @@
-/**
- * Represents an X32 OSC Address path.
- * parsing logic and component extraction.
- */
-export class X32Address {
-    private readonly _path: string;
-    private readonly _parts: string[];
-
-    /**
-     * Creates a new X32Address.
-     * @param path - The full OSC path (e.g., "/ch/01/mix/fader").
-     */
-    constructor(path: string) {
-        this._path = path;
-        // Split by '/' and remove empty strings from leading slash
-        this._parts = path.split('/').filter(p => p.length > 0);
-    }
-
-    /**
-     * Gets the full string representation of the path.
-     * @returns The full OSC path string.
-     */
-    get path(): string {
-        return this._path;
-    }
-
-    /**
-     * Gets the full string representation of the path.
-        return this._path;
-    }
-
-    /**
-     * Gets the root category (e.g., "ch", "bus", "config").
-     * @returns The first segment of the path.
-     */
-    get root(): string | undefined {
-        return this._parts[0];
-    }
-
-    /**
-     * Gets the index/ID part if present (e.g., "01" from "/ch/01").
-     * @returns The second segment of the path.
-     */
-    get index(): string | undefined {
-        return this._parts[1];
-    }
-
-    /**
-     * Gets the suffix (everything after the ID).
-     * e.g., for "/ch/01/mix/fader", returns "/mix/fader".
-     * @returns The remaining path after the index.
-     */
-    get suffix(): string {
-        if (this._parts.length < 3) return '';
-        return '/' + this._parts.slice(2).join('/');
-    }
-
-    /**
-     * Checks if this address belongs to a specific category.
-     * @param category - The category to check (e.g., "meters", "ch").
-     * @returns True if it matches the category.
-     */
-    isCategory(category: string): boolean {
-        return this.root === category;
-    }
-
-    /**
-     * Checks if the address matches a specific pattern.
-     * @param pattern - The regex or string pattern.
-     * @returns True if it matches the pattern.
-     */
-    matches(pattern: RegExp | string): boolean {
-        if (typeof pattern === 'string') {
-            return this._path === pattern;
-        }
-        return pattern.test(this._path);
-    }
-}

package/src/domain/models/X32Node.ts

@@ -1,43 +0,0 @@
-/**
- * Metadata for a single state node in the X32 schema.
- * Represents a "Knob" or "Variable" on the console.
- */
-export class X32Node {
-    /** Value type (f=float, i=int, s=string). */
-    readonly type: 'f' | 'i' | 's';
-    /** Default value for reset. */
-    readonly default: number | string;
-
-    /**
-     * Creates a new X32Node.
-     * @param type - The OSC data type ('f', 'i', 's').
-     * @param defaultValue - The default value.
-     */
-    constructor(type: 'f' | 'i' | 's', defaultValue: number | string) {
-        this.type = type;
-        this.default = defaultValue;
-    }
-
-    /**
-     * Validates if a value is compatible with this node's type.
-     * @param value - The value to check.
-     * @returns True if valid.
-     */
-    validate(value: any): boolean {
-        if (this.type === 'f') return typeof value === 'number'; // && value >= 0.0 && value <= 1.0 (optional strict check)
-        if (this.type === 'i') return typeof value === 'number'; // && Number.isInteger(value)
-        if (this.type === 's') return typeof value === 'string';
-        return false;
-    }
-
-    /**
-     * Factory method to create from a plain object (for compatibility/migration).
-     * @param obj - Plain object.
-     * @param obj.type - OSC data type.
-     * @param obj.default - Default value.
-     * @returns A new X32Node instance.
-     */
-    static from(obj: { type: 'f'|'i'|'s', default: number|string }): X32Node {
-        return new X32Node(obj.type, obj.default);
-    }
-}

package/src/domain/models/types.ts

@@ -1,96 +0,0 @@
-/**
- * Represents a basic OSC argument value.
- */
-export type OscArgumentValue = Buffer | boolean | number | string;
-
-/**
- * Represents an OSC argument, which can be a primitive value or a typed object.
- */
-export type OscArgument = OscArgumentValue | { type: string; value: OscArgumentValue };
-
-/**
- * Represents a decoded OSC packet (bundle or message) as returned by the codec.
- */
-export interface OscPacket {
-  /** The type of OSC packet. */
-  oscType: 'bundle' | 'message';
-  /** The address pattern. */
-  address: string;
-  /** The arguments of the message or elements of the bundle. */
-  args: OscArgument[];
-  /** Elements if this is a bundle. */
-  elements?: OscPacket[];
-}
-
-/**
- * Represents a remote OSC client's connection info.
- */
-export interface RemoteClient {
-  /** Target IP address. */
-  address: string;
-  /** Target port. */
-  port: number;
-}
-
-/**
- * Represents a parsed OSC message ready for handling.
- * Arguments are already unwrapped from their {type, value} containers.
- */
-export interface OscMsg {
-  /** The OSC address. */
-  address: string;
-  /** The message arguments. */
-  args: OscArgumentValue[];
-}
-
-/**
- * Metadata for a single state node.
- */
-export interface X32Node {
-  /** Value type (float, int, or string). */
-  type: 'f' | 'i' | 's';
-  /** Default value for reset. */
-  default: number | string;
-}
-
-/**
- * Represents an active subscription from a client.
- */
-export interface Subscriber {
-    /** Target IP address. */
-    address: string;
-    /** Target port. */
-    port: number;
-    /** Expiry timestamp. */
-    expires: number;
-    /** Subscription type. */
-    type: 'batch' | 'format' | 'meter' | 'path';
-    /** Optional exact path for 'path' type. */
-    path?: string;
-    /** Target meter path for 'meter' type. */
-    meterPath?: string;
-    /** Alias for batch/format responses. */
-    alias?: string;
-    /** Glob/Wildcard pattern for 'format' type. */
-    pattern?: string;
-    /** List of paths for 'batch' type. */
-    paths?: string[];
-    /** Start index for ranges. */
-    start?: number;
-    /** Number of items in range. */
-    count?: number;
-    /** Frequency reduction factor. */
-    factor?: number;
-    /** Parameter arguments for the command. */
-    args?: number[];
-}
-
-/**
- * Structure representing a reply to be sent back to an OSC client.
- */
-export interface OscReply {
-    /** The target OSC address. */
-    address: string;
-    /** The response arguments. */
-    args: OscArgument[];
-}

package/src/domain/ports/ILogger.ts

@@ -1,27 +0,0 @@
-/**
- * Represents data that can be logged.
- */
-export type LogData = Buffer | Error | LogData[] | boolean | number | string | { [key: string]: LogData } | null | undefined;
-
-/**
- * Standard log categories for the domain.
- */
-export enum LogCategory {
-    SYSTEM = 'SYSTEM',
-    OSC_IN = 'OSC_IN',
-    OSC_OUT = 'OSC_OUT',
-    DISPATCH = 'DISPATCH',
-    STATE = 'STATE',
-    SUB = 'SUB',
-    METER = 'METER'
-}
-
-/**
- * Interface for the logging port.
- */
-export interface ILogger {
-    debug(category: string, msg: string, data?: LogData): void;
-    info(category: string, msg: string, data?: LogData): void;
-    warn(category: string, msg: string, data?: LogData): void;
-    error(category: string, msg: string, err?: LogData): void;
-}

package/src/domain/ports/INetworkGateway.ts

@@ -1,8 +0,0 @@
-import { OscPacket, RemoteClient } from '../models/types';
-
-export interface INetworkGateway {
-    start(port: number, ip: string): Promise<void>;
-    stop(): Promise<void>;
-    send(target: RemoteClient, address: string, args: any[]): void;
-    onPacket(callback: (packet: OscPacket, source: RemoteClient) => void): void;
-}

package/src/domain/ports/IStateRepository.ts

@@ -1,16 +0,0 @@
-import { X32State } from '../entities/X32State';
-
-/**
- * Interface for accessing the mixer state.
- */
-export interface IStateRepository {
-    /**
-     * Retrieves the single instance of the mixer state (Singleton in this context).
-     */
-    getState(): X32State;
-
-    /**
-     * Resets the state to defaults.
-     */
-    reset(): void;
-}

package/src/domain/services/MeterService.ts

@@ -1,46 +0,0 @@
-import { X32State } from '../entities/X32State';
-import { MeterData } from '../models/MeterData';
-import { METER_COUNTS } from '../models/MeterConfig';
-
-/**
- * Service responsible for generating meter values and data.
- * Mimics the physics/audio engine of the X32.
- */
-export class MeterService {
-
-    /**
-     * Generates a MeterData object for a given path.
-     * @param path - The meter OSC path (e.g., "/meters/1").
-     * @param state - The current X32 state (for correlating faders to meters).
-     * @returns MeterData object containing the values.
-     */
-    public generateMeterData(path: string, state?: X32State): MeterData {
-        const count = METER_COUNTS[path];
-        if (count === undefined) {
-            return new MeterData(path, []);
-        }
-
-        const values: number[] = [];
-        for (let i = 0; i < count; i++) {
-            let val = Math.random() * 0.05; // Noise floor
-
-            // Simulation logic: Link meters 1-32 to Channel Faders 1-32
-            if (state && path === '/meters/1') {
-                if (i < 32) {
-                    const ch = (i + 1).toString().padStart(2, '0');
-                    // We should use X32Address logic here ideally, but string construction is fast
-                    const faderPath = `/ch/${ch}/mix/fader`;
-                    const fader = state.get(faderPath);
-
-                    if (typeof fader === 'number') {
-                        // If fader is up, show signal (simulated with random variation)
-                        val = fader > 0.01 ? fader * (0.9 + Math.random() * 0.1) : 0;
-                    }
-                }
-            }
-            values.push(val);
-        }
-
-        return new MeterData(path, values);
-    }
-}

package/src/domain/services/OscMessageHandler.ts

@@ -1,88 +0,0 @@
-import { OscMsg, RemoteClient, OscReply } from '../models/types';
-import { X32State } from '../entities/X32State';
-import { SubscriptionManager } from '../entities/SubscriptionManager';
-import { OscCommandStrategy } from './strategies/OscCommandStrategy';
-import { NodeDiscoveryStrategy } from './strategies/NodeDiscoveryStrategy';
-import { StaticResponseStrategy } from './strategies/StaticResponseStrategy';
-import { SubscriptionStrategy } from './strategies/SubscriptionStrategy';
-import { BatchStrategy } from './strategies/BatchStrategy';
-import { MeterStrategy } from './strategies/MeterStrategy';
-import { StateAccessStrategy } from './strategies/StateAccessStrategy';
-import { ILogger, LogCategory } from '../ports/ILogger';
-import { MeterService } from './MeterService';
-import { SchemaRegistry } from './SchemaRegistry';
-import { StaticResponseService } from './StaticResponseService';
-
-/**
- * The central dispatcher for incoming OSC messages.
- * Uses a Chain of Responsibility (Strategy pattern) to delegate handling.
- * Order of strategies is critical for correct prioritization.
- */
-export class OscMessageHandler {
-    /** List of active command strategies. */
-    private strategies: OscCommandStrategy[];
-
-    /**
-     * Initializes the handler with all available strategies.
-     * @param state - Global mixer state.
-     * @param subscriptionManager - Active client sessions.
-     * @param logger - Logger instance.
-     * @param serverIp - Host IP reported in handshakes.
-     * @param serverName - Console name reported in handshakes.
-     * @param serverModel - Console model reported in handshakes.
-     * @param meterService - Service for metering.
-     * @param schemaRegistry - Service for schema validation.
-     * @param staticResponseService - Service for static responses.
-     */
-    constructor(
-        state: X32State,
-        subscriptionManager: SubscriptionManager,
-        private logger: ILogger,
-        serverIp: string,
-        serverName: string,
-        serverModel: string,
-        private meterService: MeterService,
-        private schemaRegistry: SchemaRegistry,
-        private staticResponseService: StaticResponseService
-    ) {
-        // Order matters! Specific strategies (Discovery, Handshake) first, generic (State Access) last.
-        this.strategies = [
-            new NodeDiscoveryStrategy(this.schemaRegistry),
-            new StaticResponseStrategy(serverIp, serverName, serverModel, this.staticResponseService),
-            new SubscriptionStrategy(subscriptionManager, state, logger),
-            new BatchStrategy(subscriptionManager, logger),
-            new MeterStrategy(subscriptionManager, state, this.meterService),
-            new StateAccessStrategy(state, logger, this.schemaRegistry)
-        ];
-    }
-
-    /**
-     * Dispatches an incoming message to the first matching strategy.
-     * @param msg - Parsed OSC message.
-     * @param source - Source address and port of the packet.
-     * @returns Array of replies generated by the strategy.
-     */
-    public handle(msg: OscMsg, source: RemoteClient): OscReply[] {
-        const addr = msg.address;
-
-        // Skip noisy subscriptions in high-level logging
-        if (!addr.startsWith('/meters')) {
-             this.logger.debug(LogCategory.DISPATCH, `Handling`, { addr, args: msg.args });
-        }
-
-        // Delegate to first matching Strategy
-        for (const strategy of this.strategies) {
-            if (strategy.canHandle(addr)) {
-                const replies = strategy.execute(msg, source);
-                if (replies.length > 0) {
-                     this.logger.debug(LogCategory.DISPATCH, `Strategy ${strategy.constructor.name} replied`, { count: replies.length });
-                }
-                return replies;
-            }
-        }
-
-        // Mimic physical hardware: ignore unknown commands
-        this.logger.warn(LogCategory.DISPATCH, `Unknown Command`, { addr, args: msg.args, ip: source.address });
-        return [];
-    }
-}