@buoy-gg/console 7.0.28 → 7.0.30

package/src/preset.tsx

@@ -1,67 +0,0 @@
-/**
- * Pre-configured Console tool for FloatingDevTools.
- *
- * @example
- * ```tsx
- * import { consoleToolPreset } from '@buoy-gg/console';
- *
- * <FloatingDevTools apps={[consoleToolPreset]} />
- * ```
- */
-
-import { ConsoleIcon, CONSOLE_ICON_COLOR } from "./components/ConsoleIcon";
-import { ConsoleModal } from "./components/ConsoleModal";
-import { installConsoleCapture } from "./store/consoleLogStore";
-
-/**
- * Install console + fatal-error capture at IMPORT time, not first UI mount.
- *
- * Deliberately a module side effect (same pattern as @buoy-gg/network's
- * override hydration): a fatal error thrown during the app's FIRST render
- * kills the tree before FloatingDevTools' effects ever run, so mount-time
- * install (`ConsoleRoot`) captured nothing for exactly the crashes that most
- * need capturing. Importing the preset happens at bundle-eval, before any
- * rendering, so the `console.*` patch and both fatal-error hooks (`ErrorUtils`
- * and RN's native exception listener) are live from the first line of app code.
- *
- * Guards:
- * - `ErrorUtils` OR `RN$registerExceptionListener` present = a real React Native
- *   runtime. The desktop dashboard and web mirrors import this package too, and
- *   must never patch their OWN console (they mirror device entries via
- *   `replaceEntries`).
- * - Dev-only. In production the existing mount-time path still applies (the
- *   tools only mount there for licensed users), so end-user builds are never
- *   patched at import.
- */
-const rnGlobals = globalThis as {
-  ErrorUtils?: { setGlobalHandler?: unknown };
-  RN$registerExceptionListener?: unknown;
-};
-const isReactNativeRuntime =
-  typeof rnGlobals.ErrorUtils?.setGlobalHandler === "function" ||
-  typeof rnGlobals.RN$registerExceptionListener === "function";
-if (isReactNativeRuntime && typeof __DEV__ !== "undefined" && __DEV__) {
-  installConsoleCapture();
-}
-
-export const consoleToolPreset = {
-  id: "console",
-  name: "CONSOLE",
-  description: "Captured console.* output",
-  slot: "both" as const,
-  icon: ({ size, color }: { size: number; color?: string }) => (
-    <ConsoleIcon size={size} color={color || CONSOLE_ICON_COLOR} />
-  ),
-  component: ConsoleModal,
-};
-
-/** Create a custom Console tool configuration. */
-export function createConsoleTool(
-  options: { name?: string; description?: string } = {}
-) {
-  return {
-    ...consoleToolPreset,
-    name: options.name ?? consoleToolPreset.name,
-    description: options.description ?? consoleToolPreset.description,
-  };
-}

package/src/store/__tests__/consoleSyncAdapter.test.ts

