@buoy-gg/network 7.0.3 → 7.0.5

package/lib/typescript/network/utils/networkSavedStore.d.ts

@@ -0,0 +1,186 @@
+/**
+ * Pinned + saved network requests.
+ *
+ * The live `networkEventStore` is volatile by design: it caps at 500 events
+ * and `clearEvents()` wipes it. So "pin this failure so I don't lose it"
+ * cannot be an ID pointing into that store — it has to be a SNAPSHOT that
+ * outlives the stream. This store owns those snapshots and persists them.
+ *
+ * Two independent flags per record:
+ *   - `pinned` — hoisted into the PINNED section at the top of the list,
+ *     unaffected by search/filters.
+ *   - `saved`  — kept in the Saved (favorites) screen, out of the live stream.
+ * A record exists while either flag is true and is dropped when both go false,
+ * so all four states fall out without special cases.
+ *
+ * IDENTITY WARNING: `networkListener` mints request IDs from a per-runtime
+ * counter (`fetch_1`, `xhr_2`), so after an app reload `fetch_1` is a
+ * DIFFERENT request. Records are therefore keyed on a generated `key`, carry
+ * the `sessionId` that captured them, and only trust `liveId` while that
+ * session is the current one. Snapshots restored from an earlier session get
+ * their event `id` rewritten to `saved:<key>` so a restored pin can never
+ * resolve to (or dedupe against) an unrelated live request.
+ *
+ * Shape/persistence follows `ignoredPatternsStore` in @buoy-gg/shared-ui:
+ * lazy hydrate on first subscribe, a `dirty` flag so a slow read can't clobber
+ * a mutation, and commit = set + emit + persist.
+ */
+import type { NetworkEvent } from "../types";
+/** Identifies THIS runtime. Records from other sessions can't trust `liveId`. */
+export declare const SESSION_ID: string;
+/** Pins render un-virtualized in the list header, so the count stays bounded. */
+export declare const MAX_PINNED = 25;
+/** Upper bound on the persisted favorites list (oldest unpinned evicted). */
+export declare const MAX_SAVED = 50;
+/** Free tier keeps a handful of favorites; Pro is unlimited (up to MAX_SAVED). */
+export declare const FREE_TIER_SAVED_LIMIT = 5;
+export interface SavedNetworkRecord {
+    /** Stable across app launches — unlike `event.id`. */
+    key: string;
+    /** Frozen snapshot; bodies may be truncated (see `bodyTruncated`). */
+    event: NetworkEvent;
+    pinned: boolean;
+    saved: boolean;
+    savedAt: number;
+    /** Runtime that captured the request. */
+    sessionId: string;
+    /** `event.id` within `sessionId` — meaningless in any other session. */
+    liveId: string;
+    /** A request/response body was too large to keep in full. */
+    bodyTruncated?: boolean;
+}
+export interface NetworkSavedState {
+    /** Every record, newest first. */
+    records: SavedNetworkRecord[];
+    /** Pinned records' snapshots, newest first — what the PINNED section renders. */
+    pinnedEvents: NetworkEvent[];
+    /** Saved records, newest first — what the Saved screen renders. */
+    savedRecords: SavedNetworkRecord[];
+    /** Live IDs pinned IN THIS SESSION (for row glyphs + list dedupe). */
+    pinnedLiveIds: Set<string>;
+    /** Live IDs saved IN THIS SESSION (for row glyphs). */
+    savedLiveIds: Set<string>;
+}
+/** Why a toggle didn't take effect, so the UI can explain itself. */
+export type SavedToggleResult = {
+    ok: true;
+    active: boolean;
+} | {
+    ok: false;
+    reason: "pin-cap" | "saved-cap" | "invalid-event";
+};
+/**
+ * Handlers the desktop dashboard installs to forward mutations to the device.
+ *
+ * The dashboard must not keep its own copy of the device's pins: the device is
+ * the only place the snapshots can stay in sync with the traffic that produced
+ * them (and the only place a >16KB body still exists). So in remote mode this
+ * store becomes a MIRROR — same seam `networkEventStore.disableCapture()` +
+ * `replaceEvents()` uses for the event list.
+ */
+export interface NetworkSavedRemote {
+    setPinned: (eventId: string, pinned: boolean) => void;
+    setSaved: (eventId: string, saved: boolean) => void;
+    removeRecord: (key: string) => void;
+    clearSaved: () => void;
+    clearPinned: () => void;
+}
+/**
+ * Read an event's flags out of a state snapshot.
+ *
+ * Two lookups because an event ID means two different things: a live request
+ * matches by `liveId` (the fast Set path), while a snapshot restored from an
+ * earlier session carries the namespaced `saved:<key>` id and has to be found
+ * among the records.
+ */
+export declare function flagsForEventId(state: NetworkSavedState, eventId: string | null): {
+    pinned: boolean;
+    saved: boolean;
+};
+type Listener = () => void;
+declare class NetworkSavedStore {
+    private records;
+    private readonly listeners;
+    private loaded;
+    private loadPromise;
+    /** Set once a mutation happens so a slow initial load can't clobber it. */
+    private dirty;
+    private keyCounter;
+    /**
+     * Live IDs tracked in THIS session. `syncFromLive` runs on every captured
+     * response, so the hot path has to be a Set membership test.
+     */
+    private trackedLiveIds;
+    /** Derived view, rebuilt on commit so consumers get stable references. */
+    private state;
+    /** Set on the desktop dashboard — see NetworkSavedRemote. */
+    private remote;
+    private remoteEchoUntil;
+    getState(): NetworkSavedState;
+    /**
+     * Turn this store into a mirror of a connected device's records. Mutations
+     * are applied locally for immediate feedback AND forwarded to the device,
+     * which is the source of truth; nothing is persisted to this machine.
+     */
+    enableRemoteMode(remote: NetworkSavedRemote): void;
+    disableRemoteMode(): void;
+    /**
+     * Feed the device's records in (mirror mode only). `force` bypasses the
+     * echo guard — used when tearing the mirror down, where there is no later
+     * snapshot to converge on.
+     */
+    replaceRecords(records: SavedNetworkRecord[], force?: boolean): void;
+    /**
+     * Whether a record's `liveId` can be trusted against the current event
+     * stream. Locally that means "captured in this runtime"; mirrored, the ids
+     * belong to the device whose events we are also mirroring, so they line up
+     * by construction.
+     */
+    private sessionMatches;
+    getRecords(): SavedNetworkRecord[];
+    subscribe(listener: Listener): () => void;
+    /**
+     * Resolve an event the live store no longer has — a pin whose request was
+     * cleared or aged out, or a snapshot restored from an earlier session.
+     */
+    getEventById(id: string): NetworkEvent | null;
+    isPinned(liveId: string): boolean;
+    isSaved(liveId: string): boolean;
+    /**
+     * Keep a tracked snapshot current while its request is still in flight —
+     * pinning a pending request would otherwise freeze it as "Pending" forever.
+     * Called from `networkEventStore` for every response/error, so the no-op
+     * path (nothing pinned) is a single empty-Set check.
+     */
+    syncFromLive(event: NetworkEvent): void;
+    togglePin(event: NetworkEvent): SavedToggleResult;
+    toggleSave(event: NetworkEvent): SavedToggleResult;
+    /** Drop a record outright, whatever its flags. */
+    remove(key: string): void;
+    /** Empty the favorites list; pinned-only records stay pinned. */
+    clearSaved(): void;
+    /** Unpin everything; saved-only records stay saved. */
+    clearPinned(): void;
+    private setFlag;
+    /**
+     * Match an event to its record: by live ID within this session, or by the
+     * namespaced snapshot ID when the row being toggled IS a restored snapshot.
+     */
+    private findRecordFor;
+    private hasRoomFor;
+    /** Trim the oldest UNPINNED saves once the list outgrows MAX_SAVED. */
+    private evictIfNeeded;
+    private ensureLoaded;
+    private persist;
+    private commit;
+    /** Rebuild the derived view once per mutation so renders get stable refs. */
+    private rebuild;
+    private emit;
+}
+/**
+ * Singleton — one instance per JS runtime, shared by the mobile modal, the
+ * desktop inline port and the sync adapter.
+ */
+export declare const networkSavedStore: NetworkSavedStore;
+export {};
+//# sourceMappingURL=networkSavedStore.d.ts.map

