@arcanewizards/tcnet 0.1.1

package/dist/monitor.cjs

@@ -0,0 +1,307 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunk7IUB6OJ3cjs = require('./chunk-7IUB6OJ3.cjs');
+
+
+
+var _chunkVRXVI5VAcjs = require('./chunk-VRXVI5VA.cjs');
+
+
+var _chunkVYNI4G3Kcjs = require('./chunk-VYNI4G3K.cjs');
+
+// src/monitor.ts
+var _events = require('events'); var _events2 = _interopRequireDefault(_events);
+var MAX_DELTA_MS = 10;
+var layerDataIdToIndex = (dataLayerId) => {
+  return dataLayerId - 1;
+};
+var layerIndexToDataId = (index) => {
+  return index + 1;
+};
+var asLayerIndex = (rawNumber) => {
+  return rawNumber;
+};
+var getLayerId = (node, layer) => {
+  return `${_chunkVRXVI5VAcjs.calculateUniqueNodeId.call(void 0, node)}:${layer}`;
+};
+var TCNET_LAYER_INDEXES = Array.from(
+  { length: _chunk7IUB6OJ3cjs.TCNET_LAYER_COUNT },
+  (_, i) => asLayerIndex(i)
+);
+var createTCNetTimecodeMonitor = (tcNetNode, logger) => {
+  const events = new (0, _events2.default)();
+  const on = events.on.bind(events);
+  const addListener = events.addListener.bind(events);
+  const removeListener = events.removeListener.bind(events);
+  const nodeStates = /* @__PURE__ */ new Map();
+  const getNodeState = (node) => {
+    const nodeKey = _chunkVRXVI5VAcjs.calculateUniqueNodeId.call(void 0, node);
+    let nodeState = nodeStates.get(nodeKey);
+    if (nodeState) {
+      return nodeState;
+    }
+    const layerInfoArray = new Array(_chunk7IUB6OJ3cjs.TCNET_LAYER_COUNT);
+    nodeState = {
+      node,
+      trackInfo: /* @__PURE__ */ new Map(),
+      getLayerInfo: (i) => layerInfoArray[i]
+    };
+    nodeStates.set(nodeKey, nodeState);
+    for (const i of TCNET_LAYER_INDEXES) {
+      layerInfoArray[i] = {
+        name: null,
+        status: "IDLE",
+        trackId: null,
+        pitchBend: 0,
+        speed: 0,
+        layerState: {
+          layerId: `${i}`,
+          layerName: `Layer ${i + 1}`,
+          totalTime: null,
+          info: null,
+          playState: {
+            state: "stopped",
+            currentTimeMillis: 0,
+            speed: 1,
+            onAir: false
+          }
+        }
+      };
+    }
+    return nodeState;
+  };
+  const updateMetadataForLayer = (node, layer) => {
+    const trackID = _optionalChain([getNodeState, 'call', _2 => _2(node), 'access', _3 => _3.getLayerInfo, 'call', _4 => _4(layer), 'optionalAccess', _5 => _5.trackId]);
+    if (typeof trackID !== "number") {
+      return;
+    }
+    tcNetNode.requestData(node, "METADATA", layerIndexToDataId(layer));
+  };
+  const updateMetricsForLayer = (node, layer) => {
+    const trackID = _optionalChain([getNodeState, 'call', _6 => _6(node), 'access', _7 => _7.getLayerInfo, 'call', _8 => _8(layer), 'optionalAccess', _9 => _9.trackId]);
+    if (typeof trackID !== "number") {
+      return;
+    }
+    tcNetNode.requestData(node, "METRICS_DATA", layerIndexToDataId(layer));
+  };
+  const getProbableTrackInfo = (node, trackID) => {
+    if (trackID === null) {
+      return null;
+    }
+    const trackInfoForTrack = getNodeState(node).trackInfo.get(trackID);
+    if (!trackInfoForTrack) {
+      return null;
+    }
+    let bestMatch = null;
+    for (const info of trackInfoForTrack.values()) {
+      const bestMatchCount = _nullishCoalesce(_optionalChain([bestMatch, 'optionalAccess', _10 => _10.matchCount]), () => ( 0));
+      if (
+        // Best match if we've seen this track the most times
+        info.matchCount > bestMatchCount || // Or if we've seen it aa similar same amount of times,
+        // but more recently
+        info.matchCount > bestMatchCount - 4 && info.lastMatchTime > (_nullishCoalesce(_optionalChain([bestMatch, 'optionalAccess', _11 => _11.lastMatchTime]), () => ( 0)))
+      ) {
+        bestMatch = info;
+      }
+    }
+    return _nullishCoalesce(_optionalChain([bestMatch, 'optionalAccess', _12 => _12.info]), () => ( null));
+  };
+  const updatePlayingTimecode = (node, i, info, layer) => {
+    if (!layer) {
+      return;
+    }
+    const now = Date.now();
+    const effectiveStartTime = now - layer.currentTimeMillis / info.speed;
+    const trackInfo = getProbableTrackInfo(node, info.trackId);
+    if (!info.layerState || info.layerState.playState.state !== "playing" || info.layerState.playState.state === "playing" && (_chunkVRXVI5VAcjs.differsByMoreThan.call(void 0, 
+      info.layerState.playState.effectiveStartTime,
+      effectiveStartTime,
+      MAX_DELTA_MS
+    ) || _chunkVRXVI5VAcjs.differsByMoreThan.call(void 0, 
+      _nullishCoalesce(_optionalChain([info, 'access', _13 => _13.layerState, 'access', _14 => _14.totalTime, 'optionalAccess', _15 => _15.timeMillis]), () => ( 0)),
+      layer.totalTimeMillis,
+      MAX_DELTA_MS
+    )) || info.layerState.info !== trackInfo || info.layerState.playState.speed !== info.speed || info.layerState.playState.onAir !== info.layerState.playState.onAir) {
+      info.layerState = {
+        layerId: getLayerId(node, i),
+        layerName: _nullishCoalesce(info.name, () => ( `Layer ${layerIndexToDataId(i)}`)),
+        totalTime: layer.totalTimeMillis > 0 ? {
+          timeMillis: layer.totalTimeMillis,
+          precisionMillis: 1e3
+        } : null,
+        info: trackInfo,
+        playState: {
+          state: "playing",
+          effectiveStartTime,
+          speed: info.speed,
+          onAir: _optionalChain([info, 'access', _16 => _16.layerState, 'optionalAccess', _17 => _17.playState, 'access', _18 => _18.onAir])
+        }
+      };
+      events.emit("timecode-changed", info.layerState);
+    }
+  };
+  const updatePausedTimecode = (node, i, info, layer) => {
+    if (!layer) {
+      return;
+    }
+    const trackInfo = getProbableTrackInfo(node, info.trackId);
+    if (!info.layerState || info.layerState.playState.state !== "stopped" || info.layerState.playState.state === "stopped" && (_chunkVRXVI5VAcjs.differsByMoreThan.call(void 0, 
+      info.layerState.playState.currentTimeMillis,
+      layer.currentTimeMillis,
+      MAX_DELTA_MS
+    ) || _chunkVRXVI5VAcjs.differsByMoreThan.call(void 0, 
+      _nullishCoalesce(_optionalChain([info, 'access', _19 => _19.layerState, 'access', _20 => _20.totalTime, 'optionalAccess', _21 => _21.timeMillis]), () => ( 0)),
+      layer.totalTimeMillis,
+      MAX_DELTA_MS
+    )) || info.layerState.info !== trackInfo || info.layerState.playState.speed !== info.speed || info.layerState.playState.onAir !== info.layerState.playState.onAir) {
+      info.layerState = {
+        layerId: getLayerId(node, i),
+        layerName: _nullishCoalesce(info.name, () => ( `Layer ${layerIndexToDataId(i)}`)),
+        totalTime: layer.totalTimeMillis > 0 ? {
+          timeMillis: layer.totalTimeMillis,
+          precisionMillis: 1e3
+        } : null,
+        info: trackInfo,
+        playState: {
+          state: "stopped",
+          currentTimeMillis: layer.currentTimeMillis,
+          speed: info.speed,
+          onAir: _optionalChain([info, 'access', _22 => _22.layerState, 'optionalAccess', _23 => _23.playState, 'access', _24 => _24.onAir])
+        }
+      };
+      events.emit("timecode-changed", info.layerState);
+    }
+  };
+  tcNetNode.on("data", ({ packet, node }) => {
+    const nodeState = getNodeState(node);
+    if (packet.dataType === "METADATA") {
+      if (packet.trackId) {
+        logger.warn(
+          new (0, _chunkVYNI4G3Kcjs.TCNetProtocolError)(
+            `Received unexpected trackId in METADATA packet, implementation needs to be updated to handle this!`
+          )
+        );
+      }
+      const info = {
+        title: packet.trackTitle || null,
+        artist: packet.trackArtist || null
+      };
+      if (!info.title && !info.artist) {
+        return;
+      }
+      const trackID = _optionalChain([nodeState, 'access', _25 => _25.getLayerInfo, 'call', _26 => _26(
+        layerDataIdToIndex(packet.layer)
+      ), 'optionalAccess', _27 => _27.trackId]);
+      if (typeof trackID !== "number") {
+        return;
+      }
+      let trackInfoForTrack = nodeState.trackInfo.get(trackID);
+      if (!trackInfoForTrack) {
+        trackInfoForTrack = /* @__PURE__ */ new Map();
+        nodeState.trackInfo.set(trackID, trackInfoForTrack);
+      }
+      const key = `${info.artist} - ${info.title}`;
+      const weightedInfo = trackInfoForTrack.get(key) || {
+        matchCount: 0,
+        lastMatchTime: Date.now(),
+        info
+      };
+      weightedInfo.matchCount++;
+      weightedInfo.lastMatchTime = Date.now();
+      trackInfoForTrack.set(key, weightedInfo);
+    } else if (packet.dataType === "METRICS_DATA") {
+      const info = nodeState.getLayerInfo(layerDataIdToIndex(packet.layer));
+      if (info) {
+        info.pitchBend = _nullishCoalesce(packet.pitchBend, () => ( 0));
+        info.speed = 1 + info.pitchBend / 1e4;
+      }
+    }
+  });
+  tcNetNode.on("time", ({ packet, node }) => {
+    const nodeState = getNodeState(node);
+    for (const i of TCNET_LAYER_INDEXES) {
+      const info = nodeState.getLayerInfo(i);
+      switch (_optionalChain([info, 'optionalAccess', _28 => _28.status])) {
+        case "PLAYING":
+        case "LOOPING":
+        case "CUEDOWN":
+          updatePlayingTimecode(node, i, info, packet.layers[i]);
+          break;
+        case "PAUSED":
+        case "STOPPED":
+        case "LOADING":
+        case "PLATTERDOWN":
+        case "HOLD":
+        case "FFWD":
+        case "FFRV":
+          updatePausedTimecode(node, i, info, packet.layers[i]);
+          break;
+        case "UNKNOWN":
+        case "IDLE":
+      }
+    }
+  });
+  tcNetNode.on("node-status", ({ packet, node }) => {
+    for (const i of TCNET_LAYER_INDEXES) {
+      const layer = packet.layers[i];
+      const info = getNodeState(node).getLayerInfo(i);
+      if (!info || !layer) {
+        throw new Error("Inconsistent layer indexes");
+      }
+      info.status = layer.status;
+      info.name = layer.name;
+      if (info.trackId !== layer.trackId && layer.trackId > 0) {
+        logger.info(
+          `Updated trackID for layer ${i}: ${info.trackId} -> ${layer.trackId}`
+        );
+        info.trackId = layer.trackId;
+        updateMetadataForLayer(node, i);
+      }
+    }
+  });
+  tcNetNode.on("nodes-changed", (nodes) => {
+    const knownNodeIds = new Set(
+      Object.values(nodes).map((node) => _chunkVRXVI5VAcjs.calculateUniqueNodeId.call(void 0, node))
+    );
+    for (const [nodeId, nodeState] of nodeStates.entries()) {
+      if (!knownNodeIds.has(nodeId)) {
+        for (const i of TCNET_LAYER_INDEXES) {
+          const layerState = _optionalChain([nodeState, 'access', _29 => _29.getLayerInfo, 'call', _30 => _30(i), 'optionalAccess', _31 => _31.layerState]);
+          if (layerState) {
+            events.emit("layer-removed", { layerId: layerState.layerId });
+          }
+        }
+        nodeStates.delete(nodeId);
+      }
+    }
+  });
+  const updateLoadedTracks = () => {
+    for (const nodeState of nodeStates.values()) {
+      for (const i of TCNET_LAYER_INDEXES) {
+        const info = nodeState.getLayerInfo(i);
+        if (_optionalChain([info, 'optionalAccess', _32 => _32.trackId])) {
+          updateMetadataForLayer(nodeState.node, i);
+          updateMetricsForLayer(nodeState.node, i);
+        }
+      }
+    }
+  };
+  let autoUpdater = null;
+  tcNetNode.on("ready", () => {
+    autoUpdater = setInterval(updateLoadedTracks, 1e3);
+    updateLoadedTracks();
+  });
+  tcNetNode.on("destroy", () => {
+    if (autoUpdater) {
+      clearInterval(autoUpdater);
+    }
+  });
+  return {
+    on,
+    addListener,
+    removeListener
+  };
+};
+
+
+exports.createTCNetTimecodeMonitor = createTCNetTimecodeMonitor;

