@buoy-gg/images 7.0.3

package/lib/commonjs/format.js

@@ -0,0 +1,117 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cacheBadge = cacheBadge;
+exports.formatBytes = formatBytes;
+exports.formatMs = formatMs;
+exports.sizeVerdict = sizeVerdict;
+exports.statusColor = statusColor;
+exports.uriTail = uriTail;
+var _sharedUi = require("@buoy-gg/shared-ui");
+var _imageEventStore = require("./store/imageEventStore");
+/**
+ * Formatting + verdict helpers shared by list rows and the detail view.
+ */
+
+function formatBytes(bytes) {
+  if (bytes <= 0) return "0 B";
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function formatMs(ms) {
+  if (ms == null) return "—";
+  if (ms < 1000) return `${Math.round(ms)}ms`;
+  return `${(ms / 1000).toFixed(2)}s`;
+}
+
+/** Last path segment of a URI, for compact row display. */
+function uriTail(uri) {
+  if (!uri) return "(no source)";
+  // Metro dev-server asset URLs put the real path in ?unstable_path=…
+  const unstable = uri.match(/[?&]unstable_path=([^&?]+)/);
+  const effective = unstable ? decodeURIComponent(unstable[1]) : uri;
+  const withoutQuery = effective.split("?")[0] ?? effective;
+  const segments = withoutQuery.split("/").filter(Boolean);
+  return segments[segments.length - 1] ?? effective;
+}
+/**
+ * Fresco-style fit verdict: green within 10%, yellow within 50%, red beyond.
+ * Undersized sources (upscaled, likely blurry) get their own callout.
+ */
+function sizeVerdict(record) {
+  const factor = (0, _imageEventStore.oversizeFactor)(record);
+  if (factor == null) return {
+    label: "",
+    color: _sharedUi.macOSColors.text.muted,
+    factor
+  };
+  if (factor < 0.9) {
+    return {
+      label: `${factor.toFixed(1)}× upscaled`,
+      color: _sharedUi.macOSColors.semantic.info,
+      factor
+    };
+  }
+  if (factor <= 1.1) {
+    return {
+      label: "right-sized",
+      color: _sharedUi.macOSColors.semantic.success,
+      factor
+    };
+  }
+  if (factor <= 1.5) {
+    return {
+      label: `${factor.toFixed(1)}× oversized`,
+      color: _sharedUi.macOSColors.semantic.warning,
+      factor
+    };
+  }
+  return {
+    label: `${factor.toFixed(1)}× oversized`,
+    color: _sharedUi.macOSColors.semantic.error,
+    factor
+  };
+}
+function statusColor(record) {
+  switch (record.status) {
+    case "loaded":
+      return _sharedUi.macOSColors.semantic.success;
+    case "error":
+      return _sharedUi.macOSColors.semantic.error;
+    case "loading":
+      return _sharedUi.macOSColors.semantic.warning;
+    default:
+      return _sharedUi.macOSColors.text.muted;
+  }
+}
+
+/** Cache verdict badge text + tint (memory=green, disk=yellow, network=red). */
+function cacheBadge(record) {
+  const verdict = record.cacheVerdict;
+  if (verdict === "memory" || verdict === "disk/memory") {
+    return {
+      label: verdict.toUpperCase(),
+      color: _sharedUi.macOSColors.semantic.success
+    };
+  }
+  if (verdict === "disk") {
+    return {
+      label: "DISK",
+      color: _sharedUi.macOSColors.semantic.warning
+    };
+  }
+  if (verdict === "none" || record.progressSeen) {
+    return {
+      label: "NETWORK",
+      color: _sharedUi.macOSColors.semantic.error
+    };
+  }
+  return {
+    label: "?",
+    color: _sharedUi.macOSColors.text.muted
+  };
+}
+//# sourceMappingURL=format.js.map

package/lib/commonjs/format.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_sharedUi","require","_imageEventStore","formatBytes","bytes","toFixed","formatMs","ms","Math","round","uriTail","uri","unstable","match","effective","decodeURIComponent","withoutQuery","split","segments","filter","Boolean","length","sizeVerdict","record","factor","oversizeFactor","label","color","macOSColors","text","muted","semantic","info","success","warning","error","statusColor","status","cacheBadge","verdict","cacheVerdict","toUpperCase","progressSeen"],"sourceRoot":"../../src","sources":["format.ts"],"mappings":";;;;;;;;;;;AAIA,IAAAA,SAAA,GAAAC,OAAA;AACA,IAAAC,gBAAA,GAAAD,OAAA;AALA;AACA;AACA;;AAMO,SAASE,WAAWA,CAACC,KAAa,EAAU;EACjD,IAAIA,KAAK,IAAI,CAAC,EAAE,OAAO,KAAK;EAC5B,IAAIA,KAAK,GAAG,IAAI,EAAE,OAAO,GAAGA,KAAK,IAAI;EACrC,IAAIA,KAAK,GAAG,IAAI,GAAG,IAAI,EAAE,OAAO,GAAG,CAACA,KAAK,GAAG,IAAI,EAAEC,OAAO,CAAC,CAAC,CAAC,KAAK;EACjE,OAAO,GAAG,CAACD,KAAK,IAAI,IAAI,GAAG,IAAI,CAAC,EAAEC,OAAO,CAAC,CAAC,CAAC,KAAK;AACnD;AAEO,SAASC,QAAQA,CAACC,EAAsB,EAAU;EACvD,IAAIA,EAAE,IAAI,IAAI,EAAE,OAAO,GAAG;EAC1B,IAAIA,EAAE,GAAG,IAAI,EAAE,OAAO,GAAGC,IAAI,CAACC,KAAK,CAACF,EAAE,CAAC,IAAI;EAC3C,OAAO,GAAG,CAACA,EAAE,GAAG,IAAI,EAAEF,OAAO,CAAC,CAAC,CAAC,GAAG;AACrC;;AAEA;AACO,SAASK,OAAOA,CAACC,GAAW,EAAU;EAC3C,IAAI,CAACA,GAAG,EAAE,OAAO,aAAa;EAC9B;EACA,MAAMC,QAAQ,GAAGD,GAAG,CAACE,KAAK,CAAC,4BAA4B,CAAC;EACxD,MAAMC,SAAS,GAAGF,QAAQ,GAAGG,kBAAkB,CAACH,QAAQ,CAAC,CAAC,CAAE,CAAC,GAAGD,GAAG;EACnE,MAAMK,YAAY,GAAGF,SAAS,CAACG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAIH,SAAS;EACzD,MAAMI,QAAQ,GAAGF,YAAY,CAACC,KAAK,CAAC,GAAG,CAAC,CAACE,MAAM,CAACC,OAAO,CAAC;EACxD,OAAOF,QAAQ,CAACA,QAAQ,CAACG,MAAM,GAAG,CAAC,CAAC,IAAIP,SAAS;AACnD;AASA;AACA;AACA;AACA;AACO,SAASQ,WAAWA,CAACC,MAAmB,EAAe;EAC5D,MAAMC,MAAM,GAAG,IAAAC,+BAAc,EAACF,MAAM,CAAC;EACrC,IAAIC,MAAM,IAAI,IAAI,EAAE,OAAO;IAAEE,KAAK,EAAE,EAAE;IAAEC,KAAK,EAAEC,qBAAW,CAACC,IAAI,CAACC,KAAK;IAAEN;EAAO,CAAC;EAC/E,IAAIA,MAAM,GAAG,GAAG,EAAE;IAChB,OAAO;MAAEE,KAAK,EAAE,GAAGF,MAAM,CAACnB,OAAO,CAAC,CAAC,CAAC,YAAY;MAAEsB,KAAK,EAAEC,qBAAW,CAACG,QAAQ,CAACC,IAAI;MAAER;IAAO,CAAC;EAC9F;EACA,IAAIA,MAAM,IAAI,GAAG,EAAE;IACjB,OAAO;MAAEE,KAAK,EAAE,aAAa;MAAEC,KAAK,EAAEC,qBAAW,CAACG,QAAQ,CAACE,OAAO;MAAET;IAAO,CAAC;EAC9E;EACA,IAAIA,MAAM,IAAI,GAAG,EAAE;IACjB,OAAO;MAAEE,KAAK,EAAE,GAAGF,MAAM,CAACnB,OAAO,CAAC,CAAC,CAAC,aAAa;MAAEsB,KAAK,EAAEC,qBAAW,CAACG,QAAQ,CAACG,OAAO;MAAEV;IAAO,CAAC;EAClG;EACA,OAAO;IAAEE,KAAK,EAAE,GAAGF,MAAM,CAACnB,OAAO,CAAC,CAAC,CAAC,aAAa;IAAEsB,KAAK,EAAEC,qBAAW,CAACG,QAAQ,CAACI,KAAK;IAAEX;EAAO,CAAC;AAChG;AAEO,SAASY,WAAWA,CAACb,MAAmB,EAAU;EACvD,QAAQA,MAAM,CAACc,MAAM;IACnB,KAAK,QAAQ;MACX,OAAOT,qBAAW,CAACG,QAAQ,CAACE,OAAO;IACrC,KAAK,OAAO;MACV,OAAOL,qBAAW,CAACG,QAAQ,CAACI,KAAK;IACnC,KAAK,SAAS;MACZ,OAAOP,qBAAW,CAACG,QAAQ,CAACG,OAAO;IACrC;MACE,OAAON,qBAAW,CAACC,IAAI,CAACC,KAAK;EACjC;AACF;;AAEA;AACO,SAASQ,UAAUA,CAACf,MAAmB,EAAoC;EAChF,MAAMgB,OAAO,GAAGhB,MAAM,CAACiB,YAAY;EACnC,IAAID,OAAO,KAAK,QAAQ,IAAIA,OAAO,KAAK,aAAa,EAAE;IACrD,OAAO;MAAEb,KAAK,EAAEa,OAAO,CAACE,WAAW,CAAC,CAAC;MAAEd,KAAK,EAAEC,qBAAW,CAACG,QAAQ,CAACE;IAAQ,CAAC;EAC9E;EACA,IAAIM,OAAO,KAAK,MAAM,EAAE;IACtB,OAAO;MAAEb,KAAK,EAAE,MAAM;MAAEC,KAAK,EAAEC,qBAAW,CAACG,QAAQ,CAACG;IAAQ,CAAC;EAC/D;EACA,IAAIK,OAAO,KAAK,MAAM,IAAIhB,MAAM,CAACmB,YAAY,EAAE;IAC7C,OAAO;MAAEhB,KAAK,EAAE,SAAS;MAAEC,KAAK,EAAEC,qBAAW,CAACG,QAAQ,CAACI;IAAM,CAAC;EAChE;EACA,OAAO;IAAET,KAAK,EAAE,GAAG;IAAEC,KAAK,EAAEC,qBAAW,CAACC,IAAI,CAACC;EAAM,CAAC;AACtD","ignoreList":[]}

package/lib/commonjs/hooks/useImageRecords.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useImageRecords = useImageRecords;
+var _react = require("react");
+var _imageEventStore = require("../store/imageEventStore");
+/**
+ * React bindings for the image event store.
+ */
+
+function useImageRecords() {
+  const snapshot = (0, _react.useSyncExternalStore)(_imageEventStore.subscribe, _imageEventStore.getSnapshot, _imageEventStore.getSnapshot);
+  return (0, _react.useMemo)(() => ({
+    records: [...snapshot].reverse(),
+    stats: (0, _imageEventStore.computeStats)(snapshot)
+  }), [snapshot]);
+}
+//# sourceMappingURL=useImageRecords.js.map

package/lib/commonjs/hooks/useImageRecords.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","_imageEventStore","useImageRecords","snapshot","useSyncExternalStore","subscribe","getSnapshot","useMemo","records","reverse","stats","computeStats"],"sourceRoot":"../../../src","sources":["hooks/useImageRecords.ts"],"mappings":";;;;;;AAIA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,gBAAA,GAAAD,OAAA;AALA;AACA;AACA;;AAYO,SAASE,eAAeA,CAAA,EAA0B;EACvD,MAAMC,QAAQ,GAAG,IAAAC,2BAAoB,EAACC,0BAAS,EAAEC,4BAAW,EAAEA,4BAAW,CAAC;EAC1E,OAAO,IAAAC,cAAO,EACZ,OAAO;IACLC,OAAO,EAAE,CAAC,GAAGL,QAAQ,CAAC,CAACM,OAAO,CAAC,CAAC;IAChCC,KAAK,EAAE,IAAAC,6BAAY,EAACR,QAAQ;EAC9B,CAAC,CAAC,EACF,CAACA,QAAQ,CACX,CAAC;AACH","ignoreList":[]}

package/lib/commonjs/index.js

@@ -0,0 +1,236 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "IMAGES_ICON_COLOR", {
+  enumerable: true,
+  get: function () {
+    return _ImagesIcon.IMAGES_ICON_COLOR;
+  }
+});
+Object.defineProperty(exports, "ImagesIcon", {
+  enumerable: true,
+  get: function () {
+    return _ImagesIcon.ImagesIcon;
+  }
+});
+Object.defineProperty(exports, "ImagesModal", {
+  enumerable: true,
+  get: function () {
+    return _ImagesModal.ImagesModal;
+  }
+});
+Object.defineProperty(exports, "ImagesRoot", {
+  enumerable: true,
+  get: function () {
+    return _ImagesRoot.ImagesRoot;
+  }
+});
+Object.defineProperty(exports, "clearAllOverrides", {
+  enumerable: true,
+  get: function () {
+    return _overrides.clearAllOverrides;
+  }
+});
+Object.defineProperty(exports, "clearOverride", {
+  enumerable: true,
+  get: function () {
+    return _overrides.clearOverride;
+  }
+});
+Object.defineProperty(exports, "clearRecords", {
+  enumerable: true,
+  get: function () {
+    return _imageEventStore.clearRecords;
+  }
+});
+Object.defineProperty(exports, "computeInsights", {
+  enumerable: true,
+  get: function () {
+    return _insights.computeInsights;
+  }
+});
+Object.defineProperty(exports, "computeStats", {
+  enumerable: true,
+  get: function () {
+    return _imageEventStore.computeStats;
+  }
+});
+Object.defineProperty(exports, "createImagesTool", {
+  enumerable: true,
+  get: function () {
+    return _preset.createImagesTool;
+  }
+});
+Object.defineProperty(exports, "estDecodedBytes", {
+  enumerable: true,
+  get: function () {
+    return _imageEventStore.estDecodedBytes;
+  }
+});
+Object.defineProperty(exports, "estWastedBytes", {
+  enumerable: true,
+  get: function () {
+    return _imageEventStore.estWastedBytes;
+  }
+});
+Object.defineProperty(exports, "evictExpoDiskEntry", {
+  enumerable: true,
+  get: function () {
+    return _actions.evictExpoDiskEntry;
+  }
+});
+Object.defineProperty(exports, "flashAllMounted", {
+  enumerable: true,
+  get: function () {
+    return _overrides.flashAllMounted;
+  }
+});
+Object.defineProperty(exports, "flashRecord", {
+  enumerable: true,
+  get: function () {
+    return _overrides.flashRecord;
+  }
+});
+Object.defineProperty(exports, "formatRecordMarkdown", {
+  enumerable: true,
+  get: function () {
+    return _export.formatRecordMarkdown;
+  }
+});
+Object.defineProperty(exports, "formatRegistryMarkdown", {
+  enumerable: true,
+  get: function () {
+    return _export.formatRegistryMarkdown;
+  }
+});
+Object.defineProperty(exports, "getCaptureStatus", {
+  enumerable: true,
+  get: function () {
+    return _install.getCaptureStatus;
+  }
+});
+Object.defineProperty(exports, "getGlobalModes", {
+  enumerable: true,
+  get: function () {
+    return _overrides.getGlobalModes;
+  }
+});
+Object.defineProperty(exports, "getImageRecords", {
+  enumerable: true,
+  get: function () {
+    return _imageEventStore.getSnapshot;
+  }
+});
+Object.defineProperty(exports, "getOverride", {
+  enumerable: true,
+  get: function () {
+    return _overrides.getOverride;
+  }
+});
+Object.defineProperty(exports, "hardReloadAllMounted", {
+  enumerable: true,
+  get: function () {
+    return _actions.hardReloadAllMounted;
+  }
+});
+Object.defineProperty(exports, "hardReloadRecord", {
+  enumerable: true,
+  get: function () {
+    return _actions.hardReloadRecord;
+  }
+});
+Object.defineProperty(exports, "imagesSyncAdapter", {
+  enumerable: true,
+  get: function () {
+    return _imagesSyncAdapter.imagesSyncAdapter;
+  }
+});
+Object.defineProperty(exports, "imagesToolPreset", {
+  enumerable: true,
+  get: function () {
+    return _preset.imagesToolPreset;
+  }
+});
+Object.defineProperty(exports, "insightChips", {
+  enumerable: true,
+  get: function () {
+    return _insights.insightChips;
+  }
+});
+Object.defineProperty(exports, "installImageCapture", {
+  enumerable: true,
+  get: function () {
+    return _install.installImageCapture;
+  }
+});
+Object.defineProperty(exports, "oversizeFactor", {
+  enumerable: true,
+  get: function () {
+    return _imageEventStore.oversizeFactor;
+  }
+});
+Object.defineProperty(exports, "proveSavings", {
+  enumerable: true,
+  get: function () {
+    return _savings.proveSavings;
+  }
+});
+Object.defineProperty(exports, "retryRecord", {
+  enumerable: true,
+  get: function () {
+    return _actions.retryRecord;
+  }
+});
+Object.defineProperty(exports, "setBlankImages", {
+  enumerable: true,
+  get: function () {
+    return _overrides.setBlankImages;
+  }
+});
+Object.defineProperty(exports, "setNetworkMode", {
+  enumerable: true,
+  get: function () {
+    return _overrides.setNetworkMode;
+  }
+});
+Object.defineProperty(exports, "setOverride", {
+  enumerable: true,
+  get: function () {
+    return _overrides.setOverride;
+  }
+});
+Object.defineProperty(exports, "setOverrideForAllMounted", {
+  enumerable: true,
+  get: function () {
+    return _overrides.setOverrideForAllMounted;
+  }
+});
+Object.defineProperty(exports, "subscribeImageRecords", {
+  enumerable: true,
+  get: function () {
+    return _imageEventStore.subscribe;
+  }
+});
+Object.defineProperty(exports, "useImageRecords", {
+  enumerable: true,
+  get: function () {
+    return _useImageRecords.useImageRecords;
+  }
+});
+require("./register");
+var _preset = require("./preset");
+var _ImagesRoot = require("./components/ImagesRoot");
+var _ImagesModal = require("./components/ImagesModal");
+var _ImagesIcon = require("./components/ImagesIcon");
+var _install = require("./capture/install");
+var _actions = require("./capture/actions");
+var _overrides = require("./capture/overrides");
+var _savings = require("./capture/savings");
+var _insights = require("./store/insights");
+var _export = require("./export");
+var _imagesSyncAdapter = require("./sync/imagesSyncAdapter");
+var _useImageRecords = require("./hooks/useImageRecords");
+var _imageEventStore = require("./store/imageEventStore");
+//# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["require","_preset","_ImagesRoot","_ImagesModal","_ImagesIcon","_install","_actions","_overrides","_savings","_insights","_export","_imagesSyncAdapter","_useImageRecords","_imageEventStore"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiBAA,OAAA;AAKA,IAAAC,OAAA,GAAAD,OAAA;AAKA,IAAAE,WAAA,GAAAF,OAAA;AAKA,IAAAG,YAAA,GAAAH,OAAA;AACA,IAAAI,WAAA,GAAAJ,OAAA;AAKA,IAAAK,QAAA,GAAAL,OAAA;AAKA,IAAAM,QAAA,GAAAN,OAAA;AAUA,IAAAO,UAAA,GAAAP,OAAA;AAkBA,IAAAQ,QAAA,GAAAR,OAAA;AAEA,IAAAS,SAAA,GAAAT,OAAA;AACA,IAAAU,OAAA,GAAAV,OAAA;AAKA,IAAAW,kBAAA,GAAAX,OAAA;AAKA,IAAAY,gBAAA,GAAAZ,OAAA;AACA,IAAAa,gBAAA,GAAAb,OAAA","ignoreList":[]}

