@buoy-gg/assets 7.0.29 → 7.0.31

package/src/index.tsx

@@ -1,87 +0,0 @@
-/**
- * @buoy-gg/assets — bundled-asset inventory for React Native / Expo.
- *
- * Enumerates every asset in the app (images, fonts, video, audio, …) via the
- * runtime asset registry, enriched in dev with the Metro graph (full-bundle
- * coverage, byte sizes, never-loaded detection) and on Expo with loaded font
- * families + the updates localAssets map. Zero configuration: importing this
- * package installs the (cheap, synchronous) registry capture.
- */
-
-// ---------------------------------------------------------------------------
-// Tool preset (FloatingDevTools)
-// ---------------------------------------------------------------------------
-export { assetsToolPreset, createAssetsTool } from "./preset";
-
-// ---------------------------------------------------------------------------
-// Components
-// ---------------------------------------------------------------------------
-export { AssetsModal, AssetsToolView } from "./components/AssetsModal";
-export { AssetsIcon, ASSETS_ICON_COLOR } from "./components/AssetsIcon";
-
-// ---------------------------------------------------------------------------
-// Capture / scanning
-// ---------------------------------------------------------------------------
-export { installAssetCapture, rescan, getScanStatus } from "./capture/install";
-export { measureSizes } from "./capture/measure";
-export { fetchAssetGraph, getDevServerOrigin } from "./capture/metroGraph";
-export { getLoadedFontFamilies, getLocalAssets } from "./capture/expo";
-
-// ---------------------------------------------------------------------------
-// Store
-// ---------------------------------------------------------------------------
-export {
-  clearRecords,
-  computeStats,
-  estDecodedBytes,
-  getRecord,
-  getSnapshot,
-  subscribe,
-} from "./store/assetStore";
-export { computeInsights } from "./store/insights";
-export {
-  clearBaseline,
-  computeDiff,
-  getDiff,
-  loadBaseline,
-  saveBaseline,
-} from "./store/baseline";
-export { useAssetRecords } from "./hooks/useAssetRecords";
-
-// ---------------------------------------------------------------------------
-// Reports
-// ---------------------------------------------------------------------------
-export { formatAssetMarkdown, formatInventoryMarkdown } from "./export";
-
-// ---------------------------------------------------------------------------
-// External sync (desktop dashboard + MCP)
-// ---------------------------------------------------------------------------
-export { assetsSyncAdapter } from "./sync/assetsSyncAdapter";
-export {
-  disableAssetsCapture,
-  replaceAssetsFromSnapshot,
-  setRemoteAssetsHandler,
-} from "./remote";
-export type { AssetsRemoteDispatch } from "./remote";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-export type {
-  AssetKind,
-  AssetOrigin,
-  AssetRecord,
-  AssetRecordWire,
-  AssetsBaseline,
-  AssetsDiff,
-  AssetsInsights,
-  AssetsScanStatus,
-  AssetsSnapshotPayload,
-  AssetsStats,
-  DuplicateInsight,
-} from "./types";
-
-// Side effect: install the registry capture at import (walk + patch — cheap,
-// synchronous, no network). The Metro graph fetch waits for the modal/action.
-import { installAssetCapture as installOnImport } from "./capture/install";
-installOnImport();

package/src/preset.tsx

@@ -1,35 +0,0 @@
-/**
- * Pre-configured Assets tool for FloatingDevTools.
- *
- * @example
- * ```tsx
- * import { assetsToolPreset } from '@buoy-gg/assets';
- *
- * <FloatingDevTools apps={[assetsToolPreset]} />
- * ```
- */
-
-import { AssetsIcon, ASSETS_ICON_COLOR } from "./components/AssetsIcon";
-import { AssetsModal } from "./components/AssetsModal";
-
-export const assetsToolPreset = {
-  id: "assets",
-  name: "ASSETS",
-  description: "Every bundled asset — sizes, scale coverage, unused detection",
-  slot: "both" as const,
-  icon: ({ size, color }: { size: number; color?: string }) => (
-    <AssetsIcon size={size} color={color || ASSETS_ICON_COLOR} />
-  ),
-  component: AssetsModal,
-};
-
-/** Create a custom Assets tool configuration. */
-export function createAssetsTool(
-  options: { name?: string; description?: string } = {}
-) {
-  return {
-    ...assetsToolPreset,
-    name: options.name ?? assetsToolPreset.name,
-    description: options.description ?? assetsToolPreset.description,
-  };
-}

