Add Robot_JoyIt driver

node_modules/stream-json/Disassembler.js

@@ -0,0 +1,209 @@
+'use strict';
+
+const {Duplex} = require('stream');
+
+class Pump {
+  constructor(iterator, readable) {
+    this.iterator = iterator;
+    this.readable = readable;
+    this.done = false;
+  }
+  start() {
+    if (this.done) return Promise.resolve();
+
+    for (;;) {
+      const item = this.iterator.next();
+      if (item.done) return Promise.resolve();
+      if (!this.readable.push(item.value)) break;
+    }
+
+    return new Promise((resolve, reject) => {
+      this.resolve = resolve;
+      this.reject = reject;
+    });
+  }
+  resume() {
+    if (!this.resolve) return;
+
+    for (;;) {
+      const item = this.iterator.next();
+      if (item.done) {
+        this.done = true;
+        this.resolve();
+        return;
+      }
+      if (!this.readable.push(item.value)) break;
+    }
+  }
+}
+
+function* dump(value, options, processed) {
+  if (!processed) {
+    if (typeof value?.toJSON == 'function') {
+      value = value.toJSON('');
+    }
+    if (options.replacer) {
+      value = options.replacer('', value);
+    }
+  }
+
+  switch (typeof value) {
+    case 'function':
+    case 'symbol':
+    case 'undefined':
+      return;
+    case 'number':
+      if (isNaN(value) || !isFinite(value)) {
+        yield {name: 'nullValue', value: null};
+      }
+      value = String(value);
+      if (options.streamNumbers) {
+        yield {name: 'startNumber'};
+        yield {name: 'numberChunk', value};
+        yield {name: 'endNumber'};
+      }
+      if (options.packNumbers) {
+        yield {name: 'numberValue', value};
+      }
+      return;
+    case 'string':
+      if (options.streamStrings) {
+        yield {name: 'startString'};
+        yield {name: 'stringChunk', value};
+        yield {name: 'endString'};
+      }
+      if (options.packStrings) {
+        yield {name: 'stringValue', value};
+      }
+      return;
+    case 'boolean':
+      yield value ? {name: 'trueValue', value: true} : {name: 'falseValue', value: false};
+      return;
+    case 'object':
+      break;
+    default:
+      return; // skip anything else
+  }
+
+  // null
+  if (value === null) {
+    yield {name: 'nullValue', value: null};
+    return;
+  }
+
+  // Array
+  if (Array.isArray(value)) {
+    yield {name: 'startArray'};
+    for (let i = 0; i < value.length; ++i) {
+      let v = value[i];
+      if (typeof v?.toJSON == 'function') {
+        v = v.toJSON(String(i));
+      }
+      if (options.replacer) {
+        v = options.replacer(String(i), v);
+      }
+      switch (typeof v) {
+        case 'function':
+        case 'symbol':
+        case 'undefined':
+          v = null; // force null
+          break;
+      }
+      yield* dump(v, options, true);
+    }
+    yield {name: 'endArray'};
+    return;
+  }
+
+  // Object
+  yield {name: 'startObject'};
+  for (let [k, v] of Object.entries(value)) {
+    if (options.dict && options.dict[k] !== 1) continue;
+    if (typeof v?.toJSON == 'function') {
+      v = v.toJSON(k);
+    }
+    if (options.replacer) {
+      v = options.replacer(k, v);
+    }
+    switch (typeof v) {
+      case 'function':
+      case 'symbol':
+      case 'undefined':
+        continue;
+    }
+    if (options.streamKeys) {
+      yield {name: 'startKey'};
+      yield {name: 'stringChunk', value: k};
+      yield {name: 'endKey'};
+    }
+    if (options.packKeys) {
+      yield {name: 'keyValue', value: k};
+    }
+    yield* dump(v, options, true);
+  }
+  yield {name: 'endObject'};
+}
+
+const kOptions = Symbol('options'),
+  kPump = Symbol('pump');
+
+class Disassembler extends Duplex {
+  static make(options) {
+    return new Disassembler(options);
+  }
+
+  constructor(options) {
+    super(Object.assign({}, options, {writableObjectMode: true, readableObjectMode: true}));
+
+    const opt = {packKeys: true, packStrings: true, packNumbers: true, streamKeys: true, streamStrings: true, streamNumbers: true};
+
+    if (options) {
+      'packValues' in options && (opt.packKeys = opt.packStrings = opt.packNumbers = options.packValues);
+      'packKeys' in options && (opt.packKeys = options.packKeys);
+      'packStrings' in options && (opt.packStrings = options.packStrings);
+      'packNumbers' in options && (opt.packNumbers = options.packNumbers);
+
+      'streamValues' in options && (opt.streamKeys = opt.streamStrings = opt.streamNumbers = options.streamValues);
+      'streamKeys' in options && (opt.streamKeys = options.streamKeys);
+      'streamStrings' in options && (opt.streamStrings = options.streamStrings);
+      'streamNumbers' in options && (opt.streamNumbers = options.streamNumbers);
+
+      if (typeof options.replacer == 'function') {
+        opt.replacer = options.replacer;
+      } else if (Array.isArray(options.replacer)) {
+        opt.dict = options.replacer.reduce((acc, k) => ((acc[k] = 1), acc), {});
+      }
+    }
+
+    !opt.packKeys && (opt.streamKeys = true);
+    !opt.packStrings && (opt.streamStrings = true);
+    !opt.packNumbers && (opt.streamNumbers = true);
+
+    this[kOptions] = opt;
+  }
+
+  _read() {
+    this[kPump]?.resume();
+  }
+
+  _write(chunk, _, callback) {
+    const iterator = dump(chunk, this[kOptions]),
+      pump = (this[kPump] = new Pump(iterator, this));
+
+    pump.start().then(
+      () => ((this[kPump] = null), callback()),
+      error => ((this[kPump] = null), callback(error))
+    );
+  }
+
+  _final(callback) {
+    this.push(null);
+    callback();
+  }
+}
+Disassembler.disassembler = Disassembler.make;
+Disassembler.make.Constructor = Disassembler;
+
+module.exports = Disassembler;
+
+module.exports.dump = dump;