CasperSecurity
const { Readable } = require('stream');
const {
normalizeReplacer,
normalizeSpace,
replaceValue,
getTypeAsync,
type: {
PRIMITIVE,
OBJECT,
ARRAY,
PROMISE,
STRING_STREAM,
OBJECT_STREAM
}
} = require('./utils');
const noop = () => {};
const hasOwnProperty = Object.prototype.hasOwnProperty;
// TODO: Remove when drop support for Node.js 10
// Node.js 10 has no well-formed JSON.stringify()
// https://github.com/tc39/proposal-well-formed-stringify
// Adopted code from https://bugs.chromium.org/p/v8/issues/detail?id=7782#c12
const wellformedStringStringify = JSON.stringify('\ud800') === '"\\ud800"'
? JSON.stringify
: s => JSON.stringify(s).replace(
/\p{Surrogate}/gu,
m => `\\u${m.charCodeAt(0).toString(16)}`
);
function push() {
this.push(this._stack.value);
this.popStack();
}
function pushPrimitive(value) {
switch (typeof value) {
case 'string':
this.push(this.encodeString(value));
break;
case 'number':
this.push(Number.isFinite(value) ? this.encodeNumber(value) : 'null');
break;
case 'boolean':
this.push(value ? 'true' : 'false');
break;
case 'undefined':
case 'object': // typeof null === 'object'
this.push('null');
break;
default:
this.destroy(new TypeError(`Do not know how to serialize a ${value.constructor && value.constructor.name || typeof value}`));
}
}
function processObjectEntry(key) {
const current = this._stack;
if (!current.first) {
current.first = true;
} else {
this.push(',');
}
if (this.space) {
this.push(`\n${this.space.repeat(this._depth)}${this.encodeString(key)}: `);
} else {
this.push(this.encodeString(key) + ':');
}
}
function processObject() {
const current = this._stack;
// when no keys left, remove obj from stack
if (current.index === current.keys.length) {
if (this.space && current.first) {
this.push(`\n${this.space.repeat(this._depth - 1)}}`);
} else {
this.push('}');
}
this.popStack();
return;
}
const key = current.keys[current.index];
this.processValue(current.value, key, current.value[key], processObjectEntry);
current.index++;
}
function processArrayItem(index) {
if (index !== 0) {
this.push(',');
}
if (this.space) {
this.push(`\n${this.space.repeat(this._depth)}`);
}
}
function processArray() {
const current = this._stack;
if (current.index === current.value.length) {
if (this.space && current.index > 0) {
this.push(`\n${this.space.repeat(this._depth - 1)}]`);
} else {
this.push(']');
}
this.popStack();
return;
}
this.processValue(current.value, current.index, current.value[current.index], processArrayItem);
current.index++;
}
function createStreamReader(fn) {
return function() {
const current = this._stack;
const data = current.value.read(this._readSize);
if (data !== null) {
current.first = false;
fn.call(this, data, current);
} else {
if ((current.first && !current.value._readableState.reading) || current.ended) {
this.popStack();
} else {
current.first = true;
current.awaiting = true;
}
}
};
}
const processReadableObject = createStreamReader(function(data, current) {
this.processValue(current.value, current.index, data, processArrayItem);
current.index++;
});
const processReadableString = createStreamReader(function(data) {
this.push(data);
});
class JsonStringifyStream extends Readable {
constructor(value, replacer, space) {
super({
autoDestroy: true
});
this.getKeys = Object.keys;
this.replacer = normalizeReplacer(replacer);
if (Array.isArray(this.replacer)) {
const allowlist = this.replacer;
this.getKeys = (value) => allowlist.filter(key => hasOwnProperty.call(value, key));
this.replacer = null;
}
this.space = normalizeSpace(space);
this._depth = 0;
this.error = null;
this._processing = false;
this._ended = false;
this._readSize = 0;
this._buffer = '';
this._stack = null;
this._visited = new WeakSet();
this.pushStack({
handler: () => {
this.popStack();
this.processValue({ '': value }, '', value, noop);
}
});
}
encodeString(value) {
if (/[^\x20-\uD799]|[\x22\x5c]/.test(value)) {
return wellformedStringStringify(value);
}
return '"' + value + '"';
}
encodeNumber(value) {
return value;
}
processValue(holder, key, value, callback) {
value = replaceValue(holder, key, value, this.replacer);
let type = getTypeAsync(value);
switch (type) {
case PRIMITIVE:
if (callback !== processObjectEntry || value !== undefined) {
callback.call(this, key);
pushPrimitive.call(this, value);
}
break;
case OBJECT:
callback.call(this, key);
// check for circular structure
if (this._visited.has(value)) {
return this.destroy(new TypeError('Converting circular structure to JSON'));
}
this._visited.add(value);
this._depth++;
this.push('{');
this.pushStack({
handler: processObject,
value,
index: 0,
first: false,
keys: this.getKeys(value)
});
break;
case ARRAY:
callback.call(this, key);
// check for circular structure
if (this._visited.has(value)) {
return this.destroy(new TypeError('Converting circular structure to JSON'));
}
this._visited.add(value);
this.push('[');
this.pushStack({
handler: processArray,
value,
index: 0
});
this._depth++;
break;
case PROMISE:
this.pushStack({
handler: noop,
awaiting: true
});
Promise.resolve(value)
.then(resolved => {
this.popStack();
this.processValue(holder, key, resolved, callback);
this.processStack();
})
.catch(error => {
this.destroy(error);
});
break;
case STRING_STREAM:
case OBJECT_STREAM:
callback.call(this, key);
// TODO: Remove when drop support for Node.js 10
// Used `_readableState.endEmitted` as fallback, since Node.js 10 has no `readableEnded` getter
if (value.readableEnded || value._readableState.endEmitted) {
return this.destroy(new Error('Readable Stream has ended before it was serialized. All stream data have been lost'));
}
if (value.readableFlowing) {
return this.destroy(new Error('Readable Stream is in flowing mode, data may have been lost. Trying to pause stream.'));
}
if (type === OBJECT_STREAM) {
this.push('[');
this.pushStack({
handler: push,
value: this.space ? '\n' + this.space.repeat(this._depth) + ']' : ']'
});
this._depth++;
}
const self = this.pushStack({
handler: type === OBJECT_STREAM ? processReadableObject : processReadableString,
value,
index: 0,
first: false,
ended: false,
awaiting: !value.readable || value.readableLength === 0
});
const continueProcessing = () => {
if (self.awaiting) {
self.awaiting = false;
this.processStack();
}
};
value.once('error', error => this.destroy(error));
value.once('end', () => {
self.ended = true;
continueProcessing();
});
value.on('readable', continueProcessing);
break;
}
}
pushStack(node) {
node.prev = this._stack;
return this._stack = node;
}
popStack() {
const { handler, value } = this._stack;
if (handler === processObject || handler === processArray || handler === processReadableObject) {
this._visited.delete(value);
this._depth--;
}
this._stack = this._stack.prev;
}
processStack() {
if (this._processing || this._ended) {
return;
}
try {
this._processing = true;
while (this._stack !== null && !this._stack.awaiting) {
this._stack.handler.call(this);
if (!this._processing) {
return;
}
}
this._processing = false;
} catch (error) {
this.destroy(error);
return;
}
if (this._stack === null && !this._ended) {
this._finish();
this.push(null);
}
}
push(data) {
if (data !== null) {
this._buffer += data;
// check buffer overflow
if (this._buffer.length < this._readSize) {
return;
}
// flush buffer
data = this._buffer;
this._buffer = '';
this._processing = false;
}
super.push(data);
}
_read(size) {
// start processing
this._readSize = size || this.readableHighWaterMark;
this.processStack();
}
_finish() {
this._ended = true;
this._processing = false;
this._stack = null;
this._visited = null;
if (this._buffer && this._buffer.length) {
super.push(this._buffer); // flush buffer
}
this._buffer = '';
}
_destroy(error, cb) {
this.error = this.error || error;
this._finish();
cb(error);
}
}
module.exports = function createJsonStringifyStream(value, replacer, space) {
return new JsonStringifyStream(value, replacer, space);
};