package/src/remote.ts

@@ -1,65 +0,0 @@
-/**
- * Remote-dispatch seam for dashboard mirrors (Buoy Desktop).
- *
- * On device this stays null and every action runs locally. A dashboard sets
- * a handler that forwards action name + params over external-sync to the
- * SAME adapter actions the MCP uses (sync/assetsSyncAdapter.ts), so one
- * action vocabulary serves phone UI, desktop UI, and LLM automation.
- */
-
-import { assetsState } from "./state";
-import { invalidate } from "./store/assetStore";
-import type { AssetsSnapshotPayload } from "./types";
-
-export type AssetsRemoteDispatch = (
-  action: string,
-  params?: Record<string, unknown>
-) => Promise<unknown>;
-
-export function setRemoteAssetsHandler(
-  handler: AssetsRemoteDispatch | null
-): void {
-  assetsState().remoteDispatch = handler;
-}
-
-export function remoteAssetsDispatch(): AssetsRemoteDispatch | null {
-  return assetsState().remoteDispatch;
-}
-
-/** Dashboards never scan their own bundle — the store is purely a mirror. */
-export function disableAssetsCapture(): void {
-  assetsState().captureDisabled = true;
-}
-
-/** Replace the whole store from a synced adapter snapshot. */
-export function replaceAssetsFromSnapshot(payload: AssetsSnapshotPayload): void {
-  const s = assetsState();
-  const wire = payload.records ?? [];
-  s.records = wire.map((w) => ({
-    id: w.id,
-    key: w.key,
-    registryId: w.registryId ?? undefined,
-    name: w.name,
-    type: w.type,
-    kind: w.kind,
-    hash: w.hash ?? undefined,
-    httpServerLocation: w.location ?? undefined,
-    width: w.width ?? undefined,
-    height: w.height ?? undefined,
-    scales: w.scales,
-    resolvedUri: w.uri ?? undefined,
-    loaded: w.loaded,
-    origin: w.registryId != null ? ("registry" as const) : ("graph" as const),
-    sizeBytes: w.sizeBytes ?? undefined,
-    sizeSource: w.sizeSource ?? undefined,
-    firstSeenAt: Date.now(),
-  }));
-  s.byKey = new Map(s.records.map((r) => [r.key, r]));
-  s.byId = new Map(s.records.map((r) => [r.id, r]));
-  if (payload.scanStatus) {
-    s.mirrorScanStatus = payload.scanStatus;
-    s.fontFamilies = payload.scanStatus.fontFamilies ?? [];
-  }
-  s.mirrorDiff = payload.diff ?? null;
-  invalidate();
-}

package/src/state.ts

