const { test } = Deno;import { assertEquals } from "../testing/asserts.ts";import { format } from "./format.ts";
function returnArguments(...args: any[]): IArguments { return arguments;}
function MyObject(value: unknown): void { this.name = value;}
class MyArray<T> extends Array<T> {}
const createVal = () => [ { id: "8658c1d0-9eda-4a90-95e1-8001e8eb6036", text: "Add alternative serialize API for pretty-format plugins", type: "ADD_TODO", }, { id: "8658c1d0-9eda-4a90-95e1-8001e8eb6036", type: "TOGGLE_TODO", },];
const createExpected = () => [ "Array [", " Object {", ' "id": "8658c1d0-9eda-4a90-95e1-8001e8eb6036",', ' "text": "Add alternative serialize API for pretty-format plugins",', ' "type": "ADD_TODO",', " },", " Object {", ' "id": "8658c1d0-9eda-4a90-95e1-8001e8eb6036",', ' "type": "TOGGLE_TODO",', " },", "]", ].join("\n");
test({ name: "prints empty arguments", fn(): void { const val = returnArguments(); assertEquals(format(val), "Arguments []"); },});
test({ name: "prints an empty array", fn(): void { const val: unknown[] = []; assertEquals(format(val), "Array []"); },});
test({ name: "prints an array with items", fn(): void { const val = [1, 2, 3]; assertEquals(format(val), "Array [\n 1,\n 2,\n 3,\n]"); },});
test({ name: "prints a empty typed array", fn(): void { const val = new Uint32Array(0); assertEquals(format(val), "Uint32Array []"); },});
test({ name: "prints a typed array with items", fn(): void { const val = new Uint32Array(3); assertEquals(format(val), "Uint32Array [\n 0,\n 0,\n 0,\n]"); },});
test({ name: "prints an array buffer", fn(): void { const val = new ArrayBuffer(3); assertEquals(format(val), "ArrayBuffer []"); },});
test({ name: "prints a nested array", fn(): void { const val = [[1, 2, 3]]; assertEquals( format(val), "Array [\n Array [\n 1,\n 2,\n 3,\n ],\n]" ); },});
test({ name: "prints true", fn(): void { const val = true; assertEquals(format(val), "true"); },});
test({ name: "prints false", fn(): void { const val = false; assertEquals(format(val), "false"); },});
test({ name: "prints an error", fn(): void { const val = new Error(); assertEquals(format(val), "[Error]"); },});
test({ name: "prints a typed error with a message", fn(): void { const val = new TypeError("message"); assertEquals(format(val), "[TypeError: message]"); },});
test({ name: "prints a function constructor", fn(): void { const val = new Function(); assertEquals(format(val), "[Function anonymous]"); },});
test({ name: "prints an anonymous callback function", fn(): void { let val; function f(cb: () => void): void { val = cb; } f((): void => {}); assertEquals(format(val), "[Function anonymous]"); },});
test({ name: "prints an anonymous assigned function", fn(): void { const val = (): void => {}; const formatted = format(val); assertEquals( formatted === "[Function anonymous]" || formatted === "[Function val]", true ); },});
test({ name: "prints a named function", fn(): void { const val = function named(): void {}; assertEquals(format(val), "[Function named]"); },});
test({ name: "prints a named generator function", fn(): void { const val = function* generate(): IterableIterator<number> { yield 1; yield 2; yield 3; }; assertEquals(format(val), "[Function generate]"); },});
test({ name: "can customize function names", fn(): void { const val = function named(): void {}; assertEquals( format(val, { printFunctionName: false, }), "[Function]" ); },});
test({ name: "prints Infinity", fn(): void { const val = Infinity; assertEquals(format(val), "Infinity"); },});
test({ name: "prints -Infinity", fn(): void { const val = -Infinity; assertEquals(format(val), "-Infinity"); },});
test({ name: "prints an empty map", fn(): void { const val = new Map(); assertEquals(format(val), "Map {}"); },});
test({ name: "prints a map with values", fn(): void { const val = new Map(); val.set("prop1", "value1"); val.set("prop2", "value2"); assertEquals( format(val), 'Map {\n "prop1" => "value1",\n "prop2" => "value2",\n}' ); },});
test({ name: "prints a map with non-string keys", fn(): void { const val = new Map<any, any>([ [false, "boolean"], ["false", "string"], [0, "number"], ["0", "string"], [null, "null"], ["null", "string"], [undefined, "undefined"], ["undefined", "string"], [Symbol("description"), "symbol"], ["Symbol(description)", "string"], [["array", "key"], "array"], [{ key: "value" }, "object"], ]); const expected = [ "Map {", ' false => "boolean",', ' "false" => "string",', ' 0 => "number",', ' "0" => "string",', ' null => "null",', ' "null" => "string",', ' undefined => "undefined",', ' "undefined" => "string",', ' Symbol(description) => "symbol",', ' "Symbol(description)" => "string",', " Array [", ' "array",', ' "key",', ' ] => "array",', " Object {", ' "key": "value",', ' } => "object",', "}", ].join("\n"); assertEquals(format(val), expected); },});
test({ name: "prints NaN", fn(): void { const val = NaN; assertEquals(format(val), "NaN"); },});
test({ name: "prints null", fn(): void { const val = null; assertEquals(format(val), "null"); },});
test({ name: "prints a positive number", fn(): void { const val = 123; assertEquals(format(val), "123"); },});
test({ name: "prints a negative number", fn(): void { const val = -123; assertEquals(format(val), "-123"); },});
test({ name: "prints zero", fn(): void { const val = 0; assertEquals(format(val), "0"); },});
test({ name: "prints negative zero", fn(): void { const val = -0; assertEquals(format(val), "-0"); },});
test({ name: "prints a date", fn(): void { const val = new Date(10e11); assertEquals(format(val), "2001-09-09T01:46:40.000Z"); },});
test({ name: "prints an invalid date", fn(): void { const val = new Date(Infinity); assertEquals(format(val), "Date { NaN }"); },});
test({ name: "prints an empty object", fn(): void { const val = {}; assertEquals(format(val), "Object {}"); },});
test({ name: "prints an object with properties", fn(): void { const val = { prop1: "value1", prop2: "value2" }; assertEquals( format(val), 'Object {\n "prop1": "value1",\n "prop2": "value2",\n}' ); },});
test({ name: "prints an object with properties and symbols", fn(): void { const val: any = {}; val[Symbol("symbol1")] = "value2"; val[Symbol("symbol2")] = "value3"; val.prop = "value1"; assertEquals( format(val), 'Object {\n "prop": "value1",\n Symbol(symbol1): "value2",\n ' + 'Symbol(symbol2): "value3",\n}' ); },});
test({ name: "prints an object without non-enumerable properties which have string key", fn(): void { const val = { enumerable: true, }; const key = "non-enumerable"; Object.defineProperty(val, key, { enumerable: false, value: false, }); assertEquals(format(val), 'Object {\n "enumerable": true,\n}'); },});
test({ name: "prints an object without non-enumerable properties which have symbol key", fn(): void { const val = { enumerable: true, }; const key = Symbol("non-enumerable"); Object.defineProperty(val, key, { enumerable: false, value: false, }); assertEquals(format(val), 'Object {\n "enumerable": true,\n}'); },});
test({ name: "prints an object with sorted properties", fn(): void { const val = { b: 1, a: 2 }; assertEquals(format(val), 'Object {\n "a": 2,\n "b": 1,\n}'); },});
test({ name: "prints regular expressions from constructors", fn(): void { const val = new RegExp("regexp"); assertEquals(format(val), "/regexp/"); },});
test({ name: "prints regular expressions from literals", fn(): void { const val = /regexp/gi; assertEquals(format(val), "/regexp/gi"); },});
test({ name: "prints regular expressions {escapeRegex: false}", fn(): void { const val = /regexp\d/gi; assertEquals(format(val), "/regexp\\d/gi"); },});
test({ name: "prints regular expressions {escapeRegex: true}", fn(): void { const val = /regexp\d/gi; assertEquals(format(val, { escapeRegex: true }), "/regexp\\\\d/gi"); },});
test({ name: "escapes regular expressions nested inside object", fn(): void { const obj = { test: /regexp\d/gi }; assertEquals( format(obj, { escapeRegex: true }), 'Object {\n "test": /regexp\\\\d/gi,\n}' ); },});
test({ name: "prints an empty set", fn(): void { const val = new Set(); assertEquals(format(val), "Set {}"); },});
test({ name: "prints a set with values", fn(): void { const val = new Set(); val.add("value1"); val.add("value2"); assertEquals(format(val), 'Set {\n "value1",\n "value2",\n}'); },});
test({ name: "prints a string", fn(): void { const val = "string"; assertEquals(format(val), '"string"'); },});
test({ name: "prints and escape a string", fn(): void { const val = "\"'\\"; assertEquals(format(val), '"\\"\'\\\\"'); },});
test({ name: "doesn't escape string with {excapeString: false}", fn(): void { const val = "\"'\\n"; assertEquals(format(val, { escapeString: false }), '""\'\\n"'); },});
test({ name: "prints a string with escapes", fn(): void { assertEquals(format('"-"'), '"\\"-\\""'); assertEquals(format("\\ \\\\"), '"\\\\ \\\\\\\\"'); },});
test({ name: "prints a multiline string", fn(): void { const val = ["line 1", "line 2", "line 3"].join("\n"); assertEquals(format(val), '"' + val + '"'); },});
test({ name: "prints a multiline string as value of object property", fn(): void { const polyline = { props: { id: "J", points: ["0.5,0.460", "0.5,0.875", "0.25,0.875"].join("\n"), }, type: "polyline", }; const val = { props: { children: polyline, }, type: "svg", }; assertEquals( format(val), [ "Object {", ' "props": Object {', ' "children": Object {', ' "props": Object {', ' "id": "J",', ' "points": "0.5,0.460', "0.5,0.875", '0.25,0.875",', " },", ' "type": "polyline",', " },", " },", ' "type": "svg",', "}", ].join("\n") ); },});
test({ name: "prints a symbol", fn(): void { const val = Symbol("symbol"); assertEquals(format(val), "Symbol(symbol)"); },});
test({ name: "prints undefined", fn(): void { const val = undefined; assertEquals(format(val), "undefined"); },});
test({ name: "prints a WeakMap", fn(): void { const val = new WeakMap(); assertEquals(format(val), "WeakMap {}"); },});
test({ name: "prints a WeakSet", fn(): void { const val = new WeakSet(); assertEquals(format(val), "WeakSet {}"); },});
test({ name: "prints deeply nested objects", fn(): void { const val = { prop: { prop: { prop: "value" } } }; assertEquals( format(val), 'Object {\n "prop": Object {\n "prop": Object {\n "prop": ' + '"value",\n },\n },\n}' ); },});
test({ name: "prints circular references", fn(): void { const val: any = {}; val.prop = val; assertEquals(format(val), 'Object {\n "prop": [Circular],\n}'); },});
test({ name: "prints parallel references", fn(): void { const inner = {}; const val = { prop1: inner, prop2: inner }; assertEquals( format(val), 'Object {\n "prop1": Object {},\n "prop2": Object {},\n}' ); },});
test({ name: "default implicit: 2 spaces", fn(): void { assertEquals(format(createVal()), createExpected()); },});
test({ name: "default explicit: 2 spaces", fn(): void { assertEquals(format(createVal(), { indent: 2 }), createExpected()); },});
test({ name: "non-default: 0 spaces", fn(): void { const indent = 0; assertEquals( format(createVal(), { indent }), createExpected().replace(/ {2}/g, " ".repeat(indent)) ); },});
test({ name: "non-default: 4 spaces", fn(): void { const indent = 4; assertEquals( format(createVal(), { indent }), createExpected().replace(/ {2}/g, " ".repeat(indent)) ); },});
test({ name: "can customize the max depth", fn(): void { const v = [ { "arguments empty": returnArguments(), "arguments non-empty": returnArguments("arg"), "array literal empty": [], "array literal non-empty": ["item"], "extended array empty": new MyArray(), "map empty": new Map(), "map non-empty": new Map([["name", "value"]]), "object literal empty": {}, "object literal non-empty": { name: "value" }, "object with constructor": new MyObject("value"), "object without constructor": Object.create(null), "set empty": new Set(), "set non-empty": new Set(["value"]), }, ]; assertEquals( format(v, { maxDepth: 2 }), [ "Array [", " Object {", ' "arguments empty": [Arguments],', ' "arguments non-empty": [Arguments],', ' "array literal empty": [Array],', ' "array literal non-empty": [Array],', ' "extended array empty": [MyArray],', ' "map empty": [Map],', ' "map non-empty": [Map],', ' "object literal empty": [Object],', ' "object literal non-empty": [Object],', ' "object with constructor": [MyObject],', ' "object without constructor": [Object],', ' "set empty": [Set],', ' "set non-empty": [Set],', " },", "]", ].join("\n") ); },});
test({ name: "prints objects with no constructor", fn(): void { assertEquals(format(Object.create(null)), "Object {}"); },});
test({ name: "prints identity-obj-proxy with string constructor", fn(): void { const obj = Object.create(null); obj.constructor = "constructor"; const expected = [ "Object {", ' "constructor": "constructor",', "}", ].join("\n"); assertEquals(format(obj), expected); },});
test({ name: "calls toJSON and prints its return value", fn(): void { assertEquals( format({ toJSON: (): unknown => ({ value: false }), value: true, }), 'Object {\n "value": false,\n}' ); },});
test({ name: "calls toJSON and prints an internal representation.", fn(): void { assertEquals( format({ toJSON: (): string => "[Internal Object]", value: true, }), '"[Internal Object]"' ); },});
test({ name: "calls toJSON only on functions", fn(): void { assertEquals( format({ toJSON: false, value: true, }), 'Object {\n "toJSON": false,\n "value": true,\n}' ); },});
test({ name: "does not call toJSON recursively", fn(): void { assertEquals( format({ toJSON: (): unknown => ({ toJSON: (): unknown => ({ value: true }) }), value: false, }), 'Object {\n "toJSON": [Function toJSON],\n}' ); },});
test({ name: "calls toJSON on Sets", fn(): void { const set = new Set([1]); (set as any).toJSON = (): string => "map"; assertEquals(format(set), '"map"'); },});