package/lib/commonjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/lib/commonjs/preset.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createImagesTool = createImagesTool;
+exports.imagesToolPreset = void 0;
+var _ImagesIcon = require("./components/ImagesIcon");
+var _ImagesModal = require("./components/ImagesModal");
+var _jsxRuntime = require("react/jsx-runtime");
+/**
+ * Pre-configured Images tool for FloatingDevTools.
+ *
+ * @example
+ * ```tsx
+ * import { imagesToolPreset } from '@buoy-gg/images';
+ *
+ * <FloatingDevTools apps={[imagesToolPreset]} />
+ * ```
+ */
+
+const imagesToolPreset = exports.imagesToolPreset = {
+  id: "images",
+  name: "IMAGES",
+  description: "Image loads, caching, failures, and oversize checks",
+  slot: "both",
+  icon: ({
+    size,
+    color
+  }) => /*#__PURE__*/(0, _jsxRuntime.jsx)(_ImagesIcon.ImagesIcon, {
+    size: size,
+    color: color || _ImagesIcon.IMAGES_ICON_COLOR
+  }),
+  component: _ImagesModal.ImagesModal
+};
+
+/** Create a custom Images tool configuration. */
+function createImagesTool(options = {}) {
+  return {
+    ...imagesToolPreset,
+    name: options.name ?? imagesToolPreset.name,
+    description: options.description ?? imagesToolPreset.description
+  };
+}
+//# sourceMappingURL=preset.js.map

