feat: init

node_modules/@poppinss/dumper/build/formatters/console/formatter.d.ts

@@ -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;
+}

node_modules/@poppinss/dumper/build/formatters/console/main.d.ts

@@ -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;

node_modules/@poppinss/dumper/build/formatters/console/main.js

@@ -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
+};

node_modules/@poppinss/dumper/build/formatters/console/printers/main.d.ts

@@ -0,0 +1,5 @@
+import type { TokenPrinters } from '../types.js';
+/**
+ * Console printers to pretty print parser tokens
+ */
+export declare const ConsolePrinters: TokenPrinters;

node_modules/@poppinss/dumper/build/formatters/console/themes.d.ts

@@ -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;
+    };
+};

node_modules/@poppinss/dumper/build/formatters/console/types.d.ts

@@ -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;