@buoy-gg/shared-ui 7.0.40 → 7.0.42

package/lib/module/stores/createToolStore.js

@@ -1,189 +1 @@
-"use strict";
-
-import { getAccountAccess, hasAccountAccess, subscribeAccountAccess } from "../license/licenseModule.js";
-/**
- * createToolStore — the one bounded, subscribable buffer every tool used to
- * hand-roll.
- *
- * Before this existed, console, sentry, images, assets, focus-inspector,
- * tv-remote, redux, zustand, jotai and react-query each carried their own copy
- * of the same ~100 lines: a `Set` of listeners, a `Set` of clear listeners
- * (so the desktop dashboard can forward a clear to the device in mirror
- * mode), a ring buffer with a max, an optional frame-coalesced emit, and the
- * `__buoyFlushToolSync` escape hatch that pushes a tool's snapshot to the
- * dashboard NOW (a crash's last words must not wait on the sync throttle).
- *
- * This is a plain function, not a class, on purpose: every consumer exposes a
- * module-level functional API (`subscribe`, `getSnapshot`, `clearX`) and
- * feeds `useSyncExternalStore`, so the store is a value the module wraps
- * rather than something it extends. `BaseEventStore` stays for the
- * class-based, auto-start/stop capture stores (network, storage, routes).
- *
- * Contract:
- * - `getSnapshot()` returns the SAME array reference until the next
- *   mutation, so `useSyncExternalStore` never re-renders for nothing.
- * - `order: "append"` keeps the newest item LAST (console-style scrollback);
- *   `order: "prepend"` keeps it FIRST (event-log style). Trimming drops from
- *   the opposite end. Consumers never have to `.reverse()`.
- * - `clear()` fires `onClear` listeners even when the buffer is already
- *   empty — the dashboard's forwarded clear must reach the device regardless.
- * - `set()` (mirror mode) never fires clear listeners; it is a replacement.
- */
-
-/** Listener signature: change-only, read the snapshot yourself. */
-
-function scheduleFrame(cb) {
-  if (typeof requestAnimationFrame === "function") {
-    requestAnimationFrame(() => cb());
-  } else {
-    setTimeout(cb, 0);
-  }
-}
-export function createToolStore(options) {
-  const id = options.id;
-  const order = options.order ?? "append";
-  const coalesce = options.coalesce ?? "sync";
-  const flushMinIntervalMs = options.flushMinIntervalMs ?? 150;
-  let max = options.max;
-  let items = [];
-  let paused = false;
-  let nextId = options.firstId ?? 1;
-  let lastFlushAt = 0;
-  let emitScheduled = false;
-  const empty = [];
-  let observing = false;
-  function observe() {
-    if (observing) return;
-    observing = true;
-    subscribeAccountAccess(() => {
-      if (getAccountAccess().status === "locked") items = [];
-      emit();
-    });
-  }
-  const listeners = new Set();
-  const clearListeners = new Set();
-  function fire() {
-    for (const listener of listeners) {
-      try {
-        listener();
-      } catch {
-        // A broken subscriber must not take the store (or a crash path) down.
-      }
-    }
-  }
-  function emit() {
-    if (coalesce === "sync") {
-      fire();
-      return;
-    }
-    if (emitScheduled) return;
-    emitScheduled = true;
-    scheduleFrame(() => {
-      emitScheduled = false;
-      fire();
-    });
-  }
-  function trim(list) {
-    if (list.length <= max) return list;
-    return order === "append" ? list.slice(list.length - max) : list.slice(0, max);
-  }
-  const store = {
-    id,
-    subscribe(listener) {
-      observe();
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-    getSnapshot() {
-      observe();
-      return hasAccountAccess() ? items : empty;
-    },
-    size() {
-      return hasAccountAccess() ? items.length : 0;
-    },
-    add(item) {
-      observe();
-      if (paused || getAccountAccess().status === "locked") return;
-      if (order === "append") {
-        items = items.length >= max ? [...items.slice(items.length - max + 1), item] : [...items, item];
-      } else {
-        items = items.length >= max ? [item, ...items.slice(0, max - 1)] : [item, ...items];
-      }
-      emit();
-    },
-    set(next) {
-      observe();
-      if (!hasAccountAccess()) return;
-      items = trim(next);
-      emit();
-    },
-    update(fn) {
-      observe();
-      if (getAccountAccess().status === "locked") return;
-      items = trim(fn(items));
-      emit();
-    },
-    clear() {
-      for (const listener of clearListeners) {
-        try {
-          listener();
-        } catch {
-          // ignore
-        }
-      }
-      if (items.length === 0) return;
-      items = [];
-      emit();
-    },
-    onClear(listener) {
-      clearListeners.add(listener);
-      return () => {
-        clearListeners.delete(listener);
-      };
-    },
-    notify() {
-      emit();
-    },
-    flushSync(force = false) {
-      const now = Date.now();
-      if (!force && now - lastFlushAt < flushMinIntervalMs) return;
-      lastFlushAt = now;
-      try {
-        const set = globalThis.__buoyFlushToolSync;
-        if (!set) return;
-        for (const flush of set) flush(id);
-      } catch {
-        // Best-effort: a crash path must never crash.
-      }
-    },
-    setPaused(next) {
-      paused = next;
-    },
-    isPaused() {
-      return paused;
-    },
-    setMax(next) {
-      max = next;
-      const trimmed = trim(items);
-      if (trimmed !== items) {
-        items = trimmed;
-        emit();
-      }
-    },
-    getMax() {
-      return max;
-    },
-    allocId() {
-      return nextId++;
-    },
-    bumpIdAbove(idFloor) {
-      if (idFloor + 1 > nextId) nextId = idFloor + 1;
-    },
-    listenerCount() {
-      return listeners.size;
-    }
-  };
-  return store;
-}
+"use strict";import{getAccountAccess as h,hasAccountAccess as m,subscribeAccountAccess as F}from"../license/licenseModule.js";function T(n){if(typeof requestAnimationFrame==="function"){requestAnimationFrame(()=>n())}else{setTimeout(n,0)}}export function createToolStore(n){const g=n.id;const y=n.order??"append";const x=n.coalesce??"sync";const I=n.flushMinIntervalMs??150;let r=n.max;let t=[];let l=false;let a=n.firstId??1;let A=0;let f=false;const M=[];let b=false;function c(){if(b)return;b=true;F(()=>{if(h().status==="locked")t=[];s()})}const o=new Set;const i=new Set;function p(){for(const e of o){try{e()}catch{}}}function s(){if(x==="sync"){p();return}if(f)return;f=true;T(()=>{f=false;p()})}function d(e){if(e.length<=r)return e;return y==="append"?e.slice(e.length-r):e.slice(0,r)}const v={id:g,subscribe(e){c();o.add(e);return()=>{o.delete(e)}},getSnapshot(){c();return m()?t:M},size(){return m()?t.length:0},add(e){c();if(l||h().status==="locked")return;if(y==="append"){t=t.length>=r?[...t.slice(t.length-r+1),e]:[...t,e]}else{t=t.length>=r?[e,...t.slice(0,r-1)]:[e,...t]}s()},set(e){c();if(!m())return;t=d(e);s()},update(e){c();if(h().status==="locked")return;t=d(e(t));s()},clear(){for(const e of i){try{e()}catch{}}if(t.length===0)return;t=[];s()},onClear(e){i.add(e);return()=>{i.delete(e)}},notify(){s()},flushSync(e=false){const u=Date.now();if(!e&&u-A<I)return;A=u;try{const S=globalThis.__buoyFlushToolSync;if(!S)return;for(const w of S)w(g)}catch{}},setPaused(e){l=e},isPaused(){return l},setMax(e){r=e;const u=d(t);if(u!==t){t=u;s()}},getMax(){return r},allocId(){return a++},bumpIdAbove(e){if(e+1>a)a=e+1},listenerCount(){return o.size}};return v}

package/lib/module/stores/floatingToolStore.js

@@ -1,61 +1 @@
-"use strict";
-
-let entries = [];
-let revision = 0;
-const listeners = new Set();
-const notify = () => listeners.forEach(listener => listener());
-export const getFloatingTools = () => entries;
-export const subscribeFloatingTools = listener => {
-  listeners.add(listener);
-  return () => {
-    listeners.delete(listener);
-  };
-};
-
-/** Open or restore one tool. Mount FloatingToolHost once at the application root. */
-export function openFloatingTool(tool) {
-  if (!tool.id.trim()) throw new Error("Floating tools need a non-empty id");
-  const entry = {
-    ...tool,
-    revealToken: ++revision
-  };
-  entries = entries.some(value => value.id === tool.id) ? entries.map(value => value.id === tool.id ? entry : value) : [...entries, entry];
-  notify();
-}
-
-/** Removes the UI only. Tool actions such as Stop belong to the tool's own controller. */
-export function dismissFloatingTool(id) {
-  if (!entries.some(entry => entry.id === id)) return;
-  entries = entries.filter(entry => entry.id !== id);
-  notify();
-}
-
-/** Register at app startup to restore an open tool using its existing position storage. */
-export function registerPersistentFloatingTool(tool, storage) {
-  if (!tool.id.trim()) throw new Error("Floating tools need a non-empty id");
-  const key = `@buoy/floating-tool/${tool.id}/open`;
-  let disposed = false;
-  let changed = false;
-  let wasOpen = entries.some(entry => entry.id === tool.id);
-  let writes = Promise.resolve();
-  const unsubscribe = subscribeFloatingTools(() => {
-    const isOpen = entries.some(entry => entry.id === tool.id);
-    if (isOpen === wasOpen) return;
-    wasOpen = isOpen;
-    changed = true;
-    writes = writes.then(() => storage.setItem(key, isOpen ? "1" : "0")).then(() => {}, () => {});
-  });
-  void storage.getItem(key).then(saved => {
-    if (disposed || changed || wasOpen || saved !== "1") return;
-    // Zero restores the saved hidden state; explicit opens still reveal the tool.
-    entries = [...entries, {
-      ...tool,
-      revealToken: 0
-    }];
-    notify();
-  }).catch(() => {});
-  return () => {
-    disposed = true;
-    unsubscribe();
-  };
-}
+"use strict";let t=[];let m=0;const s=new Set;const d=()=>s.forEach(e=>e());export const getFloatingTools=()=>t;export const subscribeFloatingTools=e=>{s.add(e);return()=>{s.delete(e)}};export function openFloatingTool(e){if(!e.id.trim())throw new Error("Floating tools need a non-empty id");const n={...e,revealToken:++m};t=t.some(i=>i.id===e.id)?t.map(i=>i.id===e.id?n:i):[...t,n];d()}export function dismissFloatingTool(e){if(!t.some(n=>n.id===e))return;t=t.filter(n=>n.id!==e);d()}export function registerPersistentFloatingTool(e,n){if(!e.id.trim())throw new Error("Floating tools need a non-empty id");const i=`@buoy/floating-tool/${e.id}/open`;let l=false;let a=false;let r=t.some(o=>o.id===e.id);let c=Promise.resolve();const f=subscribeFloatingTools(()=>{const o=t.some(u=>u.id===e.id);if(o===r)return;r=o;a=true;c=c.then(()=>n.setItem(i,o?"1":"0")).then(()=>{},()=>{})});void n.getItem(i).then(o=>{if(l||a||r||o!=="1")return;t=[...t,{...e,revealToken:0}];d()}).catch(()=>{});return()=>{l=true;f()}}

package/lib/module/stores/floatingToolStore.test.js

@@ -1,111 +1 @@
-"use strict";
-
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { dismissFloatingTool, getFloatingTools, openFloatingTool, subscribeFloatingTools } from "./floatingToolStore.js";
-afterEach(() => getFloatingTools().forEach(tool => dismissFloatingTool(tool.id)));
-describe("floating tool registry", () => {
-  it("restores an existing id and keeps other tools intact", () => {
-    openFloatingTool({
-      id: "network",
-      render: () => null
-    });
-    openFloatingTool({
-      id: "recorder",
-      render: () => null
-    });
-    const first = getFloatingTools()[0].revealToken;
-    const other = getFloatingTools()[1];
-    openFloatingTool({
-      id: "network",
-      render: () => "updated"
-    });
-    expect(getFloatingTools()).toHaveLength(2);
-    expect(getFloatingTools()[0].revealToken).toBeGreaterThan(first);
-    expect(getFloatingTools()[1]).toBe(other);
-  });
-  it("publishes stable snapshots and isolates dismissal", () => {
-    const listener = vi.fn();
-    const unsubscribe = subscribeFloatingTools(listener);
-    openFloatingTool({
-      id: "one",
-      render: () => null
-    });
-    const snapshot = getFloatingTools();
-    expect(getFloatingTools()).toBe(snapshot);
-    dismissFloatingTool("missing");
-    expect(listener).toHaveBeenCalledTimes(1);
-    openFloatingTool({
-      id: "two",
-      render: () => null
-    });
-    dismissFloatingTool("one");
-    expect(getFloatingTools().map(tool => tool.id)).toEqual(["two"]);
-    unsubscribe();
-    dismissFloatingTool("two");
-    expect(listener).toHaveBeenCalledTimes(3);
-  });
-  it("rejects missing tool identities", () => {
-    expect(() => openFloatingTool({
-      id: "  ",
-      render: () => null
-    })).toThrow("non-empty id");
-    expect(getFloatingTools()).toHaveLength(0);
-  });
-});
-describe("persistent floating tools", () => {
-  it("restores after a fresh registry loads and remembers dismissal", async () => {
-    const values = new Map();
-    const storage = {
-      getItem: vi.fn(async key => values.get(key) ?? null),
-      setItem: vi.fn(async (key, value) => {
-        values.set(key, value);
-      })
-    };
-    const tool = {
-      id: "persisted",
-      render: () => null
-    };
-    vi.resetModules();
-    const first = await import("./floatingToolStore");
-    const disposeFirst = first.registerPersistentFloatingTool(tool, storage);
-    first.openFloatingTool(tool);
-    await vi.waitFor(() => expect(values.get("@buoy/floating-tool/persisted/open")).toBe("1"));
-    disposeFirst();
-    vi.resetModules();
-    const second = await import("./floatingToolStore");
-    const disposeSecond = second.registerPersistentFloatingTool(tool, storage);
-    await vi.waitFor(() => expect(second.getFloatingTools()).toHaveLength(1));
-    expect(second.getFloatingTools()[0].revealToken).toBe(0);
-    second.dismissFloatingTool(tool.id);
-    await vi.waitFor(() => expect(values.get("@buoy/floating-tool/persisted/open")).toBe("0"));
-    disposeSecond();
-    vi.resetModules();
-    const third = await import("./floatingToolStore");
-    const disposeThird = third.registerPersistentFloatingTool(tool, storage);
-    await Promise.resolve();
-    expect(third.getFloatingTools()).toHaveLength(0);
-    disposeThird();
-  });
-  it("does not reopen a tool closed while its saved state was loading", async () => {
-    vi.resetModules();
-    const registry = await import("./floatingToolStore");
-    let resolve;
-    const storage = {
-      getItem: () => new Promise(done => {
-        resolve = done;
-      }),
-      setItem: vi.fn(async () => {})
-    };
-    const tool = {
-      id: "race",
-      render: () => null
-    };
-    const dispose = registry.registerPersistentFloatingTool(tool, storage);
-    registry.openFloatingTool(tool);
-    registry.dismissFloatingTool(tool.id);
-    resolve("1");
-    await vi.waitFor(() => expect(storage.setItem).toHaveBeenLastCalledWith("@buoy/floating-tool/race/open", "0"));
-    expect(registry.getFloatingTools()).toHaveLength(0);
-    dispose();
-  });
-});
+"use strict";import{afterEach as h,describe as T,expect as t,it as d,vi as o}from"vitest";import{dismissFloatingTool as g,getFloatingTools as n,openFloatingTool as l,subscribeFloatingTools as f}from"./floatingToolStore.js";h(()=>n().forEach(e=>g(e.id)));T("floating tool registry",()=>{d("restores an existing id and keeps other tools intact",()=>{l({id:"network",render:()=>null});l({id:"recorder",render:()=>null});const e=n()[0].revealToken;const s=n()[1];l({id:"network",render:()=>"updated"});t(n()).toHaveLength(2);t(n()[0].revealToken).toBeGreaterThan(e);t(n()[1]).toBe(s)});d("publishes stable snapshots and isolates dismissal",()=>{const e=o.fn();const s=f(e);l({id:"one",render:()=>null});const i=n();t(n()).toBe(i);g("missing");t(e).toHaveBeenCalledTimes(1);l({id:"two",render:()=>null});g("one");t(n().map(r=>r.id)).toEqual(["two"]);s();g("two");t(e).toHaveBeenCalledTimes(3)});d("rejects missing tool identities",()=>{t(()=>l({id:"  ",render:()=>null})).toThrow("non-empty id");t(n()).toHaveLength(0)})});T("persistent floating tools",()=>{d("restores after a fresh registry loads and remembers dismissal",async()=>{const e=new Map;const s={getItem:o.fn(async p=>e.get(p)??null),setItem:o.fn(async(p,F)=>{e.set(p,F)})};const i={id:"persisted",render:()=>null};o.resetModules();const r=await import("./floatingToolStore");const c=r.registerPersistentFloatingTool(i,s);r.openFloatingTool(i);await o.waitFor(()=>t(e.get("@buoy/floating-tool/persisted/open")).toBe("1"));c();o.resetModules();const a=await import("./floatingToolStore");const u=a.registerPersistentFloatingTool(i,s);await o.waitFor(()=>t(a.getFloatingTools()).toHaveLength(1));t(a.getFloatingTools()[0].revealToken).toBe(0);a.dismissFloatingTool(i.id);await o.waitFor(()=>t(e.get("@buoy/floating-tool/persisted/open")).toBe("0"));u();o.resetModules();const m=await import("./floatingToolStore");const w=m.registerPersistentFloatingTool(i,s);await Promise.resolve();t(m.getFloatingTools()).toHaveLength(0);w()});d("does not reopen a tool closed while its saved state was loading",async()=>{o.resetModules();const e=await import("./floatingToolStore");let s;const i={getItem:()=>new Promise(a=>{s=a}),setItem:o.fn(async()=>{})};const r={id:"race",render:()=>null};const c=e.registerPersistentFloatingTool(r,i);e.openFloatingTool(r);e.dismissFloatingTool(r.id);s("1");await o.waitFor(()=>t(i.setItem).toHaveBeenLastCalledWith("@buoy/floating-tool/race/open","0"));t(e.getFloatingTools()).toHaveLength(0);c()})});

package/lib/module/stores/ignoredPatternsCore.js

@@ -1,69 +1 @@
-"use strict";
-
-/**
- * Pure, dependency-free part of the ignored-patterns feature — split from
- * ignoredPatternsStore.ts so web consumers (which shim `@buoy-gg/shared-ui`
- * and must not pull the store's relative `../utils/persistentStorage` import
- * with its expo/async-storage requires into the bundle graph) can share the
- * exact matching semantics. The store imports and re-exports everything here;
- * the native barrel is unchanged.
- */
-
-/**
- * How a pattern matches a URL:
- *
- * - `contains`: case-insensitive substring match on the full URL (legacy behavior).
- * - `exact`: smart equality — if pattern starts with `/`, matches URL.pathname;
- *   if it starts with `http://`/`https://`, matches origin+pathname; otherwise
- *   matches URL.host.
- */
-
-/** A single exclude pattern with its match mode. */
-
-/**
- * Patterns hidden by default — Buoy's own license traffic. License checks go
- * to buoy.gg/api/license (7.0.39+); older SDKs called api.keygen.sh directly,
- * and a persisted list from then still names it.
- */
-export const DEFAULT_IGNORED_PATTERNS = [{
-  value: "buoy.gg/api/license",
-  mode: "contains"
-}, {
-  value: "api.keygen.sh",
-  mode: "contains"
-}];
-
-/**
- * Returns true when `url` matches the ignored `pattern` according to its mode.
- *
- * `contains` → case-insensitive substring on the full URL (legacy behavior).
- * `exact`    → smart equality: pattern starting with `/` compares URL.pathname,
- *              full URLs compare origin+pathname (ignoring query/hash), bare
- *              values compare URL.host. Falls back to literal equality if URL
- *              parsing fails (e.g. relative URLs).
- */
-export function urlMatchesIgnoredPattern(url, pattern) {
-  const lowerUrl = url.toLowerCase();
-  const lowerValue = pattern.value.toLowerCase();
-  if (pattern.mode === "contains") {
-    return lowerUrl.includes(lowerValue);
-  }
-  try {
-    const parsed = new URL(url);
-    if (lowerValue.startsWith("/")) {
-      return parsed.pathname.toLowerCase() === lowerValue;
-    }
-    if (lowerValue.startsWith("http://") || lowerValue.startsWith("https://")) {
-      return `${parsed.origin}${parsed.pathname}`.toLowerCase() === lowerValue;
-    }
-    return parsed.host.toLowerCase() === lowerValue;
-  } catch {
-    return lowerUrl === lowerValue;
-  }
-}
-
-/** Convenience: does `url` match ANY of the ignored `patterns`? */
-export function isUrlIgnored(url, patterns) {
-  if (!url || patterns.length === 0) return false;
-  return patterns.some(pattern => urlMatchesIgnoredPattern(url, pattern));
-}
+"use strict";export const DEFAULT_IGNORED_PATTERNS=[{value:"buoy.gg/api/license",mode:"contains"},{value:"api.keygen.sh",mode:"contains"}];export function urlMatchesIgnoredPattern(t,o){const r=t.toLowerCase();const e=o.value.toLowerCase();if(o.mode==="contains"){return r.includes(e)}try{const n=new URL(t);if(e.startsWith("/")){return n.pathname.toLowerCase()===e}if(e.startsWith("http://")||e.startsWith("https://")){return`${n.origin}${n.pathname}`.toLowerCase()===e}return n.host.toLowerCase()===e}catch{return r===e}}export function isUrlIgnored(t,o){if(!t||o.length===0)return false;return o.some(r=>urlMatchesIgnoredPattern(t,r))}

package/lib/module/stores/ignoredPatternsStore.js

@@ -1,189 +1 @@
-"use strict";
-
-/**
- * Shared "ignored patterns" store for network-style URL filtering.
- *
- * This is the SINGLE source of truth for the domains/URL patterns that the
- * Network tool (and now the Events tool) hide from their lists. Both tools read
- * and mutate this one singleton, so an ignore toggled in either place is shared
- * everywhere and persisted to the same storage key.
- *
- * Lives in @buoy-gg/shared-ui (a hard dependency of both @buoy-gg/network and
- * @buoy-gg/events) so the filter logic can be shared without @buoy-gg/events
- * having to take a hard dependency on @buoy-gg/network (which is optional).
- */
-
-import { useEffect, useMemo, useState } from "react";
-import { persistentStorage } from "../utils/persistentStorage.js";
-import { devToolsStorageKeys } from "../storage/devToolsStorageKeys.js";
-
-// Pure matching types/helpers live in ignoredPatternsCore.ts (web-shim-safe);
-// re-exported here so the shared-ui barrel surface is unchanged.
-import { DEFAULT_IGNORED_PATTERNS } from "./ignoredPatternsCore.js";
-export { urlMatchesIgnoredPattern, isUrlIgnored } from "./ignoredPatternsCore.js";
-const DEFAULT_PATTERNS = DEFAULT_IGNORED_PATTERNS;
-
-/** Tolerate the legacy `string[]` persisted format and stray junk. */
-function migratePatterns(raw) {
-  if (!Array.isArray(raw)) return [];
-  const migrated = [];
-  for (const entry of raw) {
-    if (typeof entry === "string" && entry.trim()) {
-      migrated.push({
-        value: entry,
-        mode: "contains"
-      });
-    } else if (entry && typeof entry === "object" && typeof entry.value === "string") {
-      const e = entry;
-      migrated.push({
-        value: e.value,
-        mode: e.mode === "exact" ? "exact" : "contains"
-      });
-    }
-  }
-  return migrated;
-}
-
-/** Always keep the default patterns present (e.g. Buoy's license API). */
-function ensureDefaults(patterns) {
-  const result = [...patterns];
-  for (const def of DEFAULT_PATTERNS) {
-    if (!result.some(p => p.value === def.value)) {
-      result.push({
-        ...def
-      });
-    }
-  }
-  return result;
-}
-/**
- * Singleton store. One instance per JS runtime, so every consumer (Network tool,
- * Events tool, on mobile or on the desktop dashboard) shares the same patterns.
- */
-class IgnoredPatternsStore {
-  patterns = ensureDefaults(DEFAULT_PATTERNS.map(p => ({
-    ...p
-  })));
-  listeners = new Set();
-  loaded = false;
-  loadPromise = null;
-  /** Set once a mutation happens so a slow initial load can't clobber it. */
-  dirty = false;
-
-  /** Current patterns (stable reference until a mutation occurs). */
-  getPatterns() {
-    return this.patterns;
-  }
-  subscribe(listener) {
-    this.listeners.add(listener);
-    // Lazily hydrate from storage the first time anyone cares.
-    void this.ensureLoaded();
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-  emit() {
-    this.listeners.forEach(l => l());
-  }
-  ensureLoaded() {
-    if (this.loaded) return Promise.resolve();
-    if (this.loadPromise) return this.loadPromise;
-    this.loadPromise = (async () => {
-      try {
-        const stored = await persistentStorage.getItem(devToolsStorageKeys.network.ignoredDomains());
-        // A mutation may have raced this read — never overwrite user intent.
-        if (stored && !this.dirty) {
-          const migrated = ensureDefaults(migratePatterns(JSON.parse(stored)));
-          this.patterns = migrated;
-        }
-      } catch {
-        // Silently fall back to defaults.
-      } finally {
-        this.loaded = true;
-        this.emit();
-      }
-    })();
-    return this.loadPromise;
-  }
-  persist() {
-    persistentStorage.setItem(devToolsStorageKeys.network.ignoredDomains(), JSON.stringify(this.patterns)).catch(() => {
-      // Silently fail — patterns remain in memory.
-    });
-  }
-  commit(next) {
-    this.dirty = true;
-    this.patterns = next;
-    this.emit();
-    this.persist();
-  }
-
-  /** Add a pattern (no-op if its value already exists). */
-  add(pattern) {
-    const value = pattern.value.trim();
-    if (!value) return;
-    if (this.patterns.some(p => p.value === value)) return;
-    this.commit([...this.patterns, {
-      value,
-      mode: pattern.mode
-    }]);
-  }
-
-  /** Remove a pattern by value. */
-  remove(value) {
-    if (!this.patterns.some(p => p.value === value)) return;
-    this.commit(this.patterns.filter(p => p.value !== value));
-  }
-
-  /** Add as `contains` if absent, otherwise remove (used by detail-view chips). */
-  toggle(value) {
-    const trimmed = value.trim();
-    if (!trimmed) return;
-    this.commit(this.patterns.some(p => p.value === trimmed) ? this.patterns.filter(p => p.value !== trimmed) : [...this.patterns, {
-      value: trimmed,
-      mode: "contains"
-    }]);
-  }
-
-  /** Flip an existing pattern between `contains` and `exact`. */
-  toggleMode(value) {
-    if (!this.patterns.some(p => p.value === value)) return;
-    this.commit(this.patterns.map(p => p.value === value ? {
-      ...p,
-      mode: p.mode === "contains" ? "exact" : "contains"
-    } : p));
-  }
-}
-export const ignoredPatternsStore = new IgnoredPatternsStore();
-/**
- * Mutations live at module scope so they keep a STABLE identity across
- * renders. They used to be inline arrows in the return object, which handed
- * every consumer a fresh `toggle` on each render and defeated `memo` on
- * anything they were passed down to — measured on the network detail view,
- * where it forced a full re-render of the inspector per step.
- */
-const addPattern = pattern => ignoredPatternsStore.add(pattern);
-const removePattern = value => ignoredPatternsStore.remove(value);
-const togglePattern = value => ignoredPatternsStore.toggle(value);
-const togglePatternMode = value => ignoredPatternsStore.toggleMode(value);
-
-/**
- * Subscribe to the shared ignored-patterns store. All consumers in a runtime
- * see the same patterns and the same mutations.
- */
-export function useIgnoredPatterns() {
-  const [patterns, setPatterns] = useState(() => ignoredPatternsStore.getPatterns());
-  useEffect(() => {
-    return ignoredPatternsStore.subscribe(() => {
-      setPatterns(ignoredPatternsStore.getPatterns());
-    });
-  }, []);
-  const values = useMemo(() => new Set(patterns.map(p => p.value)), [patterns]);
-  return {
-    patterns,
-    values,
-    add: addPattern,
-    remove: removePattern,
-    toggle: togglePattern,
-    toggleMode: togglePatternMode
-  };
-}
+"use strict";export*from"./ignoredPatternsStore.shared.js";

package/lib/module/stores/ignoredPatternsStore.shared.js

@@ -0,0 +1 @@
+"use strict";import{useEffect as m,useMemo as d,useState as u}from"react";import{persistentStorage as o}from"../utils/persistentStorage";import{devToolsStorageKeys as i}from"../storage/devToolsStorageKeys.js";import{DEFAULT_IGNORED_PATTERNS as l}from"./ignoredPatternsCore.js";export{urlMatchesIgnoredPattern,isUrlIgnored}from"./ignoredPatternsCore.js";const n=l;function c(s){if(!Array.isArray(s))return[];const e=[];for(const t of s){if(typeof t==="string"&&t.trim()){e.push({value:t,mode:"contains"})}else if(t&&typeof t==="object"&&typeof t.value==="string"){const r=t;e.push({value:r.value,mode:r.mode==="exact"?"exact":"contains"})}}return e}function a(s){const e=[...s];for(const t of n){if(!e.some(r=>r.value===t.value)){e.push({...t})}}return e}class h{patterns=a(n.map(e=>({...e})));listeners=new Set;loaded=false;loadPromise=null;dirty=false;getPatterns(){return this.patterns}subscribe(e){this.listeners.add(e);void this.ensureLoaded();return()=>{this.listeners.delete(e)}}emit(){this.listeners.forEach(e=>e())}ensureLoaded(){if(this.loaded)return Promise.resolve();if(this.loadPromise)return this.loadPromise;this.loadPromise=(async()=>{try{const e=await o.getItem(i.network.ignoredDomains());if(e&&!this.dirty){const t=a(c(JSON.parse(e)));this.patterns=t}}catch{}finally{this.loaded=true;this.emit()}})();return this.loadPromise}persist(){o.setItem(i.network.ignoredDomains(),JSON.stringify(this.patterns)).catch(()=>{})}commit(e){this.dirty=true;this.patterns=e;this.emit();this.persist()}add(e){const t=e.value.trim();if(!t)return;if(this.patterns.some(r=>r.value===t))return;this.commit([...this.patterns,{value:t,mode:e.mode}])}remove(e){if(!this.patterns.some(t=>t.value===e))return;this.commit(this.patterns.filter(t=>t.value!==e))}toggle(e){const t=e.trim();if(!t)return;this.commit(this.patterns.some(r=>r.value===t)?this.patterns.filter(r=>r.value!==t):[...this.patterns,{value:t,mode:"contains"}])}toggleMode(e){if(!this.patterns.some(t=>t.value===e))return;this.commit(this.patterns.map(t=>t.value===e?{...t,mode:t.mode==="contains"?"exact":"contains"}:t))}}export const ignoredPatternsStore=new h;const f=s=>ignoredPatternsStore.add(s);const g=s=>ignoredPatternsStore.remove(s);const p=s=>ignoredPatternsStore.toggle(s);const v=s=>ignoredPatternsStore.toggleMode(s);export function useIgnoredPatterns(){const[s,e]=u(()=>ignoredPatternsStore.getPatterns());m(()=>{return ignoredPatternsStore.subscribe(()=>{e(ignoredPatternsStore.getPatterns())})},[]);const t=d(()=>new Set(s.map(r=>r.value)),[s]);return{patterns:s,values:t,add:f,remove:g,toggle:p,toggleMode:v}}