package/lib/commonjs/preset.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_ImagesIcon","require","_ImagesModal","_jsxRuntime","imagesToolPreset","exports","id","name","description","slot","icon","size","color","jsx","ImagesIcon","IMAGES_ICON_COLOR","component","ImagesModal","createImagesTool","options"],"sourceRoot":"../../src","sources":["preset.tsx"],"mappings":";;;;;;;AAWA,IAAAA,WAAA,GAAAC,OAAA;AACA,IAAAC,YAAA,GAAAD,OAAA;AAAuD,IAAAE,WAAA,GAAAF,OAAA;AAZvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAKO,MAAMG,gBAAgB,GAAAC,OAAA,CAAAD,gBAAA,GAAG;EAC9BE,EAAE,EAAE,QAAQ;EACZC,IAAI,EAAE,QAAQ;EACdC,WAAW,EAAE,qDAAqD;EAClEC,IAAI,EAAE,MAAe;EACrBC,IAAI,EAAEA,CAAC;IAAEC,IAAI;IAAEC;EAAwC,CAAC,kBACtD,IAAAT,WAAA,CAAAU,GAAA,EAACb,WAAA,CAAAc,UAAU;IAACH,IAAI,EAAEA,IAAK;IAACC,KAAK,EAAEA,KAAK,IAAIG;EAAkB,CAAE,CAC7D;EACDC,SAAS,EAAEC;AACb,CAAC;;AAED;AACO,SAASC,gBAAgBA,CAC9BC,OAAgD,GAAG,CAAC,CAAC,EACrD;EACA,OAAO;IACL,GAAGf,gBAAgB;IACnBG,IAAI,EAAEY,OAAO,CAACZ,IAAI,IAAIH,gBAAgB,CAACG,IAAI;IAC3CC,WAAW,EAAEW,OAAO,CAACX,WAAW,IAAIJ,gBAAgB,CAACI;EACvD,CAAC;AACH","ignoreList":[]}

