Resolve PR comments

Author: thgrund

README.md

@@ -100,7 +100,7 @@ TidalCycles needs to be configured to send editor highlight events. This is usua
 let editorTarget = Target {oName = "editor", oAddress = "127.0.0.1", oPort = 6013, oLatency = 0.2, oSchedule = Pre BundleStamp, oWindow = Nothing, oHandshake = False, oBusPort = Nothing }
 let editorShape = OSCContext "/editor/highlights"
 
-tidal <- startStream (defaultConfig {cFrameTimespan = 1/30, , cProcessAhead = (1/20)}) [(superdirtTarget {oLatency = 0.02}, [superdirtShape]), (editorTarget, [editorShape])]
+tidal <- startStream (defaultConfig {cFrameTimespan = 1/50, cProcessAhead = (1/20)}) [(superdirtTarget {oLatency = 0.02}, [superdirtShape]), (editorTarget, [editorShape])]
 ```
 
 The path to the `BootTidal.hs` file can be found in the TidalCycles output console after TidalCycles has been booted in the editor.

lib/event-highlighter.js

@@ -3,12 +3,6 @@
 import OscServer from './osc-server';
 import LineProcessor from './line-processor';
 
-if (!Set.prototype.union) {
-  Set.prototype.union = function (otherSet) {
-    return new Set([...this, ...otherSet])
-  }
-}
-
 const CLASS = Object.freeze({
   base: "event-highlight",
   idPrefix: "event-highlight-",
@@ -60,7 +54,6 @@ export default class EventHighlighter {
     const elapsed = now - this.then;
 
     const configFPS = atom.config.get('tidalcycles.eventHighlighting.fps');
-    const missThreshold = atom.config.get('tidalcycles.eventHighlighting.missThreshold');
     const delay = atom.config.get('tidalcycles.eventHighlighting.delay');
 
     const fpsInterval = 1000 / configFPS;
@@ -72,9 +65,9 @@ export default class EventHighlighter {
       [...this.messageBuffer.entries()]
         .filter(([ts]) => (ts + (delay * -1)) < this.then)
         .forEach(([ts, event]) => {
-            activeThisFrame = activeThisFrame.union(event);
-            this.messageBuffer.delete(ts);
-          }
+          activeThisFrame = new Set([...activeThisFrame, ...event]);
+          this.messageBuffer.delete(ts);
+        }
         );
 
       const { active, added, removed } = this.#diffEventMaps(
@@ -140,25 +133,22 @@ export default class EventHighlighter {
 
   /** Handle OSC message describing a highlight event */
   oscHighlightSubscriber() {
-      return (args: {}): void => {
-        const message = OscServer.asDictionary(this.highlightTransformer(args));
-        this.#queueEvent(message);
-      }
-  }
+    return (args, time) => {
 
+      const transformedArgs = [
+        { value: "time" }, { value: time },
+        { value: "id" }, args[0],
+        { value: "duration" }, args[1],
+        { value: "cycle" }, args[2],
+        { value: "colStart" }, args[3],
+        { value: "eventId" }, { value: args[4].value - 1 },
+        { value: "colEnd" }, args[5],
+      ];
 
-  highlightTransformer(args) {
-    const result = [
-            {value: "time"}, {value: args[0]},
-            {value: "id"}, args[1],
-            {value: "duration"}, args[2],
-            {value: "cycle"}, args[3],
-            {value: "colStart"}, args[4],
-            {value: "eventId"}, {value: args[5].value - 1},
-            {value: "colEnd"}, args[6],
-          ];
+      const message = OscServer.asDictionary(transformedArgs);
 
-    return result;
+      this.#queueEvent(message);
+    }
   }
 
   // ----------------------------------------------------------------------
@@ -190,21 +180,21 @@ export default class EventHighlighter {
     const highlightEvent = ensureNestedMap(this.highlights, eventId);
 
     editors.forEach(editor => {
-       const textEditorEvent = ensureNestedMap(highlightEvent, editor.id);
+      const textEditorEvent = ensureNestedMap(highlightEvent, editor.id);
 
-       if (textEditorEvent.has(colStart)) return; // already highlighted
+      if (textEditorEvent.has(colStart)) return; // already highlighted
 
-       const marker = editor.markBufferRange(baseMarker.getBufferRange(), {
-         invalidate: "inside",
-       });
+      const marker = editor.markBufferRange(baseMarker.getBufferRange(), {
+        invalidate: "inside",
+      });
 
-       // Base style
-       editor.decorateMarker(marker, { type: "text", class: CLASS.base });
+      // Base style
+      editor.decorateMarker(marker, { type: "text", class: CLASS.base });
 
-       // Style by numeric id
-       editor.decorateMarker(marker, { type: "text", class: `${CLASS.idPrefix}${id}` });
+      // Style by numeric id
+      editor.decorateMarker(marker, { type: "text", class: `${CLASS.idPrefix}${id}` });
 
-       textEditorEvent.set(colStart, marker);
+      textEditorEvent.set(colStart, marker);
     });
   }
 
@@ -214,7 +204,7 @@ export default class EventHighlighter {
 
     if (!highlightEvents || !highlightEvents.size) return;
 
-     highlightEvents.forEach(textEditorIdEvent => {
+    highlightEvents.forEach(textEditorIdEvent => {
       const marker = textEditorIdEvent.get(colStart);
       textEditorIdEvent.delete(colStart);
 
@@ -237,9 +227,9 @@ export default class EventHighlighter {
     const rowMarkers = ensureNestedMap(textBufferIdMarkers, lineNumber);
 
     LineProcessor.findTidalWordRanges(line, (range) => {
-        const bufferRange = [[lineNumber, range.start], [lineNumber, range.end + 1]];
-        const marker = currentEditor.markBufferRange(bufferRange, { invalidate: "inside" });
-        rowMarkers.set(range.start, marker);
+      const bufferRange = [[lineNumber, range.start], [lineNumber, range.end + 1]];
+      const marker = currentEditor.markBufferRange(bufferRange, { invalidate: "inside" });
+      rowMarkers.set(range.start, marker);
     });
   }
 
@@ -254,41 +244,41 @@ export default class EventHighlighter {
   }
 
   #diffEventMaps(prevEvents, currentEvents) {
-      const removed = new Set();
-      const added = new Set();
-      const active = new Set();
-
-      for (const [event, prevCols] of prevEvents) {
-        const currCols = currentEvents.get(event);
-        if (!currCols) {
-          for (const [, prevEvt] of prevCols) removed.add(prevEvt);
-          continue;
-        }
+    const removed = new Set();
+    const added = new Set();
+    const active = new Set();
+
+    for (const [event, prevCols] of prevEvents) {
+      const currCols = currentEvents.get(event);
+      if (!currCols) {
+        for (const [, prevEvt] of prevCols) removed.add(prevEvt);
+        continue;
+      }
 
-        for (const [col, prevEvt] of prevCols) {
-          if (!currCols.has(col)) {
-            removed.add(prevEvt);
-          } else {
-            active.add(prevEvt);
-          }
+      for (const [col, prevEvt] of prevCols) {
+        if (!currCols.has(col)) {
+          removed.add(prevEvt);
+        } else {
+          active.add(prevEvt);
         }
       }
+    }
 
-      for (const [event, currCols] of currentEvents) {
-        const prevCols = prevEvents.get(event);
-        if (!prevCols) {
-          for (const [, currEvt] of currCols) added.add(currEvt);
-          continue;
-        }
+    for (const [event, currCols] of currentEvents) {
+      const prevCols = prevEvents.get(event);
+      if (!prevCols) {
+        for (const [, currEvt] of currCols) added.add(currEvt);
+        continue;
+      }
 
-        for (const [col, currEvt] of currCols) {
-          if (!prevCols.has(col)) {
-            added.add(currEvt);
-          }
+      for (const [col, currEvt] of currCols) {
+        if (!prevCols.has(col)) {
+          added.add(currEvt);
         }
       }
+    }
 
-      return { removed, added, active };
+    return { removed, added, active };
   }
 
   #transformedEvents(events) {

lib/osc-server.js

@@ -5,100 +5,94 @@ const osc = require('osc-min');
 
 export default class OscServer {
 
-    port = null;
-    ip = null;
-    sock = null;
-    consoleView = null;
-    subscribers: Map<string, Function> = new Map();
-    transformers: Map<string, Function> = new Map();
-
-    constructor(consoleView, ip, port) {
-        this.ip = ip;
-        this.port = port;
-        this.consoleView = consoleView;
-        this.sock = dgram.createSocket('udp4');
-    }
-
-    start(): Promise<void> {
-        let promise = new Promise((resolve, reject) => {
-            this.sock.on('listening', () => {
-                resolve()
-            });
-
-            this.sock.on('error', (err) => {
-                reject(err);
-            });
-        });
-
-        this.sock.bind(this.port, this.ip);
-
-        this.sock.on('message', (message) => {
-            let oscMessage = osc.fromBuffer(message);
-            const timeTag = oscMessage.timetag;
-
-            if (oscMessage.oscType === "bundle") {
-              oscMessage.elements.forEach(element => {
-                if (oscMessage.timetag) {
-                  element.time = OscServer.fromNTPTime(oscMessage.timetag);
-                  this.handleOscMessage(element.address, [element.time, ...element.args]);
-                } else {
-                  this.handleOscMessage(element.address, element.args);
-                }
-              }
-              );
-            } else {
-              this.handleOscMessage(oscMessage.address, oscMessage.args);
-            }
+  port = null;
+  ip = null;
+  sock = null;
+  consoleView = null;
+  subscribers: Map<string, Function> = new Map();
+  transformers: Map<string, Function> = new Map();
+
+  constructor(consoleView, ip, port) {
+    this.ip = ip;
+    this.port = port;
+    this.consoleView = consoleView;
+    this.sock = dgram.createSocket('udp4');
+  }
+
+  start(): Promise<void> {
+    let promise = new Promise((resolve, reject) => {
+      this.sock.on('listening', () => {
+        resolve()
+      });
+
+      this.sock.on('error', (err) => {
+        reject(err);
+      });
+    });
+
+    this.sock.bind(this.port, this.ip);
+
+    this.sock.on('message', (message) => {
+      let oscMessage = osc.fromBuffer(message);
+
+      if (oscMessage.oscType === "bundle") {
+        oscMessage.elements.forEach(element => {
+          element.time = OscServer.fromNTPTime(oscMessage.timetag);
+          this.handleOscMessage(element.address, element.args, element.time);
         });
-
-        return promise
-            .then(() => {
-                this.consoleView.logStdout(`Listening for external osc messages on ${this.ip}:${this.port}`)
-            })
-            .catch(err => {
-                this.consoleView.logStderr(`OSC server error: \n${err.stack}`)
-                this.sock.close();
-            });
-    }
-
-    handleOscMessage(address, args) {
-       let subscriber = this.subscribers.get(address);
-
-       if (subscriber) {
-         subscriber(args);
-       } else {
-           this.consoleView.logStderr(`Received OSC message on unsupported ${address} address`);
-       }
-    }
-
-    stop() {
-        if (this.sock) {
-            this.sock.close();
-        }
-    }
-
-    destroy() {
-        this.stop();
-    }
-
-    register(address: string, listener: Function) {
-        this.subscribers.set(address, listener)
+      } else {
+        this.handleOscMessage(oscMessage.address, oscMessage.args);
+      }
+    });
+
+    return promise
+      .then(() => {
+        this.consoleView.logStdout(`Listening for external osc messages on ${this.ip}:${this.port}`)
+      })
+      .catch(err => {
+        this.consoleView.logStderr(`OSC server error: \n${err.stack}`)
+        this.sock.close();
+      });
+  }
+
+  handleOscMessage(address, args, time) {
+    let subscriber = this.subscribers.get(address);
+
+    if (subscriber) {
+      subscriber(args, time);
+    } else {
+      this.consoleView.logStderr(`Received OSC message on unsupported ${address} address`);
     }
+  }
 
-    static fromNTPTime([seconds, fractional]) {
-      return (
-        (seconds - 2208988800 + fractional / 4294967295) * // NTP Epoch to Unix Seconds
-          1000 - // In milliseconds
-        performance.timeOrigin // Offset by timeOrigin
-      );
+  stop() {
+    if (this.sock) {
+      this.sock.close();
     }
-
-    static asDictionary (oscMap): {} {
-        let dictionary = {}
-        for (let i = 0; i < oscMap.length; i += 2) {
-            dictionary[oscMap[i].value] = oscMap[i+1].value
-        }
-        return dictionary
+  }
+
+  destroy() {
+    this.stop();
+  }
+
+  register(address: string, listener: Function) {
+    this.subscribers.set(address, listener)
+  }
+
+  static fromNTPTime([seconds, fractional]) {
+    return (
+      (seconds - 2208988800 + fractional / 4294967295) * // NTP Epoch to Unix Seconds
+      1000 - // In milliseconds
+      performance.timeOrigin // Offset by timeOrigin
+    );
+  }
+
+  static asDictionary(oscMap): {} {
+    let dictionary = {}
+    for (let i = 0; i < oscMap.length; i += 2) {
+      dictionary[oscMap[i].value] = oscMap[i + 1].value
     }
+    return dictionary
+  }
 
 }