feat: init
This commit is contained in:
602
node_modules/@poppinss/dumper/build/chunk-26HALFTP.js
generated
vendored
Normal file
602
node_modules/@poppinss/dumper/build/chunk-26HALFTP.js
generated
vendored
Normal file
@@ -0,0 +1,602 @@
|
||||
var __defProp = Object.defineProperty;
|
||||
var __export = (target, all) => {
|
||||
for (var name in all)
|
||||
__defProp(target, name, { get: all[name], enumerable: true });
|
||||
};
|
||||
|
||||
// src/helpers.ts
|
||||
var helpers_exports = {};
|
||||
__export(helpers_exports, {
|
||||
htmlEscape: () => htmlEscape,
|
||||
tokenizeArray: () => tokenizeArray,
|
||||
tokenizeObject: () => tokenizeObject,
|
||||
tokenizePrototype: () => tokenizePrototype,
|
||||
wordWrap: () => wordWrap
|
||||
});
|
||||
import is from "@sindresorhus/is";
|
||||
var ObjectPrototype = Object.prototype;
|
||||
var ArrayPrototype = Array.prototype;
|
||||
var ObjectPrototypeKeys = Reflect.ownKeys(ObjectPrototype);
|
||||
var ArrayPrototypeKeys = Reflect.ownKeys(ArrayPrototype);
|
||||
function tokenizeObject(value, parser, config) {
|
||||
parser.context.objectsSeen = parser.context.objectsSeen ?? /* @__PURE__ */ new Set();
|
||||
parser.context.depth = parser.context.depth ?? 0;
|
||||
if (parser.context.objectsSeen.has(value)) {
|
||||
parser.collect({ type: "object-circular-ref" });
|
||||
return;
|
||||
}
|
||||
if (parser.context.depth >= parser.config.depth) {
|
||||
parser.collect({ type: "object-max-depth-ref" });
|
||||
return;
|
||||
}
|
||||
const showHidden = config.showHidden;
|
||||
const name = config.constructorName ?? Object.getPrototypeOf(value)?.constructor.name ?? null;
|
||||
if (config.collapse.includes(name)) {
|
||||
parser.collect({
|
||||
type: "collapse",
|
||||
name,
|
||||
token: {
|
||||
type: "object-start",
|
||||
constructorName: name
|
||||
}
|
||||
});
|
||||
return;
|
||||
}
|
||||
const ownKeys = Reflect.ownKeys(value);
|
||||
const eagerGetters = config.eagerGetters ?? [];
|
||||
parser.context.depth++;
|
||||
parser.context.objectsSeen.add(value);
|
||||
let keys = [];
|
||||
if (config.membersToIgnore) {
|
||||
const keysSet = /* @__PURE__ */ new Set([...ownKeys]);
|
||||
config.membersToIgnore.forEach((m) => keysSet.delete(m));
|
||||
keys = Array.from(keysSet);
|
||||
} else {
|
||||
keys = ownKeys;
|
||||
}
|
||||
parser.collect({ type: "object-start", constructorName: name });
|
||||
for (let key of keys) {
|
||||
const descriptor = Object.getOwnPropertyDescriptor(value, key);
|
||||
if (!descriptor) {
|
||||
continue;
|
||||
}
|
||||
if (!descriptor.enumerable && !showHidden) {
|
||||
continue;
|
||||
}
|
||||
const isSymbol = typeof key === "symbol";
|
||||
const isWritable = !!descriptor.set || !!descriptor.writable;
|
||||
parser.collect({
|
||||
type: "object-key",
|
||||
isSymbol,
|
||||
isWritable,
|
||||
value: String(key)
|
||||
});
|
||||
if ("get" in descriptor && !eagerGetters.includes(key)) {
|
||||
parser.collect({ type: "object-value-getter" });
|
||||
continue;
|
||||
}
|
||||
parser.collect({ type: "object-value-start" });
|
||||
parser.parse(value[key]);
|
||||
parser.collect({ type: "object-value-end" });
|
||||
}
|
||||
if (config.inspectObjectPrototype === true) {
|
||||
tokenizePrototype(value, parser, {
|
||||
membersToIgnore: ObjectPrototypeKeys
|
||||
});
|
||||
} else if (config.inspectObjectPrototype === "unless-plain-object" && !is.plainObject(value)) {
|
||||
tokenizePrototype(value, parser, {
|
||||
membersToIgnore: ObjectPrototypeKeys,
|
||||
prototypeToIgnore: ObjectPrototype
|
||||
});
|
||||
}
|
||||
parser.collect({ type: "object-end" });
|
||||
parser.context.depth--;
|
||||
parser.context.objectsSeen.delete(value);
|
||||
}
|
||||
function tokenizePrototype(value, parser, config) {
|
||||
const prototypeChain = [];
|
||||
for (let proto = Object.getPrototypeOf(value); proto && (!config.prototypeToIgnore || proto !== config.prototypeToIgnore); proto = Object.getPrototypeOf(proto)) {
|
||||
let keys = Reflect.ownKeys(proto);
|
||||
if (config.membersToIgnore) {
|
||||
const keysSet = /* @__PURE__ */ new Set([...keys]);
|
||||
config.membersToIgnore.forEach((m) => keysSet.delete(m));
|
||||
keys = Array.from(keysSet);
|
||||
}
|
||||
prototypeChain.push({ proto, keys });
|
||||
}
|
||||
if (!prototypeChain.length) {
|
||||
return;
|
||||
}
|
||||
const eagerGetters = config.eagerGetters ?? [];
|
||||
parser.collect({ type: "prototype-start" });
|
||||
for (let proto of prototypeChain) {
|
||||
for (let key of proto.keys) {
|
||||
if (key === "constructor") {
|
||||
continue;
|
||||
}
|
||||
const descriptor = Object.getOwnPropertyDescriptor(proto.proto, key);
|
||||
if (!descriptor) {
|
||||
continue;
|
||||
}
|
||||
const isSymbol = typeof key === "symbol";
|
||||
const isWritable = !!descriptor.set || !!descriptor.writable;
|
||||
parser.collect({
|
||||
type: "object-key",
|
||||
isSymbol,
|
||||
isWritable,
|
||||
value: String(key)
|
||||
});
|
||||
if ("get" in descriptor && !eagerGetters.includes(key)) {
|
||||
parser.collect({ type: "object-value-getter" });
|
||||
continue;
|
||||
}
|
||||
parser.collect({ type: "object-value-start" });
|
||||
parser.parse(value[key]);
|
||||
parser.collect({ type: "object-value-end" });
|
||||
}
|
||||
}
|
||||
parser.collect({ type: "prototype-end" });
|
||||
}
|
||||
function tokenizeArray(values, parser, config) {
|
||||
parser.context.arraysSeen = parser.context.arraysSeen ?? /* @__PURE__ */ new Set();
|
||||
parser.context.depth = parser.context.depth ?? 0;
|
||||
if (parser.context.arraysSeen.has(values)) {
|
||||
parser.collect({ type: "array-circular-ref" });
|
||||
return;
|
||||
}
|
||||
if (parser.context.depth >= config.depth) {
|
||||
parser.collect({ type: "array-max-depth-ref" });
|
||||
return;
|
||||
}
|
||||
const limit = config.maxArrayLength;
|
||||
const size = values.length;
|
||||
const name = config.name || values.constructor.name;
|
||||
if (config.collapse.includes(name)) {
|
||||
parser.collect({
|
||||
type: "collapse",
|
||||
name,
|
||||
token: {
|
||||
type: "array-start",
|
||||
name,
|
||||
size
|
||||
}
|
||||
});
|
||||
return;
|
||||
}
|
||||
parser.context.depth++;
|
||||
parser.context.arraysSeen.add(values);
|
||||
parser.collect({ type: "array-start", name, size });
|
||||
for (let index = 0; index < size; index++) {
|
||||
if (index >= limit) {
|
||||
parser.collect({ type: "array-max-length-ref", limit, size });
|
||||
break;
|
||||
}
|
||||
const value = values[index];
|
||||
if (Object.hasOwn(values, index)) {
|
||||
parser.collect({ type: "array-value-start", index });
|
||||
parser.parse(value);
|
||||
parser.collect({ type: "array-value-end", index });
|
||||
} else {
|
||||
parser.collect({ type: "array-value-hole", index });
|
||||
}
|
||||
}
|
||||
if (config.inspectArrayPrototype) {
|
||||
tokenizePrototype(values, parser, {
|
||||
membersToIgnore: ArrayPrototypeKeys,
|
||||
prototypeToIgnore: ArrayPrototype
|
||||
});
|
||||
}
|
||||
parser.collect({ type: "array-end", size });
|
||||
parser.context.depth--;
|
||||
parser.context.arraysSeen.delete(values);
|
||||
}
|
||||
function htmlEscape(value) {
|
||||
return value.replace(/&/g, "&").replace(/\\"/g, "\"").replace(/</g, "<").replace(/>/g, ">");
|
||||
}
|
||||
function wordWrap(value, options) {
|
||||
const width = options.width;
|
||||
const indent = options.indent;
|
||||
const newLine = `${options.newLine}${indent}`;
|
||||
let regexString = ".{1," + width + "}";
|
||||
regexString += "([\\s\u200B]+|$)|[^\\s\u200B]+?([\\s\u200B]+|$)";
|
||||
const re = new RegExp(regexString, "g");
|
||||
const lines = value.match(re) || [];
|
||||
const result = lines.map(function(line) {
|
||||
if (line.slice(-1) === "\n") {
|
||||
line = line.slice(0, line.length - 1);
|
||||
}
|
||||
return options.escape ? options.escape(line) : htmlEscape(line);
|
||||
}).join(newLine);
|
||||
return result;
|
||||
}
|
||||
|
||||
// src/tokenizers/main.ts
|
||||
import { inspect } from "util";
|
||||
import is2 from "@sindresorhus/is";
|
||||
var tokenizers = {
|
||||
/**
|
||||
* Tokenizes an object and its properties.
|
||||
* - Enable "showHidden" option to parse non-enumerable
|
||||
* - Enable "inspectObjectPrototype" to parse prototype members
|
||||
*/
|
||||
Object: (value, parser) => {
|
||||
tokenizeObject(value, parser, parser.config);
|
||||
},
|
||||
/**
|
||||
* Tokenizes an array of values
|
||||
*/
|
||||
Array: (values, parser) => {
|
||||
tokenizeArray(values, parser, parser.config);
|
||||
},
|
||||
/**
|
||||
* Tokenizes keys and values inside a map
|
||||
*/
|
||||
Map: (values, parser) => {
|
||||
parser.context.mapsSeen = parser.context.mapsSeen ?? /* @__PURE__ */ new Set();
|
||||
parser.context.depth = parser.context.depth ?? 0;
|
||||
if (parser.context.mapsSeen.has(values)) {
|
||||
parser.collect({ type: "map-circular-ref" });
|
||||
return;
|
||||
}
|
||||
if (parser.context.depth >= parser.config.depth) {
|
||||
parser.collect({ type: "map-max-depth-ref" });
|
||||
return;
|
||||
}
|
||||
parser.context.depth++;
|
||||
parser.context.mapsSeen.add(values);
|
||||
let index = 0;
|
||||
const size = values.size;
|
||||
const limit = parser.config.maxArrayLength;
|
||||
parser.collect({ type: "map-start", size });
|
||||
for (let [key, value] of values) {
|
||||
if (index >= limit) {
|
||||
parser.collect({ type: "map-max-length-ref", limit, size });
|
||||
break;
|
||||
}
|
||||
parser.collect({ type: "map-row-start", index });
|
||||
parser.collect({ type: "map-key-start", index });
|
||||
parser.parse(key);
|
||||
parser.collect({ type: "map-key-end", index });
|
||||
parser.collect({ type: "map-value-start", index });
|
||||
parser.parse(value);
|
||||
parser.collect({ type: "map-value-end", index });
|
||||
parser.collect({ type: "map-row-end", index });
|
||||
index++;
|
||||
}
|
||||
parser.collect({ type: "map-end", size });
|
||||
parser.context.depth--;
|
||||
parser.context.mapsSeen.delete(values);
|
||||
},
|
||||
/**
|
||||
* Tokenizes values inside a set
|
||||
*/
|
||||
Set: (values, parser) => {
|
||||
parser.context.setsSeen = parser.context.setsSeen ?? /* @__PURE__ */ new Set();
|
||||
parser.context.depth = parser.context.depth ?? 0;
|
||||
if (parser.context.setsSeen.has(values)) {
|
||||
parser.collect({ type: "set-circular-ref" });
|
||||
return;
|
||||
}
|
||||
if (parser.context.depth >= parser.config.depth) {
|
||||
parser.collect({ type: "set-max-depth-ref" });
|
||||
return;
|
||||
}
|
||||
parser.context.depth++;
|
||||
parser.context.setsSeen.add(values);
|
||||
let index = 0;
|
||||
const size = values.size;
|
||||
const limit = parser.config.maxArrayLength;
|
||||
parser.collect({ type: "set-start", size });
|
||||
for (let value of values) {
|
||||
if (index >= limit) {
|
||||
parser.collect({ type: "set-max-length-ref", limit, size });
|
||||
break;
|
||||
}
|
||||
parser.collect({ type: "set-value-start", index });
|
||||
parser.parse(value);
|
||||
parser.collect({ type: "set-value-end", index });
|
||||
index++;
|
||||
}
|
||||
parser.collect({ type: "set-end", size });
|
||||
parser.context.depth--;
|
||||
parser.context.setsSeen.delete(values);
|
||||
},
|
||||
/**
|
||||
* Tokenizes a function. If the function is a class created
|
||||
* using the [class] keyword, we will process its static
|
||||
* members when "config.inspectClassConstructor"
|
||||
* is enabled
|
||||
*/
|
||||
Function: (value, parser) => {
|
||||
const ConstructorName = value.constructor.name;
|
||||
if (ConstructorName === "GeneratorFunction") {
|
||||
return tokenizers.GeneratorFunction(value, parser);
|
||||
}
|
||||
if (ConstructorName === "AsyncGeneratorFunction") {
|
||||
return tokenizers.AsyncGeneratorFunction(value, parser);
|
||||
}
|
||||
if (ConstructorName === "AsyncFunction") {
|
||||
return tokenizers.AsyncFunction(value, parser);
|
||||
}
|
||||
const isClass = is2.class(value);
|
||||
parser.collect({
|
||||
type: "function",
|
||||
isClass,
|
||||
isAsync: false,
|
||||
isGenerator: false,
|
||||
name: value.name || "anonymous"
|
||||
});
|
||||
if (parser.config.inspectStaticMembers && isClass) {
|
||||
parser.collect({ type: "static-members-start" });
|
||||
tokenizeObject(value, parser, {
|
||||
showHidden: true,
|
||||
depth: parser.config.depth,
|
||||
inspectObjectPrototype: false,
|
||||
collapse: parser.config.collapse,
|
||||
membersToIgnore: ["prototype", "name", "length"]
|
||||
});
|
||||
parser.collect({ type: "static-members-end" });
|
||||
}
|
||||
},
|
||||
/**
|
||||
* Tokenizes a string value and handles max length and
|
||||
* correct quotes via the "util.inspect" method.
|
||||
*/
|
||||
string: (value, parser) => {
|
||||
const formatted = inspect(value, {
|
||||
maxStringLength: parser.config.maxStringLength,
|
||||
customInspect: false
|
||||
});
|
||||
parser.collect({ type: "string", value: formatted });
|
||||
},
|
||||
/**
|
||||
* Tokenizes the URL instance as an object
|
||||
*/
|
||||
URL: (value, parser) => {
|
||||
tokenizeObject(
|
||||
{
|
||||
hash: value.hash,
|
||||
host: value.host,
|
||||
hostname: value.hostname,
|
||||
href: value.href,
|
||||
origin: value.origin,
|
||||
password: value.password,
|
||||
pathname: value.pathname,
|
||||
port: value.port,
|
||||
protocol: value.protocol,
|
||||
search: value.search,
|
||||
searchParams: value.searchParams,
|
||||
username: value.username
|
||||
},
|
||||
parser,
|
||||
{ constructorName: "URL", ...parser.config }
|
||||
);
|
||||
},
|
||||
/**
|
||||
* Tokenizes the URLSearchParams instance as an object
|
||||
*/
|
||||
URLSearchParams: (value, parser) => {
|
||||
tokenizeObject(Object.fromEntries(value), parser, {
|
||||
constructorName: "URLSearchParams",
|
||||
...parser.config
|
||||
});
|
||||
},
|
||||
Error: function(value, parser) {
|
||||
tokenizeObject(value, parser, {
|
||||
eagerGetters: ["message", "stack"],
|
||||
...parser.config,
|
||||
inspectObjectPrototype: parser.config.inspectObjectPrototype === true ? true : false,
|
||||
showHidden: true
|
||||
});
|
||||
},
|
||||
FormData: function(value, parser) {
|
||||
tokenizeObject(Object.fromEntries(value.entries()), parser, {
|
||||
constructorName: "FormData",
|
||||
...parser.config
|
||||
});
|
||||
},
|
||||
/**
|
||||
* Straight forward one's
|
||||
*/
|
||||
undefined: (_, parser) => {
|
||||
parser.collect({ type: "undefined" });
|
||||
},
|
||||
null: (_, parser) => {
|
||||
parser.collect({ type: "null" });
|
||||
},
|
||||
symbol: (value, parser) => {
|
||||
parser.collect({ type: "symbol", value: String(value) });
|
||||
},
|
||||
number: (value, parser) => {
|
||||
parser.collect({ type: "number", value });
|
||||
},
|
||||
boolean: (value, parser) => {
|
||||
parser.collect({ type: "boolean", value });
|
||||
},
|
||||
bigint: (value, parser) => {
|
||||
parser.collect({ type: "bigInt", value: `${value.toString()}n` });
|
||||
},
|
||||
Date: (value, parser) => {
|
||||
parser.collect({ type: "date", value: value.toISOString() });
|
||||
},
|
||||
RegExp: (value, parser) => {
|
||||
parser.collect({ type: "regexp", value: String(value) });
|
||||
},
|
||||
Buffer: (value, parser) => {
|
||||
parser.collect({
|
||||
type: "buffer",
|
||||
value: inspect(value)
|
||||
});
|
||||
},
|
||||
WeakSet: (_, parser) => {
|
||||
parser.collect({ type: "weak-set" });
|
||||
},
|
||||
WeakMap: (_, parser) => {
|
||||
parser.collect({ type: "weak-map" });
|
||||
},
|
||||
WeakRef: function(_, parser) {
|
||||
parser.collect({ type: "weak-ref" });
|
||||
},
|
||||
Generator: function(_, parser) {
|
||||
parser.collect({ type: "generator", isAsync: false });
|
||||
},
|
||||
AsyncGenerator: function(_, parser) {
|
||||
parser.collect({ type: "generator", isAsync: true });
|
||||
},
|
||||
GeneratorFunction: function(value, parser) {
|
||||
parser.collect({
|
||||
type: "function",
|
||||
isGenerator: true,
|
||||
isClass: false,
|
||||
isAsync: false,
|
||||
name: value.name || "anonymous"
|
||||
});
|
||||
},
|
||||
AsyncGeneratorFunction: function(value, parser) {
|
||||
parser.collect({
|
||||
type: "function",
|
||||
isGenerator: true,
|
||||
isClass: false,
|
||||
isAsync: true,
|
||||
name: value.name || "anonymous"
|
||||
});
|
||||
},
|
||||
AsyncFunction: function(value, parser) {
|
||||
parser.collect({
|
||||
type: "function",
|
||||
isGenerator: false,
|
||||
isClass: false,
|
||||
isAsync: true,
|
||||
name: value.name || "anonymous"
|
||||
});
|
||||
},
|
||||
Observable: function(_, parser) {
|
||||
parser.collect({ type: "observable" });
|
||||
},
|
||||
Blob: function(value, parser) {
|
||||
parser.collect({ type: "blob", size: value.size, contentType: value.type });
|
||||
},
|
||||
Promise: function(value, parser) {
|
||||
parser.collect({
|
||||
type: "promise",
|
||||
isFulfilled: !inspect(value).includes("pending")
|
||||
});
|
||||
},
|
||||
NaN: function(_, parser) {
|
||||
parser.collect({ type: "number", value: Number.NaN });
|
||||
},
|
||||
Int8Array: function(value, parser) {
|
||||
tokenizeArray(value, parser, parser.config);
|
||||
},
|
||||
Uint8Array: function(value, parser) {
|
||||
tokenizeArray(value, parser, parser.config);
|
||||
},
|
||||
Int16Array: function(value, parser) {
|
||||
tokenizeArray(value, parser, parser.config);
|
||||
},
|
||||
Uint16Array: function(value, parser) {
|
||||
tokenizeArray(value, parser, parser.config);
|
||||
},
|
||||
Int32Array: function(value, parser) {
|
||||
tokenizeArray(value, parser, parser.config);
|
||||
},
|
||||
Uint32Array: function(value, parser) {
|
||||
tokenizeArray(value, parser, parser.config);
|
||||
},
|
||||
Float32Array: function(value, parser) {
|
||||
tokenizeArray(value, parser, parser.config);
|
||||
},
|
||||
Float64Array: function(value, parser) {
|
||||
tokenizeArray(value, parser, parser.config);
|
||||
},
|
||||
BigInt64Array: function(value, parser) {
|
||||
tokenizeArray(value, parser, parser.config);
|
||||
},
|
||||
BigUint64Array: function(value, parser) {
|
||||
tokenizeArray(value, parser, parser.config);
|
||||
}
|
||||
};
|
||||
|
||||
// src/parser.ts
|
||||
import is3 from "@sindresorhus/is";
|
||||
var Parser = class {
|
||||
#tokens = [];
|
||||
/**
|
||||
* Config shared with tokenizers
|
||||
*/
|
||||
config;
|
||||
/**
|
||||
* Context maintained through out the parsing phase.
|
||||
* Each instance of Parser has its own context
|
||||
* that gets mutated internally.
|
||||
*/
|
||||
context;
|
||||
constructor(config, context) {
|
||||
this.context = context || {};
|
||||
this.config = Object.freeze({
|
||||
showHidden: false,
|
||||
depth: 5,
|
||||
inspectObjectPrototype: "unless-plain-object",
|
||||
inspectArrayPrototype: false,
|
||||
inspectStaticMembers: false,
|
||||
maxArrayLength: 100,
|
||||
maxStringLength: 1e3,
|
||||
collapse: [],
|
||||
...config
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Normalizes the type name of a property using additional
|
||||
* bit of checks. For example, the "is" module does not
|
||||
* use instanceOf checks and hence misses out on many
|
||||
* potentional improvements.
|
||||
*/
|
||||
#normalizeTypeName(name, value) {
|
||||
if (name === "Object" && value instanceof Error) {
|
||||
return "Error";
|
||||
}
|
||||
return name;
|
||||
}
|
||||
/**
|
||||
* Collect a token inside the list of tokens. The order
|
||||
* of tokens matter during printing therefore you must
|
||||
* collect tokens in the right order.
|
||||
*/
|
||||
collect(token) {
|
||||
this.#tokens.push(token);
|
||||
}
|
||||
/**
|
||||
* Parses a value using the tokenizers. Under the hood the
|
||||
* tokenizers will call "parser.collect" to collect
|
||||
* tokens inside an array.
|
||||
*
|
||||
* You can use "parser.flush" method to get the list of
|
||||
* tokens.
|
||||
*/
|
||||
parse(value) {
|
||||
const typeName = this.#normalizeTypeName(is3.detect(value), value);
|
||||
const tokenizer = tokenizers[typeName];
|
||||
if (tokenizer) {
|
||||
tokenizer(value, this);
|
||||
} else {
|
||||
this.collect({ type: "unknown", jsType: typeName, value });
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Returns collected tokens and resets the internal state.
|
||||
*/
|
||||
flush() {
|
||||
const tokens = this.#tokens;
|
||||
this.#tokens = [];
|
||||
this.context = {};
|
||||
return tokens;
|
||||
}
|
||||
};
|
||||
|
||||
export {
|
||||
htmlEscape,
|
||||
wordWrap,
|
||||
helpers_exports,
|
||||
tokenizers,
|
||||
Parser
|
||||
};
|
||||
57
node_modules/@poppinss/dumper/build/formatters/console/formatter.d.ts
generated
vendored
Normal file
57
node_modules/@poppinss/dumper/build/formatters/console/formatter.d.ts
generated
vendored
Normal file
@@ -0,0 +1,57 @@
|
||||
import type { Token } from '../../src/types.js';
|
||||
import type { ConsoleFormatterConfig, ConsolePrinterStyles } from './types.js';
|
||||
/**
|
||||
* ConsoleFormatter is used to format a collection of parser
|
||||
* tokens to CLI output.
|
||||
*
|
||||
* @example
|
||||
* ```ts
|
||||
* const parser = new Parser()
|
||||
* parser.parse(value)
|
||||
*
|
||||
* const tokens = parser.flush()
|
||||
*
|
||||
* const formatter = new ConsoleFormatter()
|
||||
* const output = formatter.format(tokens)
|
||||
* ```
|
||||
*/
|
||||
export declare class ConsoleFormatter {
|
||||
/**
|
||||
* Styles for output elements
|
||||
*/
|
||||
readonly styles: ConsolePrinterStyles;
|
||||
/**
|
||||
* Context maintained through out the printing
|
||||
* phase. Each instance has its own context
|
||||
* that gets mutated internally.
|
||||
*/
|
||||
context: Record<string, any>;
|
||||
/**
|
||||
* Value for the newline character
|
||||
*/
|
||||
readonly newLine = "\n";
|
||||
/**
|
||||
* Utility to manage indentation
|
||||
*/
|
||||
readonly indentation: {
|
||||
counter: number;
|
||||
/**
|
||||
* Increment the identation by 1 step
|
||||
*/
|
||||
increment(): void;
|
||||
/**
|
||||
* Decrement the identation by 1 step
|
||||
*/
|
||||
decrement(): void;
|
||||
/**
|
||||
* Get the identation spaces as per the current
|
||||
* identation level
|
||||
*/
|
||||
getSpaces(): string;
|
||||
};
|
||||
constructor(config?: ConsoleFormatterConfig, context?: Record<string, any>);
|
||||
/**
|
||||
* Format a collection of tokens to ANSI output
|
||||
*/
|
||||
format(tokens: Token[]): string;
|
||||
}
|
||||
29
node_modules/@poppinss/dumper/build/formatters/console/main.d.ts
generated
vendored
Normal file
29
node_modules/@poppinss/dumper/build/formatters/console/main.d.ts
generated
vendored
Normal file
@@ -0,0 +1,29 @@
|
||||
import { ConsoleFormatter } from './formatter.js';
|
||||
import type { ConsoleDumpConfig } from './types.js';
|
||||
export { ConsoleFormatter };
|
||||
export { themes } from './themes.js';
|
||||
export { ConsolePrinters } from './printers/main.js';
|
||||
/**
|
||||
* Generate pretty printed HTML output for the provided value. You can
|
||||
* specify the parser and the formatter options as the 2nd argument.
|
||||
*
|
||||
* @example
|
||||
* ```ts
|
||||
* const html = dump(someValue)
|
||||
*
|
||||
* // With Parser options
|
||||
* const html = dump(someValue, {
|
||||
* inspectObjectPrototype: true,
|
||||
* depth: 10,
|
||||
* showHidden: true,
|
||||
* })
|
||||
*
|
||||
* // With Formatter options
|
||||
* const html = dump(someValue, {
|
||||
* styles: {
|
||||
* number: 'color: yellow; font-weight: bold;'
|
||||
* }
|
||||
* })
|
||||
* ```
|
||||
*/
|
||||
export declare function dump(value: any, config?: ConsoleDumpConfig): string;
|
||||
441
node_modules/@poppinss/dumper/build/formatters/console/main.js
generated
vendored
Normal file
441
node_modules/@poppinss/dumper/build/formatters/console/main.js
generated
vendored
Normal file
@@ -0,0 +1,441 @@
|
||||
import {
|
||||
Parser,
|
||||
wordWrap
|
||||
} from "../../chunk-26HALFTP.js";
|
||||
|
||||
// formatters/console/themes.ts
|
||||
import useColors from "@poppinss/colors";
|
||||
import supportsColor from "supports-color";
|
||||
var colors = supportsColor.stdout ? useColors.ansi() : useColors.silent();
|
||||
var themes = {
|
||||
default: {
|
||||
braces: (value) => colors.yellow(value),
|
||||
brackets: (value) => colors.yellow(value),
|
||||
number: (value) => colors.yellow(value),
|
||||
bigInt: (value) => colors.yellow().bold(value),
|
||||
boolean: (value) => colors.yellow().italic(value),
|
||||
string: (value) => colors.green(value),
|
||||
null: (value) => colors.dim(value),
|
||||
undefined: (value) => colors.dim(value),
|
||||
prototypeLabel: (value) => colors.dim(value),
|
||||
symbol: (value) => colors.magenta(value),
|
||||
regex: (value) => colors.red(value),
|
||||
date: (value) => colors.magenta(value),
|
||||
buffer: (value) => colors.magenta(value),
|
||||
functionLabel: (value) => colors.cyan().italic(value),
|
||||
arrayLabel: (value) => colors.cyan(value),
|
||||
objectLabel: (value) => colors.cyan(value),
|
||||
mapLabel: (value) => colors.cyan(value),
|
||||
setLabel: (value) => colors.cyan(value),
|
||||
objectKey: (value) => colors.blue(value),
|
||||
objectKeyPrefix: (value) => colors.dim(value),
|
||||
classLabel: (value) => colors.cyan(value),
|
||||
weakSetLabel: (value) => colors.cyan(value),
|
||||
weakRefLabel: (value) => colors.cyan(value),
|
||||
collapseLabel: (value) => colors.dim(value),
|
||||
circularLabel: (value) => colors.cyan(value),
|
||||
getterLabel: (value) => colors.cyan(value),
|
||||
weakMapLabel: (value) => colors.cyan(value),
|
||||
observableLabel: (value) => colors.cyan(value),
|
||||
promiseLabel: (value) => colors.blue(value),
|
||||
generatorLabel: (value) => colors.cyan(value),
|
||||
blobLabel: (value) => colors.magenta(value),
|
||||
unknownLabel: (value) => colors.magenta(value)
|
||||
}
|
||||
};
|
||||
|
||||
// formatters/console/printers/main.ts
|
||||
function openingBrace(formatter) {
|
||||
return formatter.styles.braces("{");
|
||||
}
|
||||
function closingBrace(formatter) {
|
||||
return formatter.styles.braces("}");
|
||||
}
|
||||
function openingBrackets(formatter) {
|
||||
return formatter.styles.brackets("[");
|
||||
}
|
||||
function closingBrackets(formatter) {
|
||||
return formatter.styles.brackets("]");
|
||||
}
|
||||
var ConsolePrinters = {
|
||||
"collapse": (token, formatter) => {
|
||||
const styles = token.token.type === "object-start" ? formatter.styles.objectLabel : formatter.styles.arrayLabel;
|
||||
const collpaseStyles = formatter.styles.collapseLabel;
|
||||
return `${styles(token.name)} ` + (token.token.type === "object-start" ? openingBrace(formatter) : openingBrackets(formatter)) + ` ${collpaseStyles("collpased")} ` + (token.token.type === "object-start" ? closingBrace(formatter) : closingBrackets(formatter));
|
||||
},
|
||||
"object-start": (token, formatter) => {
|
||||
formatter.indentation.increment();
|
||||
const styles = formatter.styles.objectLabel;
|
||||
const label = formatter.context.isStaticMember && formatter.context.staticDepth === 0 || token.constructorName === "Object" ? "" : styles(`${token.constructorName || "Object [null]"}`) + " ";
|
||||
return label + openingBrace(formatter);
|
||||
},
|
||||
"object-end": (_, formatter) => {
|
||||
formatter.indentation.decrement();
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
return indent + closingBrace(formatter);
|
||||
},
|
||||
"object-key": (token, formatter) => {
|
||||
formatter.context.isStack = token.value === "stack";
|
||||
const styles = formatter.styles.objectKey;
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
let value = token.value;
|
||||
if (token.isSymbol) {
|
||||
value = `[${value}]`;
|
||||
}
|
||||
let prefix = "";
|
||||
if (formatter.context.isStaticMember) {
|
||||
formatter.context.staticDepth++;
|
||||
if (formatter.context.staticDepth === 1) {
|
||||
const prefixStyles = formatter.styles.objectKeyPrefix;
|
||||
prefix = `${prefixStyles("static")} `;
|
||||
}
|
||||
}
|
||||
return indent + prefix + styles(value) + ": ";
|
||||
},
|
||||
"object-circular-ref": (_, formatter) => {
|
||||
const styles = formatter.styles.circularLabel;
|
||||
return styles("[*Circular]");
|
||||
},
|
||||
"object-max-depth-ref": (_, formatter) => {
|
||||
const styles = formatter.styles.objectLabel;
|
||||
return styles("[Object]");
|
||||
},
|
||||
"object-value-getter": (_, formatter) => {
|
||||
const styles = formatter.styles.getterLabel;
|
||||
return styles("[Getter]");
|
||||
},
|
||||
"object-value-start": () => {
|
||||
return "";
|
||||
},
|
||||
"object-value-end": (_, formatter) => {
|
||||
if (formatter.context.isStaticMember) {
|
||||
formatter.context.staticDepth--;
|
||||
}
|
||||
return `,`;
|
||||
},
|
||||
"array-start": (token, formatter) => {
|
||||
formatter.indentation.increment();
|
||||
const styles = formatter.styles.arrayLabel;
|
||||
const label = token.name !== "Array" ? styles(`${token.name}`) + " " : "";
|
||||
return label + openingBrackets(formatter);
|
||||
},
|
||||
"array-end": (_, formatter) => {
|
||||
formatter.indentation.decrement();
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
return indent + closingBrackets(formatter);
|
||||
},
|
||||
"array-value-start": (_, formatter) => {
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
return indent;
|
||||
},
|
||||
"array-value-hole": (_, formatter) => {
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
const styles = formatter.styles.undefined;
|
||||
return indent + styles("<hole>") + ",";
|
||||
},
|
||||
"array-value-end": () => {
|
||||
return `,`;
|
||||
},
|
||||
"array-circular-ref": (_, formatter) => {
|
||||
const styles = formatter.styles.circularLabel;
|
||||
return styles("[*Circular]");
|
||||
},
|
||||
"array-max-depth-ref": (_, formatter) => {
|
||||
const styles = formatter.styles.arrayLabel;
|
||||
return styles("[Array]");
|
||||
},
|
||||
"array-max-length-ref": (token, formatter) => {
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
const styles = formatter.styles.arrayLabel;
|
||||
const itemsLeft = token.size - token.limit;
|
||||
if (itemsLeft <= 0) {
|
||||
return "";
|
||||
}
|
||||
const label = itemsLeft === 1 ? `1 more item` : `${itemsLeft} more items`;
|
||||
return indent + styles(`[...${label}]`);
|
||||
},
|
||||
"prototype-start": (_, formatter) => {
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
formatter.indentation.increment();
|
||||
const styles = formatter.styles.prototypeLabel;
|
||||
const label = "[[Prototype]] ";
|
||||
return indent + styles(label) + openingBrace(formatter);
|
||||
},
|
||||
"prototype-end": (_, formatter) => {
|
||||
formatter.indentation.decrement();
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
return indent + closingBrace(formatter);
|
||||
},
|
||||
"map-start": (token, formatter) => {
|
||||
formatter.indentation.increment();
|
||||
const styles = formatter.styles.mapLabel;
|
||||
const label = `Map(${token.size}) `;
|
||||
return styles(label) + openingBrace(formatter);
|
||||
},
|
||||
"map-end": (_, formatter) => {
|
||||
formatter.indentation.decrement();
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
return indent + closingBrace(formatter);
|
||||
},
|
||||
"map-row-start": (_, formatter) => {
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
formatter.indentation.increment();
|
||||
return indent + openingBrackets(formatter);
|
||||
},
|
||||
"map-row-end": (_, formatter) => {
|
||||
formatter.indentation.decrement();
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
return indent + closingBrackets(formatter) + `,`;
|
||||
},
|
||||
"map-key-start": (_, formatter) => {
|
||||
const styles = formatter.styles.objectKey;
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
return indent + styles("key") + ": ";
|
||||
},
|
||||
"map-key-end": function() {
|
||||
return ",";
|
||||
},
|
||||
"map-value-start": (_, formatter) => {
|
||||
const styles = formatter.styles.objectKey;
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
return indent + styles("value") + ": ";
|
||||
},
|
||||
"map-value-end": function() {
|
||||
return ",";
|
||||
},
|
||||
"map-circular-ref": (_, formatter) => {
|
||||
const styles = formatter.styles.circularLabel;
|
||||
return styles("[*Circular]");
|
||||
},
|
||||
"map-max-depth-ref": (_, formatter) => {
|
||||
const styles = formatter.styles.mapLabel;
|
||||
return styles("[Map]");
|
||||
},
|
||||
"map-max-length-ref": (token, formatter) => {
|
||||
const styles = formatter.styles.mapLabel;
|
||||
const itemsLeft = token.size - token.limit;
|
||||
if (itemsLeft <= 0) {
|
||||
return "";
|
||||
}
|
||||
const label = itemsLeft === 1 ? `1 more item` : `${itemsLeft} more items`;
|
||||
return styles(`[...${label}]`);
|
||||
},
|
||||
"set-start": (token, formatter) => {
|
||||
formatter.indentation.increment();
|
||||
const styles = formatter.styles.setLabel;
|
||||
const label = `Set(${token.size}) `;
|
||||
return styles(label) + openingBrackets(formatter);
|
||||
},
|
||||
"set-end": (_, formatter) => {
|
||||
formatter.indentation.decrement();
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
return indent + closingBrackets(formatter);
|
||||
},
|
||||
"set-value-start": (_, formatter) => {
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
return indent;
|
||||
},
|
||||
"set-value-end": () => {
|
||||
return `,`;
|
||||
},
|
||||
"set-circular-ref": (_, formatter) => {
|
||||
const styles = formatter.styles.circularLabel;
|
||||
return styles("[*Circular]");
|
||||
},
|
||||
"set-max-depth-ref": (_, formatter) => {
|
||||
const styles = formatter.styles.setLabel;
|
||||
return styles("[Set]");
|
||||
},
|
||||
"set-max-length-ref": (token, formatter) => {
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
const styles = formatter.styles.setLabel;
|
||||
const itemsLeft = token.size - token.limit;
|
||||
if (itemsLeft <= 0) {
|
||||
return "";
|
||||
}
|
||||
const label = itemsLeft === 1 ? `1 more item` : `${itemsLeft} more items`;
|
||||
return indent + styles(`[...${label}]`);
|
||||
},
|
||||
"string": (token, formatter) => {
|
||||
let value = token.value;
|
||||
const indent = formatter.indentation.getSpaces();
|
||||
if (formatter.context.isStack) {
|
||||
value = token.value.split("\n").map((row, index) => {
|
||||
let rowValue = row.trim();
|
||||
if (index > 0) {
|
||||
rowValue = `${indent}${rowValue}`;
|
||||
}
|
||||
return rowValue;
|
||||
}).join("\n");
|
||||
} else {
|
||||
value = wordWrap(token.value, {
|
||||
newLine: formatter.newLine,
|
||||
indent: formatter.indentation.getSpaces(),
|
||||
width: 70,
|
||||
escape: (line) => line
|
||||
});
|
||||
}
|
||||
const styles = formatter.styles.string;
|
||||
return styles(value);
|
||||
},
|
||||
"boolean": (token, formatter) => {
|
||||
const styles = formatter.styles.boolean;
|
||||
return styles(String(token.value));
|
||||
},
|
||||
"number": (token, formatter) => {
|
||||
const styles = formatter.styles.number;
|
||||
return styles(String(token.value));
|
||||
},
|
||||
"bigInt": (token, formatter) => {
|
||||
const styles = formatter.styles.bigInt;
|
||||
return styles(token.value);
|
||||
},
|
||||
"undefined": (_, formatter) => {
|
||||
const styles = formatter.styles.undefined;
|
||||
return styles("undefined");
|
||||
},
|
||||
"null": (_, formatter) => {
|
||||
const styles = formatter.styles.null;
|
||||
return styles("null");
|
||||
},
|
||||
"symbol": (token, formatter) => {
|
||||
const styles = formatter.styles.symbol;
|
||||
return styles(token.value);
|
||||
},
|
||||
"function": (token, formatter) => {
|
||||
const styles = token.isClass ? formatter.styles.classLabel : formatter.styles.functionLabel;
|
||||
const async = token.isAsync ? `async ` : "";
|
||||
const generator = token.isGenerator ? `*` : "";
|
||||
const label = token.isClass ? `[class ${token.name}]` : `[${async}${generator}function ${token.name}]`;
|
||||
return styles(label);
|
||||
},
|
||||
"date": function(token, formatter) {
|
||||
const styles = formatter.styles.date;
|
||||
return styles(token.value);
|
||||
},
|
||||
"buffer": function(token, formatter) {
|
||||
const styles = formatter.styles.buffer;
|
||||
return styles(token.value);
|
||||
},
|
||||
"regexp": function(token, formatter) {
|
||||
const styles = formatter.styles.regex;
|
||||
return styles(token.value);
|
||||
},
|
||||
"unknown": function(token, formatter) {
|
||||
const styles = formatter.styles.unknownLabel;
|
||||
return styles(String(token.value));
|
||||
},
|
||||
"weak-set": function(_, formatter) {
|
||||
const styles = formatter.styles.weakSetLabel;
|
||||
return styles("[WeakSet]");
|
||||
},
|
||||
"weak-ref": function(_, formatter) {
|
||||
const styles = formatter.styles.weakRefLabel;
|
||||
return styles("[WeakRef]");
|
||||
},
|
||||
"weak-map": function(_, formatter) {
|
||||
const styles = formatter.styles.weakMapLabel;
|
||||
return styles("[WeakMap]");
|
||||
},
|
||||
"observable": function(_, formatter) {
|
||||
const styles = formatter.styles.observableLabel;
|
||||
return styles("[Observable]");
|
||||
},
|
||||
"blob": function(token, formatter) {
|
||||
const styles = formatter.styles.objectLabel;
|
||||
const sizeProp = formatter.styles.objectKey("size: ");
|
||||
const sizeValue = formatter.styles.number(`${token.size}`);
|
||||
const typeProp = token.contentType ? `, ${formatter.styles.objectKey("type: ")}` : "";
|
||||
const typeValue = token.contentType ? formatter.styles.string(`${token.contentType}`) : "";
|
||||
return styles("[Blob]") + " " + openingBrace(formatter) + `${sizeProp}${sizeValue}${typeProp}${typeValue}` + closingBrace(formatter);
|
||||
},
|
||||
"promise": function(token, formatter) {
|
||||
const styles = formatter.styles.promiseLabel;
|
||||
const label = token.isFulfilled ? "resolved" : "pending";
|
||||
return styles(`[Promise${`<${label}>`}]`);
|
||||
},
|
||||
"generator": function(token, formatter) {
|
||||
const styles = formatter.styles.generatorLabel;
|
||||
const label = token.isAsync ? "[AsyncGenerator] {}" : "[Generator] {}";
|
||||
return styles(label);
|
||||
},
|
||||
"static-members-start": function(_, formatter) {
|
||||
formatter.context.isStaticMember = true;
|
||||
formatter.context.staticDepth = 0;
|
||||
return " ";
|
||||
},
|
||||
"static-members-end": function(_, formatter) {
|
||||
formatter.context.isStaticMember = false;
|
||||
formatter.context.staticDepth = 0;
|
||||
return "";
|
||||
}
|
||||
};
|
||||
|
||||
// formatters/console/formatter.ts
|
||||
var ConsoleFormatter = class {
|
||||
/**
|
||||
* Styles for output elements
|
||||
*/
|
||||
styles;
|
||||
/**
|
||||
* Context maintained through out the printing
|
||||
* phase. Each instance has its own context
|
||||
* that gets mutated internally.
|
||||
*/
|
||||
context;
|
||||
/**
|
||||
* Value for the newline character
|
||||
*/
|
||||
newLine = "\n";
|
||||
/**
|
||||
* Utility to manage indentation
|
||||
*/
|
||||
indentation = {
|
||||
counter: 0,
|
||||
/**
|
||||
* Increment the identation by 1 step
|
||||
*/
|
||||
increment() {
|
||||
this.counter++;
|
||||
},
|
||||
/**
|
||||
* Decrement the identation by 1 step
|
||||
*/
|
||||
decrement() {
|
||||
this.counter--;
|
||||
},
|
||||
/**
|
||||
* Get the identation spaces as per the current
|
||||
* identation level
|
||||
*/
|
||||
getSpaces() {
|
||||
return new Array(this.counter * 2 + 1).join(" ");
|
||||
}
|
||||
};
|
||||
constructor(config, context) {
|
||||
this.context = context || {};
|
||||
this.styles = Object.freeze({ ...themes.default, ...config?.styles });
|
||||
}
|
||||
/**
|
||||
* Format a collection of tokens to ANSI output
|
||||
*/
|
||||
format(tokens) {
|
||||
return tokens.map((token) => {
|
||||
const formatter = ConsolePrinters[token.type];
|
||||
return formatter(token, this) || "";
|
||||
}).join("");
|
||||
}
|
||||
};
|
||||
|
||||
// formatters/console/main.ts
|
||||
function dump(value, config) {
|
||||
const parser = new Parser(config);
|
||||
parser.parse(value);
|
||||
return new ConsoleFormatter(config).format(parser.flush());
|
||||
}
|
||||
export {
|
||||
ConsoleFormatter,
|
||||
ConsolePrinters,
|
||||
dump,
|
||||
themes
|
||||
};
|
||||
5
node_modules/@poppinss/dumper/build/formatters/console/printers/main.d.ts
generated
vendored
Normal file
5
node_modules/@poppinss/dumper/build/formatters/console/printers/main.d.ts
generated
vendored
Normal file
@@ -0,0 +1,5 @@
|
||||
import type { TokenPrinters } from '../types.js';
|
||||
/**
|
||||
* Console printers to pretty print parser tokens
|
||||
*/
|
||||
export declare const ConsolePrinters: TokenPrinters;
|
||||
39
node_modules/@poppinss/dumper/build/formatters/console/themes.d.ts
generated
vendored
Normal file
39
node_modules/@poppinss/dumper/build/formatters/console/themes.d.ts
generated
vendored
Normal file
@@ -0,0 +1,39 @@
|
||||
/**
|
||||
* Default styles to use for pretty printing to ANSI output
|
||||
*/
|
||||
export declare const themes: {
|
||||
default: {
|
||||
braces: (value: string) => string;
|
||||
brackets: (value: string) => string;
|
||||
number: (value: string) => string;
|
||||
bigInt: (value: string) => string;
|
||||
boolean: (value: string) => string;
|
||||
string: (value: string) => string;
|
||||
null: (value: string) => string;
|
||||
undefined: (value: string) => string;
|
||||
prototypeLabel: (value: string) => string;
|
||||
symbol: (value: string) => string;
|
||||
regex: (value: string) => string;
|
||||
date: (value: string) => string;
|
||||
buffer: (value: string) => string;
|
||||
functionLabel: (value: string) => string;
|
||||
arrayLabel: (value: string) => string;
|
||||
objectLabel: (value: string) => string;
|
||||
mapLabel: (value: string) => string;
|
||||
setLabel: (value: string) => string;
|
||||
objectKey: (value: string) => string;
|
||||
objectKeyPrefix: (value: string) => string;
|
||||
classLabel: (value: string) => string;
|
||||
weakSetLabel: (value: string) => string;
|
||||
weakRefLabel: (value: string) => string;
|
||||
collapseLabel: (value: string) => string;
|
||||
circularLabel: (value: string) => string;
|
||||
getterLabel: (value: string) => string;
|
||||
weakMapLabel: (value: string) => string;
|
||||
observableLabel: (value: string) => string;
|
||||
promiseLabel: (value: string) => string;
|
||||
generatorLabel: (value: string) => string;
|
||||
blobLabel: (value: string) => string;
|
||||
unknownLabel: (value: string) => string;
|
||||
};
|
||||
};
|
||||
114
node_modules/@poppinss/dumper/build/formatters/console/types.d.ts
generated
vendored
Normal file
114
node_modules/@poppinss/dumper/build/formatters/console/types.d.ts
generated
vendored
Normal file
@@ -0,0 +1,114 @@
|
||||
import type { ParserConfig, TokensMap } from '../../src/types.js';
|
||||
import { type ConsoleFormatter } from './formatter.js';
|
||||
/**
|
||||
* Styles to use for pretty printing parser tokens. The token
|
||||
* printer receives a string value and must return back
|
||||
* a styled string value.
|
||||
*
|
||||
* @example
|
||||
* ```ts
|
||||
* {
|
||||
* braces: (value) => chalk.yellow(value)
|
||||
* }
|
||||
* ```
|
||||
*/
|
||||
export type ConsolePrinterStyles = {
|
||||
braces: (value: string) => string;
|
||||
brackets: (value: string) => string;
|
||||
string: (value: string) => string;
|
||||
number: (value: string) => string;
|
||||
boolean: (value: string) => string;
|
||||
bigInt: (value: string) => string;
|
||||
undefined: (value: string) => string;
|
||||
null: (value: string) => string;
|
||||
symbol: (value: string) => string;
|
||||
regex: (value: string) => string;
|
||||
date: (value: string) => string;
|
||||
buffer: (value: string) => string;
|
||||
/**
|
||||
* Styles for displaying the function value with
|
||||
* its name
|
||||
*/
|
||||
functionLabel: (value: string) => string;
|
||||
/**
|
||||
* Styles for displaying the class value with
|
||||
* its name
|
||||
*/
|
||||
classLabel: (value: string) => string;
|
||||
/**
|
||||
* Styles for the Object label. Use braces setting to define
|
||||
* the braces color
|
||||
*/
|
||||
objectLabel: (value: string) => string;
|
||||
/**
|
||||
* Styles for the Object key name
|
||||
*/
|
||||
objectKey: (value: string) => string;
|
||||
/**
|
||||
* Styles for the Object key prefix name.
|
||||
*/
|
||||
objectKeyPrefix: (value: string) => string;
|
||||
/**
|
||||
* Styles for the Array label. Use brackets setting to define
|
||||
* the brackets color
|
||||
*/
|
||||
arrayLabel: (value: string) => string;
|
||||
/**
|
||||
* Styles for the Map label. Use brackets setting to define
|
||||
* the brackets color
|
||||
*/
|
||||
mapLabel: (value: string) => string;
|
||||
/**
|
||||
* Styles for the Set label. Use brackets setting to define
|
||||
* the brackets color
|
||||
*/
|
||||
setLabel: (value: string) => string;
|
||||
collapseLabel: (value: string) => string;
|
||||
circularLabel: (value: string) => string;
|
||||
getterLabel: (value: string) => string;
|
||||
weakSetLabel: (value: string) => string;
|
||||
weakRefLabel: (value: string) => string;
|
||||
weakMapLabel: (value: string) => string;
|
||||
observableLabel: (value: string) => string;
|
||||
promiseLabel: (value: string) => string;
|
||||
generatorLabel: (value: string) => string;
|
||||
prototypeLabel: (value: string) => string;
|
||||
/**
|
||||
* Styles for displaying Blob keyword label. The blob
|
||||
* properties like the type and size are styled as
|
||||
* an object
|
||||
*/
|
||||
blobLabel: (value: string) => string;
|
||||
/**
|
||||
* Styles for displaying values not parsed by the
|
||||
* parser as first-class citizen but still printed
|
||||
* by casting them to String
|
||||
*/
|
||||
unknownLabel: (value: string) => string;
|
||||
};
|
||||
/**
|
||||
* Printers collection that are used to print parser
|
||||
* tokens to ANSI output (one at a time)
|
||||
*/
|
||||
export type TokenPrinters = {
|
||||
[K in keyof TokensMap]: (
|
||||
/**
|
||||
* Value of the token
|
||||
*/
|
||||
token: TokensMap[K],
|
||||
/**
|
||||
* Formatter reference
|
||||
*/
|
||||
formatter: ConsoleFormatter) => string;
|
||||
};
|
||||
/**
|
||||
* Config accepted by the Console Formatter
|
||||
*/
|
||||
export type ConsoleFormatterConfig = {
|
||||
styles?: Partial<ConsolePrinterStyles>;
|
||||
};
|
||||
/**
|
||||
* Configuration accepted by the "dump" method exported
|
||||
* by the cli sub-module.
|
||||
*/
|
||||
export type ConsoleDumpConfig = ParserConfig & ConsoleFormatterConfig;
|
||||
0
node_modules/@poppinss/dumper/build/formatters/console/types.js
generated
vendored
Normal file
0
node_modules/@poppinss/dumper/build/formatters/console/types.js
generated
vendored
Normal file
60
node_modules/@poppinss/dumper/build/formatters/html/formatter.d.ts
generated
vendored
Normal file
60
node_modules/@poppinss/dumper/build/formatters/html/formatter.d.ts
generated
vendored
Normal file
@@ -0,0 +1,60 @@
|
||||
import type { Token } from '../../src/types.js';
|
||||
import type { HTMLFormatterConfig, HTMLPrinterStyles } from './types.js';
|
||||
export declare let nanoid: (length?: number) => string;
|
||||
/**
|
||||
* HTMLFormatter is used to format a collection of parser
|
||||
* tokens into HTML output containing pre-tags.
|
||||
*
|
||||
* @example
|
||||
* ```ts
|
||||
* const parser = new Parser()
|
||||
* parser.parse(value)
|
||||
*
|
||||
* const tokens = parser.flush()
|
||||
*
|
||||
* const formatter = new HTMLFormatter()
|
||||
* const html = formatter.format(tokens)
|
||||
* ```
|
||||
*/
|
||||
export declare class HTMLFormatter {
|
||||
#private;
|
||||
/**
|
||||
* Styles for output elements
|
||||
*/
|
||||
readonly styles: HTMLPrinterStyles;
|
||||
/**
|
||||
* Context maintained through out the printing
|
||||
* phase. Each instance has its own context
|
||||
* that gets mutated internally.
|
||||
*/
|
||||
context: Record<string, any>;
|
||||
/**
|
||||
* Value for the newline character
|
||||
*/
|
||||
readonly newLine = "\n";
|
||||
/**
|
||||
* Utility to manage indentation
|
||||
*/
|
||||
readonly indentation: {
|
||||
counter: number;
|
||||
/**
|
||||
* Increment the identation by 1 step
|
||||
*/
|
||||
increment(): void;
|
||||
/**
|
||||
* Decrement the identation by 1 step
|
||||
*/
|
||||
decrement(): void;
|
||||
/**
|
||||
* Get the identation spaces as per the current
|
||||
* identation level
|
||||
*/
|
||||
getSpaces(): string;
|
||||
};
|
||||
constructor(config?: HTMLFormatterConfig, context?: Record<string, any>);
|
||||
/**
|
||||
* Format a collection of tokens to HTML output wrapped
|
||||
* inside the `pre` tag.
|
||||
*/
|
||||
format(tokens: Token[]): string;
|
||||
}
|
||||
10
node_modules/@poppinss/dumper/build/formatters/html/head.d.ts
generated
vendored
Normal file
10
node_modules/@poppinss/dumper/build/formatters/html/head.d.ts
generated
vendored
Normal file
@@ -0,0 +1,10 @@
|
||||
/**
|
||||
* Creates the stylesheet content to be injected inside the head
|
||||
* of the document
|
||||
*/
|
||||
export declare function createStyleSheet(): string;
|
||||
/**
|
||||
* Returns the script tag contents to be injected inside the head
|
||||
* of the document
|
||||
*/
|
||||
export declare function createScript(): string;
|
||||
29
node_modules/@poppinss/dumper/build/formatters/html/main.d.ts
generated
vendored
Normal file
29
node_modules/@poppinss/dumper/build/formatters/html/main.d.ts
generated
vendored
Normal file
@@ -0,0 +1,29 @@
|
||||
import type { HTMLDumpConfig } from './types.js';
|
||||
export * from './head.js';
|
||||
export { themes } from './themes.js';
|
||||
export { HTMLFormatter } from './formatter.js';
|
||||
export { HTMLPrinters } from './printers/main.js';
|
||||
/**
|
||||
* Generate pretty printed HTML output for the provided value. You can
|
||||
* specify the parser and the formatter options as the 2nd argument.
|
||||
*
|
||||
* @example
|
||||
* ```ts
|
||||
* const html = dump(someValue)
|
||||
*
|
||||
* // With Parser options
|
||||
* const html = dump(someValue, {
|
||||
* inspectObjectPrototype: true,
|
||||
* depth: 10,
|
||||
* showHidden: true,
|
||||
* })
|
||||
*
|
||||
* // With Formatter options
|
||||
* const html = dump(someValue, {
|
||||
* styles: {
|
||||
* number: 'color: yellow; font-weight: bold;'
|
||||
* }
|
||||
* })
|
||||
* ```
|
||||
*/
|
||||
export declare function dump(value: any, config?: HTMLDumpConfig): string;
|
||||
717
node_modules/@poppinss/dumper/build/formatters/html/main.js
generated
vendored
Normal file
717
node_modules/@poppinss/dumper/build/formatters/html/main.js
generated
vendored
Normal file
@@ -0,0 +1,717 @@
|
||||
import {
|
||||
Parser,
|
||||
htmlEscape,
|
||||
wordWrap
|
||||
} from "../../chunk-26HALFTP.js";
|
||||
|
||||
// formatters/html/themes.ts
|
||||
var themes = {
|
||||
nightOwl: {
|
||||
pre: "background-color: #061626; color: #c792ea;",
|
||||
toggle: "color: #4f5357; background: none; border: none;",
|
||||
braces: "color: #ffd700;",
|
||||
brackets: "color: #ffd700;",
|
||||
number: "color: #f78c6c;",
|
||||
bigInt: "color: #f78c6c; font-weight: bold;",
|
||||
boolean: "color: #ff5874; font-style: italic;",
|
||||
string: "color: #ecc48d;",
|
||||
null: "color: #637777;",
|
||||
undefined: "color: #637777;",
|
||||
prototypeLabel: "color: #637777;",
|
||||
symbol: "color: #82aaff;",
|
||||
regex: "color: #ff5874;",
|
||||
date: "color: #7fdbca;",
|
||||
buffer: "color: #7fdbca;",
|
||||
functionLabel: "color: #89b4fa;",
|
||||
arrayLabel: "color: #82aaff;",
|
||||
objectLabel: "color: #82aaff;",
|
||||
mapLabel: "color: #82aaff;",
|
||||
setLabel: "color: #82aaff;",
|
||||
objectKey: "color: #c792ea;",
|
||||
objectKeyPrefix: "color: #637777; font-style: italic; font-weight: bold",
|
||||
classLabel: "color: #82aaff;",
|
||||
collapseLabel: "color: #7fdbca; font-style: italic;",
|
||||
getterLabel: "color: #7fdbca;",
|
||||
circularLabel: "color: #7fdbca;",
|
||||
weakSetLabel: "color: #7fdbca;",
|
||||
weakRefLabel: "color: #7fdbca;",
|
||||
weakMapLabel: "color: #7fdbca;",
|
||||
observableLabel: "color: #7fdbca;",
|
||||
promiseLabel: "color: #7fdbca;",
|
||||
generatorLabel: "color: #7fdbca;",
|
||||
blobLabel: "color: #7fdbca;",
|
||||
unknownLabel: "color: #7fdbca;"
|
||||
},
|
||||
minLight: {
|
||||
pre: "background-color: #fff; color: #212121;",
|
||||
toggle: "color: #989999; background: none; border: none;",
|
||||
braces: "color: #0431fa;",
|
||||
brackets: "color: #0431fa;",
|
||||
number: "color: #1976d2;",
|
||||
bigInt: "color: #1976d2; font-weight: bold;",
|
||||
boolean: "color: #1976d2; font-style: italic;",
|
||||
string: "color: #22863a;",
|
||||
null: "color: #9c9c9d;",
|
||||
undefined: "color: #9c9c9d;",
|
||||
prototypeLabel: "color: #9c9c9d;",
|
||||
symbol: "color: #d32f2f;",
|
||||
regex: "color: #1976d2;",
|
||||
date: "color: #7b3814;",
|
||||
buffer: "color: #7b3814;",
|
||||
functionLabel: "color: #6f42c1;",
|
||||
arrayLabel: "color: #d32f2f;",
|
||||
objectLabel: "color: #d32f2f;",
|
||||
mapLabel: "color: #d32f2f;",
|
||||
setLabel: "color: #d32f2f;",
|
||||
objectKey: "color: #212121;",
|
||||
objectKeyPrefix: "color: #9c9c9d; font-style: italic; font-weight: bold",
|
||||
classLabel: "color: #6f42c1;",
|
||||
collapseLabel: "color: #9c9c9d; font-style: italic;",
|
||||
getterLabel: "color: #7b3814;",
|
||||
circularLabel: "color: #7b3814;",
|
||||
weakSetLabel: "color: #7b3814;",
|
||||
weakRefLabel: "color: #7b3814;",
|
||||
weakMapLabel: "color: #7b3814;",
|
||||
observableLabel: "color: #7b3814;",
|
||||
promiseLabel: "color: #7b3814;",
|
||||
generatorLabel: "color: #7b3814;",
|
||||
blobLabel: "color: #7b3814;",
|
||||
unknownLabel: "color: #7b3814;"
|
||||
},
|
||||
catppuccin: {
|
||||
pre: "background-color: #1e1e2e; color: #94e2d5;",
|
||||
toggle: "color: #7c7c8c; background: none; border: none;",
|
||||
braces: "color: #f38ba8;",
|
||||
brackets: "color: #f38ba8;",
|
||||
number: "color: #fab387;",
|
||||
bigInt: "color: #fab387; font-weight: bold;",
|
||||
boolean: "color: #cba6f7; font-style: italic;",
|
||||
string: "color: #a6e3a1;",
|
||||
null: "color: #6c7086;",
|
||||
undefined: "color: #6c7086;",
|
||||
prototypeLabel: "color: #6c7086;",
|
||||
symbol: "color: #f9e2af;",
|
||||
regex: "color: #cba6f7;",
|
||||
date: "color: #94e2d5;",
|
||||
buffer: "color: #94e2d5;",
|
||||
functionLabel: "color: #cba6f7;",
|
||||
arrayLabel: "color: #f9e2af;",
|
||||
objectLabel: "color: #f9e2af;",
|
||||
mapLabel: "color: #f9e2af;",
|
||||
setLabel: "color: #f9e2af;",
|
||||
objectKey: "color: #89b4fa;",
|
||||
objectKeyPrefix: "color: #6c7086; font-style: italic; font-weight: bold",
|
||||
classLabel: "color: #cba6f7;",
|
||||
collapseLabel: "color: #6c7086; font-style: italic;",
|
||||
getterLabel: "color: #94e2d5;",
|
||||
circularLabel: "color: #94e2d5;",
|
||||
weakSetLabel: "color: #94e2d5;",
|
||||
weakRefLabel: "color: #94e2d5;",
|
||||
weakMapLabel: "color: #94e2d5;",
|
||||
observableLabel: "color: #94e2d5;",
|
||||
promiseLabel: "color: #94e2d5;",
|
||||
generatorLabel: "color: #94e2d5;",
|
||||
blobLabel: "color: #94e2d5;",
|
||||
unknownLabel: "color: #94e2d5;"
|
||||
},
|
||||
/**
|
||||
* Following is the list of defined variables
|
||||
--pre-bg-color
|
||||
--pre-fg-color
|
||||
--toggle-fg-color
|
||||
--braces-fg-color
|
||||
--brackets-fg-color
|
||||
--dt-number-fg-color
|
||||
--dt-bigint-fg-color
|
||||
--dt-boolean-fg-color
|
||||
--dt-string-fg-color
|
||||
--dt-null-fg-color
|
||||
--dt-undefined-fg-color
|
||||
--prototype-label-fg-color
|
||||
--dt-symbol-fg-color
|
||||
--dt-regex-fg-color
|
||||
--dt-date-fg-color
|
||||
--dt-buffer-fg-color
|
||||
--function-label-fg-color
|
||||
--array-label-fg-color
|
||||
--object-label-fg-color
|
||||
--map-label-fg-color
|
||||
--set-label-fg-color
|
||||
--object-key-fg-color
|
||||
--object-key-prefix-fg-color
|
||||
--class-label-fg-color
|
||||
--collpase-label-fg-color
|
||||
--getter-label-fg-color
|
||||
--circular-label-fg-color
|
||||
--weakset-label-fg-color
|
||||
--weakref-label-fg-color
|
||||
--weakmap-label-fg-color
|
||||
--observable-label-fg-color
|
||||
--promise-label-fg-color
|
||||
--generator-label-fg-color
|
||||
--blob-label-fg-color
|
||||
--unknown-label-fg-color
|
||||
*/
|
||||
cssVariables: {
|
||||
pre: "background-color: var(--pre-bg-color); color: var(--pre-fg-color);",
|
||||
toggle: "color: var(--toggle-fg-color); background: none; border: none;",
|
||||
braces: "color: var(--braces-fg-color);",
|
||||
brackets: "color: var(--brackets-fg-color);",
|
||||
number: "color: var(--dt-number-fg-color);",
|
||||
bigInt: "color: var(--dt-bigint-fg-color); font-weight: bold;",
|
||||
boolean: "color: var(--dt-boolean-fg-color); font-style: italic;",
|
||||
string: "color: var(--dt-string-fg-color);",
|
||||
null: "color: var(--dt-null-fg-color);",
|
||||
undefined: "color: var(--dt-undefined-fg-color);",
|
||||
prototypeLabel: "color: var(--prototype-label-fg-color);",
|
||||
symbol: "color: var(--dt-symbol-fg-color);",
|
||||
regex: "color: var(--dt-regex-fg-color);",
|
||||
date: "color: var(--dt-date-fg-color);",
|
||||
buffer: "color: var(--dt-buffer-fg-color);",
|
||||
functionLabel: "color: var(--function-label-fg-color);",
|
||||
arrayLabel: "color: var(--array-label-fg-color);",
|
||||
objectLabel: "color: var(--object-label-fg-color);",
|
||||
mapLabel: "color: var(--map-label-fg-color);",
|
||||
setLabel: "color: var(--set-label-fg-color);",
|
||||
objectKey: "color: var(--object-key-fg-color);",
|
||||
objectKeyPrefix: "color: var(--object-key-prefix-fg-color); font-style: italic; font-weight: bold",
|
||||
classLabel: "color: var(--class-label-fg-color);",
|
||||
collapseLabel: "color: var(--collpase-label-fg-color); font-style: italic;",
|
||||
getterLabel: "color: var(--getter-label-fg-color);",
|
||||
circularLabel: "color: var(--circular-label-fg-color);",
|
||||
weakSetLabel: "color: var(--weakset-label-fg-color);",
|
||||
weakRefLabel: "color: var(--weakref-label-fg-color);",
|
||||
weakMapLabel: "color: var(--weakmap-label-fg-color);",
|
||||
observableLabel: "color: var(--observable-label-fg-color);",
|
||||
promiseLabel: "color: var(--promise-label-fg-color);",
|
||||
generatorLabel: "color: var(--generator-label-fg-color);",
|
||||
blobLabel: "color: var(--blob-label-fg-color);",
|
||||
unknownLabel: "color: var(--unknown-label-fg-color);"
|
||||
}
|
||||
};
|
||||
|
||||
// formatters/html/printers/main.ts
|
||||
var dropdownIcon = "▼";
|
||||
function openingBrace(formatter) {
|
||||
return `<span style="${formatter.styles.braces}">{</span>`;
|
||||
}
|
||||
function closingBrace(formatter) {
|
||||
return `<span style="${formatter.styles.braces}">}</span>`;
|
||||
}
|
||||
function openingBrackets(formatter) {
|
||||
return `<span style="${formatter.styles.brackets}">[</span>`;
|
||||
}
|
||||
function closingBrackets(formatter) {
|
||||
return `<span style="${formatter.styles.brackets}">]</span>`;
|
||||
}
|
||||
var HTMLPrinters = {
|
||||
"collapse": (token, formatter) => {
|
||||
const styles = token.token.type === "object-start" ? formatter.styles.objectLabel : formatter.styles.arrayLabel;
|
||||
const collpaseStyles = formatter.styles.collapseLabel;
|
||||
return `<span style="${styles}">${token.name}</span> ` + (token.token.type === "object-start" ? openingBrace(formatter) : openingBrackets(formatter)) + ` <span style="${collpaseStyles}">collapsed</span> ` + (token.token.type === "object-start" ? closingBrace(formatter) : closingBrackets(formatter));
|
||||
},
|
||||
"object-start": (token, formatter) => {
|
||||
formatter.indentation.increment();
|
||||
const styles = formatter.styles.objectLabel;
|
||||
const toggleStyles = formatter.styles.toggle;
|
||||
const label = formatter.context.isStaticMember && formatter.context.staticDepth === 0 ? " " : `${token.constructorName || "Object [null]"} `;
|
||||
return `<span class="dumper-group dumper-object-group"><span style="${styles}">${label}</span>` + openingBrace(formatter) + `<button class="dumper-toggle" style="${toggleStyles}"><span>${dropdownIcon}</span></button><samp hidden="true">`;
|
||||
},
|
||||
"object-end": (_, formatter) => {
|
||||
formatter.indentation.decrement();
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
return indent + "</samp>" + closingBrace(formatter) + "</span>";
|
||||
},
|
||||
"object-key": (token, formatter) => {
|
||||
formatter.context.isStack = token.value === "stack";
|
||||
const styles = formatter.styles.objectKey;
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
let value = token.value;
|
||||
if (token.isSymbol) {
|
||||
value = `[${value}]`;
|
||||
} else if (!/^[a-z$_][$\w]*$/i.test(value)) {
|
||||
value = `"${htmlEscape(value.replace(/"/g, '\\"'))}"`;
|
||||
}
|
||||
let prefix = "";
|
||||
if (formatter.context.isStaticMember) {
|
||||
formatter.context.staticDepth++;
|
||||
if (formatter.context.staticDepth === 1) {
|
||||
const prefixStyles = formatter.styles.objectKeyPrefix;
|
||||
prefix = `<span class="dumper-object-prefix" style="${prefixStyles}">static </span>`;
|
||||
}
|
||||
}
|
||||
return indent + prefix + `<span class="dumper-object-key" style="${styles}">${value}</span>: `;
|
||||
},
|
||||
"object-circular-ref": (_, formatter) => {
|
||||
const styles = formatter.styles.circularLabel;
|
||||
return `<span style="${styles}">[*Circular]</span>`;
|
||||
},
|
||||
"object-max-depth-ref": (_, formatter) => {
|
||||
const styles = formatter.styles.objectLabel;
|
||||
return `<span style="${styles}">[Object]</span>`;
|
||||
},
|
||||
"object-value-getter": (_, formatter) => {
|
||||
const styles = formatter.styles.getterLabel;
|
||||
return `<span style="${styles}">[Getter]</span>`;
|
||||
},
|
||||
"object-value-start": () => {
|
||||
return "";
|
||||
},
|
||||
"object-value-end": (_, formatter) => {
|
||||
if (formatter.context.isStaticMember) {
|
||||
formatter.context.staticDepth--;
|
||||
}
|
||||
return `,`;
|
||||
},
|
||||
"array-start": (token, formatter) => {
|
||||
formatter.indentation.increment();
|
||||
const toggleStyles = formatter.styles.toggle;
|
||||
const styles = formatter.styles.arrayLabel;
|
||||
const label = `${token.name}:${token.size} `;
|
||||
return `<span class="dumper-group dumper-array-group"><span style="${styles}">${label}</span>` + openingBrackets(formatter) + `<button class="dumper-toggle" style="${toggleStyles}"><span>${dropdownIcon}</span></button><samp hidden="true">`;
|
||||
},
|
||||
"array-end": (_, formatter) => {
|
||||
formatter.indentation.decrement();
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
return indent + "</samp>" + closingBrackets(formatter) + "</span>";
|
||||
},
|
||||
"array-value-start": (_, formatter) => {
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
return indent;
|
||||
},
|
||||
"array-value-hole": (_, formatter) => {
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
const styles = formatter.styles.undefined;
|
||||
return indent + `<span class="dumper-undefined" style="${styles}">${htmlEscape("<hole>")},</span>`;
|
||||
},
|
||||
"array-value-end": () => {
|
||||
return `,`;
|
||||
},
|
||||
"array-circular-ref": (_, formatter) => {
|
||||
const styles = formatter.styles.circularLabel;
|
||||
return `<span style="${styles}">[*Circular]</span>`;
|
||||
},
|
||||
"array-max-depth-ref": (_, formatter) => {
|
||||
const styles = formatter.styles.arrayLabel;
|
||||
return `<span style="${styles}">[Array]</span>`;
|
||||
},
|
||||
"array-max-length-ref": (token, formatter) => {
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
const styles = formatter.styles.arrayLabel;
|
||||
const itemsLeft = token.size - token.limit;
|
||||
if (itemsLeft <= 0) {
|
||||
return "";
|
||||
}
|
||||
const label = itemsLeft === 1 ? `1 more item` : `${itemsLeft} more items`;
|
||||
return `${indent}<span style="${styles}">[...${label}]</span>`;
|
||||
},
|
||||
"prototype-start": (_, formatter) => {
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
formatter.indentation.increment();
|
||||
const styles = formatter.styles.prototypeLabel;
|
||||
const toggleStyles = formatter.styles.toggle;
|
||||
const label = "[[Prototype]] ";
|
||||
return indent + `<span class="dumper-group dumper-prototype-group"><span style="${styles}">${label}</span>` + openingBrace(formatter) + `<button class="dumper-toggle" style="${toggleStyles}"><span>${dropdownIcon}</span></button><samp hidden="true">`;
|
||||
},
|
||||
"prototype-end": (_, formatter) => {
|
||||
formatter.indentation.decrement();
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
return indent + "</samp>" + closingBrace(formatter) + "</span>";
|
||||
},
|
||||
"map-start": (token, formatter) => {
|
||||
formatter.indentation.increment();
|
||||
const toggleStyles = formatter.styles.toggle;
|
||||
const styles = formatter.styles.mapLabel;
|
||||
const label = `Map:${token.size} `;
|
||||
return `<span class="dumper-group dumper-map-group"><span style="${styles}">${label}</span>` + openingBrace(formatter) + `<button class="dumper-toggle" style="${toggleStyles}"><span>${dropdownIcon}</span></button><samp hidden="true">`;
|
||||
},
|
||||
"map-end": (_, formatter) => {
|
||||
formatter.indentation.decrement();
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
return indent + "</samp>" + closingBrace(formatter) + "</span>";
|
||||
},
|
||||
"map-row-start": (_, formatter) => {
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
formatter.indentation.increment();
|
||||
return indent + openingBrackets(formatter);
|
||||
},
|
||||
"map-row-end": (_, formatter) => {
|
||||
formatter.indentation.decrement();
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
return indent + closingBrackets(formatter) + `,`;
|
||||
},
|
||||
"map-key-start": (_, formatter) => {
|
||||
const styles = formatter.styles.objectKey;
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
return indent + `<span style="${styles}">key</span>: `;
|
||||
},
|
||||
"map-key-end": function() {
|
||||
return "";
|
||||
},
|
||||
"map-value-start": (_, formatter) => {
|
||||
const styles = formatter.styles.objectKey;
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
return indent + `<span style="${styles}">value</span>: `;
|
||||
},
|
||||
"map-value-end": function() {
|
||||
return "";
|
||||
},
|
||||
"map-circular-ref": (_, formatter) => {
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
const styles = formatter.styles.circularLabel;
|
||||
return `${indent}<span style="${styles}">[*Circular]</span>`;
|
||||
},
|
||||
"map-max-depth-ref": (_, formatter) => {
|
||||
const styles = formatter.styles.mapLabel;
|
||||
return `<span style="${styles}">[Map]</span>`;
|
||||
},
|
||||
"map-max-length-ref": (token, formatter) => {
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
const styles = formatter.styles.mapLabel;
|
||||
const itemsLeft = token.size - token.limit;
|
||||
if (itemsLeft <= 0) {
|
||||
return "";
|
||||
}
|
||||
const label = itemsLeft === 1 ? `1 more item` : `${itemsLeft} more items`;
|
||||
return `${indent}<span style="${styles}">[...${label}]</span>`;
|
||||
},
|
||||
"set-start": (token, formatter) => {
|
||||
formatter.indentation.increment();
|
||||
const toggleStyles = formatter.styles.toggle;
|
||||
const styles = formatter.styles.setLabel;
|
||||
const label = `Set:${token.size} `;
|
||||
return `<span class="dumper-group dumper-set-group"><span class="dumper-set-label" style="${styles}">${label}</span>` + openingBrackets(formatter) + `<button class="dumper-toggle" style="${toggleStyles}"><span>${dropdownIcon}</span></button><samp hidden="true">`;
|
||||
},
|
||||
"set-end": (_, formatter) => {
|
||||
formatter.indentation.decrement();
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
return indent + "</samp>" + closingBrackets(formatter) + "</span>";
|
||||
},
|
||||
"set-value-start": (_, formatter) => {
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
return indent;
|
||||
},
|
||||
"set-value-end": () => {
|
||||
return `,`;
|
||||
},
|
||||
"set-circular-ref": (_, formatter) => {
|
||||
const styles = formatter.styles.circularLabel;
|
||||
return `<span style="${styles}">[*Circular]</span>`;
|
||||
},
|
||||
"set-max-depth-ref": (_, formatter) => {
|
||||
const styles = formatter.styles.setLabel;
|
||||
return `<span style="${styles}">[Set]</span>`;
|
||||
},
|
||||
"set-max-length-ref": (token, formatter) => {
|
||||
const indent = `${formatter.newLine}${formatter.indentation.getSpaces()}`;
|
||||
const styles = formatter.styles.setLabel;
|
||||
const itemsLeft = token.size - token.limit;
|
||||
if (itemsLeft <= 0) {
|
||||
return "";
|
||||
}
|
||||
const label = itemsLeft === 1 ? `1 more item` : `${itemsLeft} more items`;
|
||||
return `${indent}<span style="${styles}">[...${label}]</span>`;
|
||||
},
|
||||
"string": (token, formatter) => {
|
||||
let value = token.value;
|
||||
const indent = formatter.indentation.getSpaces();
|
||||
if (formatter.context.isStack) {
|
||||
value = token.value.split("\n").map((row, index) => {
|
||||
let rowValue = `<span>${htmlEscape(row.trim())}</span>`;
|
||||
if (index > 0) {
|
||||
rowValue = `${indent}${rowValue}`;
|
||||
}
|
||||
return rowValue;
|
||||
}).join("\n");
|
||||
} else {
|
||||
value = wordWrap(token.value, {
|
||||
newLine: formatter.newLine,
|
||||
indent: formatter.indentation.getSpaces(),
|
||||
width: 70
|
||||
});
|
||||
}
|
||||
const styles = formatter.styles.string;
|
||||
return `<span class="dumper-string" style="${styles}">${value}</span>`;
|
||||
},
|
||||
"boolean": (token, formatter) => {
|
||||
const styles = formatter.styles.boolean;
|
||||
return `<span class="dumper-boolean" style="${styles}">` + token.value + "</span>";
|
||||
},
|
||||
"number": (token, formatter) => {
|
||||
const styles = formatter.styles.number;
|
||||
return `<span class="dumper-number" style="${styles}">` + token.value + "</span>";
|
||||
},
|
||||
"bigInt": (token, formatter) => {
|
||||
const styles = formatter.styles.bigInt;
|
||||
return `<span class="dumper-big-int" style="${styles}">` + token.value + "</span>";
|
||||
},
|
||||
"undefined": (_, formatter) => {
|
||||
const styles = formatter.styles.undefined;
|
||||
return `<span class="dumper-undefined" style="${styles}">undefined</span>`;
|
||||
},
|
||||
"null": (_, formatter) => {
|
||||
const styles = formatter.styles.null;
|
||||
return `<span class="dumper-null" style="${styles}">null</span>`;
|
||||
},
|
||||
"symbol": (token, formatter) => {
|
||||
const styles = formatter.styles.symbol;
|
||||
return `<span class="dumper-symbol" style="${styles}">` + token.value + "</span>";
|
||||
},
|
||||
"function": (token, formatter) => {
|
||||
const className = token.isClass ? "dumper-class" : "dumper-function";
|
||||
const styles = token.isClass ? formatter.styles.classLabel : formatter.styles.functionLabel;
|
||||
const async = token.isAsync ? `async ` : "";
|
||||
const generator = token.isGenerator ? `*` : "";
|
||||
const label = token.isClass ? `[class ${token.name}]` : `[${async}${generator}function ${token.name}]`;
|
||||
return `<span class="${className}" style="${styles}">` + label + "</span>";
|
||||
},
|
||||
"date": function(token, formatter) {
|
||||
const styles = formatter.styles.date;
|
||||
return `<span class="dumper-date" style="${styles}">` + token.value + "</span>";
|
||||
},
|
||||
"buffer": function(token, formatter) {
|
||||
const styles = formatter.styles.buffer;
|
||||
return `<span class="dumper-buffer" style="${styles}">` + htmlEscape(token.value) + "</span>";
|
||||
},
|
||||
"regexp": function(token, formatter) {
|
||||
const styles = formatter.styles.regex;
|
||||
return `<span class="dumper-regex" style="${styles}">` + token.value + "</span>";
|
||||
},
|
||||
"unknown": function(token, formatter) {
|
||||
const styles = formatter.styles.unknownLabel;
|
||||
return `<span class="dumper-value-unknown" style="${styles}">` + String(token.value) + "</span>";
|
||||
},
|
||||
"weak-set": function(_, formatter) {
|
||||
const styles = formatter.styles.weakSetLabel;
|
||||
return `<span class="dumper-weak-set" style="${styles}">[WeakSet]</span>`;
|
||||
},
|
||||
"weak-ref": function(_, formatter) {
|
||||
const styles = formatter.styles.weakRefLabel;
|
||||
return `<span class="dumper-weak-ref" style="${styles}">[WeakRef]</span>`;
|
||||
},
|
||||
"weak-map": function(_, formatter) {
|
||||
const styles = formatter.styles.weakMapLabel;
|
||||
return `<span class="dumper-weak-map" style="${styles}">[WeakMap]</span>`;
|
||||
},
|
||||
"observable": function(_, formatter) {
|
||||
const styles = formatter.styles.observableLabel;
|
||||
return `<span class="dumper-observable" style="${styles}">[Observable]</span>`;
|
||||
},
|
||||
"blob": function(token, formatter) {
|
||||
const styles = formatter.styles.objectLabel;
|
||||
const propertiesStart = `<span styles="${formatter.styles.braces}">{ `;
|
||||
const propertiesEnd = `<span styles="${formatter.styles.braces}"> }</span></span>`;
|
||||
const sizeProp = `<span styles="${formatter.styles.objectKey}">size: </span>`;
|
||||
const sizeValue = `<span styles="${formatter.styles.number}">${token.size}</span>,`;
|
||||
const typeProp = `<span styles="${formatter.styles.objectKey}">type: </span>`;
|
||||
const typeValue = `<span styles="${formatter.styles.string}">${token.contentType}</span>`;
|
||||
return `<span class="dumper-blob" style="${styles}">[Blob]` + propertiesStart + `${sizeProp}${sizeValue} ${typeProp}${typeValue}` + propertiesEnd + "</span>";
|
||||
},
|
||||
"promise": function(token, formatter) {
|
||||
const styles = formatter.styles.promiseLabel;
|
||||
const label = token.isFulfilled ? "resolved" : "pending";
|
||||
return `<span class="dumper-promise" style="${styles}">[Promise${htmlEscape(`<${label}>`)}]</span>`;
|
||||
},
|
||||
"generator": function(token, formatter) {
|
||||
const styles = formatter.styles.generatorLabel;
|
||||
const label = token.isAsync ? "[AsyncGenerator] {}" : "[Generator] {}";
|
||||
return `<span class="dumper-generator" style="${styles}">` + label + "</span>";
|
||||
},
|
||||
"static-members-start": function(_, formatter) {
|
||||
formatter.context.isStaticMember = true;
|
||||
formatter.context.staticDepth = 0;
|
||||
return "";
|
||||
},
|
||||
"static-members-end": function(_, formatter) {
|
||||
formatter.context.isStaticMember = false;
|
||||
formatter.context.staticDepth = 0;
|
||||
return "";
|
||||
}
|
||||
};
|
||||
|
||||
// formatters/html/formatter.ts
|
||||
var seed = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
|
||||
var nanoid = (length = 15) => {
|
||||
let output = "";
|
||||
let random = new Uint8Array(length);
|
||||
if (globalThis.crypto) {
|
||||
crypto.getRandomValues(random);
|
||||
} else {
|
||||
for (let i = 0; i < length; i++) {
|
||||
random[i] = Math.floor(Math.random() * 256);
|
||||
}
|
||||
}
|
||||
for (let n = 0; n < length; n++) {
|
||||
output += seed[63 & random[n]];
|
||||
}
|
||||
return output;
|
||||
};
|
||||
var HTMLFormatter = class {
|
||||
#config;
|
||||
/**
|
||||
* Styles for output elements
|
||||
*/
|
||||
styles;
|
||||
/**
|
||||
* Context maintained through out the printing
|
||||
* phase. Each instance has its own context
|
||||
* that gets mutated internally.
|
||||
*/
|
||||
context;
|
||||
/**
|
||||
* Value for the newline character
|
||||
*/
|
||||
newLine = "\n";
|
||||
/**
|
||||
* Utility to manage indentation
|
||||
*/
|
||||
indentation = {
|
||||
counter: 0,
|
||||
/**
|
||||
* Increment the identation by 1 step
|
||||
*/
|
||||
increment() {
|
||||
this.counter++;
|
||||
},
|
||||
/**
|
||||
* Decrement the identation by 1 step
|
||||
*/
|
||||
decrement() {
|
||||
this.counter--;
|
||||
},
|
||||
/**
|
||||
* Get the identation spaces as per the current
|
||||
* identation level
|
||||
*/
|
||||
getSpaces() {
|
||||
return new Array(this.counter * 2 + 1).join(" ");
|
||||
}
|
||||
};
|
||||
constructor(config, context) {
|
||||
this.context = context || {};
|
||||
this.#config = config || {};
|
||||
this.styles = Object.freeze({ ...themes.nightOwl, ...config?.styles });
|
||||
}
|
||||
/**
|
||||
* Wraps the final output inside pre tags and add the script
|
||||
* to activate the frontend iteractions.
|
||||
*/
|
||||
#wrapOutput(code) {
|
||||
const id = `dump-${nanoid()}`;
|
||||
const expand = this.#config.expand === "all" ? `'all'` : this.#config.expand;
|
||||
const nonce = this.#config.cspNonce ? ` nonce="${this.#config.cspNonce}"` : "";
|
||||
return `<div id="${id}" class="dumper-dump"><pre style="${this.styles.pre}"><code>${code}</code></pre><script${nonce}>dumperActivate('${id}', ${expand})</script></div>`;
|
||||
}
|
||||
/**
|
||||
* Format a collection of tokens to HTML output wrapped
|
||||
* inside the `pre` tag.
|
||||
*/
|
||||
format(tokens) {
|
||||
return this.#wrapOutput(
|
||||
tokens.map((token) => {
|
||||
const formatter = HTMLPrinters[token.type];
|
||||
return formatter(token, this) || "";
|
||||
}).join("")
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
// formatters/html/head.ts
|
||||
function createStyleSheet() {
|
||||
return `.dumper-dump, .dumper-dump pre, .dumper-dump code, .dumper-dump samp {
|
||||
font-family: JetBrains Mono, monaspace argon, Menlo, Monaco, Consolas, monospace;
|
||||
}
|
||||
.dumper-dump pre {
|
||||
line-height: 24px;
|
||||
font-size: 15px;
|
||||
overflow-x: auto;
|
||||
position:relative;
|
||||
z-index:99999;
|
||||
padding: 10px 15px;
|
||||
margin: 0;
|
||||
}
|
||||
.dumper-dump pre samp {
|
||||
position: relative;
|
||||
}
|
||||
.dumper-dump pre samp[hidden="true"] {
|
||||
display: none;
|
||||
}
|
||||
.dumper-dump .dumper-prototype-group {
|
||||
opacity: 0.5;
|
||||
}
|
||||
|
||||
.dumper-dump .dumper-toggle {
|
||||
transform: rotate(270deg);
|
||||
}
|
||||
|
||||
.dumper-dump .dumper-toggle span {
|
||||
display: inline-block;
|
||||
position: relative;
|
||||
top: 1px;
|
||||
margin: 0 5px;
|
||||
font-size: 14px;
|
||||
}
|
||||
.dumper-dump .dumper-toggle[aria-expanded="true"] {
|
||||
transform: none;
|
||||
}`;
|
||||
}
|
||||
function createScript() {
|
||||
return `function expandGroup(group) {
|
||||
const trigger = group.querySelector('button')
|
||||
trigger.setAttribute('aria-expanded', 'true')
|
||||
|
||||
const samp = group.querySelector('samp')
|
||||
samp.removeAttribute('hidden')
|
||||
}
|
||||
|
||||
function collapseGroup(group) {
|
||||
const trigger = group.querySelector('button')
|
||||
trigger.removeAttribute('aria-expanded', 'true')
|
||||
|
||||
const samp = group.querySelector('samp')
|
||||
samp.setAttribute('hidden', 'true')
|
||||
}
|
||||
|
||||
function dumperActivate(dumpId, expand) {
|
||||
if (expand === true) {
|
||||
expandGroup(document.querySelector(\`#\${dumpId} .dumper-group\`))
|
||||
} else if (expand === 'all') {
|
||||
document.querySelectorAll(\`#\${dumpId} .dumper-group\`).forEach((c) => expandGroup(c))
|
||||
}
|
||||
|
||||
document.querySelectorAll(\`#\${dumpId} .dumper-toggle\`).forEach((trigger) => {
|
||||
trigger.addEventListener('click', function (event) {
|
||||
const target = event.currentTarget
|
||||
const parent = target.parentElement
|
||||
const isExpanded = !!target.getAttribute('aria-expanded')
|
||||
|
||||
if (isExpanded) {
|
||||
collapseGroup(parent)
|
||||
if (event.metaKey) {
|
||||
parent.querySelectorAll('.dumper-group').forEach((c) => collapseGroup(c))
|
||||
}
|
||||
} else {
|
||||
expandGroup(parent)
|
||||
if (event.metaKey) {
|
||||
parent.querySelectorAll('.dumper-group').forEach((c) => expandGroup(c))
|
||||
}
|
||||
}
|
||||
})
|
||||
})
|
||||
}`;
|
||||
}
|
||||
|
||||
// formatters/html/main.ts
|
||||
function dump(value, config) {
|
||||
const parser = new Parser(config);
|
||||
parser.parse(value);
|
||||
return new HTMLFormatter(config).format(parser.flush());
|
||||
}
|
||||
export {
|
||||
HTMLFormatter,
|
||||
HTMLPrinters,
|
||||
createScript,
|
||||
createStyleSheet,
|
||||
dump,
|
||||
themes
|
||||
};
|
||||
5
node_modules/@poppinss/dumper/build/formatters/html/printers/main.d.ts
generated
vendored
Normal file
5
node_modules/@poppinss/dumper/build/formatters/html/printers/main.d.ts
generated
vendored
Normal file
@@ -0,0 +1,5 @@
|
||||
import type { TokenPrinters } from '../types.js';
|
||||
/**
|
||||
* HTML printers to pretty print parser tokens
|
||||
*/
|
||||
export declare const HTMLPrinters: TokenPrinters;
|
||||
188
node_modules/@poppinss/dumper/build/formatters/html/themes.d.ts
generated
vendored
Normal file
188
node_modules/@poppinss/dumper/build/formatters/html/themes.d.ts
generated
vendored
Normal file
@@ -0,0 +1,188 @@
|
||||
/**
|
||||
* Default styles to use for pretty printing
|
||||
* the HTML output.
|
||||
*/
|
||||
export declare const themes: {
|
||||
nightOwl: {
|
||||
pre: string;
|
||||
toggle: string;
|
||||
braces: string;
|
||||
brackets: string;
|
||||
number: string;
|
||||
bigInt: string;
|
||||
boolean: string;
|
||||
string: string;
|
||||
null: string;
|
||||
undefined: string;
|
||||
prototypeLabel: string;
|
||||
symbol: string;
|
||||
regex: string;
|
||||
date: string;
|
||||
buffer: string;
|
||||
functionLabel: string;
|
||||
arrayLabel: string;
|
||||
objectLabel: string;
|
||||
mapLabel: string;
|
||||
setLabel: string;
|
||||
objectKey: string;
|
||||
objectKeyPrefix: string;
|
||||
classLabel: string;
|
||||
collapseLabel: string;
|
||||
getterLabel: string;
|
||||
circularLabel: string;
|
||||
weakSetLabel: string;
|
||||
weakRefLabel: string;
|
||||
weakMapLabel: string;
|
||||
observableLabel: string;
|
||||
promiseLabel: string;
|
||||
generatorLabel: string;
|
||||
blobLabel: string;
|
||||
unknownLabel: string;
|
||||
};
|
||||
minLight: {
|
||||
pre: string;
|
||||
toggle: string;
|
||||
braces: string;
|
||||
brackets: string;
|
||||
number: string;
|
||||
bigInt: string;
|
||||
boolean: string;
|
||||
string: string;
|
||||
null: string;
|
||||
undefined: string;
|
||||
prototypeLabel: string;
|
||||
symbol: string;
|
||||
regex: string;
|
||||
date: string;
|
||||
buffer: string;
|
||||
functionLabel: string;
|
||||
arrayLabel: string;
|
||||
objectLabel: string;
|
||||
mapLabel: string;
|
||||
setLabel: string;
|
||||
objectKey: string;
|
||||
objectKeyPrefix: string;
|
||||
classLabel: string;
|
||||
collapseLabel: string;
|
||||
getterLabel: string;
|
||||
circularLabel: string;
|
||||
weakSetLabel: string;
|
||||
weakRefLabel: string;
|
||||
weakMapLabel: string;
|
||||
observableLabel: string;
|
||||
promiseLabel: string;
|
||||
generatorLabel: string;
|
||||
blobLabel: string;
|
||||
unknownLabel: string;
|
||||
};
|
||||
catppuccin: {
|
||||
pre: string;
|
||||
toggle: string;
|
||||
braces: string;
|
||||
brackets: string;
|
||||
number: string;
|
||||
bigInt: string;
|
||||
boolean: string;
|
||||
string: string;
|
||||
null: string;
|
||||
undefined: string;
|
||||
prototypeLabel: string;
|
||||
symbol: string;
|
||||
regex: string;
|
||||
date: string;
|
||||
buffer: string;
|
||||
functionLabel: string;
|
||||
arrayLabel: string;
|
||||
objectLabel: string;
|
||||
mapLabel: string;
|
||||
setLabel: string;
|
||||
objectKey: string;
|
||||
objectKeyPrefix: string;
|
||||
classLabel: string;
|
||||
collapseLabel: string;
|
||||
getterLabel: string;
|
||||
circularLabel: string;
|
||||
weakSetLabel: string;
|
||||
weakRefLabel: string;
|
||||
weakMapLabel: string;
|
||||
observableLabel: string;
|
||||
promiseLabel: string;
|
||||
generatorLabel: string;
|
||||
blobLabel: string;
|
||||
unknownLabel: string;
|
||||
};
|
||||
/**
|
||||
* Following is the list of defined variables
|
||||
--pre-bg-color
|
||||
--pre-fg-color
|
||||
--toggle-fg-color
|
||||
--braces-fg-color
|
||||
--brackets-fg-color
|
||||
--dt-number-fg-color
|
||||
--dt-bigint-fg-color
|
||||
--dt-boolean-fg-color
|
||||
--dt-string-fg-color
|
||||
--dt-null-fg-color
|
||||
--dt-undefined-fg-color
|
||||
--prototype-label-fg-color
|
||||
--dt-symbol-fg-color
|
||||
--dt-regex-fg-color
|
||||
--dt-date-fg-color
|
||||
--dt-buffer-fg-color
|
||||
--function-label-fg-color
|
||||
--array-label-fg-color
|
||||
--object-label-fg-color
|
||||
--map-label-fg-color
|
||||
--set-label-fg-color
|
||||
--object-key-fg-color
|
||||
--object-key-prefix-fg-color
|
||||
--class-label-fg-color
|
||||
--collpase-label-fg-color
|
||||
--getter-label-fg-color
|
||||
--circular-label-fg-color
|
||||
--weakset-label-fg-color
|
||||
--weakref-label-fg-color
|
||||
--weakmap-label-fg-color
|
||||
--observable-label-fg-color
|
||||
--promise-label-fg-color
|
||||
--generator-label-fg-color
|
||||
--blob-label-fg-color
|
||||
--unknown-label-fg-color
|
||||
*/
|
||||
cssVariables: {
|
||||
pre: string;
|
||||
toggle: string;
|
||||
braces: string;
|
||||
brackets: string;
|
||||
number: string;
|
||||
bigInt: string;
|
||||
boolean: string;
|
||||
string: string;
|
||||
null: string;
|
||||
undefined: string;
|
||||
prototypeLabel: string;
|
||||
symbol: string;
|
||||
regex: string;
|
||||
date: string;
|
||||
buffer: string;
|
||||
functionLabel: string;
|
||||
arrayLabel: string;
|
||||
objectLabel: string;
|
||||
mapLabel: string;
|
||||
setLabel: string;
|
||||
objectKey: string;
|
||||
objectKeyPrefix: string;
|
||||
classLabel: string;
|
||||
collapseLabel: string;
|
||||
getterLabel: string;
|
||||
circularLabel: string;
|
||||
weakSetLabel: string;
|
||||
weakRefLabel: string;
|
||||
weakMapLabel: string;
|
||||
observableLabel: string;
|
||||
promiseLabel: string;
|
||||
generatorLabel: string;
|
||||
blobLabel: string;
|
||||
unknownLabel: string;
|
||||
};
|
||||
};
|
||||
117
node_modules/@poppinss/dumper/build/formatters/html/types.d.ts
generated
vendored
Normal file
117
node_modules/@poppinss/dumper/build/formatters/html/types.d.ts
generated
vendored
Normal file
@@ -0,0 +1,117 @@
|
||||
import type { ParserConfig, TokensMap } from '../../src/types.js';
|
||||
import type { HTMLFormatter } from './main.js';
|
||||
/**
|
||||
* CSS styles to use for pretty printing parser tokens. The values
|
||||
* should be compatible with the HTML style attribute.
|
||||
*
|
||||
* @example
|
||||
* ```ts
|
||||
* {
|
||||
* pre: "background-color: black; color: white;"
|
||||
* }
|
||||
* ```
|
||||
*/
|
||||
export type HTMLPrinterStyles = {
|
||||
pre: string;
|
||||
braces: string;
|
||||
brackets: string;
|
||||
toggle: string;
|
||||
string: string;
|
||||
number: string;
|
||||
boolean: string;
|
||||
bigInt: string;
|
||||
undefined: string;
|
||||
null: string;
|
||||
symbol: string;
|
||||
regex: string;
|
||||
date: string;
|
||||
buffer: string;
|
||||
/**
|
||||
* Styles for displaying the function value with
|
||||
* its name
|
||||
*/
|
||||
functionLabel: string;
|
||||
/**
|
||||
* Styles for displaying the class value with
|
||||
* its name
|
||||
*/
|
||||
classLabel: string;
|
||||
/**
|
||||
* Styles for the Object label. Use braces setting to define
|
||||
* the braces color
|
||||
*/
|
||||
objectLabel: string;
|
||||
/**
|
||||
* Styles for the Object key name
|
||||
*/
|
||||
objectKey: string;
|
||||
/**
|
||||
* Styles for the Object key prefix name.
|
||||
*/
|
||||
objectKeyPrefix: string;
|
||||
/**
|
||||
* Styles for the Array label. Use brackets setting to define
|
||||
* the brackets color
|
||||
*/
|
||||
arrayLabel: string;
|
||||
/**
|
||||
* Styles for the Map label. Use brackets setting to define
|
||||
* the brackets color
|
||||
*/
|
||||
mapLabel: string;
|
||||
/**
|
||||
* Styles for the Set label. Use brackets setting to define
|
||||
* the brackets color
|
||||
*/
|
||||
setLabel: string;
|
||||
collapseLabel: string;
|
||||
circularLabel: string;
|
||||
getterLabel: string;
|
||||
weakSetLabel: string;
|
||||
weakRefLabel: string;
|
||||
weakMapLabel: string;
|
||||
observableLabel: string;
|
||||
promiseLabel: string;
|
||||
generatorLabel: string;
|
||||
prototypeLabel: string;
|
||||
/**
|
||||
* Styles for displaying Blob keyword label. The blob
|
||||
* properties like the type and size are styled as
|
||||
* an object
|
||||
*/
|
||||
blobLabel: string;
|
||||
/**
|
||||
* Styles for displaying values not parsed by the
|
||||
* parser as first-class citizen but still printed
|
||||
* by casting them to String
|
||||
*/
|
||||
unknownLabel: string;
|
||||
};
|
||||
/**
|
||||
* Printers collection that are used to print parser
|
||||
* tokens to HTML output (one at a time)
|
||||
*/
|
||||
export type TokenPrinters = {
|
||||
[K in keyof TokensMap]: (
|
||||
/**
|
||||
* Value of the token
|
||||
*/
|
||||
token: TokensMap[K],
|
||||
/**
|
||||
* Formatter reference
|
||||
*/
|
||||
formatter: HTMLFormatter) => string;
|
||||
};
|
||||
/**
|
||||
* Config accepted by the HTML Formatter
|
||||
*/
|
||||
export type HTMLFormatterConfig = {
|
||||
styles?: Partial<HTMLPrinterStyles>;
|
||||
cspNonce?: string;
|
||||
expand?: boolean | 'all';
|
||||
};
|
||||
/**
|
||||
* Configuration accepted by the "dump" method exported
|
||||
* by the html sub-module.
|
||||
*/
|
||||
export type HTMLDumpConfig = ParserConfig & HTMLFormatterConfig;
|
||||
0
node_modules/@poppinss/dumper/build/formatters/html/types.js
generated
vendored
Normal file
0
node_modules/@poppinss/dumper/build/formatters/html/types.js
generated
vendored
Normal file
3
node_modules/@poppinss/dumper/build/index.d.ts
generated
vendored
Normal file
3
node_modules/@poppinss/dumper/build/index.d.ts
generated
vendored
Normal file
@@ -0,0 +1,3 @@
|
||||
export * as helpers from './src/helpers.js';
|
||||
export { Parser } from './src/parser.js';
|
||||
export { tokenizers } from './src/tokenizers/main.js';
|
||||
10
node_modules/@poppinss/dumper/build/index.js
generated
vendored
Normal file
10
node_modules/@poppinss/dumper/build/index.js
generated
vendored
Normal file
@@ -0,0 +1,10 @@
|
||||
import {
|
||||
Parser,
|
||||
helpers_exports,
|
||||
tokenizers
|
||||
} from "./chunk-26HALFTP.js";
|
||||
export {
|
||||
Parser,
|
||||
helpers_exports as helpers,
|
||||
tokenizers
|
||||
};
|
||||
47
node_modules/@poppinss/dumper/build/src/helpers.d.ts
generated
vendored
Normal file
47
node_modules/@poppinss/dumper/build/src/helpers.d.ts
generated
vendored
Normal file
@@ -0,0 +1,47 @@
|
||||
import type { Parser } from './parser.js';
|
||||
/**
|
||||
* Helper to tokenize an object and its prototype
|
||||
*/
|
||||
export declare function tokenizeObject(value: Record<string | symbol, any>, parser: Parser, config: {
|
||||
depth: number;
|
||||
showHidden: boolean;
|
||||
collapse: string[];
|
||||
inspectObjectPrototype: boolean | 'unless-plain-object';
|
||||
constructorName?: string;
|
||||
membersToIgnore?: (string | symbol)[];
|
||||
eagerGetters?: (string | symbol)[];
|
||||
}): void;
|
||||
/**
|
||||
* Tokenizes the prototype of a value by calling Object.getPrototypeOf
|
||||
* method on the value.
|
||||
*/
|
||||
export declare function tokenizePrototype(value: any, parser: Parser, config: {
|
||||
prototypeToIgnore?: any;
|
||||
membersToIgnore?: (string | symbol)[];
|
||||
eagerGetters?: (string | symbol)[];
|
||||
}): void;
|
||||
/**
|
||||
* Helper to tokenize array like values.
|
||||
*/
|
||||
export declare function tokenizeArray(values: Array<any> | Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array, parser: Parser, config: {
|
||||
name?: string;
|
||||
depth: number;
|
||||
collapse: string[];
|
||||
inspectArrayPrototype: boolean;
|
||||
maxArrayLength: number;
|
||||
}): void;
|
||||
/**
|
||||
* HTML escape string values so that they can be nested
|
||||
* inside the pre-tags.
|
||||
*/
|
||||
export declare function htmlEscape(value: string): string;
|
||||
/**
|
||||
* Wraps a string value to be on multiple lines after
|
||||
* a certain characters limit has been hit.
|
||||
*/
|
||||
export declare function wordWrap(value: string, options: {
|
||||
width: number;
|
||||
indent: string;
|
||||
newLine: string;
|
||||
escape?: (value: string) => string;
|
||||
}): string;
|
||||
53
node_modules/@poppinss/dumper/build/src/parser.d.ts
generated
vendored
Normal file
53
node_modules/@poppinss/dumper/build/src/parser.d.ts
generated
vendored
Normal file
@@ -0,0 +1,53 @@
|
||||
import type { ParserConfig, Token } from './types.js';
|
||||
/**
|
||||
* Parser is used to parse a JavaScript value into a set
|
||||
* of tokens that can be used to pretty-print the same
|
||||
* value.
|
||||
*
|
||||
* @example
|
||||
* ```ts
|
||||
* import { Parser } from '@poppinss/dumper'
|
||||
*
|
||||
* const parser = new Parser()
|
||||
* const value = {
|
||||
* id: 1,
|
||||
* username: 'foo',
|
||||
* }
|
||||
*
|
||||
* parser.parse(value)
|
||||
* parser.flush() // Token[]
|
||||
* ```
|
||||
*/
|
||||
export declare class Parser {
|
||||
#private;
|
||||
/**
|
||||
* Config shared with tokenizers
|
||||
*/
|
||||
config: Readonly<Required<ParserConfig>>;
|
||||
/**
|
||||
* Context maintained through out the parsing phase.
|
||||
* Each instance of Parser has its own context
|
||||
* that gets mutated internally.
|
||||
*/
|
||||
context: Record<string, any>;
|
||||
constructor(config?: ParserConfig, context?: Record<string, any>);
|
||||
/**
|
||||
* Collect a token inside the list of tokens. The order
|
||||
* of tokens matter during printing therefore you must
|
||||
* collect tokens in the right order.
|
||||
*/
|
||||
collect(token: Token): void;
|
||||
/**
|
||||
* Parses a value using the tokenizers. Under the hood the
|
||||
* tokenizers will call "parser.collect" to collect
|
||||
* tokens inside an array.
|
||||
*
|
||||
* You can use "parser.flush" method to get the list of
|
||||
* tokens.
|
||||
*/
|
||||
parse(value: unknown): void;
|
||||
/**
|
||||
* Returns collected tokens and resets the internal state.
|
||||
*/
|
||||
flush(): Token[];
|
||||
}
|
||||
7
node_modules/@poppinss/dumper/build/src/tokenizers/main.d.ts
generated
vendored
Normal file
7
node_modules/@poppinss/dumper/build/src/tokenizers/main.d.ts
generated
vendored
Normal file
@@ -0,0 +1,7 @@
|
||||
import { type TypeName } from '@sindresorhus/is';
|
||||
import type { Tokenizer } from '../types.js';
|
||||
/**
|
||||
* Tokenizers are responsible for converting JS data types
|
||||
* to known dumper tokens.
|
||||
*/
|
||||
export declare const tokenizers: Partial<Record<TypeName, Tokenizer>>;
|
||||
270
node_modules/@poppinss/dumper/build/src/types.d.ts
generated
vendored
Normal file
270
node_modules/@poppinss/dumper/build/src/types.d.ts
generated
vendored
Normal file
@@ -0,0 +1,270 @@
|
||||
import type { TypeName } from '@sindresorhus/is';
|
||||
import type { Parser } from './parser.js';
|
||||
/**
|
||||
* Simplifies the complex merged types
|
||||
*/
|
||||
export type Simplify<T> = {
|
||||
[KeyType in keyof T]: T[KeyType];
|
||||
} & {};
|
||||
/**
|
||||
* Representation of a tokenizer function. Tokenizers are
|
||||
* responsible for converting values to a list of tokens
|
||||
* and collect them using the "parser.collect" method.
|
||||
*/
|
||||
export type Tokenizer = (value: any, parser: Parser) => void;
|
||||
/**
|
||||
* Tokens Map represents the list of supported tokens. Tokens
|
||||
* without any properties acts as a boundary for enclosed
|
||||
* values.
|
||||
*/
|
||||
export type TokensMap = {
|
||||
/**
|
||||
* Object tokens
|
||||
*/
|
||||
'object-start': {
|
||||
constructorName: null | string;
|
||||
};
|
||||
'object-end': {};
|
||||
'object-key': {
|
||||
isWritable: boolean;
|
||||
isSymbol: boolean;
|
||||
value: string;
|
||||
};
|
||||
'object-value-start': {};
|
||||
'object-value-end': {};
|
||||
'object-value-getter': {};
|
||||
'object-circular-ref': {};
|
||||
'object-max-depth-ref': {};
|
||||
/**
|
||||
* Array tokens
|
||||
*/
|
||||
'array-start': {
|
||||
name: string;
|
||||
size: number;
|
||||
};
|
||||
'array-end': {
|
||||
size: number;
|
||||
};
|
||||
'array-value-start': {
|
||||
index: number;
|
||||
};
|
||||
'array-value-hole': {
|
||||
index: number;
|
||||
};
|
||||
'array-value-end': {
|
||||
index: number;
|
||||
};
|
||||
'array-circular-ref': {};
|
||||
'array-max-depth-ref': {};
|
||||
'array-max-length-ref': {
|
||||
limit: number;
|
||||
size: number;
|
||||
};
|
||||
/**
|
||||
* Boundary for the prototype properties
|
||||
*/
|
||||
'prototype-start': {};
|
||||
'prototype-end': {};
|
||||
/**
|
||||
* Set tokens
|
||||
*/
|
||||
'set-start': {
|
||||
size: number;
|
||||
};
|
||||
'set-end': {
|
||||
size: number;
|
||||
};
|
||||
'set-value-start': {
|
||||
index: number;
|
||||
};
|
||||
'set-value-end': {
|
||||
index: number;
|
||||
};
|
||||
'set-circular-ref': {};
|
||||
'set-max-depth-ref': {};
|
||||
'set-max-length-ref': {
|
||||
limit: number;
|
||||
size: number;
|
||||
};
|
||||
/**
|
||||
* Map tokens
|
||||
*/
|
||||
'map-start': {
|
||||
size: number;
|
||||
};
|
||||
'map-end': {
|
||||
size: number;
|
||||
};
|
||||
'map-row-start': {
|
||||
index: number;
|
||||
};
|
||||
'map-row-end': {
|
||||
index: number;
|
||||
};
|
||||
'map-key-start': {
|
||||
index: number;
|
||||
};
|
||||
'map-key-end': {
|
||||
index: number;
|
||||
};
|
||||
'map-value-start': {
|
||||
index: number;
|
||||
};
|
||||
'map-value-end': {
|
||||
index: number;
|
||||
};
|
||||
'map-max-depth-ref': {};
|
||||
'map-circular-ref': {};
|
||||
'map-max-length-ref': {
|
||||
limit: number;
|
||||
size: number;
|
||||
};
|
||||
/**
|
||||
* Primitives
|
||||
*/
|
||||
'string': {
|
||||
value: string;
|
||||
};
|
||||
'number': {
|
||||
value: number;
|
||||
};
|
||||
'bigInt': {
|
||||
value: string;
|
||||
};
|
||||
'boolean': {
|
||||
value: boolean;
|
||||
};
|
||||
'undefined': {};
|
||||
'null': {};
|
||||
'symbol': {
|
||||
value: string;
|
||||
};
|
||||
/**
|
||||
* Others
|
||||
*/
|
||||
'function': {
|
||||
name: string;
|
||||
isGenerator: boolean;
|
||||
isAsync: boolean;
|
||||
isClass: boolean;
|
||||
};
|
||||
/**
|
||||
* Boundary for the static members
|
||||
*/
|
||||
'static-members-start': {};
|
||||
'static-members-end': {};
|
||||
'date': {
|
||||
value: string;
|
||||
};
|
||||
'buffer': {
|
||||
value: string;
|
||||
};
|
||||
'regexp': {
|
||||
value: string;
|
||||
};
|
||||
'unknown': {
|
||||
jsType: TypeName;
|
||||
value: any;
|
||||
};
|
||||
'weak-set': {};
|
||||
'weak-ref': {};
|
||||
'weak-map': {};
|
||||
'observable': {};
|
||||
'blob': {
|
||||
size: number;
|
||||
contentType: string;
|
||||
};
|
||||
'promise': {
|
||||
isFulfilled: boolean;
|
||||
};
|
||||
'generator': {
|
||||
isAsync: boolean;
|
||||
};
|
||||
/**
|
||||
* Collapse token represents a value that has been
|
||||
* collpased and its children are not further
|
||||
* processed.
|
||||
*
|
||||
* Only objects and arrays can be collapsed
|
||||
*/
|
||||
'collapse': {
|
||||
name: string;
|
||||
token: ({
|
||||
type: 'object-start';
|
||||
} & TokensMap['object-start']) | ({
|
||||
type: 'array-start';
|
||||
} & TokensMap['array-start']);
|
||||
};
|
||||
};
|
||||
/**
|
||||
* A union of known tokens. The tokenizer will always
|
||||
* output only these tokens
|
||||
*/
|
||||
export type Token = {
|
||||
[K in keyof TokensMap]: Simplify<{
|
||||
type: K;
|
||||
} & TokensMap[K]>;
|
||||
}[keyof TokensMap];
|
||||
/**
|
||||
* Configuration accepted by the parser
|
||||
*/
|
||||
export type ParserConfig = {
|
||||
/**
|
||||
* When set to true, the non-enumerable properties of an
|
||||
* object will be processed.
|
||||
*
|
||||
* Defaults to false
|
||||
*/
|
||||
showHidden?: boolean;
|
||||
/**
|
||||
* The depth at which to stop parsing nested values. The depth
|
||||
* is shared among all tree like data structures.
|
||||
*
|
||||
* Defaults to 5
|
||||
*/
|
||||
depth?: number;
|
||||
/**
|
||||
* Inspect prototype properties of an object. The non-enumerable properties
|
||||
* of prototype are included by default.
|
||||
*
|
||||
* Defaults to "unless-plain-object"
|
||||
*
|
||||
* - The "unless-plain-object" will inspect the prototype of objects
|
||||
* created with a prototype other than the "Object"
|
||||
* - True will inspect the prototype for all objects that has a prototype
|
||||
* - False will not inpsect the prototype
|
||||
*/
|
||||
inspectObjectPrototype?: boolean | 'unless-plain-object';
|
||||
/**
|
||||
* Inspect prototype properties of an array. The non-enumerable properties
|
||||
* of prototype are included by default.
|
||||
*
|
||||
* Defaults to false
|
||||
*/
|
||||
inspectArrayPrototype?: boolean;
|
||||
/**
|
||||
* Inspect static members of a class. Even though functions and classes are
|
||||
* technically same, this config only applies to functions defined using
|
||||
* the [class] keyword.
|
||||
*
|
||||
* Defaults to false
|
||||
*/
|
||||
inspectStaticMembers?: boolean;
|
||||
/**
|
||||
* Maximum number of members to process for Arrays, Maps and Sets.
|
||||
*
|
||||
* Defaults to 100
|
||||
*/
|
||||
maxArrayLength?: number;
|
||||
/**
|
||||
* Maximum number of characters to display for a string.
|
||||
*
|
||||
* Defaults to 1000
|
||||
*/
|
||||
maxStringLength?: number;
|
||||
/**
|
||||
* An array of values that must be collapsed. The objects and
|
||||
* arrays constructor names are checked against these values.
|
||||
*/
|
||||
collapse?: string[];
|
||||
};
|
||||
0
node_modules/@poppinss/dumper/build/src/types.js
generated
vendored
Normal file
0
node_modules/@poppinss/dumper/build/src/types.js
generated
vendored
Normal file
Reference in New Issue
Block a user