@teincfood/core 0.8.0 → 0.8.1

package/dist/hooks/image.hooks.d.ts

@@ -16,5 +16,9 @@ export declare const CACHED_IMAGE_KEYS: {
 };
 /** Invalidate every cached-image query (e.g. after a bulk reference sync). */
 export declare function invalidateCachedImages(queryClient: ReturnType<typeof useQueryClient>): void;
-/** Resolve an image URL to a URI. Prefers local cache; null for null URL. */
+/** Resolve an image URL to a URI safe for RN `<Image>`. Prefers local cache;
+ * null for null URL AND for URIs no native loader can handle (tfimg://
+ * leaks, bare S3 keys, blob:) — callers render placeholders instead of
+ * crashing the screen. resolveImageSource passthrough is preserved for
+ * non-render consumers; this gate applies at the render boundary only. */
 export declare function useCachedImageUrl(url: string | null | undefined): string | null;

package/dist/hooks/image.hooks.js

@@ -8,7 +8,7 @@
 import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { useSyncExternalStore } from "react";
 import { getConnectivityState, subscribeConnectivity } from "../adapters/connectivity";
-import { cacheRemoteImage, getCachedImageInfo, resolveImageSource, stableCacheUrl } from "../image-cache/service";
+import { cacheRemoteImage, getCachedImageInfo, resolveImageSource, stableCacheUrl, toRenderableUri } from "../image-cache/service";
 export const IMAGE_CACHE_KEYS = {
     all: ["cachedImage"],
     url: (url) => ["cachedImage", url],
@@ -18,7 +18,11 @@ export const CACHED_IMAGE_KEYS = IMAGE_CACHE_KEYS;
 export function invalidateCachedImages(queryClient) {
     queryClient.invalidateQueries({ queryKey: IMAGE_CACHE_KEYS.all });
 }
-/** Resolve an image URL to a URI. Prefers local cache; null for null URL. */
+/** Resolve an image URL to a URI safe for RN `<Image>`. Prefers local cache;
+ * null for null URL AND for URIs no native loader can handle (tfimg://
+ * leaks, bare S3 keys, blob:) — callers render placeholders instead of
+ * crashing the screen. resolveImageSource passthrough is preserved for
+ * non-render consumers; this gate applies at the render boundary only. */
 export function useCachedImageUrl(url) {
     const queryClient = useQueryClient();
     const connectivity = useSyncExternalStore(subscribeConnectivity, getConnectivityState, getConnectivityState);
@@ -58,5 +62,5 @@ export function useCachedImageUrl(url) {
     });
     if (!enabled || !data)
         return null;
-    return data.uri;
+    return toRenderableUri(data.uri);
 }

package/dist/image-cache/service.d.ts

@@ -22,6 +22,26 @@ export declare function getCachedImageInfo(url: string): Promise<ImageCacheEntry
  * hook's warm-then-invalidate cycle into an unbounded retry storm.
  */
 export declare function isDownloadableImageUrl(url: string): boolean;
