lognal 0.1.0

package/dist/sources/console/recorder.js

@@ -0,0 +1,239 @@
+import { formatArguments } from './format.js';
+import { DEFAULT_CAPTURE_OPTIONS, snapshotValue } from './snapshot.js';
+import { formatTable } from './table.js';
+export const CONSOLE_METHODS = [
+    'log',
+    'info',
+    'warn',
+    'error',
+    'debug',
+    'trace',
+    'dir',
+    'dirxml',
+    'table',
+    'group',
+    'groupCollapsed',
+    'groupEnd',
+    'count',
+    'countReset',
+    'time',
+    'timeLog',
+    'timeEnd',
+    'assert',
+    'clear'
+];
+export const DEFAULT_RECORDER_OPTIONS = {
+    ...DEFAULT_CAPTURE_OPTIONS,
+    clearStore: true
+};
+const DEFAULT_LABEL = 'default';
+const now = () => {
+    return typeof performance !== 'undefined' ? performance.now() : Date.now();
+};
+const labelOf = (value) => {
+    return value === undefined ? DEFAULT_LABEL : String(value);
+};
+const formatDuration = (milliseconds) => {
+    return `${Number(milliseconds.toFixed(3))} ms`;
+};
+const text = (value, extra = {}) => {
+    return { type: 'text', text: value, ...extra };
+};
+/**
+ * Turns console calls into store entries.
+ *
+ * A recorder keeps the state the Console Standard gives a console: the count map, the timer
+ * table and the group stack. Everything is captured synchronously, when the method is called.
+ */
+export class ConsoleRecorder {
+    store;
+    options;
+    counts = new Map();
+    timers = new Map();
+    groups = [];
+    constructor(store, options = {}) {
+        this.store = store;
+        this.options = { ...DEFAULT_RECORDER_OPTIONS, ...options };
+    }
+    setOptions(options) {
+        this.options = { ...this.options, ...options };
+    }
+    /**
+     * Records one call. `stack` is the caller's stack trace, which only `trace` uses.
+     */
+    record(method, args, stack) {
+        switch (method) {
+            case 'log':
+            case 'info':
+            case 'warn':
+            case 'error':
+            case 'debug':
+                this.add(method, formatArguments(args, this.capture));
+                break;
+            case 'dir':
+                this.add('log', [{ type: 'value', value: this.capture(args[0]) }]);
+                break;
+            case 'dirxml':
+                this.add('log', args.length > 0
+                    ? args.flatMap((value, index) => [
+                        ...(index > 0 ? [text(' ')] : []),
+                        { type: 'value', value: this.capture(value) }
+                    ])
+                    : [text('undefined', { token: 'null' })]);
+                break;
+            case 'trace':
+                this.trace(args, stack);
+                break;
+            case 'table':
+                this.table(args);
+                break;
+            case 'group':
+            case 'groupCollapsed':
+                this.group(args, method === 'groupCollapsed');
+                break;
+            case 'groupEnd':
+                this.groups = this.groups.slice(0, -1);
+                break;
+            case 'count':
+                this.count(args[0]);
+                break;
+            case 'countReset':
+                this.countReset(args[0]);
+                break;
+            case 'time':
+                this.time(args[0]);
+                break;
+            case 'timeLog':
+                this.timeLog(args[0], args.slice(1));
+                break;
+            case 'timeEnd':
+                this.timeEnd(args[0]);
+                break;
+            case 'assert':
+                this.assert(args);
+                break;
+            case 'clear':
+                this.clear();
+                break;
+            default:
+                break;
+        }
+    }
+    capture = (value) => {
+        return snapshotValue(value, this.options);
+    };
+    add(level, parts, kind = 'message', init = {}) {
+        this.store.append({ level, kind, parts, groups: [...this.groups], ...init });
+    }
+    trace(args, stack) {
+        const parts = args.length > 0 ? formatArguments(args, this.capture) : [text('console.trace')];
+        if (stack) {
+            const frames = stack
+                .split('\n')
+                .map((frame) => frame.trim())
+                .filter(Boolean)
+                .map((frame) => `    ${frame}`)
+                .join('\n');
+            parts.push(text(`\n${frames}`, { token: 'muted' }));
+        }
+        this.add('log', parts);
+    }
+    table(args) {
+        const [data, properties] = args;
+        if (data === null || typeof data !== 'object') {
+            this.add('log', formatArguments(args, this.capture));
+            return;
+        }
+        const node = snapshotValue(data, { ...this.options, maxDepth: 2 });
+        const columns = Array.isArray(properties) ? properties.map((key) => String(key)) : undefined;
+        const table = formatTable(node, columns);
+        // A table keeps its rows whole; a table wider than the viewer scrolls sideways.
+        this.add('log', table === null ? [{ type: 'value', value: node }] : [text(table, { wrap: false })]);
+    }
+    group(args, collapsed) {
+        const parts = args.length > 0
+            ? formatArguments(args, this.capture).map((part) => part.type === 'text' ? { ...part, style: { ...part.style, bold: true } } : part)
+            : [text(collapsed ? 'console.groupCollapsed' : 'console.group', { style: { bold: true } })];
+        const [entry] = this.store.append({
+            level: 'log',
+            kind: 'group',
+            parts,
+            groups: [...this.groups],
+            collapsed
+        });
+        if (entry) {
+            this.groups = [...this.groups, entry.id];
+        }
+    }
+    count(label) {
+        const key = labelOf(label);
+        const count = (this.counts.get(key) ?? 0) + 1;
+        this.counts.set(key, count);
+        this.add('info', [text(`${key}: ${count}`)]);
+    }
+    countReset(label) {
+        const key = labelOf(label);
+        if (this.counts.has(key)) {
+            this.counts.set(key, 0);
+        }
+        else {
+            this.add('warn', [text(`Count for '${key}' does not exist`)]);
+        }
+    }
+    time(label) {
+        const key = labelOf(label);
+        if (this.timers.has(key)) {
+            this.add('warn', [text(`Timer '${key}' already exists`)]);
+            return;
+        }
+        this.timers.set(key, now());
+    }
+    timeLog(label, data) {
+        const key = labelOf(label);
+        const start = this.timers.get(key);
+        if (start === undefined) {
+            this.add('warn', [text(`Timer '${key}' does not exist`)]);
+            return;
+        }
+        const parts = [text(`${key}: ${formatDuration(now() - start)}`)];
+        for (const value of data) {
+            parts.push(text(' '));
+            parts.push(typeof value === 'string' ? text(value) : { type: 'value', value: this.capture(value) });
+        }
+        this.add('log', parts);
+    }
+    timeEnd(label) {
+        const key = labelOf(label);
+        const start = this.timers.get(key);
+        if (start === undefined) {
+            this.add('warn', [text(`Timer '${key}' does not exist`)]);
+            return;
+        }
+        this.timers.delete(key);
+        this.add('info', [text(`${key}: ${formatDuration(now() - start)}`)]);
+    }
+    assert(args) {
+        const [condition, ...data] = args;
+        if (condition) {
+            return;
+        }
+        if (data.length === 0) {
+            this.add('error', [text('Assertion failed')]);
+            return;
+        }
+        if (typeof data[0] === 'string') {
+            data[0] = `Assertion failed: ${data[0]}`;
+        }
+        else {
+            data.unshift('Assertion failed');
+        }
+        this.add('error', formatArguments(data, this.capture));
+    }
+    clear() {
+        this.groups = [];
+        if (this.options.clearStore) {
+            this.store.clear();
+        }
+        this.add('log', [text('Console was cleared', { token: 'muted' })], 'system');
+    }
+}

package/dist/sources/console/snapshot.d.ts

@@ -0,0 +1,22 @@
+import type { ValueNode } from '../../core/types.js';
+/** Limits that keep capturing a large or deep value cheap. */
+export interface CaptureOptions {
+    /** How many levels of nested objects are captured. Deeper objects are shown by name only. */
+    maxDepth: number;
+    /** The most properties, items or entries captured from one object, array, map or set. */
+    maxProperties: number;
+    /** The longest string captured in full. */
+    maxStringLength: number;
+    /** The most values captured for one argument, counting every nested value. */
+    maxNodes: number;
+}
+export declare const DEFAULT_CAPTURE_OPTIONS: CaptureOptions;
+/**
+ * Captures a value as plain data, at the moment of the call.
+ *
+ * Getters defined by the page are never run: an accessor property is recorded as an accessor.
+ * Built-in types are recognized with the engine's own methods rather than `instanceof`, so
+ * values from another frame are recognized too. Each limit in `options` bounds the work, and
+ * whatever it cuts is counted in the node's `omitted` field.
+ */
+export declare const snapshotValue: (value: unknown, options?: Partial<CaptureOptions>) => ValueNode;