@buoy-gg/assets 7.0.29 → 7.0.30

package/src/format.ts

@@ -1,53 +0,0 @@
-/**
- * Shared formatting helpers for rows, detail view, and markdown export.
- */
-
-import type { AssetKind, AssetRecord } from "./types";
-
-export function formatBytes(bytes: number | null | undefined): string {
-  if (bytes == null || bytes <= 0) return "—";
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
-}
-
-export function formatScales(scales: number[]): string {
-  const unique = [...new Set(scales)].sort((a, b) => a - b);
-  if (!unique.length) return "—";
-  if (unique.length === 1) return `@${unique[0]}x`;
-  if (unique.length <= 3) return unique.map((s) => `@${s}x`).join(" ");
-  return `@${unique[0]}x–@${unique[unique.length - 1]}x`;
-}
-
-export function formatDimensions(record: AssetRecord): string {
-  if (record.width == null || record.height == null) return "—";
-  return `${Math.round(record.width)}×${Math.round(record.height)}`;
-}
-
-/** Display size: measured bytes, or "~" decoded estimate for unmeasured images. */
-export function formatSize(record: AssetRecord, estDecoded: number): string {
-  if (record.sizeBytes != null && record.sizeSource === "measured") {
-    return formatBytes(record.sizeBytes);
-  }
-  if (estDecoded > 0) return `~${formatBytes(estDecoded)}`;
-  return "—";
-}
-
-export const KIND_LABELS: Record<AssetKind, string> = {
-  image: "IMG",
-  font: "FONT",
-  video: "VID",
-  audio: "AUD",
-  data: "DATA",
-  other: "MISC",
-};
-
-/** Family accent per kind — the card's left edge, like network's method bar. */
-export const KIND_COLORS: Record<AssetKind, string> = {
-  image: "#2DD4BF",
-  font: "#C084FC",
-  video: "#FF9F1C",
-  audio: "#FF3366",
-  data: "#00D4FF",
-  other: "#8E8E93",
-};

package/src/hooks/useAssetRecords.ts

@@ -1,26 +0,0 @@
-/**
- * React bindings for the asset store.
- */
-
-import { useMemo, useSyncExternalStore } from "react";
-import { computeStats, getSnapshot, subscribe } from "../store/assetStore";
-import { computeInsights } from "../store/insights";
-import type { AssetRecord, AssetsInsights, AssetsStats } from "../types";
-
-export interface UseAssetRecordsResult {
-  records: AssetRecord[];
-  stats: AssetsStats;
-  insights: AssetsInsights;
-}
-
-export function useAssetRecords(): UseAssetRecordsResult {
-  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-  return useMemo(
-    () => ({
-      records: snapshot,
-      stats: computeStats(snapshot),
-      insights: computeInsights(snapshot),
-    }),
-    [snapshot]
-  );
-}

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;
-}