@depup/stream-json 1.9.1-depup.0

package/Stringer.js

@@ -0,0 +1,153 @@
+'use strict';
+
+const {Transform} = require('stream');
+
+const noCommaAfter = {startObject: 1, startArray: 1, endKey: 1, keyValue: 1},
+  noSpaceAfter = {endObject: 1, endArray: 1, '': 1},
+  noSpaceBefore = {startObject: 1, startArray: 1},
+  depthIncrement = {startObject: 1, startArray: 1},
+  depthDecrement = {endObject: 1, endArray: 1},
+  values = {startKey: 'keyValue', startString: 'stringValue', startNumber: 'numberValue'},
+  stopNames = {startKey: 'endKey', startString: 'endString', startNumber: 'endNumber'},
+  symbols = {
+    startObject: '{',
+    endObject: '}',
+    startArray: '[',
+    endArray: ']',
+    startKey: '"',
+    endKey: '":',
+    startString: '"',
+    endString: '"',
+    startNumber: '',
+    endNumber: '',
+    nullValue: 'null',
+    trueValue: 'true',
+    falseValue: 'false'
+  };
+
+const skipValue = endName =>
+  function (chunk, encoding, callback) {
+    if (chunk.name === endName) {
+      this._transform = this._prev_transform;
+    }
+    callback(null);
+  };
+
+const replaceSymbols = {'\b': '\\b', '\f': '\\f', '\n': '\\n', '\r': '\\r', '\t': '\\t', '"': '\\"', '\\': '\\\\'};
+const sanitizeString = value =>
+  value.replace(/[\b\f\n\r\t\"\\\u0000-\u001F\u007F-\u009F]/g, match =>
+    replaceSymbols.hasOwnProperty(match) ? replaceSymbols[match] : '\\u' + ('0000' + match.charCodeAt(0).toString(16)).slice(-4)
+  );
+
+const doNothing = () => {};
+
+class Stringer extends Transform {
+  static make(options) {
+    return new Stringer(options);
+  }
+
+  constructor(options) {
+    super(Object.assign({}, options, {writableObjectMode: true, readableObjectMode: false}));
+
+    this._values = {};
+    if (options) {
+      'useValues' in options && (this._values.keyValue = this._values.stringValue = this._values.numberValue = options.useValues);
+      'useKeyValues' in options && (this._values.keyValue = options.useKeyValues);
+      'useStringValues' in options && (this._values.stringValue = options.useStringValues);
+      'useNumberValues' in options && (this._values.numberValue = options.useNumberValues);
+      this._makeArray = options.makeArray;
+    }
+
+    this._prev = '';
+    this._depth = 0;
+
+    if (this._makeArray) {
+      this._transform = this._arrayTransform;
+      this._flush = this._arrayFlush;
+    }
+  }
+
+  _arrayTransform(chunk, encoding, callback) {
+    // it runs once
+    delete this._transform;
+    this._transform({name: 'startArray'}, encoding, doNothing);
+    this._transform(chunk, encoding, callback);
+  }
+
+  _arrayFlush(callback) {
+    if (this._transform === this._arrayTransform) {
+      delete this._transform;
+      this._transform({name: 'startArray'}, null, doNothing);
+    }
+    this._transform({name: 'endArray'}, null, callback);
+  }
+
+  _transform(chunk, _, callback) {
+    if (this._values[chunk.name]) {
+      if (this._depth && noCommaAfter[this._prev] !== 1) this.push(',');
+      switch (chunk.name) {
+        case 'keyValue':
+          this.push('"' + sanitizeString(chunk.value) + '":');
+          break;
+        case 'stringValue':
+          this.push('"' + sanitizeString(chunk.value) + '"');
+          break;
+        case 'numberValue':
+          this.push(chunk.value);
+          break;
+      }
+    } else {
+      // filter out values
+      switch (chunk.name) {
+        case 'endObject':
+        case 'endArray':
+        case 'endKey':
+        case 'endString':
+        case 'endNumber':
+          this.push(symbols[chunk.name]);
+          break;
+        case 'stringChunk':
+          this.push(sanitizeString(chunk.value));
+          break;
+        case 'numberChunk':
+          this.push(chunk.value);
+          break;
+        case 'keyValue':
+        case 'stringValue':
+        case 'numberValue':
+          // skip completely
+          break;
+        case 'startKey':
+        case 'startString':
+        case 'startNumber':
+          if (this._values[values[chunk.name]]) {
+            this._prev_transform = this._transform;
+            this._transform = skipValue(stopNames[chunk.name]);
+            return callback(null);
+          }
+        // intentional fall down
+        default:
+          // case 'startObject': case 'startArray': case 'startKey': case 'startString':
+          // case 'startNumber': case 'nullValue': case 'trueValue': case 'falseValue':
+          if (this._depth) {
+            if (noCommaAfter[this._prev] !== 1) this.push(',');
+          } else {
+            if (noSpaceAfter[this._prev] !== 1 && noSpaceBefore[chunk.name] !== 1) this.push(' ');
+          }
+          this.push(symbols[chunk.name]);
+          break;
+      }
+      if (depthIncrement[chunk.name]) {
+        ++this._depth;
+      } else if (depthDecrement[chunk.name]) {
+        --this._depth;
+      }
+    }
+    this._prev = chunk.name;
+    callback(null);
+  }
+}
+Stringer.stringer = Stringer.make;
+Stringer.make.Constructor = Stringer;
+
+module.exports = Stringer;

package/changes.json

@@ -0,0 +1,10 @@
+{
+  "bumped": {
+    "stream-chain": {
+      "from": "^2.2.5",
+      "to": "^3.4.1"
+    }
+  },
+  "timestamp": "2026-03-17T16:39:24.506Z",
+  "totalUpdated": 1
+}

package/filters/Filter.js

@@ -0,0 +1,130 @@
+'use strict';
+
+const FilterBase = require('./FilterBase');
+const withParser = require('../utils/withParser');
+
+class Filter extends FilterBase {
+  static make(options) {
+    return new Filter(options);
+  }
+
+  static withParser(options) {
+    return withParser(Filter.make, options);
+  }
+
+  constructor(options) {
+    super(options);
+    this._once = false;
+    this._lastStack = [];
+  }
+
+  _flush(callback) {
+    this._syncStack();
+    callback(null);
+  }
+
+  _checkChunk(chunk) {
+    switch (chunk.name) {
+      case 'startObject':
+        if (this._filter(this._stack, chunk)) {
+          this._syncStack();
+          this.push(chunk);
+          this._lastStack.push(null);
+        }
+        break;
+      case 'startArray':
+        if (this._filter(this._stack, chunk)) {
+          this._syncStack();
+          this.push(chunk);
+          this._lastStack.push(-1);
+        }
+        break;
+      case 'nullValue':
+      case 'trueValue':
+      case 'falseValue':
+      case 'stringValue':
+      case 'numberValue':
+        if (this._filter(this._stack, chunk)) {
+          this._syncStack();
+          this.push(chunk);
+        }
+        break;
+      case 'startString':
+        if (this._filter(this._stack, chunk)) {
+          this._syncStack();
+          this.push(chunk);
+          this._transform = this._passString;
+        } else {
+          this._transform = this._skipString;
+        }
+        break;
+      case 'startNumber':
+        if (this._filter(this._stack, chunk)) {
+          this._syncStack();
+          this.push(chunk);
+          this._transform = this._passNumber;
+        } else {
+          this._transform = this._skipNumber;
+        }
+        break;
+    }
+    return false;
+  }
+
+  _syncStack() {
+    const stack = this._stack,
+      last = this._lastStack,
+      stackLength = stack.length,
+      lastLength = last.length;
+
+    // find the common part
+    let commonLength = 0;
+    for (const n = Math.min(stackLength, lastLength); commonLength < n && stack[commonLength] === last[commonLength]; ++commonLength);
+
+    // close old objects
+    for (let i = lastLength - 1; i > commonLength; --i) {
+      this.push({name: typeof last[i] == 'number' ? 'endArray' : 'endObject'});
+    }
+    if (commonLength < lastLength) {
+      if (commonLength < stackLength) {
+        if (typeof stack[commonLength] == 'string') {
+          const key = stack[commonLength];
+          if (this._streamKeys) {
+            this.push({name: 'startKey'});
+            this.push({name: 'stringChunk', value: key});
+            this.push({name: 'endKey'});
+          }
+          this.push({name: 'keyValue', value: key});
+        }
+        ++commonLength;
+      } else {
+        this.push({name: typeof last[commonLength] == 'number' ? 'endArray' : 'endObject'});
+      }
+    }
+
+    // open new objects
+    for (let i = commonLength; i < stackLength; ++i) {
+      const key = stack[i];
+      if (typeof key == 'number') {
+        if (key >= 0) {
+          this.push({name: 'startArray'});
+        }
+      } else if (typeof key == 'string') {
+        this.push({name: 'startObject'});
+        if (this._streamKeys) {
+          this.push({name: 'startKey'});
+          this.push({name: 'stringChunk', value: key});
+          this.push({name: 'endKey'});
+        }
+        this.push({name: 'keyValue', value: key});
+      }
+    }
+
+    // update the last stack
+    this._lastStack = Array.prototype.concat.call(stack);
+  }
+}
+Filter.filter = Filter.make;
+Filter.make.Constructor = Filter;
+
+module.exports = Filter;

package/filters/FilterBase.js

@@ -0,0 +1,201 @@
+'use strict';
+
+const {Transform} = require('stream');
+
+class FilterBase extends Transform {
+  static stringFilter(string, separator) {
+    return stack => {
+      const path = stack.join(separator);
+      return (
+        (path.length === string.length && path === string) ||
+        (path.length > string.length && path.substr(0, string.length) === string && path.substr(string.length, separator.length) === separator)
+      );
+    };
+  }
+
+  static regExpFilter(regExp, separator) {
+    return stack => regExp.test(stack.join(separator));
+  }
+
+  static arrayReplacement(array) {
+    return () => array;
+  }
+
+  constructor(options) {
+    super(Object.assign({}, options, {writableObjectMode: true, readableObjectMode: true}));
+    this._transform = this._check;
+    this._stack = [];
+
+    const filter = options && options.filter,
+      separator = (options && options.pathSeparator) || '.';
+    if (typeof filter == 'string') {
+      this._filter = FilterBase.stringFilter(filter, separator);
+    } else if (typeof filter == 'function') {
+      this._filter = filter;
+    } else if (filter instanceof RegExp) {
+      this._filter = FilterBase.regExpFilter(filter, separator);
+    }
+
+    const replacement = options && options.replacement;
+    if (typeof replacement == 'function') {
+      this._replacement = replacement;
+    } else {
+      this._replacement = FilterBase.arrayReplacement(replacement || FilterBase.defaultReplacement);
+    }
+    this._allowEmptyReplacement = options && options.allowEmptyReplacement;
+
+    this._streamKeys = true;
+    if (options) {
+      'streamValues' in options && (this._streamKeys = options.streamValues);
+      'streamKeys' in options && (this._streamKeys = options.streamKeys);
+    }
+
+    this._once = options && options.once;
+    this._previousToken = '';
+  }
+
+  _check(chunk, _, callback) {
+    // update the last stack key
+    switch (chunk.name) {
+      case 'startObject':
+      case 'startArray':
+      case 'startString':
+      case 'startNumber':
+      case 'nullValue':
+      case 'trueValue':
+      case 'falseValue':
+        if (typeof this._stack[this._stack.length - 1] == 'number') {
+          // array
+          ++this._stack[this._stack.length - 1];
+        }
+        break;
+      case 'keyValue':
+        this._stack[this._stack.length - 1] = chunk.value;
+        break;
+      case 'numberValue':
+        if (this._previousToken !== 'endNumber' && typeof this._stack[this._stack.length - 1] == 'number') {
+          // array
+          ++this._stack[this._stack.length - 1];
+        }
+        break;
+      case 'stringValue':
+        if (this._previousToken !== 'endString' && typeof this._stack[this._stack.length - 1] == 'number') {
+          // array
+          ++this._stack[this._stack.length - 1];
+        }
+        break;
+    }
+    this._previousToken = chunk.name;
+    // check, if we allow a chunk
+    if (this._checkChunk(chunk)) {
+      return callback(null);
+    }
+    // update the stack
+    switch (chunk.name) {
+      case 'startObject':
+        this._stack.push(null);
+        break;
+      case 'startArray':
+        this._stack.push(-1);
+        break;
+      case 'endObject':
+      case 'endArray':
+        this._stack.pop();
+        break;
+    }
+    callback(null);
+  }
+
+  _passObject(chunk, _, callback) {
+    this.push(chunk);
+    switch (chunk.name) {
+      case 'startObject':
+      case 'startArray':
+        ++this._depth;
+        break;
+      case 'endObject':
+      case 'endArray':
+        --this._depth;
+        break;
+    }
+    if (!this._depth) {
+      this._transform = this._once ? this._skip : this._check;
+    }
+    callback(null);
+  }
+
+  _pass(chunk, _, callback) {
+    this.push(chunk);
+    callback(null);
+  }
+
+  _skipObject(chunk, _, callback) {
+    switch (chunk.name) {
+      case 'startObject':
+      case 'startArray':
+        ++this._depth;
+        break;
+      case 'endObject':
+      case 'endArray':
+        --this._depth;
+        break;
+    }
+    if (!this._depth) {
+      this._transform = this._once ? this._pass : this._check;
+    }
+    callback(null);
+  }
+
+  _skip(chunk, _, callback) {
+    callback(null);
+  }
+}
+
+FilterBase.defaultReplacement = [{name: 'nullValue', value: null}];
+
+const passValue = (last, post) =>
+  function(chunk, _, callback) {
+    if (this._expected) {
+      const expected = this._expected;
+      this._expected = '';
+      this._transform = this._once ? this._skip : this._check;
+      if (expected === chunk.name) {
+        this.push(chunk);
+      } else {
+        return this._transform(chunk, _, callback);
+      }
+    } else {
+      this.push(chunk);
+      if (chunk.name === last) {
+        this._expected = post;
+      }
+    }
+    callback(null);
+  };
+
+FilterBase.prototype._passNumber = passValue('endNumber', 'numberValue');
+FilterBase.prototype._passString = passValue('endString', 'stringValue');
+FilterBase.prototype._passKey = passValue('endKey', 'keyValue');
+
+const skipValue = (last, post) =>
+  function(chunk, _, callback) {
+    if (this._expected) {
+      const expected = this._expected;
+      this._expected = '';
+      this._transform = this._once ? this._pass : this._check;
+      if (expected !== chunk.name) {
+        return this._transform(chunk, _, callback);
+      }
+    } else {
+      if (chunk.name === last) {
+        this._expected = post;
+      }
+    }
+    callback(null);
+  };
+
+FilterBase.prototype._skipNumber = skipValue('endNumber', 'numberValue');
+FilterBase.prototype._skipString = skipValue('endString', 'stringValue');
+FilterBase.prototype._skipKey = skipValue('endKey', 'keyValue');
+
+module.exports = FilterBase;

package/filters/Ignore.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const Replace = require('./Replace');
+const withParser = require('../utils/withParser');
+
+class Ignore extends Replace {
+  static make(options) {
+    return new Ignore(options);
+  }
+
+  static withParser(options) {
+    return withParser(Ignore.make, options);
+  }
+
+  constructor(options) {
+    super(options);
+    this._replacement = Replace.arrayReplacement([]);
+    this._allowEmptyReplacement = true;
+  }
+}
+Ignore.ignore = Ignore.make;
+Ignore.make.Constructor = Ignore;
+
+module.exports = Ignore;

package/filters/Pick.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const FilterBase = require('./FilterBase');
+const withParser = require('../utils/withParser');
+
+class Pick extends FilterBase {
+  static make(options) {
+    return new Pick(options);
+  }
+
+  static withParser(options) {
+    return withParser(Pick.make, options);
+  }
+
+  _checkChunk(chunk) {
+    switch (chunk.name) {
+      case 'startObject':
+      case 'startArray':
+        if (this._filter(this._stack, chunk)) {
+          this.push(chunk);
+          this._transform = this._passObject;
+          this._depth = 1;
+          return true;
+        }
+        break;
+      case 'startString':
+        if (this._filter(this._stack, chunk)) {
+          this.push(chunk);
+          this._transform = this._passString;
+          return true;
+        }
+        break;
+      case 'startNumber':
+        if (this._filter(this._stack, chunk)) {
+          this.push(chunk);
+          this._transform = this._passNumber;
+          return true;
+        }
+        break;
+      case 'nullValue':
+      case 'trueValue':
+      case 'falseValue':
+      case 'stringValue':
+      case 'numberValue':
+        if (this._filter(this._stack, chunk)) {
+          this.push(chunk);
+          this._transform = this._once ? this._skip : this._check;
+          return true;
+        }
+        break;
+    }
+    return false;
+  }
+}
+Pick.pick = Pick.make;
+Pick.make.Constructor = Pick;
+
+module.exports = Pick;

package/filters/Replace.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const FilterBase = require('./FilterBase');
+const withParser = require('../utils/withParser');
+
+class Replace extends FilterBase {
+  static make(options) {
+    return new Replace(options);
+  }
+
+  static withParser(options) {
+    return withParser(Replace.make, options);
+  }
+
+  _checkChunk(chunk) {
+    switch (chunk.name) {
+      case 'startKey':
+        if (this._allowEmptyReplacement) {
+          this._transform = this._skipKeyChunks;
+          return true;
+        }
+        break;
+      case 'keyValue':
+        if (this._allowEmptyReplacement) return true;
+        break;
+      case 'startObject':
+      case 'startArray':
+      case 'startString':
+      case 'startNumber':
+      case 'nullValue':
+      case 'trueValue':
+      case 'falseValue':
+      case 'stringValue':
+      case 'numberValue':
+        if (this._filter(this._stack, chunk)) {
+          let replacement = this._replacement(this._stack, chunk);
+          if (this._allowEmptyReplacement) {
+            if (replacement.length) {
+              const key = this._stack[this._stack.length - 1];
+              if (typeof key == 'string') {
+                if (this._streamKeys) {
+                  this.push({name: 'startKey'});
+                  this.push({name: 'stringChunk', value: key});
+                  this.push({name: 'endKey'});
+                }
+                this.push({name: 'keyValue', value: key});
+              }
+            }
+          } else {
+            if (!replacement.length) replacement = FilterBase.defaultReplacement;
+          }
+          replacement.forEach(value => this.push(value));
+          switch (chunk.name) {
+            case 'startObject':
+            case 'startArray':
+              this._transform = this._skipObject;
+              this._depth = 1;
+              break;
+            case 'startString':
+              this._transform = this._skipString;
+              break;
+            case 'startNumber':
+              this._transform = this._skipNumber;
+              break;
+            case 'nullValue':
+            case 'trueValue':
+            case 'falseValue':
+            case 'stringValue':
+            case 'numberValue':
+              this._transform = this._once ? this._pass : this._check;
+              break;
+          }
+          return true;
+        }
+        break;
+    }
+    // issue a key, if needed
+    if (this._allowEmptyReplacement) {
+      const key = this._stack[this._stack.length - 1];
+      if (typeof key == 'string') {
+        switch (chunk.name) {
+          case 'startObject':
+          case 'startArray':
+          case 'startString':
+          case 'startNumber':
+          case 'nullValue':
+          case 'trueValue':
+          case 'falseValue':
+          case 'stringValue':
+          case 'numberValue':
+            if (this._streamKeys) {
+              this.push({name: 'startKey'});
+              this.push({name: 'stringChunk', value: key});
+              this.push({name: 'endKey'});
+            }
+            this.push({name: 'keyValue', value: key});
+            break;
+        }
+      }
+    }
+    this.push(chunk);
+    return false;
+  }
+
+  _skipKeyChunks(chunk, _, callback) {
+    if (chunk.name === 'endKey') {
+      this._transform = this._check;
+    }
+    callback(null);
+  }
+}
+Replace.replace = Replace.make;
+Replace.make.Constructor = Replace;
+
+module.exports = Replace;

package/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const Parser = require('./Parser');
+const emit = require('./utils/emit');
+
+const make = options => emit(new Parser(options));
+
+make.Parser = Parser;
+make.parser = Parser.parser;
+
+module.exports = make;