Spaces:
Running
Running
const { isReadableStream } = require('./utils'); | |
const TextDecoder = require('./text-decoder'); | |
const STACK_OBJECT = 1; | |
const STACK_ARRAY = 2; | |
const decoder = new TextDecoder(); | |
function isObject(value) { | |
return value !== null && typeof value === 'object'; | |
} | |
function adjustPosition(error, parser) { | |
if (error.name === 'SyntaxError' && parser.jsonParseOffset) { | |
error.message = error.message.replace(/at position (\d+)/, (_, pos) => | |
'at position ' + (Number(pos) + parser.jsonParseOffset) | |
); | |
} | |
return error; | |
} | |
function append(array, elements) { | |
// Note: Avoid to use array.push(...elements) since it may lead to | |
// "RangeError: Maximum call stack size exceeded" for a long arrays | |
const initialLength = array.length; | |
array.length += elements.length; | |
for (let i = 0; i < elements.length; i++) { | |
array[initialLength + i] = elements[i]; | |
} | |
} | |
module.exports = function(chunkEmitter) { | |
let parser = new ChunkParser(); | |
if (isObject(chunkEmitter) && isReadableStream(chunkEmitter)) { | |
return new Promise((resolve, reject) => { | |
chunkEmitter | |
.on('data', chunk => { | |
try { | |
parser.push(chunk); | |
} catch (e) { | |
reject(adjustPosition(e, parser)); | |
parser = null; | |
} | |
}) | |
.on('error', (e) => { | |
parser = null; | |
reject(e); | |
}) | |
.on('end', () => { | |
try { | |
resolve(parser.finish()); | |
} catch (e) { | |
reject(adjustPosition(e, parser)); | |
} finally { | |
parser = null; | |
} | |
}); | |
}); | |
} | |
if (typeof chunkEmitter === 'function') { | |
const iterator = chunkEmitter(); | |
if (isObject(iterator) && (Symbol.iterator in iterator || Symbol.asyncIterator in iterator)) { | |
return new Promise(async (resolve, reject) => { | |
try { | |
for await (const chunk of iterator) { | |
parser.push(chunk); | |
} | |
resolve(parser.finish()); | |
} catch (e) { | |
reject(adjustPosition(e, parser)); | |
} finally { | |
parser = null; | |
} | |
}); | |
} | |
} | |
throw new Error( | |
'Chunk emitter should be readable stream, generator, ' + | |
'async generator or function returning an iterable object' | |
); | |
}; | |
class ChunkParser { | |
constructor() { | |
this.value = undefined; | |
this.valueStack = null; | |
this.stack = new Array(100); | |
this.lastFlushDepth = 0; | |
this.flushDepth = 0; | |
this.stateString = false; | |
this.stateStringEscape = false; | |
this.pendingByteSeq = null; | |
this.pendingChunk = null; | |
this.chunkOffset = 0; | |
this.jsonParseOffset = 0; | |
} | |
parseAndAppend(fragment, wrap) { | |
// Append new entries or elements | |
if (this.stack[this.lastFlushDepth - 1] === STACK_OBJECT) { | |
if (wrap) { | |
this.jsonParseOffset--; | |
fragment = '{' + fragment + '}'; | |
} | |
Object.assign(this.valueStack.value, JSON.parse(fragment)); | |
} else { | |
if (wrap) { | |
this.jsonParseOffset--; | |
fragment = '[' + fragment + ']'; | |
} | |
append(this.valueStack.value, JSON.parse(fragment)); | |
} | |
} | |
prepareAddition(fragment) { | |
const { value } = this.valueStack; | |
const expectComma = Array.isArray(value) | |
? value.length !== 0 | |
: Object.keys(value).length !== 0; | |
if (expectComma) { | |
// Skip a comma at the beginning of fragment, otherwise it would | |
// fail to parse | |
if (fragment[0] === ',') { | |
this.jsonParseOffset++; | |
return fragment.slice(1); | |
} | |
// When value (an object or array) is not empty and a fragment | |
// doesn't start with a comma, a single valid fragment starting | |
// is a closing bracket. If it's not, a prefix is adding to fail | |
// parsing. Otherwise, the sequence of chunks can be successfully | |
// parsed, although it should not, e.g. ["[{}", "{}]"] | |
if (fragment[0] !== '}' && fragment[0] !== ']') { | |
this.jsonParseOffset -= 3; | |
return '[[]' + fragment; | |
} | |
} | |
return fragment; | |
} | |
flush(chunk, start, end) { | |
let fragment = chunk.slice(start, end); | |
// Save position correction an error in JSON.parse() if any | |
this.jsonParseOffset = this.chunkOffset + start; | |
// Prepend pending chunk if any | |
if (this.pendingChunk !== null) { | |
fragment = this.pendingChunk + fragment; | |
this.jsonParseOffset -= this.pendingChunk.length; | |
this.pendingChunk = null; | |
} | |
if (this.flushDepth === this.lastFlushDepth) { | |
// Depth didn't changed, so it's a root value or entry/element set | |
if (this.flushDepth > 0) { | |
this.parseAndAppend(this.prepareAddition(fragment), true); | |
} else { | |
// That's an entire value on a top level | |
this.value = JSON.parse(fragment); | |
this.valueStack = { | |
value: this.value, | |
prev: null | |
}; | |
} | |
} else if (this.flushDepth > this.lastFlushDepth) { | |
// Add missed closing brackets/parentheses | |
for (let i = this.flushDepth - 1; i >= this.lastFlushDepth; i--) { | |
fragment += this.stack[i] === STACK_OBJECT ? '}' : ']'; | |
} | |
if (this.lastFlushDepth === 0) { | |
// That's a root value | |
this.value = JSON.parse(fragment); | |
this.valueStack = { | |
value: this.value, | |
prev: null | |
}; | |
} else { | |
this.parseAndAppend(this.prepareAddition(fragment), true); | |
} | |
// Move down to the depths to the last object/array, which is current now | |
for (let i = this.lastFlushDepth || 1; i < this.flushDepth; i++) { | |
let value = this.valueStack.value; | |
if (this.stack[i - 1] === STACK_OBJECT) { | |
// find last entry | |
let key; | |
// eslint-disable-next-line curly | |
for (key in value); | |
value = value[key]; | |
} else { | |
// last element | |
value = value[value.length - 1]; | |
} | |
this.valueStack = { | |
value, | |
prev: this.valueStack | |
}; | |
} | |
} else /* this.flushDepth < this.lastFlushDepth */ { | |
fragment = this.prepareAddition(fragment); | |
// Add missed opening brackets/parentheses | |
for (let i = this.lastFlushDepth - 1; i >= this.flushDepth; i--) { | |
this.jsonParseOffset--; | |
fragment = (this.stack[i] === STACK_OBJECT ? '{' : '[') + fragment; | |
} | |
this.parseAndAppend(fragment, false); | |
for (let i = this.lastFlushDepth - 1; i >= this.flushDepth; i--) { | |
this.valueStack = this.valueStack.prev; | |
} | |
} | |
this.lastFlushDepth = this.flushDepth; | |
} | |
push(chunk) { | |
if (typeof chunk !== 'string') { | |
// Suppose chunk is Buffer or Uint8Array | |
// Prepend uncompleted byte sequence if any | |
if (this.pendingByteSeq !== null) { | |
const origRawChunk = chunk; | |
chunk = new Uint8Array(this.pendingByteSeq.length + origRawChunk.length); | |
chunk.set(this.pendingByteSeq); | |
chunk.set(origRawChunk, this.pendingByteSeq.length); | |
this.pendingByteSeq = null; | |
} | |
// In case Buffer/Uint8Array, an input is encoded in UTF8 | |
// Seek for parts of uncompleted UTF8 symbol on the ending | |
// This makes sense only if we expect more chunks and last char is not multi-bytes | |
if (chunk[chunk.length - 1] > 127) { | |
for (let seqLength = 0; seqLength < chunk.length; seqLength++) { | |
const byte = chunk[chunk.length - 1 - seqLength]; | |
// 10xxxxxx - 2nd, 3rd or 4th byte | |
// 110xxxxx – first byte of 2-byte sequence | |
// 1110xxxx - first byte of 3-byte sequence | |
// 11110xxx - first byte of 4-byte sequence | |
if (byte >> 6 === 3) { | |
seqLength++; | |
// If the sequence is really incomplete, then preserve it | |
// for the future chunk and cut off it from the current chunk | |
if ((seqLength !== 4 && byte >> 3 === 0b11110) || | |
(seqLength !== 3 && byte >> 4 === 0b1110) || | |
(seqLength !== 2 && byte >> 5 === 0b110)) { | |
this.pendingByteSeq = chunk.slice(chunk.length - seqLength); | |
chunk = chunk.slice(0, -seqLength); | |
} | |
break; | |
} | |
} | |
} | |
// Convert chunk to a string, since single decode per chunk | |
// is much effective than decode multiple small substrings | |
chunk = decoder.decode(chunk); | |
} | |
const chunkLength = chunk.length; | |
let lastFlushPoint = 0; | |
let flushPoint = 0; | |
// Main scan loop | |
scan: for (let i = 0; i < chunkLength; i++) { | |
if (this.stateString) { | |
for (; i < chunkLength; i++) { | |
if (this.stateStringEscape) { | |
this.stateStringEscape = false; | |
} else { | |
switch (chunk.charCodeAt(i)) { | |
case 0x22: /* " */ | |
this.stateString = false; | |
continue scan; | |
case 0x5C: /* \ */ | |
this.stateStringEscape = true; | |
} | |
} | |
} | |
break; | |
} | |
switch (chunk.charCodeAt(i)) { | |
case 0x22: /* " */ | |
this.stateString = true; | |
this.stateStringEscape = false; | |
break; | |
case 0x2C: /* , */ | |
flushPoint = i; | |
break; | |
case 0x7B: /* { */ | |
// Open an object | |
flushPoint = i + 1; | |
this.stack[this.flushDepth++] = STACK_OBJECT; | |
break; | |
case 0x5B: /* [ */ | |
// Open an array | |
flushPoint = i + 1; | |
this.stack[this.flushDepth++] = STACK_ARRAY; | |
break; | |
case 0x5D: /* ] */ | |
case 0x7D: /* } */ | |
// Close an object or array | |
flushPoint = i + 1; | |
this.flushDepth--; | |
if (this.flushDepth < this.lastFlushDepth) { | |
this.flush(chunk, lastFlushPoint, flushPoint); | |
lastFlushPoint = flushPoint; | |
} | |
break; | |
case 0x09: /* \t */ | |
case 0x0A: /* \n */ | |
case 0x0D: /* \r */ | |
case 0x20: /* space */ | |
// Move points forward when they points on current position and it's a whitespace | |
if (lastFlushPoint === i) { | |
lastFlushPoint++; | |
} | |
if (flushPoint === i) { | |
flushPoint++; | |
} | |
break; | |
} | |
} | |
if (flushPoint > lastFlushPoint) { | |
this.flush(chunk, lastFlushPoint, flushPoint); | |
} | |
// Produce pendingChunk if something left | |
if (flushPoint < chunkLength) { | |
if (this.pendingChunk !== null) { | |
// When there is already a pending chunk then no flush happened, | |
// appending entire chunk to pending one | |
this.pendingChunk += chunk; | |
} else { | |
// Create a pending chunk, it will start with non-whitespace since | |
// flushPoint was moved forward away from whitespaces on scan | |
this.pendingChunk = chunk.slice(flushPoint, chunkLength); | |
} | |
} | |
this.chunkOffset += chunkLength; | |
} | |
finish() { | |
if (this.pendingChunk !== null) { | |
this.flush('', 0, 0); | |
this.pendingChunk = null; | |
} | |
return this.value; | |
} | |
}; | |