+/**
+ * URI schemes React Native's `<Image>` can actually load on device. Anything
+ * else has no RCTImageURLLoader on iOS ("No suitable image URL loader
+ * found") and crashes the screen — notably `tfimg://` disk URIs leaked from
+ * desktop rows, bare S3 keys (`menus/biz/img.jpg`), and `blob:` preview
+ * URLs. The hook maps these to null so callers render their placeholder
+ * branch instead of feeding a fatal URI to the native loader.
+ */
+export declare function isLoadableImageUri(uri: string): boolean;
+/** Map a resolved URI to one RN `<Image>` can load, else null (placeholder). */
+export declare function toRenderableUri(uri: string | null | undefined): string | null;
+/**
+ * Values safe to persist as a menu image reference: S3 keys, http(s) URLs,
+ * null. Preview URIs (tfimg:, blob:, file:, data:) must never be stored —
+ * the backend keeps non-http values verbatim and they poison every other
+ * device (mobile has no native loader for tfimg:// and crashes). Returns
+ * null for un-storable values, so re-saving a poisoned row self-heals it
+ * (caller re-uploads to restore the image).
+ */
+export declare function toStorableImageUrl(value: string | null | undefined): string | null;
 export declare function cacheRemoteImage(url: string | null | undefined, opts?: {
     skipIfCached?: boolean;
     removeOnFailure?: boolean;

package/dist/image-cache/service.js

@@ -60,6 +60,42 @@ const DOWNLOADABLE_RE = /^https?:\/\//i;
 export function isDownloadableImageUrl(url) {
     return DOWNLOADABLE_RE.test(url);
 }
+const LOADABLE_RE = /^(https?|file|data|asset|content):/i;
+/**
+ * URI schemes React Native's `<Image>` can actually load on device. Anything
+ * else has no RCTImageURLLoader on iOS ("No suitable image URL loader
+ * found") and crashes the screen — notably `tfimg://` disk URIs leaked from
+ * desktop rows, bare S3 keys (`menus/biz/img.jpg`), and `blob:` preview
+ * URLs. The hook maps these to null so callers render their placeholder
+ * branch instead of feeding a fatal URI to the native loader.
+ */
+export function isLoadableImageUri(uri) {
+    return LOADABLE_RE.test(uri);
+}
+/** Map a resolved URI to one RN `<Image>` can load, else null (placeholder). */
+export function toRenderableUri(uri) {
+    if (!uri)
+        return null;
+    return isLoadableImageUri(uri) ? uri : null;
+}
+const URI_SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
+/**
+ * Values safe to persist as a menu image reference: S3 keys, http(s) URLs,
+ * null. Preview URIs (tfimg:, blob:, file:, data:) must never be stored —
+ * the backend keeps non-http values verbatim and they poison every other
+ * device (mobile has no native loader for tfimg:// and crashes). Returns
+ * null for un-storable values, so re-saving a poisoned row self-heals it
+ * (caller re-uploads to restore the image).
+ */
+export function toStorableImageUrl(value) {
+    if (!value)
+        return null;
+    if (URI_SCHEME_RE.test(value) && !DOWNLOADABLE_RE.test(value)) {
+        syncLogger.warn("ImageCache", "Dropping un-storable image URL", { value: value.slice(0, 32) });
+        return null;
+    }
+    return value;
+}
 export async function cacheRemoteImage(url, opts = {}) {
     if (!url)
         return null;

package/dist/reference/menu-record.js

@@ -9,6 +9,7 @@
  */
 import { generateUUID } from "../utils/uuid";
 import { CATALOG_KEYS } from "../catalog/hooks";
+import { toStorableImageUrl } from "../image-cache/service";
 export function buildMenuItemRecord(input) {
     const currencyCode = input.currencyCode || "GHS";
     const now = input.now ?? new Date().toISOString();
@@ -17,7 +18,9 @@ export function buildMenuItemRecord(input) {
         name: input.name,
         description: input.description ?? null,
         basePrice: { amountMinor: input.priceMinor, currencyCode },
-        image_url: input.imageUrl ?? null,
+        // Never persist preview URIs (tfimg:/blob:/file:): the backend stores
+        // non-http values verbatim and they poison every other device.
+        image_url: toStorableImageUrl(input.imageUrl),
         is_available: input.available ?? true,
         dietary_tags: input.dietaryTags ?? [],
         category_id: input.categoryId,
@@ -152,7 +155,9 @@ export function buildMenuItemEnvelope(input) {
                 : { name: e.name, price_minor: e.price_minor ?? 0 };
         }),
         available: input.available ?? true,
-        image_url: input.imageUrl ?? null,
+        // Same storable rule as the cache record: preview URIs must not reach
+        // the backend (it stores them verbatim).
+        image_url: toStorableImageUrl(input.imageUrl),
         ...(input.wireExtra ?? {}),
     };
     return { wire, cacheRecord };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teincfood/core",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "TeincFood shared offline-first core — types, sync engine, local DB, reference data, and repositories for mobile + desktop",
   "type": "module",
   "main": "dist/index.js",