@@ -1,84 +0,0 @@
-/**
- * Global singleton state for the Assets tool.
- *
- * Same rationale as the images tool: the package can be evaluated as two
- * module instances (lib vs src resolution), and the registerAsset patch must
- * share one store with whichever copy the UI renders from. All mutable state
- * lives on globalThis under a well-known symbol.
- */
-
-import type { AssetRecord, AssetsBaseline, AssetsDiff, AssetsScanStatus } from "./types";
-
-export interface AssetsGlobalState {
-  // store
-  records: AssetRecord[];
-  byKey: Map<string, AssetRecord>;
-  byId: Map<number, AssetRecord>;
-  nextId: number;
-  listeners: Set<() => void>;
-  snapshot: AssetRecord[];
-  emitScheduled: boolean;
-  // install / scan status
-  installed: boolean;
-  patched: boolean;
-  registryAvailable: boolean;
-  graphSupported: boolean;
-  graphCount: number | null;
-  graphError: string | null;
-  graphFetchInFlight: boolean;
-  lastScanAt: number | null;
-  measuring: boolean;
-  measuredCount: number;
-  fontFamilies: string[];
-  localAssetCount: number | null;
-  // baseline diff
-  baseline: AssetsBaseline | null;
-  baselineLoaded: boolean;
-  // mirror mode (desktop dashboard)
-  captureDisabled: boolean;
-  remoteDispatch:
-    | ((action: string, params?: Record<string, unknown>) => Promise<unknown>)
-    | null;
-  mirrorScanStatus: AssetsScanStatus | null;
-  /** Device PixelRatio adopted from a synced snapshot (scale-gap math). */
-  mirrorPixelRatio: number | null;
-  /** Device-computed diff adopted from a synced snapshot. */
-  mirrorDiff: AssetsDiff | null;
-}
-
-const KEY = Symbol.for("buoy.assets.globalState.v1");
-
-export function assetsState(): AssetsGlobalState {
-  const g = globalThis as Record<symbol, AssetsGlobalState | undefined>;
-  if (!g[KEY]) {
-    g[KEY] = {
-      records: [],
-      byKey: new Map(),
-      byId: new Map(),
-      nextId: 1,
-      listeners: new Set(),
-      snapshot: [],
-      emitScheduled: false,
-      installed: false,
-      patched: false,
-      registryAvailable: false,
-      graphSupported: false,
-      graphCount: null,
-      graphError: null,
-      graphFetchInFlight: false,
-      lastScanAt: null,
-      measuring: false,
-      measuredCount: 0,
-      fontFamilies: [],
-      localAssetCount: null,
-      baseline: null,
-      baselineLoaded: false,
-      captureDisabled: false,
-      remoteDispatch: null,
-      mirrorScanStatus: null,
-      mirrorPixelRatio: null,
-      mirrorDiff: null,
-    };
-  }
-  return g[KEY];
-}

package/src/store/assetStore.ts

