@deneb-ui/ui 2.0.60 → 2.0.61

package/README.md

@@ -100,6 +100,7 @@ export default function Page() {
 | `ProductGrid` | `EditableProductGrid` | `data-preview-list-path`, `data-preview-item-path` | Catalog grid with quick-view modal hook & filter integration |
 | `ProductShowcase` | `EditableProductShowcase` | `data-preview-field-path`, `data-preview-list-path`, `color` swatch | Flagship product showcase with color swatches, filter tabs, quick-view & WhatsApp order |
 | `ProductDetail` | `EditableProductDetail` | `data-preview-page-key`, `data-preview-field-path` | Full single-product view with gallery, specs, & inquiry actions |
+| `PlatformProductDetail` | `PlatformProductDetail` | `useProducts`, live catalog API | Stable static-export product page with URL lookup, retries, and fallback states |
 | `ProductQuickView` | `ProductQuickView` | `data-preview-field-path` | Instant lightbox modal product inspection with quantity counter |
 | `CartDrawer` | `EditableCartDrawer` | `data-preview-list-path`, `data-preview-item-path` | Slide-over cart drawer with 1-click unified WhatsApp order compilation |
 | `FilterSidebar` | `EditableFilterSidebar` | `data-preview-field-path`, `useSiteData` | Faceted catalog filter sidebar (categories, price range, sizes) |
@@ -159,6 +160,7 @@ export default function Page() {
 | :--- | :--- | :--- |
 | `SiteDataProvider` / `DenebDataProvider` | `SiteDataProvider` | Real-time backend catalog fetcher & `postMessage` preview state synchronizer |
 | `useProducts` | `SiteDataProvider` | React hook to access live synchronized products list (`content.products`) |
+| `usePlatformProductDetail` | `PlatformProductDetail` | Resolves `?id=` against live data and the catalog API for a custom detail design |
 | `useServices` | `SiteDataProvider` | React hook to access live synchronized services list (`content.services`) |
 | `useSiteCatalog` | `SiteDataProvider` | Returns `{ products, services, project, siteInstance, api }` in one call |
 | `useSiteApi` | `SiteDataProvider` | Returns official Fivora backend endpoints (`catalogUrl`, `contactUrl`, `analyticsUrl`) |
@@ -170,6 +172,51 @@ export default function Page() {
 | `useDenebFonts` | `fonts/useDenebFonts` | Hook for checking active font definitions |
 | `CartProvider` / `useCart`| `cart/useCart` | Global cart state management with persistent storage |
 
+## Safe product detail routes for static exports
+
+Never link live products to `/products/${product.id}`. A product created after
+the template build has no matching static directory, so that URL can return a
+404. Export one stable page and pass the product ID in the query string.
+
+```tsx
+// src/app/products/detail/page.tsx
+import { PlatformProductDetail } from '@deneb-ui/ui';
+
+export default function ProductDetailPage() {
+  return <PlatformProductDetail />;
+}
+```
+
+Build product links with the matching helper:
+
+```tsx
+import { platformProductDetailHref } from '@deneb-ui/ui';
+
+<a href={platformProductDetailHref(product.id)}>View product</a>
+```
+
+For a template-specific design, keep the platform data behavior and replace
+only the renderer:
+
+```tsx
+import { PlatformProductDetail } from '@deneb-ui/ui';
+
+export default function ProductDetailPage() {
+  return (
+    <PlatformProductDetail
+      renderProduct={(product, { productIndex }) => (
+        <MyProductDetail product={product} index={productIndex} />
+      )}
+    />
+  );
+}
+```
+
+`PlatformProductDetail` reads `/products/detail/?id=PRODUCT_ID`, checks the
+reactive `SiteDataProvider` catalog, retries `api.catalogUrl`, and renders safe
+loading, network-error, and not-found states. `usePlatformProductDetail()` is
+also exported for developers who need complete control of the page markup.
+
 ---
 
 ## Data Fetching & Backend Integration Hooks

package/dist/EditableProductDetail.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 import { MeasurementUnit } from './utils/productOptions';
 export interface ProductDetailItem {
-    id?: string;
+    id?: string | number;
     name?: string;
     title?: string;
     brand?: string;
@@ -13,7 +13,9 @@ export interface ProductDetailItem {
     badge?: string;
     featuredImage?: string;
     imageUrl?: string;
+    image?: string;
     gallery?: string[];
+    images?: string[];
     addToSelectionLabel?: string;
     specsTitle?: string;
     specs?: Array<{

package/dist/PlatformProductDetail.d.ts

@@ -0,0 +1,55 @@
+import React from 'react';
+import { type EditableProductDetailProps, type ProductDetailItem } from './EditableProductDetail';
+export type PlatformProductDetailStatus = 'loading' | 'ready' | 'not-found' | 'error';
+export interface UsePlatformProductDetailOptions {
+    /** Product ID override. When omitted, the ID is read from `?id=` in the browser URL. */
+    productId?: string | number | null;
+    /** Query-string key used when `productId` is omitted. Defaults to `id`. */
+    queryParam?: string;
+    /** Optional product seed used when SiteDataProvider has not supplied a catalog yet. */
+    products?: ProductDetailItem[];
+    /** Optional live catalog endpoint override. Pass `null` to disable the remote lookup. */
+    catalogUrl?: string | null;
+    /** Retry delays in milliseconds. The default makes three attempts: immediately, 750ms, and 2s. */
+    retryDelays?: readonly number[];
+}
+export interface PlatformProductDetailResult {
+    product: ProductDetailItem | null;
+    productId: string;
+    productIndex: number;
+    status: PlatformProductDetailStatus;
+    error: Error | null;
+    retry: () => void;
+}
+export interface PlatformProductDetailRenderContext extends PlatformProductDetailResult {
+    sectionPath: string;
+}
+export interface PlatformProductDetailProps extends Omit<EditableProductDetailProps, 'product'>, UsePlatformProductDetailOptions {
+    /** Render a template-specific detail design while the platform handles URL and live-data resolution. */
+    renderProduct?: (product: ProductDetailItem, context: PlatformProductDetailRenderContext) => React.ReactNode;
+    /** Custom loading content. */
+    loadingFallback?: React.ReactNode;
+    /** Custom missing-product content. */
+    notFoundFallback?: React.ReactNode;
+    /** Custom network-error content. */
+    errorFallback?: React.ReactNode;
+    /** Destination used by the default Back to products action. */
+    backHref?: string;
+    /** Label used by the default Back to products action. */
+    backLabel?: string;
+}
+/**
+ * Resolves a product from the stable static route (`/products/detail/?id=...`).
+ * It checks the live SiteDataProvider catalog first, then retries the public
+ * catalog endpoint so newly-created merchant products work without rebuilding
+ * one static route per product.
+ */
+export declare function usePlatformProductDetail({ productId: productIdOverride, queryParam, products: fallbackProducts, catalogUrl: catalogUrlOverride, retryDelays, }?: UsePlatformProductDetailOptions): PlatformProductDetailResult;
+/** Build the only product-detail URL that is safe for newly-created products in a static export. */
+export declare function platformProductDetailHref(productId: string | number | null | undefined, route?: string, queryParam?: string): string;
+/**
+ * Ready-made live product page for Fivora templates. Use `renderProduct` when
+ * the template needs its own design; URL parsing, live lookup, retries, and
+ * fallback states remain owned by this component.
+ */
+export declare function PlatformProductDetail({ productId, queryParam, products, catalogUrl, retryDelays, renderProduct, loadingFallback, notFoundFallback, errorFallback, backHref, backLabel, sectionPath, ...detailProps }: PlatformProductDetailProps): string | number | bigint | boolean | React.JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined>;

package/dist/PlatformProductDetail.js

@@ -0,0 +1,294 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePlatformProductDetail = usePlatformProductDetail;
+exports.platformProductDetailHref = platformProductDetailHref;
+exports.PlatformProductDetail = PlatformProductDetail;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const EditableProductDetail_1 = require("./EditableProductDetail");
+const SiteDataProvider_1 = require("./SiteDataProvider");
+const utils_1 = require("./utils");
+const DEFAULT_QUERY_PARAM = 'id';
+const DEFAULT_DETAIL_ROUTE = '/products/detail/';
+const DEFAULT_RETRY_DELAYS = [0, 750, 2_000];
+function normalizeId(value) {
+    if (typeof value !== 'string' && typeof value !== 'number')
+        return '';
+    return String(value).trim();
+}
+function readProductId(queryParam) {
+    if (typeof window === 'undefined')
+        return '';
+    return normalizeId(new URL(window.location.href).searchParams.get(queryParam));
+}
+function resolveCatalogUrl(siteData, override) {
+    if (override === null)
+        return null;
+    if (typeof override === 'string')
+        return override.trim() || null;
+    const configured = siteData.api?.catalogUrl;
+    if (typeof configured === 'string' && configured.trim()) {
+        return configured.trim();
+    }
+    const slug = normalizeId(siteData.siteInstance?.slug || siteData.project?.slug || siteData.project?.id);
+    if (!slug)
+        return null;
+    const baseUrl = siteData.api?.baseUrl;
+    if (typeof baseUrl === 'string' && baseUrl.trim()) {
+        return `${baseUrl.replace(/\/+$/, '')}/site-catalog/${encodeURIComponent(slug)}/live-data`;
+    }
+    return `/site-catalog/${encodeURIComponent(slug)}/live-data`;
+}
+function readCatalogProducts(payload) {
+    if (!(0, SiteDataProvider_1.isRecord)(payload))
+        return [];
+    if (Array.isArray(payload.products)) {
+        return payload.products;
+    }
+    if ((0, SiteDataProvider_1.isRecord)(payload.content) && Array.isArray(payload.content.products)) {
+        return payload.content.products;
+    }
+    return [];
+}
+function findProduct(products, productId) {
+    if (!productId)
+        return { product: null, index: -1 };
+    const index = products.findIndex((candidate) => normalizeId(candidate?.id) === productId);
+    return {
+        product: index >= 0 ? products[index] : null,
+        index,
+    };
+}
+function normalizeProductForDetail(product, siteData) {
+    const image = (typeof product.featuredImage === 'string' && product.featuredImage) ||
+        (typeof product.imageUrl === 'string' && product.imageUrl) ||
+        (typeof product.image === 'string' && product.image) ||
+        undefined;
+    const images = Array.isArray(product.gallery)
+        ? product.gallery
+        : Array.isArray(product.images)
+            ? product.images
+            : undefined;
+    const shop = (0, SiteDataProvider_1.isRecord)(siteData.shop) ? siteData.shop : {};
+    const merchant = (0, SiteDataProvider_1.isRecord)(siteData.merchant) ? siteData.merchant : {};
+    const whatsappNumber = (typeof product.whatsappNumber === 'string' && product.whatsappNumber) ||
+        (typeof shop.whatsapp === 'string' && shop.whatsapp) ||
+        (typeof shop.whatsappNumber === 'string' && shop.whatsappNumber) ||
+        (typeof merchant.whatsapp === 'string' && merchant.whatsapp) ||
+        undefined;
+    return {
+        ...product,
+        ...(image && !product.featuredImage ? { featuredImage: image } : {}),
+        ...(images && !product.gallery ? { gallery: images } : {}),
+        ...(whatsappNumber && !product.whatsappNumber ? { whatsappNumber } : {}),
+    };
+}
+/**
+ * Resolves a product from the stable static route (`/products/detail/?id=...`).
+ * It checks the live SiteDataProvider catalog first, then retries the public
+ * catalog endpoint so newly-created merchant products work without rebuilding
+ * one static route per product.
+ */
+function usePlatformProductDetail({ productId: productIdOverride, queryParam = DEFAULT_QUERY_PARAM, products: fallbackProducts = [], catalogUrl: catalogUrlOverride, retryDelays = DEFAULT_RETRY_DELAYS, } = {}) {
+    const siteData = (0, SiteDataProvider_1.useSiteData)();
+    const products = (0, SiteDataProvider_1.useProducts)(fallbackProducts);
+    const explicitProductId = normalizeId(productIdOverride);
+    const [locationState, setLocationState] = (0, react_1.useState)(() => ({
+        initialized: Boolean(explicitProductId),
+        productId: explicitProductId,
+    }));
+    const [requestVersion, setRequestVersion] = (0, react_1.useState)(0);
+    const [remoteState, setRemoteState] = (0, react_1.useState)({
+        key: '',
+        product: null,
+        index: -1,
+        status: 'loading',
+        error: null,
+    });
+    (0, react_1.useEffect)(() => {
+        if (explicitProductId) {
+            setLocationState({ initialized: true, productId: explicitProductId });
+            return;
+        }
+        const updateFromLocation = () => {
+            setLocationState({
+                initialized: true,
+                productId: readProductId(queryParam),
+            });
+        };
+        updateFromLocation();
+        window.addEventListener('popstate', updateFromLocation);
+        return () => window.removeEventListener('popstate', updateFromLocation);
+    }, [explicitProductId, queryParam]);
+    const productId = explicitProductId || locationState.productId;
+    const localMatch = (0, react_1.useMemo)(() => findProduct(products, productId), [productId, products]);
+    const catalogUrl = (0, react_1.useMemo)(() => resolveCatalogUrl(siteData, catalogUrlOverride), [catalogUrlOverride, siteData]);
+    const retryKey = retryDelays.join(',');
+    (0, react_1.useEffect)(() => {
+        if (!locationState.initialized || !productId || localMatch.product || !catalogUrl) {
+            return;
+        }
+        const controller = new AbortController();
+        const requestKey = `${productId}|${catalogUrl}|${requestVersion}`;
+        const parsedDelays = retryKey
+            .split(',')
+            .map((value) => Number(value))
+            .filter((value) => Number.isFinite(value));
+        const delays = parsedDelays.length > 0 ? parsedDelays : [0];
+        let timer = null;
+        setRemoteState({
+            key: requestKey,
+            product: null,
+            index: -1,
+            status: 'loading',
+            error: null,
+        });
+        const attempt = async (attemptIndex) => {
+            const delay = Math.max(0, delays[attemptIndex] ?? 0);
+            if (delay > 0) {
+                await new Promise((resolve) => {
+                    timer = setTimeout(resolve, delay);
+                });
+            }
+            if (controller.signal.aborted)
+                return;
+            try {
+                const response = await fetch(catalogUrl, {
+                    cache: 'no-store',
+                    headers: { Accept: 'application/json' },
+                    signal: controller.signal,
+                });
+                if (!response.ok) {
+                    throw new Error(`Catalog request failed with status ${response.status}.`);
+                }
+                const remoteProducts = readCatalogProducts(await response.json());
+                const match = findProduct(remoteProducts, productId);
+                if (match.product) {
+                    setRemoteState({
+                        key: requestKey,
+                        product: match.product,
+                        index: match.index,
+                        status: 'ready',
+                        error: null,
+                    });
+                    return;
+                }
+                if (attemptIndex + 1 < delays.length) {
+                    await attempt(attemptIndex + 1);
+                    return;
+                }
+                setRemoteState({
+                    key: requestKey,
+                    product: null,
+                    index: -1,
+                    status: 'not-found',
+                    error: null,
+                });
+            }
+            catch (cause) {
+                if (controller.signal.aborted)
+                    return;
+                if (attemptIndex + 1 < delays.length) {
+                    await attempt(attemptIndex + 1);
+                    return;
+                }
+                setRemoteState({
+                    key: requestKey,
+                    product: null,
+                    index: -1,
+                    status: 'error',
+                    error: cause instanceof Error ? cause : new Error('Unable to load the product.'),
+                });
+            }
+        };
+        void attempt(0);
+        return () => {
+            controller.abort();
+            if (timer)
+                clearTimeout(timer);
+        };
+    }, [
+        catalogUrl,
+        localMatch.product,
+        locationState.initialized,
+        productId,
+        requestVersion,
+        retryKey,
+    ]);
+    const retry = (0, react_1.useCallback)(() => setRequestVersion((version) => version + 1), []);
+    const requestKey = catalogUrl
+        ? `${productId}|${catalogUrl}|${requestVersion}`
+        : '';
+    if (!locationState.initialized) {
+        return { product: null, productId, productIndex: -1, status: 'loading', error: null, retry };
+    }
+    if (!productId) {
+        return { product: null, productId, productIndex: -1, status: 'not-found', error: null, retry };
+    }
+    if (localMatch.product) {
+        return {
+            product: normalizeProductForDetail(localMatch.product, siteData),
+            productId,
+            productIndex: localMatch.index,
+            status: 'ready',
+            error: null,
+            retry,
+        };
+    }
+    if (!catalogUrl) {
+        return { product: null, productId, productIndex: -1, status: 'not-found', error: null, retry };
+    }
+    if (remoteState.key !== requestKey) {
+        return { product: null, productId, productIndex: -1, status: 'loading', error: null, retry };
+    }
+    return {
+        product: remoteState.product
+            ? normalizeProductForDetail(remoteState.product, siteData)
+            : null,
+        productId,
+        productIndex: remoteState.index,
+        status: remoteState.status,
+        error: remoteState.error,
+        retry,
+    };
+}
+/** Build the only product-detail URL that is safe for newly-created products in a static export. */
+function platformProductDetailHref(productId, route = DEFAULT_DETAIL_ROUTE, queryParam = DEFAULT_QUERY_PARAM) {
+    const normalizedProductId = normalizeId(productId);
+    if (!normalizedProductId)
+        return (0, utils_1.withBasePath)('/products/');
+    const separator = route.includes('?') ? '&' : '?';
+    return (0, utils_1.withBasePath)(`${route}${separator}${encodeURIComponent(queryParam)}=${encodeURIComponent(normalizedProductId)}`);
+}
+/**
+ * Ready-made live product page for Fivora templates. Use `renderProduct` when
+ * the template needs its own design; URL parsing, live lookup, retries, and
+ * fallback states remain owned by this component.
+ */
+function PlatformProductDetail({ productId, queryParam = DEFAULT_QUERY_PARAM, products, catalogUrl, retryDelays, renderProduct, loadingFallback, notFoundFallback, errorFallback, backHref = '/products/', backLabel = 'Back to products', sectionPath = 'product', ...detailProps }) {
+    const result = usePlatformProductDetail({
+        productId,
+        queryParam,
+        products,
+        catalogUrl,
+        retryDelays,
+    });
+    if (result.status === 'loading') {
+        return loadingFallback ?? ((0, jsx_runtime_1.jsx)("div", { role: "status", className: "mx-auto flex min-h-[40vh] max-w-7xl items-center justify-center px-4 py-16 text-sm text-slate-400", children: "Loading product\u2026" }));
+    }
+    if (result.status === 'error') {
+        return errorFallback ?? ((0, jsx_runtime_1.jsxs)("div", { className: "mx-auto flex min-h-[40vh] max-w-xl flex-col items-center justify-center gap-4 px-4 py-16 text-center", children: [(0, jsx_runtime_1.jsx)("h1", { className: "text-3xl font-bold text-slate-100", children: "Unable to load product" }), (0, jsx_runtime_1.jsx)("p", { className: "text-sm text-slate-400", children: "Please check your connection and try again." }), (0, jsx_runtime_1.jsx)("button", { type: "button", onClick: result.retry, className: "rounded-xl bg-white px-5 py-2.5 text-sm font-bold text-slate-950", children: "Try again" })] }));
+    }
+    if (result.status === 'not-found' || !result.product) {
+        return notFoundFallback ?? ((0, jsx_runtime_1.jsxs)("div", { className: "mx-auto flex min-h-[40vh] max-w-xl flex-col items-center justify-center gap-4 px-4 py-16 text-center", children: [(0, jsx_runtime_1.jsx)("h1", { className: "text-3xl font-bold text-slate-100", children: "Product unavailable" }), (0, jsx_runtime_1.jsx)("p", { className: "text-sm text-slate-400", children: "This product could not be found or is no longer listed." }), (0, jsx_runtime_1.jsx)("a", { href: (0, utils_1.withBasePath)(backHref), className: "rounded-xl bg-white px-5 py-2.5 text-sm font-bold text-slate-950", children: backLabel })] }));
+    }
+    const context = {
+        ...result,
+        sectionPath,
+    };
+    if (renderProduct) {
+        return (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: renderProduct(result.product, context) });
+    }
+    return ((0, jsx_runtime_1.jsx)(EditableProductDetail_1.EditableProductDetail, { ...detailProps, product: result.product, sectionPath: sectionPath }));
+}

package/dist/SiteDataProvider.js

@@ -195,15 +195,12 @@ function SiteDataProvider({ children, initialSiteData, fallbackSiteData, liveCat
                     : null);
         if (!endpoint)
             return;
-        const controller = new AbortController();
-        fetch(endpoint, {
-            signal: controller.signal,
-            headers: { Accept: "application/json" },
-        })
-            .then((res) => (res.ok ? res.json() : null))
-            .then((live) => {
-            if (!live || !isRecord(live))
-                return;
+        let stopped = false;
+        let activeController = null;
+        let retryTimer = null;
+        let lastSuccessfulFetchAt = 0;
+        const retryDelays = [750, 2_000, 5_000];
+        const applyLiveCatalog = (live) => {
             setSiteData((current) => {
                 const currentContent = isRecord(current.content) ? current.content : {};
                 const currentHome = isRecord(currentContent.home) ? currentContent.home : null;
@@ -251,11 +248,63 @@ function SiteDataProvider({ children, initialSiteData, fallbackSiteData, liveCat
                     rootStyle.setProperty("--brand-accent", live.theme.accentColor);
                 }
             }
-        })
-            .catch(() => {
-            // Gracefully keep pre-rendered static fallback if live API is unreachable
-        });
-        return () => controller.abort();
+        };
+        const loadLiveCatalog = async (attempt = 0) => {
+            if (stopped)
+                return;
+            activeController?.abort();
+            const controller = new AbortController();
+            activeController = controller;
+            try {
+                const response = await fetch(endpoint, {
+                    signal: controller.signal,
+                    cache: "no-store",
+                    headers: { Accept: "application/json" },
+                });
+                if (!response.ok) {
+                    throw new Error(`Live catalog request failed with ${response.status}`);
+                }
+                const live = await response.json();
+                if (stopped || !isRecord(live))
+                    return;
+                applyLiveCatalog(live);
+                lastSuccessfulFetchAt = Date.now();
+            }
+            catch (error) {
+                if (stopped ||
+                    (error instanceof DOMException && error.name === "AbortError")) {
+                    return;
+                }
+                const retryDelay = retryDelays[attempt];
+                if (retryDelay !== undefined) {
+                    retryTimer = window.setTimeout(() => {
+                        void loadLiveCatalog(attempt + 1);
+                    }, retryDelay);
+                }
+            }
+        };
+        const refreshIfStale = () => {
+            if (document.visibilityState === "visible" &&
+                Date.now() - lastSuccessfulFetchAt >= 30_000) {
+                if (retryTimer !== null)
+                    window.clearTimeout(retryTimer);
+                retryTimer = null;
+                void loadLiveCatalog();
+            }
+        };
+        void loadLiveCatalog();
+        window.addEventListener("focus", refreshIfStale);
+        window.addEventListener("online", refreshIfStale);
+        document.addEventListener("visibilitychange", refreshIfStale);
+        return () => {
+            stopped = true;
+            activeController?.abort();
+            if (retryTimer !== null)
+                window.clearTimeout(retryTimer);
+            window.removeEventListener("focus", refreshIfStale);
+            window.removeEventListener("online", refreshIfStale);
+            document.removeEventListener("visibilitychange", refreshIfStale);
+        };
     }, [liveCatalogEndpoint, siteSlug, initialSiteData]);
     (0, react_1.useEffect)(() => {
         let parentOrigin = resolveParentOrigin();

package/dist/index.d.ts

@@ -14,6 +14,7 @@ export * from './EditableProductCard';
 export * from './EditableProductGrid';
 export * from './EditableProductShowcase';
 export * from './EditableProductDetail';
+export * from './PlatformProductDetail';
 export * from './EditableCustomerReviews';
 export * from './EditableGoogleFeedback';
 export * from './EditableServiceCard';

package/dist/index.js

@@ -32,6 +32,7 @@ __exportStar(require("./EditableProductCard"), exports);
 __exportStar(require("./EditableProductGrid"), exports);
 __exportStar(require("./EditableProductShowcase"), exports);
 __exportStar(require("./EditableProductDetail"), exports);
+__exportStar(require("./PlatformProductDetail"), exports);
 __exportStar(require("./EditableCustomerReviews"), exports);
 __exportStar(require("./EditableGoogleFeedback"), exports);
 __exportStar(require("./EditableServiceCard"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deneb-ui/ui",
-  "version": "2.0.60",
+  "version": "2.0.61",
   "description": "Visual-first React component library for editable commerce storefronts. Built for Next.js and Fivora.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -50,7 +50,7 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@deneb-ui/core": "^2.0.60"
+    "@deneb-ui/core": "^2.0.61"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",