package/lib/typescript/network/utils/networkSavedStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"networkSavedStore.d.ts","sourceRoot":"","sources":["../../../../src/network/utils/networkSavedStore.ts"],"names":[],"mappings":"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"}

package/lib/typescript/network/utils/withPinnedFirst.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Split a filtered event list into its PINNED section and the rest.
+ *
+ * Lives as a pure function because there are TWO list implementations — the
+ * mobile modal's `NetworkListScreen` and the desktop dashboard's hand-mirrored
+ * `NetworkInline` — and pin ordering silently diverging between them is
+ * exactly the drift `buoy.tools.json` exists to prevent.
+ *
+ * Pins are deliberately NOT filtered: they come straight from the saved store,
+ * so a pinned request stays visible no matter what the search box or the
+ * status chips say. The only thing the filtered list contributes is the
+ * dedupe — a pinned request that is still live must not render twice.
+ */
+import type { NetworkEvent } from "../types";
+export interface PinnedSplit {
+    /** Pinned snapshots, newest first — rendered above the list. */
+    pinned: NetworkEvent[];
+    /** The filtered list minus anything already shown as a pin. */
+    rest: NetworkEvent[];
+}
+export declare function splitPinned(filtered: NetworkEvent[], pinnedEvents: NetworkEvent[], 
+/** Live IDs pinned in THIS session — from `networkSavedStore.getState()`. */
+pinnedLiveIds: Set<string>): PinnedSplit;
+//# sourceMappingURL=withPinnedFirst.d.ts.map

package/lib/typescript/network/utils/withPinnedFirst.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withPinnedFirst.d.ts","sourceRoot":"","sources":["../../../../src/network/utils/withPinnedFirst.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAI7C,MAAM,WAAW,WAAW;IAC1B,gEAAgE;IAChE,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,+DAA+D;IAC/D,IAAI,EAAE,YAAY,EAAE,CAAC;CACtB;AAED,wBAAgB,WAAW,CACzB,QAAQ,EAAE,YAAY,EAAE,EACxB,YAAY,EAAE,YAAY,EAAE;AAC5B,6EAA6E;AAC7E,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,GACzB,WAAW,CASb"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buoy-gg/network",
-  "version": "7.0.3",
+  "version": "7.0.5",
   "description": "In-app network inspector for React Native — requests, responses, timing & errors live, with GraphQL operation parsing. Part of Buoy devtools.",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",
@@ -26,7 +26,7 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@buoy-gg/shared-ui": "7.0.3"
+    "@buoy-gg/shared-ui": "7.0.5"
   },
   "peerDependencies": {
     "react": "*",