diff options
Diffstat (limited to 'sandbox/testAppNevena/Front/node_modules/minipass-json-stream/index.js')
| -rw-r--r-- | sandbox/testAppNevena/Front/node_modules/minipass-json-stream/index.js | 227 |
1 files changed, 227 insertions, 0 deletions
diff --git a/sandbox/testAppNevena/Front/node_modules/minipass-json-stream/index.js b/sandbox/testAppNevena/Front/node_modules/minipass-json-stream/index.js new file mode 100644 index 00000000..5168d132 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/minipass-json-stream/index.js @@ -0,0 +1,227 @@ +// put javascript in here +'use strict' + +const Parser = require('jsonparse') +const Minipass = require('minipass') + +class JSONStreamError extends Error { + constructor (err, caller) { + super(err.message) + Error.captureStackTrace(this, caller || this.constructor) + } + get name () { + return 'JSONStreamError' + } + set name (n) {} +} + +const check = (x, y) => + typeof x === 'string' ? String(y) === x + : x && typeof x.test === 'function' ? x.test(y) + : typeof x === 'boolean' || typeof x === 'object' ? x + : typeof x === 'function' ? x(y) + : false + +const _parser = Symbol('_parser') +const _onValue = Symbol('_onValue') +const _onTokenOriginal = Symbol('_onTokenOriginal') +const _onToken = Symbol('_onToken') +const _onError = Symbol('_onError') +const _count = Symbol('_count') +const _path = Symbol('_path') +const _map = Symbol('_map') +const _root = Symbol('_root') +const _header = Symbol('_header') +const _footer = Symbol('_footer') +const _setHeaderFooter = Symbol('_setHeaderFooter') +const _ending = Symbol('_ending') + +class JSONStream extends Minipass { + constructor (opts = {}) { + super({ + ...opts, + objectMode: true, + }) + + this[_ending] = false + const parser = this[_parser] = new Parser() + parser.onValue = value => this[_onValue](value) + this[_onTokenOriginal] = parser.onToken + parser.onToken = (token, value) => this[_onToken](token, value) + parser.onError = er => this[_onError](er) + + this[_count] = 0 + this[_path] = typeof opts.path === 'string' + ? opts.path.split('.').map(e => + e === '$*' ? { emitKey: true } + : e === '*' ? true + : e === '' ? { recurse: true } + : e) + : Array.isArray(opts.path) && opts.path.length ? opts.path + : null + + this[_map] = typeof opts.map === 'function' ? opts.map : null + this[_root] = null + this[_header] = null + this[_footer] = null + this[_count] = 0 + } + + [_setHeaderFooter] (key, value) { + // header has not been emitted yet + if (this[_header] !== false) { + this[_header] = this[_header] || {} + this[_header][key] = value + } + + // footer has not been emitted yet but header has + if (this[_footer] !== false && this[_header] === false) { + this[_footer] = this[_footer] || {} + this[_footer][key] = value + } + } + + [_onError] (er) { + // error will always happen during a write() call. + const caller = this[_ending] ? this.end : this.write + this[_ending] = false + return this.emit('error', new JSONStreamError(er, caller)) + } + + [_onToken] (token, value) { + const parser = this[_parser] + this[_onTokenOriginal].call(parser, token, value) + if (parser.stack.length === 0) { + if (this[_root]) { + const root = this[_root] + if (!this[_path]) + super.write(root) + this[_root] = null + this[_count] = 0 + } + } + } + + [_onValue] (value) { + const parser = this[_parser] + // the LAST onValue encountered is the root object. + // just overwrite it each time. + this[_root] = value + + if(!this[_path]) return + + let i = 0 // iterates on path + let j = 0 // iterates on stack + let emitKey = false + let emitPath = false + while (i < this[_path].length) { + const key = this[_path][i] + j++ + + if (key && !key.recurse) { + const c = (j === parser.stack.length) ? parser : parser.stack[j] + if (!c) return + if (!check(key, c.key)) { + this[_setHeaderFooter](c.key, value) + return + } + emitKey = !!key.emitKey; + emitPath = !!key.emitPath; + i++ + } else { + i++ + if (i >= this[_path].length) + return + const nextKey = this[_path][i] + if (!nextKey) + return + while (true) { + const c = (j === parser.stack.length) ? parser : parser.stack[j] + if (!c) return + if (check(nextKey, c.key)) { + i++ + if (!Object.isFrozen(parser.stack[j])) + parser.stack[j].value = null + break + } else { + this[_setHeaderFooter](c.key, value) + } + j++ + } + } + } + + // emit header + if (this[_header]) { + const header = this[_header] + this[_header] = false + this.emit('header', header) + } + if (j !== parser.stack.length) return + + this[_count] ++ + const actualPath = parser.stack.slice(1) + .map(e => e.key).concat([parser.key]) + if (value !== null && value !== undefined) { + const data = this[_map] ? this[_map](value, actualPath) : value + if (data !== null && data !== undefined) { + const emit = emitKey || emitPath ? { value: data } : data + if (emitKey) + emit.key = parser.key + if (emitPath) + emit.path = actualPath + super.write(emit) + } + } + + if (parser.value) + delete parser.value[parser.key] + + for (const k of parser.stack) { + k.value = null + } + } + + write (chunk, encoding, cb) { + if (typeof encoding === 'function') + cb = encoding, encoding = null + if (typeof chunk === 'string') + chunk = Buffer.from(chunk, encoding) + else if (!Buffer.isBuffer(chunk)) + return this.emit('error', new TypeError( + 'Can only parse JSON from string or buffer input')) + this[_parser].write(chunk) + if (cb) + cb() + return this.flowing + } + + end (chunk, encoding, cb) { + this[_ending] = true + if (typeof encoding === 'function') + cb = encoding, encoding = null + if (typeof chunk === 'function') + cb = chunk, chunk = null + if (chunk) + this.write(chunk, encoding) + if (cb) + this.once('end', cb) + + const h = this[_header] + this[_header] = null + const f = this[_footer] + this[_footer] = null + if (h) + this.emit('header', h) + if (f) + this.emit('footer', f) + return super.end() + } + + static get JSONStreamError () { return JSONStreamError } + static parse (path, map) { + return new JSONStream({path, map}) + } +} + +module.exports = JSONStream |