@buoy-gg/console 7.0.29 → 7.0.30

package/src/devtools/consoleFilter.ts

@@ -1,123 +0,0 @@
-/**
- * consoleFilter — port of DevTools `panels/console/ConsoleFilter.ts` plus the
- * `TextUtils.FilterParser` text-filter grammar.
- *
- * - Level mask: 4 levels (verbose/info/warning/error); "Default" = all but verbose.
- * - Text filter: space-separated tokens, AND-combined. Each token may be a plain
- *   substring, a `/regex/`, or `key:value` (url/source/context), and a leading
- *   `-` negates it. Our captured entries have no url/source/context fields, so
- *   keyed tokens degrade to a substring test against the rendered message.
- */
-
-import type { ConsoleLevel, ConsoleLogEntry } from "../store/consoleLogStore";
-
-export type LevelsMask = Record<ConsoleLevel, boolean>;
-
-export const ALL_LEVELS: LevelsMask = {
-  verbose: true,
-  info: true,
-  warning: true,
-  error: true,
-};
-
-/** "Default levels": everything except Verbose. */
-export const DEFAULT_LEVELS: LevelsMask = { ...ALL_LEVELS, verbose: false };
-
-export interface ParsedFilter {
-  key?: string;
-  text?: string;
-  regex?: RegExp;
-  negative: boolean;
-}
-
-const KEY_VALUE_RE = /^([\w-]+):(.+)$/;
-const REGEXP_RE = /^\/(.+)\/$/;
-
-/** Parse a filter query string into AND-combined parsed filters. */
-export function parseFilterQuery(query: string): ParsedFilter[] {
-  const filters: ParsedFilter[] = [];
-  for (const rawToken of query.split(/\s+/)) {
-    if (!rawToken) continue;
-    let token = rawToken;
-    let negative = false;
-    if (token.startsWith("-") && token.length > 1) {
-      negative = true;
-      token = token.slice(1);
-    }
-
-    const kv = token.match(KEY_VALUE_RE);
-    if (kv) {
-      filters.push({ key: kv[1].toLowerCase(), text: kv[2], negative });
-      continue;
-    }
-    const rx = token.match(REGEXP_RE);
-    if (rx) {
-      try {
-        filters.push({ regex: new RegExp(rx[1], "im"), negative });
-        continue;
-      } catch {
-        // Invalid regex falls back to literal text (DevTools does the same).
-      }
-    }
-    filters.push({ text: token, negative });
-  }
-  return filters;
-}
-
-/** Does the entry's rendered text contain `text` (case-insensitive)? */
-function textMatches(entry: ConsoleLogEntry, text: string): boolean {
-  return entry.message.toLowerCase().includes(text.toLowerCase());
-}
-
-/** Apply the parsed text filters (all must pass). */
-function applyFilters(entry: ConsoleLogEntry, parsed: ParsedFilter[]): boolean {
-  for (const filter of parsed) {
-    if (filter.regex) {
-      if (filter.regex.test(entry.message) === filter.negative) return false;
-    } else if (filter.text) {
-      // Keyed tokens (url:/source:/context:) degrade to a substring test since
-      // captured RN logs carry no such fields.
-      if (textMatches(entry, filter.text) === filter.negative) return false;
-    }
-  }
-  return true;
-}
-
-/** DevTools ConsoleFilter.shouldBeVisible, adapted to our entry model. */
-export function shouldBeVisible(
-  entry: ConsoleLogEntry,
-  levelsMask: LevelsMask,
-  parsed: ParsedFilter[]
-): boolean {
-  // Group-end markers are control rows, never filtered out (handled by the view).
-  if (entry.method === "groupEnd") return true;
-  if (!levelsMask[entry.level]) return false;
-  return applyFilters(entry, parsed);
-}
-
-// ─── Level menu summary text (DevTools updateLevelMenuButtonText) ────────────
-
-const LEVEL_LABEL: Record<ConsoleLevel, string> = {
-  verbose: "Verbose",
-  info: "Info",
-  warning: "Warnings",
-  error: "Errors",
-};
-
-const LEVEL_ORDER: ConsoleLevel[] = ["verbose", "info", "warning", "error"];
-
-function masksEqual(a: LevelsMask, b: LevelsMask): boolean {
-  return LEVEL_ORDER.every((l) => a[l] === b[l]);
-}
-
-/** The summary shown on the level menu button. */
-export function levelMenuSummary(mask: LevelsMask): string {
-  if (masksEqual(mask, ALL_LEVELS)) return "All levels";
-  if (masksEqual(mask, DEFAULT_LEVELS)) return "Default levels";
-  const enabled = LEVEL_ORDER.filter((l) => mask[l]);
-  if (enabled.length === 0) return "Hide all";
-  if (enabled.length === 1) return `${LEVEL_LABEL[enabled[0]]} only`;
-  return "Custom levels";
-}
-
-export { LEVEL_LABEL, LEVEL_ORDER };