package/dist/monitor.d.cts

@@ -0,0 +1,70 @@
+import { TCNetNode, TCNetLogger } from './types.cjs';
+import '@arcanewizards/net-utils';
+import './protocol.cjs';
+
+type TCNetTimecodeTrackInfo = {
+    title: string | null;
+    artist: string | null;
+};
+type TCNetTimecodePlayState = {
+    state: 'playing';
+    effectiveStartTime: number;
+    /**
+     * 1.0 means normal speed, 2.0 means double speed, etc.
+     * Can be negative for reverse playback,
+     *
+     * in which case effectiveStartTime represents the time when the track will reach 0:00.
+     */
+    speed: number;
+    onAir: boolean;
+} | {
+    state: 'stopped';
+    currentTimeMillis: number;
+    /**
+     * Speed still exists when stopped,
+     * to indicate what speed the track will play at when started.
+     */
+    speed: number;
+    onAir: boolean;
+};
+type TCNetTimecodeState = {
+    layerId: string;
+    layerName: string;
+    /**
+     * If available, the total time of the track loaded in this layer.
+     *
+     * Some timecode sources will not have this information.
+     */
+    totalTime: {
+        timeMillis: number;
+        /**
+         * How accurate is the totalTimeMillis value,
+         * some sources (such as ShowKontrol) are not completely accurate.
+         */
+        precisionMillis: number;
+    } | null;
+    /**
+     * If available, the metadata info of the track loaded in this layer.
+     */
+    info: TCNetTimecodeTrackInfo | null;
+    playState: TCNetTimecodePlayState;
+};
+type TCNetTimecodeMonitorEventMap = {
+    'timecode-changed': [TCNetTimecodeState];
+    'layer-removed': [Pick<TCNetTimecodeState, 'layerId'>];
+};
+type TCNetTimecodeMonitor = {
+    on<K extends keyof TCNetTimecodeMonitorEventMap>(event: K, callback: (...args: TCNetTimecodeMonitorEventMap[K]) => void): void;
+    addListener<K extends keyof TCNetTimecodeMonitorEventMap>(event: K, callback: (...args: TCNetTimecodeMonitorEventMap[K]) => void): void;
+    removeListener<K extends keyof TCNetTimecodeMonitorEventMap>(event: K, callback: (...args: TCNetTimecodeMonitorEventMap[K]) => void): void;
+};
+/**
+ * Create a monitor that listens to TCNet messages to keep track of the current
+ * timecodes,
+ * accounts for differences in implementation details for different products,
+ * and produces a unified and simplified interface for monitoring timecodes
+ * with respect the internal clock.
+ */
+declare const createTCNetTimecodeMonitor: (tcNetNode: TCNetNode, logger: TCNetLogger) => TCNetTimecodeMonitor;
+
+export { type TCNetTimecodeMonitor, type TCNetTimecodeMonitorEventMap, type TCNetTimecodePlayState, type TCNetTimecodeState, type TCNetTimecodeTrackInfo, createTCNetTimecodeMonitor };

