2024-10-17 21:31:23 +03:00

259 lines
11 KiB
JavaScript

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.asyncStringify = exports.possiblyAsyncStringify = exports.stringify = exports.stringifyInternal = exports.hasAsyncToStringMethod = exports.asyncToStringMethod = exports.hasToStringMethod = exports.toStringMethod = void 0;
exports.toStringMethod = Symbol('fast-check/toStringMethod');
function hasToStringMethod(instance) {
return (instance !== null &&
(typeof instance === 'object' || typeof instance === 'function') &&
exports.toStringMethod in instance &&
typeof instance[exports.toStringMethod] === 'function');
}
exports.hasToStringMethod = hasToStringMethod;
exports.asyncToStringMethod = Symbol('fast-check/asyncToStringMethod');
function hasAsyncToStringMethod(instance) {
return (instance !== null &&
(typeof instance === 'object' || typeof instance === 'function') &&
exports.asyncToStringMethod in instance &&
typeof instance[exports.asyncToStringMethod] === 'function');
}
exports.hasAsyncToStringMethod = hasAsyncToStringMethod;
const findSymbolNameRegex = /^Symbol\((.*)\)$/;
function getSymbolDescription(s) {
if (s.description !== undefined)
return s.description;
const m = findSymbolNameRegex.exec(String(s));
return m && m[1].length ? m[1] : null;
}
function stringifyNumber(numValue) {
switch (numValue) {
case 0:
return 1 / numValue === Number.NEGATIVE_INFINITY ? '-0' : '0';
case Number.NEGATIVE_INFINITY:
return 'Number.NEGATIVE_INFINITY';
case Number.POSITIVE_INFINITY:
return 'Number.POSITIVE_INFINITY';
default:
return numValue === numValue ? String(numValue) : 'Number.NaN';
}
}
function isSparseArray(arr) {
let previousNumberedIndex = -1;
for (const index in arr) {
const numberedIndex = Number(index);
if (numberedIndex !== previousNumberedIndex + 1)
return true;
previousNumberedIndex = numberedIndex;
}
return previousNumberedIndex + 1 !== arr.length;
}
function stringifyInternal(value, previousValues, getAsyncContent) {
const currentValues = previousValues.concat([value]);
if (typeof value === 'object') {
if (previousValues.indexOf(value) !== -1) {
return '[cyclic]';
}
}
if (hasAsyncToStringMethod(value)) {
const content = getAsyncContent(value);
if (content.state === 'fulfilled') {
return content.value;
}
}
if (hasToStringMethod(value)) {
try {
return value[exports.toStringMethod]();
}
catch (err) {
}
}
switch (Object.prototype.toString.call(value)) {
case '[object Array]': {
const arr = value;
if (arr.length >= 50 && isSparseArray(arr)) {
const assignments = [];
for (const index in arr) {
if (!Number.isNaN(Number(index)))
assignments.push(`${index}:${stringifyInternal(arr[index], currentValues, getAsyncContent)}`);
}
return assignments.length !== 0
? `Object.assign(Array(${arr.length}),{${assignments.join(',')}})`
: `Array(${arr.length})`;
}
const stringifiedArray = arr.map((v) => stringifyInternal(v, currentValues, getAsyncContent)).join(',');
return arr.length === 0 || arr.length - 1 in arr ? `[${stringifiedArray}]` : `[${stringifiedArray},]`;
}
case '[object BigInt]':
return `${value}n`;
case '[object Boolean]':
return typeof value === 'boolean' ? JSON.stringify(value) : `new Boolean(${JSON.stringify(value)})`;
case '[object Date]': {
const d = value;
return Number.isNaN(d.getTime()) ? `new Date(NaN)` : `new Date(${JSON.stringify(d.toISOString())})`;
}
case '[object Map]':
return `new Map(${stringifyInternal(Array.from(value), currentValues, getAsyncContent)})`;
case '[object Null]':
return `null`;
case '[object Number]':
return typeof value === 'number' ? stringifyNumber(value) : `new Number(${stringifyNumber(Number(value))})`;
case '[object Object]': {
try {
const toStringAccessor = value.toString;
if (typeof toStringAccessor === 'function' && toStringAccessor !== Object.prototype.toString) {
return value.toString();
}
}
catch (err) {
return '[object Object]';
}
const mapper = (k) => `${k === '__proto__'
? '["__proto__"]'
: typeof k === 'symbol'
? `[${stringifyInternal(k, currentValues, getAsyncContent)}]`
: JSON.stringify(k)}:${stringifyInternal(value[k], currentValues, getAsyncContent)}`;
const stringifiedProperties = [
...Object.keys(value).map(mapper),
...Object.getOwnPropertySymbols(value)
.filter((s) => {
const descriptor = Object.getOwnPropertyDescriptor(value, s);
return descriptor && descriptor.enumerable;
})
.map(mapper),
];
const rawRepr = '{' + stringifiedProperties.join(',') + '}';
if (Object.getPrototypeOf(value) === null) {
return rawRepr === '{}' ? 'Object.create(null)' : `Object.assign(Object.create(null),${rawRepr})`;
}
return rawRepr;
}
case '[object Set]':
return `new Set(${stringifyInternal(Array.from(value), currentValues, getAsyncContent)})`;
case '[object String]':
return typeof value === 'string' ? JSON.stringify(value) : `new String(${JSON.stringify(value)})`;
case '[object Symbol]': {
const s = value;
if (Symbol.keyFor(s) !== undefined) {
return `Symbol.for(${JSON.stringify(Symbol.keyFor(s))})`;
}
const desc = getSymbolDescription(s);
if (desc === null) {
return 'Symbol()';
}
const knownSymbol = desc.startsWith('Symbol.') && Symbol[desc.substring(7)];
return s === knownSymbol ? desc : `Symbol(${JSON.stringify(desc)})`;
}
case '[object Promise]': {
const promiseContent = getAsyncContent(value);
switch (promiseContent.state) {
case 'fulfilled':
return `Promise.resolve(${stringifyInternal(promiseContent.value, currentValues, getAsyncContent)})`;
case 'rejected':
return `Promise.reject(${stringifyInternal(promiseContent.value, currentValues, getAsyncContent)})`;
case 'pending':
return `new Promise(() => {/*pending*/})`;
case 'unknown':
default:
return `new Promise(() => {/*unknown*/})`;
}
}
case '[object Error]':
if (value instanceof Error) {
return `new Error(${stringifyInternal(value.message, currentValues, getAsyncContent)})`;
}
break;
case '[object Undefined]':
return `undefined`;
case '[object Int8Array]':
case '[object Uint8Array]':
case '[object Uint8ClampedArray]':
case '[object Int16Array]':
case '[object Uint16Array]':
case '[object Int32Array]':
case '[object Uint32Array]':
case '[object Float32Array]':
case '[object Float64Array]':
case '[object BigInt64Array]':
case '[object BigUint64Array]': {
if (typeof Buffer !== 'undefined' && typeof Buffer.isBuffer === 'function' && Buffer.isBuffer(value)) {
return `Buffer.from(${stringifyInternal(Array.from(value.values()), currentValues, getAsyncContent)})`;
}
const valuePrototype = Object.getPrototypeOf(value);
const className = valuePrototype && valuePrototype.constructor && valuePrototype.constructor.name;
if (typeof className === 'string') {
const typedArray = value;
const valuesFromTypedArr = typedArray.values();
return `${className}.from(${stringifyInternal(Array.from(valuesFromTypedArr), currentValues, getAsyncContent)})`;
}
break;
}
}
try {
return value.toString();
}
catch (_a) {
return Object.prototype.toString.call(value);
}
}
exports.stringifyInternal = stringifyInternal;
function stringify(value) {
return stringifyInternal(value, [], () => ({ state: 'unknown', value: undefined }));
}
exports.stringify = stringify;
function possiblyAsyncStringify(value) {
const stillPendingMarker = Symbol();
const pendingPromisesForCache = [];
const cache = new Map();
function createDelay0() {
let handleId = null;
const cancel = () => {
if (handleId !== null) {
clearTimeout(handleId);
}
};
const delay = new Promise((resolve) => {
handleId = setTimeout(() => {
handleId = null;
resolve(stillPendingMarker);
}, 0);
});
return { delay, cancel };
}
const unknownState = { state: 'unknown', value: undefined };
const getAsyncContent = function getAsyncContent(data) {
const cacheKey = data;
if (cache.has(cacheKey)) {
return cache.get(cacheKey);
}
const delay0 = createDelay0();
const p = exports.asyncToStringMethod in data
? Promise.resolve().then(() => data[exports.asyncToStringMethod]())
: data;
p.catch(() => { });
pendingPromisesForCache.push(Promise.race([p, delay0.delay]).then((successValue) => {
if (successValue === stillPendingMarker)
cache.set(cacheKey, { state: 'pending', value: undefined });
else
cache.set(cacheKey, { state: 'fulfilled', value: successValue });
delay0.cancel();
}, (errorValue) => {
cache.set(cacheKey, { state: 'rejected', value: errorValue });
delay0.cancel();
}));
cache.set(cacheKey, unknownState);
return unknownState;
};
function loop() {
const stringifiedValue = stringifyInternal(value, [], getAsyncContent);
if (pendingPromisesForCache.length === 0) {
return stringifiedValue;
}
return Promise.all(pendingPromisesForCache.splice(0)).then(loop);
}
return loop();
}
exports.possiblyAsyncStringify = possiblyAsyncStringify;
async function asyncStringify(value) {
return Promise.resolve(possiblyAsyncStringify(value));
}
exports.asyncStringify = asyncStringify;