@@ -1,209 +0,0 @@
-/**
- * assetStore
- *
- * Bounded store of AssetRecords keyed by their stable asset key
- * (`location/name.type`). Follows the images tool's store shape — Set of
- * listeners, frame-coalesced emit, all mutable state on the globalThis
- * singleton (../state.ts) so dual module instances share one store.
- *
- * Unlike the images tool this is an INVENTORY, not an event log: upserts
- * merge into the existing record for a key instead of appending, and there
- * is no ring-buffer cap (a bundle has a bounded asset count by construction).
- */
-
-import { assetsState } from "../state";
-import type { AssetKind, AssetRecord, AssetsStats } from "../types";
-
-function emit(): void {
-  const s = assetsState();
-  if (s.emitScheduled) return;
-  s.emitScheduled = true;
-  requestAnimationFrame(() => {
-    s.emitScheduled = false;
-    for (const listener of s.listeners) listener();
-  });
-}
-
-/** Snapshot identity only changes on emit, so useSyncExternalStore stays cheap. */
-export function invalidate(): void {
-  const s = assetsState();
-  s.snapshot = [...s.records];
-  emit();
-}
-
-const KIND_BY_EXT: Record<string, AssetKind> = {
-  png: "image", jpg: "image", jpeg: "image", gif: "image", webp: "image",
-  bmp: "image", psd: "image", svg: "image", tiff: "image", ktx: "image",
-  heic: "image", heif: "image", avif: "image",
-  ttf: "font", otf: "font", woff: "font", woff2: "font", ttc: "font",
-  mp4: "video", m4v: "video", mov: "video", mpeg: "video", mpg: "video",
-  webm: "video", avi: "video",
-  mp3: "audio", wav: "audio", aac: "audio", aiff: "audio", caf: "audio",
-  m4a: "audio", ogg: "audio",
-  json: "data", db: "data", yaml: "data", yml: "data", xml: "data",
-  html: "data", pdf: "data", zip: "data",
-};
-
-export function kindForType(type: string): AssetKind {
-  return KIND_BY_EXT[type.toLowerCase()] ?? "other";
-}
-
-export function assetKey(
-  httpServerLocation: string | undefined,
-  name: string,
-  type: string
-): string {
-  // The runtime registry percent-encodes ?unstable_path= locations while the
-  // Metro graph endpoint returns them decoded — normalize or every asset
-  // splits into a registry record + a graph record.
-  let location = httpServerLocation ?? "";
-  try {
-    location = decodeURIComponent(location);
-  } catch {
-    // malformed escapes: keep the raw string
-  }
-  return `${location}/${name}.${type}`;
-}
-
-export interface AssetUpsert {
-  key: string;
-  name: string;
-  type: string;
-  origin: AssetRecord["origin"];
-  registryId?: number;
-  hash?: string;
-  httpServerLocation?: string;
-  width?: number;
-  height?: number;
-  scales?: number[];
-  resolvedUri?: string;
-  resolvedScale?: number;
-  loaded?: boolean;
-  fileSystemLocation?: string;
-  files?: string[];
-  fileHashes?: string[];
-}
-
-/** Merge an asset sighting into the store; creates the record on first sight. */
-export function upsertRecord(input: AssetUpsert): AssetRecord {
-  const s = assetsState();
-  let record = s.byKey.get(input.key);
-  if (!record) {
-    record = {
-      id: s.nextId++,
-      key: input.key,
-      name: input.name,
-      type: input.type,
-      kind: kindForType(input.type),
-      scales: input.scales ?? [],
-      loaded: input.loaded ?? false,
-      origin: input.origin,
-      firstSeenAt: Date.now(),
-    };
-    s.records.push(record);
-    s.byKey.set(record.key, record);
-    s.byId.set(record.id, record);
-  }
-  if (input.registryId != null) record.registryId = input.registryId;
-  if (input.hash != null) record.hash = input.hash;
-  if (input.httpServerLocation != null) record.httpServerLocation = input.httpServerLocation;
-  if (input.width != null) record.width = input.width;
-  if (input.height != null) record.height = input.height;
-  if (input.scales && input.scales.length) {
-    // Dedupe: foo.png + foo@1x.png both existing yields [1, 1, …] from Metro.
-    record.scales = [...new Set(input.scales)].sort((a, b) => a - b);
-  }
-  if (input.resolvedUri != null) record.resolvedUri = input.resolvedUri;
-  if (input.resolvedScale != null) record.resolvedScale = input.resolvedScale;
-  if (input.loaded) record.loaded = true;
-  if (input.fileSystemLocation != null) record.fileSystemLocation = input.fileSystemLocation;
-  if (input.files) record.files = input.files;
-  if (input.fileHashes) record.fileHashes = input.fileHashes;
-  invalidate();
-  return record;
-}
-
-/** Mutate a record in place (records are owned by the store) and notify. */
-export function updateRecord(
-  id: number,
-  patch: Partial<AssetRecord>
-): AssetRecord | undefined {
-  const s = assetsState();
-  const record = s.byId.get(id);
-  if (!record) return undefined;
-  Object.assign(record, patch);
-  invalidate();
-  return record;
-}
-
-export function getRecord(id: number): AssetRecord | undefined {
-  return assetsState().byId.get(id);
-}
-
-export function getRecordByKey(key: string): AssetRecord | undefined {
-  return assetsState().byKey.get(key);
-}
-
-export function getSnapshot(): AssetRecord[] {
-  return assetsState().snapshot;
-}
-
-export function subscribe(listener: () => void): () => void {
-  const s = assetsState();
-  s.listeners.add(listener);
-  return () => assetsState().listeners.delete(listener);
-}
-
-export function clearRecords(): void {
-  const s = assetsState();
-  s.records = [];
-  s.byKey = new Map();
-  s.byId = new Map();
-  s.measuredCount = 0;
-  s.graphCount = null;
-  invalidate();
-}
-
-/**
- * Estimated decoded-bitmap memory (RGBA8888) at the scale this device would
- * pick — the size fallback when bytes can't be measured (release builds).
- */
-export function estDecodedBytes(record: AssetRecord): number {
-  if (record.kind !== "image" || !record.width || !record.height) return 0;
-  const scale =
-    record.resolvedScale ??
-    (record.scales.length ? record.scales[record.scales.length - 1] : 1);
-  return Math.round(record.width * scale * record.height * scale * 4);
-}
-
-export function computeStats(list: AssetRecord[]): AssetsStats {
-  const s = assetsState();
-  const byKind: AssetsStats["byKind"] = {
-    image: { count: 0, bytes: 0 },
-    font: { count: 0, bytes: 0 },
-    video: { count: 0, bytes: 0 },
-    audio: { count: 0, bytes: 0 },
-    data: { count: 0, bytes: 0 },
-    other: { count: 0, bytes: 0 },
-  };
-  const stats: AssetsStats = {
-    total: list.length,
-    loaded: 0,
-    neverLoaded: 0,
-    byKind,
-    totalBytes: 0,
-    measuredCount: 0,
-    fontFamilies: s.fontFamilies.length,
-  };
-  for (const r of list) {
-    if (r.loaded) stats.loaded++;
-    else stats.neverLoaded++;
-    byKind[r.kind].count++;
-    if (r.sizeBytes != null && r.sizeSource === "measured") {
-      byKind[r.kind].bytes += r.sizeBytes;
-      stats.totalBytes += r.sizeBytes;
-      stats.measuredCount++;
-    }
-  }
-  return stats;
-}