package/src/devtools/consoleFormat.ts

@@ -1,314 +0,0 @@
-/**
- * consoleFormat — port of DevTools `panels/console/ConsoleFormat.ts`.
- *
- * Implements the WHATWG console Formatter: %s/%d/%i/%f/%o/%O/%c/%_ substitutions
- * plus ANSI SGR (\x1B[…m) styling. Where DevTools works over V8 RemoteObjects we
- * work over raw JS values; the substitution/ANSI logic is otherwise 1:1.
- *
- * Output is a flat list of tokens the row renderer consumes:
- *  - { type: 'string', value, style? }  — text, optionally styled by %c / ANSI
- *  - { type: 'value', value, mode }     — an object/array substitution (%o/%O)
- *                                         or a trailing non-string argument
- */
-
-import type { TextStyle } from "react-native";
-import { ansiColors } from "./theme";
-
-export type FormatToken =
-  | { type: "string"; value: string; style?: TextStyle }
-  | { type: "value"; value: unknown; mode: "optimal" | "generic" };
-
-// VGA color palette (matches DevTools ANSI_COLORS / ANSI_BRIGHT_COLORS).
-const ANSI_COLORS = ["black", "red", "green", "yellow", "blue", "magenta", "cyan", "gray"];
-const ANSI_BRIGHT_COLORS = [
-  "darkgray",
-  "lightred",
-  "lightgreen",
-  "lightyellow",
-  "lightblue",
-  "lightmagenta",
-  "lightcyan",
-  "white",
-];
-
-/** A console arg's `description` (string form) — DevTools uses RemoteObject.description. */
-function description(arg: unknown): string {
-  if (typeof arg === "string") return arg;
-  if (arg === undefined) return "undefined";
-  if (arg === null) return "null";
-  if (typeof arg === "number" || typeof arg === "boolean" || typeof arg === "bigint") {
-    return String(arg);
-  }
-  if (arg instanceof Error) return arg.stack ?? `${arg.name}: ${arg.message}`;
-  if (typeof arg === "function") return `ƒ ${arg.name || "(anonymous)"}`;
-  try {
-    return JSON.stringify(arg);
-  } catch {
-    return String(arg);
-  }
-}
-
-// \x1B is the ANSI escape (ESC) — intentional, for parsing color codes.
-// eslint-disable-next-line no-control-regex
-const FORMAT_RE = /%([%_Oocsdfi])|\x1B\[([\d;]*)m/;
-
-/** Does the first arg actually need the substitution engine? */
-function hasFormatting(fmt: string): boolean {
-  return FORMAT_RE.test(fmt);
-}
-
-/** Convert a CSS declaration string (from %c or ANSI) into an RN TextStyle. */
-function cssToTextStyle(css: string): TextStyle | undefined {
-  const style: TextStyle = {};
-  let any = false;
-  for (const decl of css.split(";")) {
-    const idx = decl.indexOf(":");
-    if (idx === -1) continue;
-    const prop = decl.slice(0, idx).trim().toLowerCase();
-    let value = decl.slice(idx + 1).trim();
-    if (!value) continue;
-    // Resolve DevTools ANSI color vars to concrete hex.
-    const varMatch = value.match(/var\(--console-color-([a-z]+)\)/);
-    if (varMatch) value = ansiColors[varMatch[1]] ?? value;
-
-    switch (prop) {
-      case "color":
-        style.color = value;
-        any = true;
-        break;
-      case "background-color":
-      case "background":
-        style.backgroundColor = value;
-        any = true;
-        break;
-      case "font-weight":
-        style.fontWeight = value === "lighter" ? "300" : (value as TextStyle["fontWeight"]);
-        any = true;
-        break;
-      case "font-style":
-        if (value === "italic") {
-          style.fontStyle = "italic";
-          any = true;
-        }
-        break;
-      case "font-size": {
-        const n = parseFloat(value);
-        if (!Number.isNaN(n)) {
-          style.fontSize = n;
-          any = true;
-        }
-        break;
-      }
-      case "text-decoration":
-      case "text-decoration-line":
-        if (value.includes("underline") && value.includes("line-through")) {
-          style.textDecorationLine = "underline line-through";
-        } else if (value.includes("underline")) {
-          style.textDecorationLine = "underline";
-        } else if (value.includes("line-through")) {
-          style.textDecorationLine = "line-through";
-        }
-        any = true;
-        break;
-      default:
-        break;
-    }
-  }
-  return any ? style : undefined;
-}
-
-/** Apply one ANSI SGR sequence to the running style map (DevTools algorithm). */
-function applyAnsi(codes: number[], currentStyle: Map<string, string>): void {
-  const addTextDecoration = (value: string) => {
-    const td = currentStyle.get("text-decoration") ?? "";
-    if (!td.includes(value)) currentStyle.set("text-decoration", `${td} ${value}`);
-  };
-  const removeTextDecoration = (value: string) => {
-    const td = currentStyle.get("text-decoration")?.replace(` ${value}`, "");
-    if (td) currentStyle.set("text-decoration", td);
-    else currentStyle.delete("text-decoration");
-  };
-
-  while (codes.length) {
-    const code = codes.shift() as number;
-    switch (code) {
-      case 0:
-        currentStyle.clear();
-        break;
-      case 1:
-        currentStyle.set("font-weight", "bold");
-        break;
-      case 2:
-        currentStyle.set("font-weight", "lighter");
-        break;
-      case 3:
-        currentStyle.set("font-style", "italic");
-        break;
-      case 4:
-        addTextDecoration("underline");
-        break;
-      case 9:
-        addTextDecoration("line-through");
-        break;
-      case 22:
-        currentStyle.delete("font-weight");
-        break;
-      case 23:
-        currentStyle.delete("font-style");
-        break;
-      case 24:
-        removeTextDecoration("underline");
-        break;
-      case 29:
-        removeTextDecoration("line-through");
-        break;
-      case 38:
-      case 48:
-        if (codes.shift() === 2) {
-          const r = codes.shift() ?? 0;
-          const g = codes.shift() ?? 0;
-          const b = codes.shift() ?? 0;
-          currentStyle.set(code === 38 ? "color" : "background-color", `rgb(${r},${g},${b})`);
-        }
-        break;
-      case 39:
-      case 49:
-        currentStyle.delete(code === 39 ? "color" : "background-color");
-        break;
-      default: {
-        const color = ANSI_COLORS[code - 30] ?? ANSI_BRIGHT_COLORS[code - 90];
-        if (color !== undefined) {
-          currentStyle.set("color", `var(--console-color-${color})`);
-        } else {
-          const bg = ANSI_COLORS[code - 40] ?? ANSI_BRIGHT_COLORS[code - 100];
-          if (bg !== undefined) currentStyle.set("background-color", `var(--console-color-${bg})`);
-        }
-        break;
-      }
-    }
-  }
-}
-
-/** Run the substitution engine over a format string + its args. */
-function formatWithSubstitutions(fmtIn: string, args: unknown[]): {
-  tokens: FormatToken[];
-  rest: unknown[];
-} {
-  let fmt = fmtIn;
-  const tokens: FormatToken[] = [];
-  const currentStyle = new Map<string, string>();
-  let cssStyle: TextStyle | undefined;
-
-  const pushString = (value: string) => {
-    if (!value) return;
-    const last = tokens[tokens.length - 1];
-    if (last && last.type === "string" && styleEq(last.style, cssStyle)) {
-      last.value += value;
-      return;
-    }
-    tokens.push({ type: "string", value, style: cssStyle });
-  };
-
-  let argIndex = 0;
-  for (let match = FORMAT_RE.exec(fmt); match !== null; match = FORMAT_RE.exec(fmt)) {
-    pushString(match.input.substring(0, match.index));
-    let substitution: number | string | undefined;
-    const specifier = match[1];
-    switch (specifier) {
-      case "%":
-        pushString("%");
-        substitution = "";
-        break;
-      case "s":
-        if (argIndex < args.length) substitution = description(args[argIndex++]);
-        break;
-      case "c":
-        if (argIndex < args.length) {
-          cssStyle = cssToTextStyle(description(args[argIndex++]));
-          substitution = "";
-        }
-        break;
-      case "o":
-      case "O":
-        if (argIndex < args.length) {
-          tokens.push({
-            type: "value",
-            value: args[argIndex++],
-            mode: specifier === "O" ? "generic" : "optimal",
-          });
-          substitution = "";
-        }
-        break;
-      case "_":
-        if (argIndex < args.length) {
-          argIndex++;
-          substitution = "";
-        }
-        break;
-      case "d":
-      case "f":
-      case "i": {
-        if (argIndex < args.length) {
-          const v = args[argIndex++];
-          let n = typeof v !== "number" ? NaN : v;
-          if (specifier !== "f") n = Math.floor(n);
-          substitution = n;
-        }
-        break;
-      }
-      case undefined: {
-        const codes = (match[2] || "0").split(";").map((c) => (c ? parseInt(c, 10) : 0));
-        applyAnsi(codes, currentStyle);
-        const css = [...currentStyle.entries()]
-          .map(([k, val]) => `${k}:${val.trimStart()}`)
-          .join(";");
-        cssStyle = cssToTextStyle(css);
-        substitution = "";
-        break;
-      }
-    }
-    if (substitution === undefined) {
-      pushString(match[0]);
-      substitution = "";
-    }
-    fmt = substitution + match.input.substring(match.index + match[0].length);
-  }
-  pushString(fmt);
-  return { tokens, rest: args.slice(argIndex) };
-}
-
-function styleEq(a?: TextStyle, b?: TextStyle): boolean {
-  if (a === b) return true;
-  if (!a || !b) return false;
-  return JSON.stringify(a) === JSON.stringify(b);
-}
-
-/**
- * Format a console call's arguments into renderable tokens, mirroring how the
- * DevTools console renders a message: if the first arg is a format string it
- * drives substitution, then any leftover args are appended (space-separated).
- */
-export function formatConsoleMessage(args: unknown[]): FormatToken[] {
-  if (args.length === 0) return [];
-
-  let tokens: FormatToken[] = [];
-  let rest = args;
-
-  if (typeof args[0] === "string" && hasFormatting(args[0])) {
-    const result = formatWithSubstitutions(args[0], args.slice(1));
-    tokens = result.tokens;
-    rest = result.rest;
-  }
-
-  // Append remaining args (the common case: console.log("x", obj, 1)).
-  for (const arg of rest) {
-    if (tokens.length > 0) tokens.push({ type: "string", value: " " });
-    if (typeof arg === "string") {
-      tokens.push({ type: "string", value: arg });
-    } else {
-      tokens.push({ type: "value", value: arg, mode: "optimal" });
-    }
-  }
-
-  return tokens;
-}

package/src/devtools/origin.ts

@@ -1,190 +0,0 @@
-/**
- * origin — attributes a console call to *where it came from*, and provides the
- * lnav-style colored connecting bracket helpers.
- *
- * Three independent signals (captured in the store at log time):
- *  - **component**  — nearest owning React component (React.captureOwnerStack,
- *    dev only; null outside render / in async callbacks)
- *  - **function**   — the enclosing function of the call site (JS stack)
- *  - **callSite**   — the exact `file:line` of the call site (JS stack)
- *
- * The view groups consecutive same-source rows and draws a colored bracket
- * gutter (┌ │ └ ─) exactly like lnav's per-file gutter.
- */
-
-export type GroupDimension = "component" | "callsite" | "function" | "off";
-
-export interface LogOrigin {
-  component?: string;
-  functionName?: string;
-  callSite?: string;
-  file?: string;
-  line?: number;
-}
-
-/**
- * Our own capture frames, matched by FUNCTION NAME. This is the primary filter:
- * in a Metro/Hermes bundle every frame shares one bundle URL, so filename
- * filtering can't distinguish them — and that URL often contains `node_modules`
- * (e.g. expo-router/entry.bundle), which would wrongly reject *every* frame.
- * The first frame after these is the real caller (framework internals sit
- * deeper in the stack, after the app frame).
- */
-const INTERNAL_FUNC =
-  /^(buoyConsoleProxy|record|cleanStack|captureOwnerStack|formatArgs|formatArg)$/;
-
-/** Narrow filename guard — only our own module (used when stacks carry real
- * file paths, e.g. on web/V8 rather than a single Hermes bundle). */
-const INTERNAL_FILE = /consoleLogStore/;
-
-function isInternalFrame(frame: RawFrame): boolean {
-  if (frame.func && INTERNAL_FUNC.test(frame.func.replace(/^Object\./, ""))) {
-    return true;
-  }
-  return Boolean(frame.file && INTERNAL_FILE.test(frame.file));
-}
-
-interface RawFrame {
-  func?: string;
-  file?: string;
-  line?: number;
-}
-
-/** Parse a V8 or Hermes stack string into frames. */
-function parseFrames(stack: string): RawFrame[] {
-  const frames: RawFrame[] = [];
-  for (const raw of stack.split("\n")) {
-    const line = raw.trim();
-    if (!line || line === "Error") continue;
-    // V8: "at func (file:line:col)"
-    let m = line.match(/^at\s+(.+?)\s+\((.+?):(\d+):(\d+)\)$/);
-    if (m) {
-      frames.push({ func: m[1], file: m[2], line: Number(m[3]) });
-      continue;
-    }
-    // V8: "at file:line:col"
-    m = line.match(/^at\s+(.+?):(\d+):(\d+)$/);
-    if (m) {
-      frames.push({ file: m[1], line: Number(m[2]) });
-      continue;
-    }
-    // Hermes: "func@file:line:col"
-    m = line.match(/^(.*?)@(.+?):(\d+):(\d+)$/);
-    if (m) {
-      frames.push({ func: m[1] || undefined, file: m[2], line: Number(m[3]) });
-      continue;
-    }
-  }
-  return frames;
-}
-
-function basename(file?: string): string | undefined {
-  if (!file) return undefined;
-  const noQuery = file.split("?")[0];
-  return noQuery.split("/").pop() || noQuery;
-}
-
-function cleanFunctionName(func?: string): string | undefined {
-  if (!func) return undefined;
-  const f = func.replace(/^Object\./, "").trim();
-  if (!f || f === "<anonymous>" || f === "anonymous") return undefined;
-  return f;
-}
-
-/** First component name from a React owner stack (nearest owner). */
-function firstComponent(ownerStack?: string): string | undefined {
-  if (!ownerStack) return undefined;
-  for (const raw of ownerStack.split("\n")) {
-    const m = raw.trim().match(/^at\s+([A-Za-z_$][\w$]*)/);
-    if (m) return m[1];
-  }
-  return undefined;
-}
-
-/** Derive the origin of a log from its captured JS stack + React owner stack. */
-export function parseOrigin(stack?: string, ownerStack?: string): LogOrigin | undefined {
-  const component = firstComponent(ownerStack);
-
-  let appFrame: RawFrame | undefined;
-  if (stack) {
-    const frames = parseFrames(stack);
-    appFrame = frames.find((f) => !isInternalFrame(f));
-  }
-
-  const functionName = cleanFunctionName(appFrame?.func);
-  const file = basename(appFrame?.file);
-  const line = appFrame?.line;
-  const callSite = file && line != null ? `${file}:${line}` : undefined;
-
-  if (!component && !functionName && !callSite) return undefined;
-  return { component, functionName, callSite, file, line };
-}
-
-// ─── Grouping by dimension ───────────────────────────────────────────────────
-
-/**
- * Stable key used to group consecutive rows (null = ungrouped).
- *
- * Each dimension falls back to the next-best signal so a row is never lumped
- * into a single catch-all bucket: a handler-fired log (no React owner) still
- * differentiates by its function / call site under "Component".
- */
-export function sourceKey(origin: LogOrigin | undefined, dim: GroupDimension): string | null {
-  if (dim === "off" || !origin) return dim === "off" ? null : "—unknown—";
-  if (dim === "component") {
-    return origin.component ?? origin.functionName ?? origin.callSite ?? "—unknown—";
-  }
-  if (dim === "function") {
-    return origin.functionName ?? origin.callSite ?? origin.component ?? "—anonymous—";
-  }
-  return origin.callSite ?? origin.functionName ?? "—unknown—";
-}
-
-/** Human label shown next to the row. */
-export function sourceLabel(origin: LogOrigin | undefined, dim: GroupDimension): string {
-  if (!origin) return "(unknown)";
-  if (dim === "component") {
-    if (origin.component) return origin.component;
-    if (origin.functionName) return `ƒ ${origin.functionName}`;
-    return origin.callSite ?? "(unknown)";
-  }
-  if (dim === "function") {
-    if (origin.functionName) return origin.functionName;
-    return origin.callSite ?? "(anonymous)";
-  }
-  if (dim === "callsite") {
-    if (origin.functionName && origin.callSite) return `${origin.functionName} · ${origin.callSite}`;
-    return origin.callSite ?? (origin.functionName ? `ƒ ${origin.functionName}` : "(unknown)");
-  }
-  return "";
-}
-
-// ─── Color + bracket ─────────────────────────────────────────────────────────
-
-function hashString(s: string): number {
-  let h = 0;
-  for (let i = 0; i < s.length; i++) h = (h * 31 + s.charCodeAt(i)) | 0;
-  return Math.abs(h);
-}
-
-/** Stable, readable color for a source key (bright enough for a dark surface). */
-export function colorForKey(key: string): string {
-  const hue = hashString(key) % 360;
-  return `hsl(${hue}, 70%, 66%)`;
-}
-
-export type Bracket = "top" | "mid" | "bottom" | "single";
-
-/** lnav gutter glyph: ┌ run-start · │ run-middle · └ run-end · ─ single. */
-export function bracketGlyph(bracket: Bracket): string {
-  switch (bracket) {
-    case "top":
-      return "┌";
-    case "bottom":
-      return "└";
-    case "single":
-      return "─";
-    default:
-      return "│";
-  }
-}