@guiexpert/demo-table-models 1.1.107 → 1.1.108

package/lib/log-tail/createLogTailModel.d.ts

@@ -0,0 +1,17 @@
+import { AreaIdent, AreaModelIf, CellRendererIf, DomServiceIf, RendererCleanupFnType, TableModelAndOptionsIf } from '@guiexpert/table';
+import { LogLineIf } from '../../model/log-line.if.js';
+
+/** The level of a log line as a small badge: class `ge-log-level ge-log-level-error` … (text, never HTML). */
+export declare class LogLevelCellRenderer implements CellRendererIf {
+    render(cellDiv: HTMLDivElement, _rowIndex: number, _columnIndex: number, _areaIdent: AreaIdent, _areaModel: AreaModelIf, cellValue: unknown, domService: DomServiceIf): RendererCleanupFnType | undefined;
+}
+/**
+ * A log viewer table (live data, since 1.1.108): #, time, level (badge), source, message; 24 px rows, range
+ * selection, cell focus. Feed it with `tableApi.appendRows(lines, { follow: "auto", maxRows })` or the
+ * {@link LogTailController}.
+ *
+ * CSS for the level badges (not part of the table CSS): `.ge-log-level-error { color: … }` – see the showcase.
+ *
+ * @param lines - the first lines (default none) – the table appends to this array
+ */
+export declare function createLogTailModelAndOptions(lines?: LogLineIf[]): TableModelAndOptionsIf;

package/lib/log-tail/log-generator.d.ts

@@ -0,0 +1,24 @@
+import { LogLineIf } from '../../model/log-line.if.js';
+
+/**
+ * Generates log lines with a fixed seed – the same seed gives the same lines (live data demos, since 1.1.108).
+ * Levels: ~70 % INFO, 15 % DEBUG, 10 % WARN, 5 % ERROR; the time advances by `msPerLine`.
+ *
+ * @example
+ * const generator = new LogGenerator(42);
+ * const lines = generator.next(500);
+ */
+export declare class LogGenerator {
+    private readonly msPerLine;
+    private seed;
+    private nextId;
+    private timeMs;
+    constructor(seed?: number, startTimeMs?: number, msPerLine?: number);
+    /** The next `count` lines. */
+    next(count: number): LogLineIf[];
+    /** Number of lines generated so far. */
+    getCount(): number;
+    private line;
+    /** mulberry32 */
+    private random;
+}

package/lib/log-tail/log-tail-controller.d.ts

@@ -0,0 +1,100 @@
+import { AppendRowsResultIf, TableApi } from '@guiexpert/table';
+import { LogLineIf } from '../../model/log-line.if.js';
+
+/** Numbers of a running {@link LogTailController} – reported about four times per second. */
+export interface LogTailStatsIf {
+    /** lines generated so far */
+    totalLines: number;
+    /** lines in the table now (ring buffer) */
+    rowCount: number;
+    /** lines per second (measured) */
+    linesPerSecond: number;
+    /** animation frames per second */
+    fps: number;
+    /** median time of `appendRows` incl. its render pass over the last second, ms */
+    msPerUpdate: number;
+    /** lines that came in below the view while it did not follow ("+N new lines") */
+    newBelow: number;
+    /** lines waiting while the intake is paused */
+    pending: number;
+    frozen: boolean;
+    intakePaused: boolean;
+    following: boolean;
+}
+export interface LogTailControllerOptionsIf {
+    /** lines per second, default 500 */
+    rate?: number;
+    /** ring buffer size, default 1,000,000 */
+    maxRows?: number;
+    /** seed of the {@link LogGenerator}, default 42 */
+    seed?: number;
+    /** called about four times per second */
+    onStats?: (stats: LogTailStatsIf) => void;
+    /** where the lines come from (default: a {@link LogGenerator}) */
+    source?: (count: number) => LogLineIf[];
+}
+/**
+ * Drives a live log table (since 1.1.108) – the shared logic of the showcase `logtail`, `apps/table-demo/log-tail.html`
+ * and the specs. Per animation frame: the lines that are due at `rate` go to a buffer, then **one**
+ * `tableApi.appendRows(buffer, { follow, maxRows })`.
+ *
+ * - **Freeze scroll** (`setFreezeScroll(true)`): `follow: false` – the view stays where it is, even at the end; lines keep
+ *   coming ("+N new lines").
+ * - **Scroll to end** (`scrollToEnd()`): unfreezes and jumps to the end; from then on `follow: "auto"` follows again –
+ *   also when the user scrolls to the end by hand.
+ * - **Pause intake** (`setIntakePaused(true)`): the app pattern "freeze" – lines are collected, nothing is appended;
+ *   unpausing appends the whole block at once.
+ *
+ * @example
+ * const live = new LogTailController(tableApi, { rate: 5_000, maxRows: 1_000_000, onStats: s => show(s) });
+ * live.start();
+ * freezeButton.onclick = () => live.setFreezeScroll(!live.isFrozen());
+ * endButton.onclick = () => live.scrollToEnd();
+ */
+export declare class LogTailController {
+    private readonly tableApi;
+    private readonly options;
+    private readonly generator;
+    private readonly source;
+    private rate;
+    private readonly maxRows;
+    private readonly pending;
+    private frozen;
+    private intakePaused;
+    private following;
+    private newBelow;
+    private running;
+    private frameId;
+    private lastTime;
+    private due;
+    private statsStart;
+    private statsFrames;
+    private statsLines;
+    private statsTimes;
+    private lastStats?;
+    constructor(tableApi: TableApi, options?: LogTailControllerOptionsIf);
+    /** Starts the frame loop. */
+    start(): void;
+    /** Stops the frame loop (lines in the buffer stay). */
+    stop(): void;
+    isRunning(): boolean;
+    /** Lines per second. */
+    setRate(linesPerSecond: number): void;
+    getRate(): number;
+    /** Freeze scroll: the view stays where it is, lines keep coming. */
+    setFreezeScroll(frozen: boolean): void;
+    isFrozen(): boolean;
+    /** Pause intake (app pattern "freeze"): lines are buffered and appended as one block when unpaused. */
+    setIntakePaused(paused: boolean): void;
+    isIntakePaused(): boolean;
+    /** Unfreezes and jumps to the end – the view follows again. */
+    scrollToEnd(): void;
+    /** Appends the buffered lines now (one `appendRows`) – also used by the frame loop. */
+    flush(): AppendRowsResultIf | false | undefined;
+    /** Adds lines from outside (e.g. a WebSocket) – appended with the next frame. */
+    push(lines: LogLineIf[]): void;
+    /** The latest numbers (also passed to `onStats`). */
+    getStats(): LogTailStatsIf;
+    private frame;
+    private createStats;
+}

package/model/log-line.if.d.ts

@@ -0,0 +1,11 @@
+/** One line of a log file (live data demos, since 1.1.108). */
+export interface LogLineIf {
+    /** running number, unique */
+    id: number;
+    /** "HH:MM:SS.mmm" */
+    time: string;
+    level: "DEBUG" | "INFO" | "WARN" | "ERROR";
+    /** the service that wrote the line */
+    source: string;
+    text: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guiexpert/demo-table-models",
-  "version": "1.1.107",
+  "version": "1.1.108",
   "license": "MIT",
   "author": "Dr. Marc Kronberg <info@gui.expert> (https://gui.expert)",
   "repository": {
@@ -31,7 +31,7 @@
   },
   "dependencies": {
     "tslib": "^2.3.0",
-    "@guiexpert/table": "^1.1.107"
+    "@guiexpert/table": "^1.1.108"
   },
   "devDependencies": {
     "@types/node": "^20.11.17",