package/dist/monitor.d.ts

@@ -0,0 +1,70 @@
+import { TCNetNode, TCNetLogger } from './types.js';
+import '@arcanewizards/net-utils';
+import './protocol.js';
+
+type TCNetTimecodeTrackInfo = {
+    title: string | null;
+    artist: string | null;
+};
+type TCNetTimecodePlayState = {
+    state: 'playing';
+    effectiveStartTime: number;
+    /**
+     * 1.0 means normal speed, 2.0 means double speed, etc.
+     * Can be negative for reverse playback,
+     *
+     * in which case effectiveStartTime represents the time when the track will reach 0:00.
+     */
+    speed: number;
+    onAir: boolean;
+} | {
+    state: 'stopped';
+    currentTimeMillis: number;
+    /**
+     * Speed still exists when stopped,
+     * to indicate what speed the track will play at when started.
+     */
+    speed: number;
+    onAir: boolean;
+};
+type TCNetTimecodeState = {
+    layerId: string;
+    layerName: string;
+    /**
+     * If available, the total time of the track loaded in this layer.
+     *
+     * Some timecode sources will not have this information.
+     */
+    totalTime: {
+        timeMillis: number;
+        /**
+         * How accurate is the totalTimeMillis value,
+         * some sources (such as ShowKontrol) are not completely accurate.
+         */
+        precisionMillis: number;
+    } | null;
+    /**
+     * If available, the metadata info of the track loaded in this layer.
+     */
+    info: TCNetTimecodeTrackInfo | null;
+    playState: TCNetTimecodePlayState;
+};
+type TCNetTimecodeMonitorEventMap = {
+    'timecode-changed': [TCNetTimecodeState];
+    'layer-removed': [Pick<TCNetTimecodeState, 'layerId'>];
+};
+type TCNetTimecodeMonitor = {
+    on<K extends keyof TCNetTimecodeMonitorEventMap>(event: K, callback: (...args: TCNetTimecodeMonitorEventMap[K]) => void): void;
+    addListener<K extends keyof TCNetTimecodeMonitorEventMap>(event: K, callback: (...args: TCNetTimecodeMonitorEventMap[K]) => void): void;
+    removeListener<K extends keyof TCNetTimecodeMonitorEventMap>(event: K, callback: (...args: TCNetTimecodeMonitorEventMap[K]) => void): void;
+};
+/**
+ * Create a monitor that listens to TCNet messages to keep track of the current
+ * timecodes,
+ * accounts for differences in implementation details for different products,
+ * and produces a unified and simplified interface for monitoring timecodes
+ * with respect the internal clock.
+ */
+declare const createTCNetTimecodeMonitor: (tcNetNode: TCNetNode, logger: TCNetLogger) => TCNetTimecodeMonitor;
+
+export { type TCNetTimecodeMonitor, type TCNetTimecodeMonitorEventMap, type TCNetTimecodePlayState, type TCNetTimecodeState, type TCNetTimecodeTrackInfo, createTCNetTimecodeMonitor };