package/src/store/baseline.ts

@@ -1,152 +0,0 @@
-/**
- * Baseline diff — the regression-prevention half of the tool.
- *
- * "Save baseline" persists a slim {hash, size} snapshot of the inventory via
- * shared-ui's persistentStorage (FileSystem → AsyncStorage → memory), and
- * every later scan diffs against it: new assets, removed assets, grown
- * assets, net bytes. Run it before and after a branch and you get "this
- * branch added 2.3 MB" without any CI tooling.
- *
- * On dashboard mirrors the actions forward to the device (the baseline
- * belongs to the app being inspected, not the dashboard) and the computed
- * diff arrives back inside the synced snapshot.
- */
-
-import { persistentStorage } from "@buoy-gg/shared-ui";
-import { remoteAssetsDispatch } from "../remote";
-import { assetsState } from "../state";
-import { getSnapshot, invalidate } from "./assetStore";
-import type { AssetRecord, AssetsBaseline, AssetsDiff } from "../types";
-
-const STORAGE_KEY = "@react_buoy/assets/baseline";
-
-/** ≥1 KB counts as growth; below that is codec/metadata noise. */
-const GROWN_THRESHOLD_BYTES = 1024;
-
-/** Load the persisted baseline into state once; safe to call repeatedly. */
-export async function loadBaseline(): Promise<AssetsBaseline | null> {
-  const s = assetsState();
-  if (s.baselineLoaded) return s.baseline;
-  s.baselineLoaded = true;
-  try {
-    const raw = await persistentStorage.getItem(STORAGE_KEY);
-    if (raw) {
-      const parsed = JSON.parse(raw) as AssetsBaseline;
-      if (parsed && typeof parsed.savedAt === "number" && parsed.entries) {
-        s.baseline = parsed;
-        invalidate();
-      }
-    }
-  } catch {
-    // unreadable baseline = no baseline
-  }
-  return s.baseline;
-}
-
-export async function saveBaseline(): Promise<AssetsBaseline> {
-  const remote = remoteAssetsDispatch();
-  if (remote) {
-    await remote("saveBaseline");
-    return assetsState().baseline ?? { savedAt: Date.now(), entries: {} };
-  }
-  const s = assetsState();
-  const entries: AssetsBaseline["entries"] = {};
-  for (const r of getSnapshot()) {
-    entries[r.key] = {
-      hash: r.hash ?? null,
-      sizeBytes: r.sizeSource === "measured" ? (r.sizeBytes ?? null) : null,
-      name: r.name,
-      type: r.type,
-    };
-  }
-  const baseline: AssetsBaseline = { savedAt: Date.now(), entries };
-  s.baseline = baseline;
-  s.baselineLoaded = true;
-  invalidate();
-  try {
-    await persistentStorage.setItem(STORAGE_KEY, JSON.stringify(baseline));
-  } catch {
-    // in-memory baseline still works for this session
-  }
-  return baseline;
-}
-
-export async function clearBaseline(): Promise<void> {
-  const remote = remoteAssetsDispatch();
-  if (remote) {
-    await remote("clearBaseline");
-    return;
-  }
-  const s = assetsState();
-  s.baseline = null;
-  s.baselineLoaded = true;
-  invalidate();
-  try {
-    await persistentStorage.removeItem(STORAGE_KEY);
-  } catch {
-    // nothing to clean up
-  }
-}
-
-export function computeDiff(
-  records: AssetRecord[],
-  baseline: AssetsBaseline
-): AssetsDiff {
-  const added: number[] = [];
-  const grown: Array<{ id: number; deltaBytes: number }> = [];
-  const seen = new Set<string>();
-  let currentBytes = 0;
-  let baselineBytes = 0;
-  let comparable = false;
-
-  for (const r of records) {
-    seen.add(r.key);
-    const then = baseline.entries[r.key];
-    if (!then) {
-      added.push(r.id);
-      continue;
-    }
-    const now = r.sizeSource === "measured" ? (r.sizeBytes ?? null) : null;
-    if (now != null && then.sizeBytes != null) {
-      comparable = true;
-      currentBytes += now;
-      baselineBytes += then.sizeBytes;
-      if (now - then.sizeBytes >= GROWN_THRESHOLD_BYTES) {
-        grown.push({ id: r.id, deltaBytes: now - then.sizeBytes });
-      }
-    }
-  }
-
-  const removed: AssetsDiff["removed"] = [];
-  for (const [key, entry] of Object.entries(baseline.entries)) {
-    if (!seen.has(key)) {
-      removed.push({ key, name: entry.name, type: entry.type });
-      if (entry.sizeBytes != null) baselineBytes += entry.sizeBytes;
-    }
-  }
-  // Added assets' measured bytes count toward the net even without a
-  // baseline counterpart — that's exactly the growth being reported.
-  for (const id of added) {
-    const r = records.find((rec) => rec.id === id);
-    if (r?.sizeSource === "measured" && r.sizeBytes != null) {
-      comparable = true;
-      currentBytes += r.sizeBytes;
-    }
-  }
-
-  return {
-    baselineSavedAt: baseline.savedAt,
-    added,
-    removed,
-    grown: grown.sort((a, b) => b.deltaBytes - a.deltaBytes),
-    netBytes: comparable ? currentBytes - baselineBytes : null,
-  };
-}
-
-/** Current diff: the synced device's on mirrors, computed locally on device. */
-export function getDiff(): AssetsDiff | null {
-  const s = assetsState();
-  if (s.mirrorDiff) return s.mirrorDiff;
-  if (!s.baseline) return null;
-  return computeDiff(getSnapshot(), s.baseline);
-}