package/lib/commonjs/register.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var _install = require("./capture/install");
+/**
+ * Side-effect entry: installs image capture on import.
+ *
+ * Import this FIRST in your app entry file so the RN-core <Image> decorator
+ * lands before React Native's Image module is evaluated:
+ *
+ * ```ts
+ * import "@buoy-gg/images/register";
+ * ```
+ *
+ * This module intentionally imports nothing that touches react-native's Image
+ * (directly or transitively) before installing.
+ */
+
+(0, _install.installImageCapture)();
+//# sourceMappingURL=register.js.map

package/lib/commonjs/register.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_install","require","installImageCapture"],"sourceRoot":"../../src","sources":["register.ts"],"mappings":";;AAcA,IAAAA,QAAA,GAAAC,OAAA;AAdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA,IAAAC,4BAAmB,EAAC,CAAC","ignoreList":[]}

package/lib/commonjs/state.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.imagesState = imagesState;
+/**
+ * Global singleton state for the Images tool.
+ *
+ * The package can get evaluated twice as two separate module instances (e.g.
+ * the `/register` entry shim resolving to one copy while the package root
+ * import resolves to another — lib vs src). If capture state lived in module
+ * scope, the early copy would install the RN decorator and collect records
+ * while the UI copy read an empty store and a false "decorator never ran"
+ * flag. Keying all mutable state on globalThis under a well-known symbol makes
+ * every copy operate on the same data.
+ */
+
+const KEY = Symbol.for("buoy.images.globalState.v1");
+function imagesState() {
+  const g = globalThis;
+  if (!g[KEY]) {
+    g[KEY] = {
+      records: [],
+      byId: new Map(),
+      nextId: 1,
+      listeners: new Set(),
+      snapshot: [],
+      emitScheduled: false,
+      captureInstalled: false,
+      rnInstalled: false,
+      expoInstalled: false,
+      decoratorRegistered: false,
+      decoratorInvoked: false,
+      attachSeen: 0,
+      expoAvailable: false,
+      expoPatched: false,
+      reloadRequests: new Map(),
+      actionListeners: new Set(),
+      expoInstances: new Map(),
+      overrides: new Map(),
+      flashUntil: new Map(),
+      recordVersions: new Map(),
+      globalVersion: 0,
+      versionCounter: 0,
+      globalModes: {
+        network: "normal",
+        blank: false
+      }
+    };
+  }
+  return g[KEY];
+}
+//# sourceMappingURL=state.js.map