@@ -1,156 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { capString, sanitizeArgs, SNAPSHOT_STRING_LIMIT } from "../sanitize";
-import { clearEntries, replaceEntries } from "../consoleLogStore";
-import { consoleSyncAdapter } from "../../sync/consoleSyncAdapter";
-import type { ConsoleLogEntry } from "../consoleLogStore";
-
-// Node has no rAF; the store coalesces listener notifies onto one frame.
-globalThis.requestAnimationFrame = ((cb: (t: number) => void) => {
-  cb(0);
-  return 0;
-}) as typeof requestAnimationFrame;
-
-function entry(
-  partial: Partial<ConsoleLogEntry> & Pick<ConsoleLogEntry, "id" | "args" | "message">,
-): ConsoleLogEntry {
-  return {
-    method: "log",
-    level: "info",
-    timestamp: Date.now(),
-    ...partial,
-  };
-}
-
-afterEach(() => {
-  clearEntries();
-});
-
-describe("sanitizeArgs", () => {
-  it("round-trips Errors, functions, and circular refs as JSON", () => {
-    const circular: { self?: unknown } = {};
-    circular.self = circular;
-    const sanitized = sanitizeArgs([
-      new Error("boom"),
-      () => {},
-      circular,
-      1n,
-    ]);
-    expect(() => JSON.stringify(sanitized)).not.toThrow();
-    expect(sanitized[0]).toEqual(
-      expect.objectContaining({ name: "Error", message: "boom" }),
-    );
-    expect(sanitized[2]).toEqual(
-      expect.objectContaining({ self: "[Circular]" }),
-    );
-  });
-
-  it("caps oversized strings so a fat console.log cannot blow the snapshot", () => {
-    const huge = "x".repeat(SNAPSHOT_STRING_LIMIT + 50_000);
-    const sanitized = sanitizeArgs([huge]);
-    expect(typeof sanitized[0]).toBe("string");
-    expect((sanitized[0] as string).length).toBeLessThan(huge.length);
-    expect((sanitized[0] as string).startsWith("x".repeat(32))).toBe(true);
-    expect(capString("short")).toBe("short");
-  });
-});
-
-describe("consoleSyncAdapter", () => {
-  it("snapshots { entries } as JSON and clearEntries does not hang", () => {
-    expect(consoleSyncAdapter.version).toBe(1);
-    clearEntries();
-    const snapshot = consoleSyncAdapter.getSnapshot();
-    expect(snapshot).toEqual({ entries: expect.any(Array) });
-    expect(() => JSON.stringify(snapshot)).not.toThrow();
-    expect(consoleSyncAdapter.actions.clearEntries()).toEqual({ cleared: true });
-    expect(consoleSyncAdapter.getSnapshot()).toEqual({ entries: [] });
-  });
-
-  it("does not drop the console snapshot when one log is multi-MB", () => {
-    const huge = "x".repeat(3 * 1024 * 1024);
-    replaceEntries([
-      entry({
-        id: 1,
-        args: [huge],
-        message: huge,
-      }),
-    ]);
-
-    const snapshot = consoleSyncAdapter.getSnapshot();
-    expect(snapshot.entries).toHaveLength(1);
-    expect(snapshot.entries[0]?.id).toBe(1);
-    expect(snapshot.entries[0]?.method).toBe("log");
-    expect(String(snapshot.entries[0]?.args[0]).length).toBeLessThan(huge.length);
-    expect(snapshot.entries[0]?.message.length).toBeLessThan(huge.length);
-    expect(() => JSON.stringify(snapshot)).not.toThrow();
-    expect(JSON.stringify(snapshot).length).toBeLessThan(2 * 1024 * 1024);
-  });
-
-  it("keeps a burst of fat logs under the 2MB emit budget", () => {
-    const huge = "x".repeat(20 * 1024);
-    replaceEntries(
-      Array.from({ length: 80 }, (_, i) =>
-        entry({
-          id: i + 1,
-          args: [huge],
-          message: huge,
-        }),
-      ),
-    );
-
-    const snapshot = consoleSyncAdapter.getSnapshot();
-    expect(snapshot.entries.length).toBeGreaterThan(0);
-    expect(snapshot.entries[snapshot.entries.length - 1]?.id).toBe(80);
-    expect(JSON.stringify(snapshot).length).toBeLessThan(2 * 1024 * 1024);
-  });
-
-  // ---------------------------------------------------------------------
-  // Cost guard. The snapshot is rebuilt ~5x/sec while a dashboard watches,
-  // and `sanitizeArgs` deep-copies every argument to make it JSON-safe — so
-  // WHETHER that copy is redone per tick is part of the contract. Measured at
-  // 12.6ms/tick on 1000 ordinary object logs before this cache, and note that
-  // cost predates the size guards entirely.
-  // ---------------------------------------------------------------------
-
-  it("reuses the wire form of an unchanged entry across snapshots", () => {
-    replaceEntries([
-      entry({ id: 1, message: "hello", args: ["hello"] }),
-      entry({
-        id: 2,
-        message: "payload",
-        args: ["payload", { rows: Array.from({ length: 40 }, (_, i) => ({ i })) }],
-      }),
-    ]);
-
-    const first = consoleSyncAdapter.getSnapshot().entries;
-    const second = consoleSyncAdapter.getSnapshot().entries;
-    // Identity, not deep equality: a fresh sanitized copy per tick is exactly
-    // the waste this guards, and the desktop mirror also feeds these into
-    // effect dependencies.
-    expect(second[0]).toBe(first[0]);
-    expect(second[1]).toBe(first[1]);
-  });
-
-  it("keeps the newest entries when the budget forces a cut", () => {
-    // 1000 logs of a ~4KB object are each individually legal and still total
-    // over the 2MB emit budget, which would drop the WHOLE console panel.
-    replaceEntries(
-      Array.from({ length: 1000 }, (_, i) =>
-        entry({
-          id: i,
-          message: `line ${i}`,
-          // ~4KB each: individually far under the per-entry cap, and 1000 of
-          // them still exceed the snapshot budget.
-          args: [`line ${i}`, { blob: "p".repeat(4 * 1024) }],
-        }),
-      ),
-    );
-
-    const { entries } = consoleSyncAdapter.getSnapshot();
-    expect(JSON.stringify({ entries }).length).toBeLessThan(2 * 1024 * 1024);
-    // Not a drop, and not everything — the budget genuinely bit.
-    expect(entries.length).toBeGreaterThan(0);
-    expect(entries.length).toBeLessThan(1000);
-    // A console reader cares about the most RECENT lines, so those survive.
-    expect(entries[entries.length - 1]?.id).toBe(999);
-  });
-});