@depup/stream-json 1.9.1-depup.0

package/Assembler.js

@@ -0,0 +1,154 @@
+'use strict';
+
+const EventEmitter = require('events');
+
+const startObject = Ctr =>
+  function () {
+    if (this.done) {
+      this.done = false;
+    } else {
+      this.stack.push(this.current, this.key);
+    }
+    this.current = new Ctr();
+    this.key = null;
+  };
+
+class Assembler extends EventEmitter {
+  static connectTo(stream, options) {
+    return new Assembler(options).connectTo(stream);
+  }
+
+  constructor(options) {
+    super();
+    this.stack = [];
+    this.current = this.key = null;
+    this.done = true;
+    if (options) {
+      this.reviver = typeof options.reviver == 'function' && options.reviver;
+      if (this.reviver) {
+        this.stringValue = this._saveValue = this._saveValueWithReviver;
+      }
+      if (options.numberAsString) {
+        this.numberValue = this.stringValue;
+      }
+    }
+  }
+
+  connectTo(stream) {
+    stream.on('data', chunk => {
+      if (this[chunk.name]) {
+        this[chunk.name](chunk.value);
+        if (this.done) this.emit('done', this);
+      }
+    });
+    return this;
+  }
+
+  get depth() {
+    return (this.stack.length >> 1) + (this.done ? 0 : 1);
+  }
+
+  get path() {
+    const path = [];
+    for (let i = 0; i < this.stack.length; i += 2) {
+      const key = this.stack[i + 1];
+      path.push(key === null ? this.stack[i].length : key);
+    }
+    return path;
+  }
+
+  dropToLevel(level) {
+    if (level < this.depth) {
+      if (level) {
+        const index = (level - 1) << 1;
+        this.current = this.stack[index];
+        this.key = this.stack[index + 1];
+        this.stack.splice(index);
+      } else {
+        this.stack = [];
+        this.current = this.key = null;
+        this.done = true;
+      }
+    }
+    return this;
+  }
+
+  consume(chunk) {
+    this[chunk.name] && this[chunk.name](chunk.value);
+    return this;
+  }
+
+  keyValue(value) {
+    this.key = value;
+  }
+
+  //stringValue() - aliased below to _saveValue()
+
+  numberValue(value) {
+    this._saveValue(parseFloat(value));
+  }
+  nullValue() {
+    this._saveValue(null);
+  }
+  trueValue() {
+    this._saveValue(true);
+  }
+  falseValue() {
+    this._saveValue(false);
+  }
+
+  //startObject() - assigned below
+
+  endObject() {
+    if (this.stack.length) {
+      const value = this.current;
+      this.key = this.stack.pop();
+      this.current = this.stack.pop();
+      this._saveValue(value);
+    } else {
+      this.done = true;
+    }
+  }
+
+  //startArray() - assigned below
+  //endArray() - aliased below to endObject()
+
+  _saveValue(value) {
+    if (this.done) {
+      this.current = value;
+    } else {
+      if (this.current instanceof Array) {
+        this.current.push(value);
+      } else {
+        this.current[this.key] = value;
+        this.key = null;
+      }
+    }
+  }
+  _saveValueWithReviver(value) {
+    if (this.done) {
+      this.current = this.reviver('', value);
+    } else {
+      if (this.current instanceof Array) {
+        value = this.reviver('' + this.current.length, value);
+        this.current.push(value);
+        if (value === undefined) {
+          delete this.current[this.current.length - 1];
+        }
+      } else {
+        value = this.reviver(this.key, value);
+        if (value !== undefined) {
+          this.current[this.key] = value;
+        }
+        this.key = null;
+      }
+    }
+  }
+}
+
+Assembler.prototype.stringValue = Assembler.prototype._saveValue;
+Assembler.prototype.startObject = startObject(Object);
+Assembler.prototype.startArray = startObject(Array);
+Assembler.prototype.endArray = Assembler.prototype.endObject;
+
+module.exports = Assembler;

package/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;

package/Emitter.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const {Writable} = require('stream');
+
+class Emitter extends Writable {
+  static make(options) {
+    return new Emitter(options);
+  }
+
+  constructor(options) {
+    super(Object.assign({}, options, {objectMode: true}));
+  }
+
+  _write(chunk, encoding, callback) {
+    this.emit(chunk.name, chunk.value);
+    callback(null);
+  }
+}
+Emitter.emitter = Emitter.make;
+Emitter.make.Constructor = Emitter;
+
+module.exports = Emitter;

package/LICENSE

@@ -0,0 +1,34 @@
+This library is available under the terms of the modified BSD license. No external contributions
+are allowed under licenses which are fundamentally incompatible with the BSD license that this library is distributed under.
+
+The text of the BSD license is reproduced below.
+
+-------------------------------------------------------------------------------
+The "New" BSD License:
+**********************
+
+Copyright (c) 2005-2024, Eugene Lazutkin
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+  * Neither the name of Eugene Lazutkin nor the names of other contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.