package/lib/commonjs/state.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["KEY","Symbol","for","imagesState","g","globalThis","records","byId","Map","nextId","listeners","Set","snapshot","emitScheduled","captureInstalled","rnInstalled","expoInstalled","decoratorRegistered","decoratorInvoked","attachSeen","expoAvailable","expoPatched","reloadRequests","actionListeners","expoInstances","overrides","flashUntil","recordVersions","globalVersion","versionCounter","globalModes","network","blank"],"sourceRoot":"../../src","sources":["state.ts"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AA6CA,MAAMA,GAAG,GAAGC,MAAM,CAACC,GAAG,CAAC,4BAA4B,CAAC;AAE7C,SAASC,WAAWA,CAAA,EAAsB;EAC/C,MAAMC,CAAC,GAAGC,UAA2D;EACrE,IAAI,CAACD,CAAC,CAACJ,GAAG,CAAC,EAAE;IACXI,CAAC,CAACJ,GAAG,CAAC,GAAG;MACPM,OAAO,EAAE,EAAE;MACXC,IAAI,EAAE,IAAIC,GAAG,CAAC,CAAC;MACfC,MAAM,EAAE,CAAC;MACTC,SAAS,EAAE,IAAIC,GAAG,CAAC,CAAC;MACpBC,QAAQ,EAAE,EAAE;MACZC,aAAa,EAAE,KAAK;MACpBC,gBAAgB,EAAE,KAAK;MACvBC,WAAW,EAAE,KAAK;MAClBC,aAAa,EAAE,KAAK;MACpBC,mBAAmB,EAAE,KAAK;MAC1BC,gBAAgB,EAAE,KAAK;MACvBC,UAAU,EAAE,CAAC;MACbC,aAAa,EAAE,KAAK;MACpBC,WAAW,EAAE,KAAK;MAClBC,cAAc,EAAE,IAAId,GAAG,CAAC,CAAC;MACzBe,eAAe,EAAE,IAAIZ,GAAG,CAAC,CAAC;MAC1Ba,aAAa,EAAE,IAAIhB,GAAG,CAAC,CAAC;MACxBiB,SAAS,EAAE,IAAIjB,GAAG,CAAC,CAAC;MACpBkB,UAAU,EAAE,IAAIlB,GAAG,CAAC,CAAC;MACrBmB,cAAc,EAAE,IAAInB,GAAG,CAAC,CAAC;MACzBoB,aAAa,EAAE,CAAC;MAChBC,cAAc,EAAE,CAAC;MACjBC,WAAW,EAAE;QAAEC,OAAO,EAAE,QAAQ;QAAEC,KAAK,EAAE;MAAM;IACjD,CAAC;EACH;EACA,OAAO5B,CAAC,CAACJ,GAAG,CAAC;AACf","ignoreList":[]}

package/lib/commonjs/store/imageEventStore.js

@@ -0,0 +1,160 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clearRecords = clearRecords;
+exports.computeStats = computeStats;
+exports.createRecord = createRecord;
+exports.estDecodedBytes = estDecodedBytes;
+exports.estWastedBytes = estWastedBytes;
+exports.getRecord = getRecord;
+exports.getSnapshot = getSnapshot;
+exports.neededPixels = neededPixels;
+exports.oversizeFactor = oversizeFactor;
+exports.subscribe = subscribe;
+exports.updateRecord = updateRecord;
+var _reactNative = require("react-native");
+var _state = require("../state");
+/**
+ * imageEventStore
+ *
+ * Bounded buffer of ImageRecords fed by the capture layer (installRnImage /
+ * installExpoImage). Follows the console tool's store shape — Set of
+ * listeners, frame-coalesced emit so bursty image grids don't turn every
+ * event into its own React commit — but ALL mutable state lives on the
+ * globalThis singleton (see ../state.ts) so a dual module instance of this
+ * package still reads/writes one shared store.
+ */
+
+/** Max records retained before the oldest are dropped. */
+const MAX_RECORDS = 500;
+function emit() {
+  const s = (0, _state.imagesState)();
+  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. */
+function invalidate() {
+  const s = (0, _state.imagesState)();
+  s.snapshot = [...s.records];
+  emit();
+}
+function createRecord(partial) {
+  const s = (0, _state.imagesState)();
+  const record = {
+    ...partial,
+    id: s.nextId++,
+    createdAt: Date.now(),
+    status: "pending",
+    mounted: true,
+    loadCount: 0
+  };
+  s.records.push(record);
+  s.byId.set(record.id, record);
+  if (s.records.length > MAX_RECORDS) {
+    const dropped = s.records.splice(0, s.records.length - MAX_RECORDS);
+    for (const d of dropped) s.byId.delete(d.id);
+  }
+  invalidate();
+  return record;
+}
+
+/** Mutate a record in place (records are owned by the store) and notify. */
+function updateRecord(id, patch) {
+  const s = (0, _state.imagesState)();
+  const record = s.byId.get(id);
+  if (!record) return undefined;
+  Object.assign(record, patch);
+  invalidate();
+  return record;
+}
+function getRecord(id) {
+  return (0, _state.imagesState)().byId.get(id);
+}
+function getSnapshot() {
+  return (0, _state.imagesState)().snapshot;
+}
+function subscribe(listener) {
+  const s = (0, _state.imagesState)();
+  s.listeners.add(listener);
+  return () => (0, _state.imagesState)().listeners.delete(listener);
+}
+function clearRecords() {
+  const s = (0, _state.imagesState)();
+  // Keep records still actively loading so in-flight events don't orphan.
+  s.records = s.records.filter(r => r.mounted && r.status !== "loaded" && r.status !== "error");
+  s.byId = new Map(s.records.map(r => [r.id, r]));
+  invalidate();
+}
+
+// ---------------------------------------------------------------------------
+// Derived math (shared by rows, detail view, and stats)
+// ---------------------------------------------------------------------------
+
+/** Physical pixels actually needed to fill the laid-out view 1:1. */
+function neededPixels(record) {
+  if (!record.layout || record.layout.width <= 0 || record.layout.height <= 0) return null;
+  const scale = _reactNative.PixelRatio.get();
+  return {
+    width: Math.round(record.layout.width * scale),
+    height: Math.round(record.layout.height * scale)
+  };
+}
+
+/**
+ * Linear oversize factor: how many times larger (per axis, area-normalized)
+ * the decoded bitmap is vs what the view needs. 1 = perfect, 2 = 4× the pixels.
+ */
+function oversizeFactor(record) {
+  const needed = neededPixels(record);
+  if (!needed || !record.intrinsic) return null;
+  const neededArea = needed.width * needed.height;
+  const intrinsicArea = record.intrinsic.width * record.intrinsic.height;
+  if (neededArea <= 0 || intrinsicArea <= 0) return null;
+  return Math.sqrt(intrinsicArea / neededArea);
+}
+
+/** Estimated decoded-bitmap memory for a loaded record (RGBA8888). */
+function estDecodedBytes(record) {
+  if (!record.intrinsic) return 0;
+  return record.intrinsic.width * record.intrinsic.height * 4;
+}
+
+/** Decoded bytes beyond what the laid-out size needs (0 if not oversized). */
+function estWastedBytes(record) {
+  const needed = neededPixels(record);
+  if (!needed || !record.intrinsic) return 0;
+  const wasted = (record.intrinsic.width * record.intrinsic.height - needed.width * needed.height) * 4;
+  return Math.max(0, wasted);
+}
+function computeStats(list) {
+  const stats = {
+    total: list.length,
+    loading: 0,
+    loaded: 0,
+    errors: 0,
+    networkLoads: 0,
+    estDecodedBytes: 0,
+    estWastedBytes: 0
+  };
+  for (const r of list) {
+    // Unmounted in-flight records are stale (the instance died mid-load) —
+    // they must not count as live in-flight work.
+    if ((r.status === "loading" || r.status === "pending") && r.mounted) stats.loading++;
+    if (r.status === "loaded") stats.loaded++;
+    if (r.status === "error") stats.errors++;
+    if (r.progressSeen || r.cacheVerdict === "none") stats.networkLoads++;
+    if (r.mounted && r.status === "loaded") {
+      stats.estDecodedBytes += estDecodedBytes(r);
+      stats.estWastedBytes += estWastedBytes(r);
+    }
+  }
+  return stats;
+}
+//# sourceMappingURL=imageEventStore.js.map