@voyantjs/products-ui 0.101.0 → 0.101.2

package/dist/components/product-detail/timezone-options.js

@@ -0,0 +1,28 @@
+import { timezones } from "@voyantjs/utils/timezones";
+function buildTimezoneOptions() {
+    const seen = new Map();
+    for (const tz of timezones) {
+        for (const id of tz.utc) {
+            if (seen.has(id))
+                continue;
+            seen.set(id, { id, label: tz.text, offset: tz.offset });
+        }
+    }
+    // Include the browser-resolved zone if not already present
+    const browserZone = typeof Intl !== "undefined" ? Intl.DateTimeFormat().resolvedOptions().timeZone : null;
+    if (browserZone && !seen.has(browserZone)) {
+        seen.set(browserZone, { id: browserZone, label: browserZone, offset: 0 });
+    }
+    return Array.from(seen.values()).sort((a, b) => {
+        if (a.offset !== b.offset)
+            return a.offset - b.offset;
+        return a.id.localeCompare(b.id);
+    });
+}
+export const TIMEZONE_OPTIONS = buildTimezoneOptions();
+export const TIMEZONE_IDS = TIMEZONE_OPTIONS.map((t) => t.id);
+const TIMEZONE_BY_ID = new Map(TIMEZONE_OPTIONS.map((t) => [t.id, t]));
+export function getTimezoneLabel(id) {
+    const tz = TIMEZONE_BY_ID.get(id);
+    return tz ? `${id} — ${tz.label}` : id;
+}

package/dist/components/product-detail/use-product-detail-data.d.ts

@@ -0,0 +1,41 @@
+import { useMutation } from "@tanstack/react-query";
+import { useProduct } from "@voyantjs/products-react";
+import { type AvailabilityRule, type ChannelInfo, type ChannelProductMapping, type DepartureSlot, type ProductMediaItem } from "./product-detail-shared.js";
+export interface UseProductDetailDataResult {
+    product: ReturnType<typeof useProduct>["data"];
+    isPending: boolean;
+    slots: DepartureSlot[];
+    rules: AvailabilityRule[];
+    channels: ChannelInfo[];
+    mappings: ChannelProductMapping[];
+    media: ProductMediaItem[];
+    itineraryNameById: Map<string, string>;
+    refetch: {
+        slots: () => void;
+        rules: () => void;
+        mappings: () => void;
+        media: () => void;
+    };
+    mutations: {
+        addChannelMapping: ReturnType<typeof useMutation<unknown, Error, string>>;
+        removeChannelMapping: ReturnType<typeof useMutation<unknown, Error, string>>;
+        duplicateProduct: ReturnType<typeof useMutation<{
+            data: {
+                id: string;
+            };
+        }, Error, void>>;
+        deleteProduct: ReturnType<typeof useMutation<unknown, Error, void>>;
+        deleteSlot: ReturnType<typeof useMutation<unknown, Error, string>>;
+        deleteRule: ReturnType<typeof useMutation<unknown, Error, string>>;
+        uploadMedia: ReturnType<typeof useMutation<unknown, Error, {
+            file: File;
+            dayId?: string;
+        }>>;
+        deleteMedia: ReturnType<typeof useMutation<unknown, Error, string>>;
+        setCover: ReturnType<typeof useMutation<unknown, Error, string>>;
+        generateBrochure: ReturnType<typeof useMutation<unknown, Error, void>>;
+    };
+    invalidateProduct: () => void;
+}
+export declare function useProductDetailData(productId: string): UseProductDetailDataResult;
+//# sourceMappingURL=use-product-detail-data.d.ts.map

package/dist/components/product-detail/use-product-detail-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-product-detail-data.d.ts","sourceRoot":"","sources":["../../../src/components/product-detail/use-product-detail-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAA4B,MAAM,uBAAuB,CAAA;AAC7E,OAAO,EAAqB,UAAU,EAAyB,MAAM,0BAA0B,CAAA;AAK/F,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAChB,KAAK,qBAAqB,EAC1B,KAAK,aAAa,EAMlB,KAAK,gBAAgB,EACtB,MAAM,4BAA4B,CAAA;AAEnC,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAA;IAC9C,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,aAAa,EAAE,CAAA;IACtB,KAAK,EAAE,gBAAgB,EAAE,CAAA;IACzB,QAAQ,EAAE,WAAW,EAAE,CAAA;IACvB,QAAQ,EAAE,qBAAqB,EAAE,CAAA;IACjC,KAAK,EAAE,gBAAgB,EAAE,CAAA;IACzB,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACtC,OAAO,EAAE;QACP,KAAK,EAAE,MAAM,IAAI,CAAA;QACjB,KAAK,EAAE,MAAM,IAAI,CAAA;QACjB,QAAQ,EAAE,MAAM,IAAI,CAAA;QACpB,KAAK,EAAE,MAAM,IAAI,CAAA;KAClB,CAAA;IACD,SAAS,EAAE;QACT,iBAAiB,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAA;QACzE,oBAAoB,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAA;QAC5E,gBAAgB,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC;YAAE,IAAI,EAAE;gBAAE,EAAE,EAAE,MAAM,CAAA;aAAE,CAAA;SAAE,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CAAA;QACvF,aAAa,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CAAA;QACnE,UAAU,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAA;QAClE,UAAU,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAA;QAClE,WAAW,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,OAAO,EAAE,KAAK,EAAE;YAAE,IAAI,EAAE,IAAI,CAAC;YAAC,KAAK,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC,CAAA;QAC3F,WAAW,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAA;QACnE,QAAQ,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAA;QAChE,gBAAgB,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CAAA;KACvE,CAAA;IACD,iBAAiB,EAAE,MAAM,IAAI,CAAA;CAC9B;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,0BAA0B,CAiKlF"}

package/dist/components/product-detail/use-product-detail-data.js

@@ -0,0 +1,143 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { productsQueryKeys, useProduct, useProductItineraries } from "@voyantjs/products-react";
+import { useMemo } from "react";
+import { useProductDetailHost, useProductDetailMessages } from "./host.js";
+import { getChannelsQueryOptions, getProductChannelMappingsQueryOptions, getProductMediaQueryOptions, getProductRulesQueryOptions, getProductSlotsQueryOptions, } from "./product-detail-shared.js";
+export function useProductDetailData(productId) {
+    const queryClient = useQueryClient();
+    const host = useProductDetailHost();
+    const api = host.api;
+    const messages = useProductDetailMessages();
+    const productMessages = messages.products.core;
+    const productQuery = useProduct(productId);
+    const itinerariesQuery = useProductItineraries(productId);
+    const productActionLedgerQueryKey = [...productsQueryKeys.product(productId), "action-ledger"];
+    const slotsQuery = useQuery(getProductSlotsQueryOptions(api, productId));
+    const rulesQuery = useQuery(getProductRulesQueryOptions(api, productId));
+    const channelsQuery = useQuery(getChannelsQueryOptions(api));
+    const mappingsQuery = useQuery(getProductChannelMappingsQueryOptions(api, productId));
+    const mediaQuery = useQuery(getProductMediaQueryOptions(api, productId));
+    const addChannelMapping = useMutation({
+        mutationFn: (channelId) => api.post("/v1/distribution/product-mappings", {
+            channelId,
+            productId,
+            active: true,
+        }),
+        onSuccess: () => {
+            void mappingsQuery.refetch();
+            void queryClient.invalidateQueries({ queryKey: productActionLedgerQueryKey });
+        },
+    });
+    const removeChannelMapping = useMutation({
+        mutationFn: (mappingId) => api.delete(`/v1/distribution/product-mappings/${mappingId}`),
+        onSuccess: () => {
+            void mappingsQuery.refetch();
+            void queryClient.invalidateQueries({ queryKey: productActionLedgerQueryKey });
+        },
+    });
+    const deleteProduct = useMutation({
+        mutationFn: () => api.delete(`/v1/products/${productId}`),
+        onSuccess: () => {
+            void queryClient.invalidateQueries({ queryKey: ["products"] });
+            void queryClient.invalidateQueries({ queryKey: productActionLedgerQueryKey });
+        },
+    });
+    const duplicateProduct = useMutation({
+        mutationFn: () => api.post(`/v1/admin/products/${productId}/duplicate`),
+        onSuccess: () => {
+            void queryClient.invalidateQueries({ queryKey: productsQueryKeys.products() });
+        },
+    });
+    const deleteSlot = useMutation({
+        mutationFn: (slotId) => api.delete(`/v1/availability/slots/${slotId}`),
+        onSuccess: () => {
+            void slotsQuery.refetch();
+            void queryClient.invalidateQueries({ queryKey: productActionLedgerQueryKey });
+        },
+    });
+    const deleteRule = useMutation({
+        mutationFn: (ruleId) => api.delete(`/v1/availability/rules/${ruleId}`),
+        onSuccess: () => {
+            void rulesQuery.refetch();
+            void queryClient.invalidateQueries({ queryKey: productActionLedgerQueryKey });
+        },
+    });
+    const uploadMedia = useMutation({
+        mutationFn: async ({ file, dayId }) => {
+            if (!host.uploadMedia)
+                throw new Error(productMessages.uploadFailed);
+            const result = await host.uploadMedia(file, { productId, dayId });
+            const endpoint = dayId
+                ? `/v1/products/${productId}/days/${dayId}/media`
+                : `/v1/products/${productId}/media`;
+            return api.post(endpoint, {
+                mediaType: result.mediaType,
+                name: result.name,
+                url: result.url,
+                storageKey: result.storageKey,
+                mimeType: result.mimeType,
+                fileSize: result.fileSize,
+            });
+        },
+        onSuccess: () => {
+            void mediaQuery.refetch();
+            void queryClient.invalidateQueries({ queryKey: productActionLedgerQueryKey });
+        },
+    });
+    const deleteMedia = useMutation({
+        mutationFn: (mediaId) => api.delete(`/v1/products/media/${mediaId}`),
+        onSuccess: () => {
+            void mediaQuery.refetch();
+            void queryClient.invalidateQueries({ queryKey: productActionLedgerQueryKey });
+        },
+    });
+    const setCover = useMutation({
+        mutationFn: (mediaId) => api.patch(`/v1/products/media/${mediaId}/set-cover`, {}),
+        onSuccess: () => {
+            void mediaQuery.refetch();
+            void queryClient.invalidateQueries({ queryKey: productActionLedgerQueryKey });
+        },
+    });
+    const generateBrochure = useMutation({
+        mutationFn: () => api.post(`/v1/admin/products/${productId}/brochure/generate`, {}),
+        onSuccess: () => {
+            void mediaQuery.refetch();
+            void queryClient.invalidateQueries({ queryKey: productActionLedgerQueryKey });
+        },
+    });
+    const itineraryNameById = useMemo(() => new Map((itinerariesQuery.data?.data ?? []).map((itinerary) => [itinerary.id, itinerary.name])), [itinerariesQuery.data]);
+    const invalidateProduct = () => {
+        void queryClient.invalidateQueries({ queryKey: productsQueryKeys.product(productId) });
+        void queryClient.invalidateQueries({ queryKey: productsQueryKeys.products() });
+        void queryClient.invalidateQueries({ queryKey: productActionLedgerQueryKey });
+    };
+    return {
+        product: productQuery.data,
+        isPending: productQuery.isPending,
+        slots: slotsQuery.data?.data ?? [],
+        rules: rulesQuery.data?.data ?? [],
+        channels: channelsQuery.data?.data ?? [],
+        mappings: mappingsQuery.data?.data ?? [],
+        media: mediaQuery.data?.data ?? [],
+        itineraryNameById,
+        refetch: {
+            slots: () => void slotsQuery.refetch(),
+            rules: () => void rulesQuery.refetch(),
+            mappings: () => void mappingsQuery.refetch(),
+            media: () => void mediaQuery.refetch(),
+        },
+        mutations: {
+            addChannelMapping,
+            removeChannelMapping,
+            duplicateProduct,
+            deleteProduct,
+            deleteSlot,
+            deleteRule,
+            uploadMedia,
+            deleteMedia,
+            setCover,
+            generateBrochure,
+        },
+        invalidateProduct,
+    };
+}

package/dist/components/product-detail/use-product-detail-dialogs.d.ts

@@ -0,0 +1,24 @@
+import type { AvailabilityRule, DepartureSlot } from "./product-detail-shared.js";
+export interface Toggle {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    openNow: () => void;
+    close: () => void;
+}
+export interface EditingToggle<T> {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    editing: T | undefined;
+    openNew: () => void;
+    openEdit: (item: T) => void;
+    close: () => void;
+}
+export interface UseProductDetailDialogsResult {
+    edit: Toggle;
+    bookingCreate: Toggle;
+    departure: EditingToggle<DepartureSlot>;
+    departureOverride: EditingToggle<DepartureSlot>;
+    schedule: EditingToggle<AvailabilityRule>;
+}
+export declare function useProductDetailDialogs(): UseProductDetailDialogsResult;
+//# sourceMappingURL=use-product-detail-dialogs.d.ts.map

package/dist/components/product-detail/use-product-detail-dialogs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-product-detail-dialogs.d.ts","sourceRoot":"","sources":["../../../src/components/product-detail/use-product-detail-dialogs.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAEjF,MAAM,WAAW,MAAM;IACrB,IAAI,EAAE,OAAO,CAAA;IACb,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAA;IAChC,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,KAAK,EAAE,MAAM,IAAI,CAAA;CAClB;AAED,MAAM,WAAW,aAAa,CAAC,CAAC;IAC9B,IAAI,EAAE,OAAO,CAAA;IACb,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAA;IAChC,OAAO,EAAE,CAAC,GAAG,SAAS,CAAA;IACtB,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAA;IAC3B,KAAK,EAAE,MAAM,IAAI,CAAA;CAClB;AAED,MAAM,WAAW,6BAA6B;IAC5C,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,EAAE,MAAM,CAAA;IACrB,SAAS,EAAE,aAAa,CAAC,aAAa,CAAC,CAAA;IACvC,iBAAiB,EAAE,aAAa,CAAC,aAAa,CAAC,CAAA;IAC/C,QAAQ,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAA;CAC1C;AAkCD,wBAAgB,uBAAuB,IAAI,6BAA6B,CAQvE"}

package/dist/components/product-detail/use-product-detail-dialogs.js

@@ -0,0 +1,40 @@
+import { useState } from "react";
+function useToggle() {
+    const [open, setOpen] = useState(false);
+    return {
+        open,
+        setOpen,
+        openNow: () => setOpen(true),
+        close: () => setOpen(false),
+    };
+}
+function useEditingToggle() {
+    const [open, setOpen] = useState(false);
+    const [editing, setEditing] = useState();
+    return {
+        open,
+        setOpen,
+        editing,
+        openNew: () => {
+            setEditing(undefined);
+            setOpen(true);
+        },
+        openEdit: (item) => {
+            setEditing(item);
+            setOpen(true);
+        },
+        close: () => {
+            setOpen(false);
+            setEditing(undefined);
+        },
+    };
+}
+export function useProductDetailDialogs() {
+    return {
+        edit: useToggle(),
+        bookingCreate: useToggle(),
+        departure: useEditingToggle(),
+        departureOverride: useEditingToggle(),
+        schedule: useEditingToggle(),
+    };
+}

package/dist/components/product-detail/zod-resolver.d.ts

@@ -0,0 +1,4 @@
+import type { FieldValues, Resolver } from "react-hook-form";
+import type { z } from "zod/v4";
+export declare function zodResolver<TSchema extends z.ZodType<FieldValues, FieldValues>>(schema: TSchema): Resolver<z.input<TSchema>, unknown, z.output<TSchema>>;
+//# sourceMappingURL=zod-resolver.d.ts.map

package/dist/components/product-detail/zod-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-resolver.d.ts","sourceRoot":"","sources":["../../../src/components/product-detail/zod-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,WAAW,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AACzE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AA+B/B,wBAAgB,WAAW,CAAC,OAAO,SAAS,CAAC,CAAC,OAAO,CAAC,WAAW,EAAE,WAAW,CAAC,EAC7E,MAAM,EAAE,OAAO,GACd,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CA6BxD"}

package/dist/components/product-detail/zod-resolver.js

@@ -0,0 +1,39 @@
+function setFieldError(target, path, error) {
+    let current = target;
+    for (let index = 0; index < path.length; index += 1) {
+        const key = String(path[index] ?? "root");
+        if (index === path.length - 1) {
+            current[key] = error;
+            return;
+        }
+        const next = current[key];
+        if (typeof next !== "object" || next === null) {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+}
+export function zodResolver(schema) {
+    return async (values) => {
+        const result = await schema.safeParseAsync(values);
+        if (result.success) {
+            return {
+                values: result.data,
+                errors: {},
+            };
+        }
+        const errors = {};
+        for (const issue of result.error.issues) {
+            const path = issue.path.filter((segment) => typeof segment !== "symbol");
+            const normalizedPath = path.length > 0 ? path : ["root"];
+            setFieldError(errors, normalizedPath, {
+                type: issue.code,
+                message: issue.message,
+            });
+        }
+        return {
+            values: {},
+            errors: errors,
+        };
+    };
+}

package/dist/components/product-option-form.js

@@ -29,7 +29,7 @@ function initialState(mode) {
         name: "",
         code: "",
         description: "",
-        status: "draft",
+        status: "active",
         isDefault: false,
         sortOrder: String(mode.sortOrder ?? 0),
         availableFrom: "",

package/dist/components/product-options-section.d.ts

@@ -1,5 +1,7 @@
-import { type ProductOptionRecord } from "@voyantjs/products-react";
+import { type OptionUnitRecord, type ProductOptionRecord } from "@voyantjs/products-react";
 import * as React from "react";
+export declare function optionLooksLikeRoomArrangementLabel(option: Pick<ProductOptionRecord, "code" | "name">): boolean;
+export declare function getRoomArrangementOptionNames(options: ReadonlyArray<Pick<ProductOptionRecord, "code" | "id" | "name" | "status">>, unitsByOptionId: ReadonlyMap<string, readonly Pick<OptionUnitRecord, "unitType">[]>): string[];
 export interface ProductOptionsSectionProps {
     productId: string;
     pageSize?: number;

package/dist/components/product-options-section.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"product-options-section.d.ts","sourceRoot":"","sources":["../../src/components/product-options-section.tsx"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,mBAAmB,EAMzB,MAAM,0BAA0B,CAAA;AAmBjC,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAoB9B,MAAM,WAAW,0BAA0B;IACzC,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,mBAAmB,CAAC,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,KAAK,CAAC,SAAS,CAAA;CACvE;AAED,wBAAgB,qBAAqB,CAAC,EACpC,SAAS,EACT,QAAc,EACd,KAAK,EACL,WAAW,EACX,mBAAmB,GACpB,EAAE,0BAA0B,2CAoH5B"}
+{"version":3,"file":"product-options-section.d.ts","sourceRoot":"","sources":["../../src/components/product-options-section.tsx"],"names":[],"mappings":"AAIA,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EAOzB,MAAM,0BAA0B,CAAA;AA6BjC,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAqC9B,wBAAgB,mCAAmC,CACjD,MAAM,EAAE,IAAI,CAAC,mBAAmB,EAAE,MAAM,GAAG,MAAM,CAAC,GACjD,OAAO,CAIT;AAED,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,mBAAmB,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,QAAQ,CAAC,CAAC,EACpF,eAAe,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,IAAI,CAAC,gBAAgB,EAAE,UAAU,CAAC,EAAE,CAAC,GAClF,MAAM,EAAE,CASV;AA0CD,MAAM,WAAW,0BAA0B;IACzC,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,mBAAmB,CAAC,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,KAAK,CAAC,SAAS,CAAA;CACvE;AAED,wBAAgB,qBAAqB,CAAC,EACpC,SAAS,EACT,QAAc,EACd,KAAK,EACL,WAAW,EACX,mBAAmB,GACpB,EAAE,0BAA0B,2CAsJ5B"}

package/dist/components/product-options-section.js

@@ -1,12 +1,14 @@
 "use client";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useQueries } from "@tanstack/react-query";
 import { useDuplicateOptionPricingMutation } from "@voyantjs/pricing-react";
-import { useDuplicateProductOptionMutation, useOptionUnitMutation, useOptionUnits, useProductOptionMutation, useProductOptions, } from "@voyantjs/products-react";
+import { getOptionUnitsQueryOptions, useDuplicateProductOptionMutation, useOptionUnitMutation, useOptionUnits, useProductOptionMutation, useProductOptions, useVoyantProductsContext, } from "@voyantjs/products-react";
+import { Alert, AlertDescription, AlertTitle } from "@voyantjs/ui/components/alert";
 import { Badge } from "@voyantjs/ui/components/badge";
 import { Button } from "@voyantjs/ui/components/button";
 import { Card, CardContent, CardDescription, CardHeader, CardTitle, } from "@voyantjs/ui/components/card";
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow, } from "@voyantjs/ui/components/table";
-import { ChevronDown, ChevronRight, Copy, Loader2, Pencil, Plus, Trash2 } from "lucide-react";
+import { ChevronDown, ChevronRight, Copy, Loader2, Pencil, Plus, Trash2, TriangleAlert, } from "lucide-react";
 import * as React from "react";
 import { useProductsUiMessagesOrDefault } from "../i18n/provider.js";
 import { OptionUnitDialog } from "./option-unit-dialog.js";
@@ -22,8 +24,60 @@ function formatRange(min, max) {
     }
     return `${min ?? 0}–${max ?? "∞"}`;
 }
+function formatMessage(template, replacements) {
+    return Object.entries(replacements).reduce((message, [key, value]) => message.replaceAll(`{${key}}`, String(value)), template);
+}
+const ROOM_ARRANGEMENT_LABEL_PATTERN = /\b(single|sgl|double|dbl|twin|triple|tpl|quad|dubla|tripla|camera)\b/i;
+function normalizeConfigurationLabel(value) {
+    return (value ?? "")
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase();
+}
+export function optionLooksLikeRoomArrangementLabel(option) {
+    return [option.name, option.code].some((value) => ROOM_ARRANGEMENT_LABEL_PATTERN.test(normalizeConfigurationLabel(value)));
+}
+export function getRoomArrangementOptionNames(options, unitsByOptionId) {
+    return options
+        .filter((option) => option.status !== "archived")
+        .filter(optionLooksLikeRoomArrangementLabel)
+        .filter((option) => {
+        const units = unitsByOptionId.get(option.id) ?? [];
+        return units.length > 0 && units.every((unit) => unit.unitType === "room");
+    })
+        .map((option) => option.name);
+}
+function formatInventory(unit, messages) {
+    if (unit.unitType === "room") {
+        if (unit.maxQuantity != null && unit.maxQuantity > 0) {
+            return formatMessage(messages.unitSummaries.roomsWithCount, { count: unit.maxQuantity });
+        }
+        return messages.unitSummaries.rooms;
+    }
+    if (unit.unitType === "vehicle") {
+        if (unit.maxQuantity != null && unit.maxQuantity > 0) {
+            return formatMessage(messages.unitSummaries.vehiclesWithCount, { count: unit.maxQuantity });
+        }
+        return messages.unitSummaries.vehicles;
+    }
+    return formatMessage(messages.unitSummaries.range, {
+        range: formatRange(unit.minQuantity, unit.maxQuantity),
+    });
+}
+function formatOccupancyText(unit, messages) {
+    if (unit.occupancyMin == null && unit.occupancyMax == null) {
+        return "—";
+    }
+    if (unit.occupancyMin === unit.occupancyMax) {
+        return formatMessage(messages.unitSummaries.sleeps, { count: unit.occupancyMin ?? 0 });
+    }
+    return formatMessage(messages.unitSummaries.sleepsRange, {
+        range: `${unit.occupancyMin ?? 0}–${unit.occupancyMax ?? "∞"}`,
+    });
+}
 export function ProductOptionsSection({ productId, pageSize = 100, title, description, renderOptionDetails, }) {
     const messages = useProductsUiMessagesOrDefault();
+    const productsClient = useVoyantProductsContext();
     const [expandedOptionId, setExpandedOptionId] = React.useState(null);
     const [dialogOpen, setDialogOpen] = React.useState(false);
     const [editingOption, setEditingOption] = React.useState(undefined);
@@ -35,13 +89,32 @@ export function ProductOptionsSection({ productId, pageSize = 100, title, descri
     const duplicateOption = useDuplicateProductOptionMutation();
     const duplicatePricing = useDuplicateOptionPricingMutation();
     const options = React.useMemo(() => (data?.data ?? []).slice().sort((a, b) => a.sortOrder - b.sortOrder), [data?.data]);
+    const optionUnitQueries = useQueries({
+        queries: options.map((option) => ({
+            ...getOptionUnitsQueryOptions(productsClient, {
+                optionId: option.id,
+                limit: 100,
+            }),
+            enabled: options.length > 1,
+        })),
+    });
+    const roomArrangementOptionNames = React.useMemo(() => {
+        const unitsByOptionId = new Map();
+        options.forEach((option, index) => {
+            const units = optionUnitQueries[index]?.data?.data;
+            if (units)
+                unitsByOptionId.set(option.id, units);
+        });
+        return getRoomArrangementOptionNames(options, unitsByOptionId);
+    }, [options, optionUnitQueries]);
+    const showRoomArrangementWarning = roomArrangementOptionNames.length >= 2;
     const nextSortOrder = options.length > 0 ? Math.max(...options.map((option) => option.sortOrder)) + 1 : 0;
     const resolvedTitle = title ?? messages.productOptionsSection.titles.default;
     const resolvedDescription = description ?? messages.productOptionsSection.descriptions.default;
     return (_jsxs(Card, { "data-slot": "product-options-section", children: [_jsxs(CardHeader, { className: "flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between", children: [_jsxs("div", { className: "space-y-1", children: [_jsx(CardTitle, { children: resolvedTitle }), _jsx(CardDescription, { children: resolvedDescription })] }), _jsxs(Button, { onClick: () => {
                             setEditingOption(undefined);
                             setDialogOpen(true);
-                        }, children: [_jsx(Plus, { className: "mr-2 size-4", "aria-hidden": "true" }), messages.productOptionsSection.actions.addOption] })] }), _jsxs(CardContent, { className: "flex flex-col gap-3", children: [isPending ? (_jsx("div", { className: "flex min-h-24 items-center justify-center", children: _jsx(Loader2, { className: "size-4 animate-spin text-muted-foreground" }) })) : isError ? (_jsx("p", { className: "text-sm text-destructive", children: messages.productOptionsSection.loadingError.options })) : options.length === 0 ? (_jsx("p", { className: "text-sm text-muted-foreground", children: messages.productOptionsSection.empty.options })) : (options.map((option) => (_jsx(OptionRow, { option: option, expanded: expandedOptionId === option.id, onToggle: () => setExpandedOptionId((current) => (current === option.id ? null : option.id)), onEdit: () => {
+                        }, children: [_jsx(Plus, { className: "mr-2 size-4", "aria-hidden": "true" }), messages.productOptionsSection.actions.addOption] })] }), _jsxs(CardContent, { className: "flex flex-col gap-3", children: [showRoomArrangementWarning ? (_jsxs(Alert, { className: "border-amber-500/40 bg-amber-500/10", children: [_jsx(TriangleAlert, { className: "size-4 text-amber-600", "aria-hidden": "true" }), _jsx(AlertTitle, { children: messages.productOptionsSection.configurationWarnings.roomOptionsTitle }), _jsx(AlertDescription, { children: formatMessage(messages.productOptionsSection.configurationWarnings.roomOptionsDescription, { options: roomArrangementOptionNames.join(", ") }) })] })) : null, isPending ? (_jsx("div", { className: "flex min-h-24 items-center justify-center", children: _jsx(Loader2, { className: "size-4 animate-spin text-muted-foreground" }) })) : isError ? (_jsx("p", { className: "text-sm text-destructive", children: messages.productOptionsSection.loadingError.options })) : options.length === 0 ? (_jsx("p", { className: "text-sm text-muted-foreground", children: messages.productOptionsSection.empty.options })) : (options.map((option) => (_jsx(OptionRow, { option: option, expanded: expandedOptionId === option.id, onToggle: () => setExpandedOptionId((current) => (current === option.id ? null : option.id)), onEdit: () => {
                             setEditingOption(option);
                             setDialogOpen(true);
                         }, onDuplicate: () => {
@@ -74,10 +147,34 @@ function UnitsPanel({ optionId, messages, }) {
     const { remove } = useOptionUnitMutation();
     const units = React.useMemo(() => (data?.data ?? []).slice().sort((a, b) => a.sortOrder - b.sortOrder), [data?.data]);
     const nextSortOrder = units.length > 0 ? Math.max(...units.map((unit) => unit.sortOrder)) + 1 : 0;
-    return (_jsxs("div", { className: "flex flex-col gap-3", children: [_jsxs("div", { className: "flex items-center justify-between", children: [_jsxs("div", { children: [_jsx("p", { className: "text-xs font-medium uppercase tracking-wide text-muted-foreground", children: messages.productOptionsSection.titles.units }), _jsx("p", { className: "text-xs text-muted-foreground", children: messages.productOptionsSection.descriptions.units })] }), _jsxs(Button, { variant: "outline", size: "sm", onClick: () => {
+    const isPersonOnly = units.length > 0 && units.every((unit) => unit.unitType === "person");
+    const showAge = units.some((unit) => unit.unitType === "person");
+    const hasRoomUnits = units.some((unit) => unit.unitType === "room");
+    const showOccupancy = units.some((unit) => unit.unitType === "room" || unit.occupancyMin != null || unit.occupancyMax != null);
+    const unitsTitle = isPersonOnly
+        ? messages.productOptionsSection.titles.personUnits
+        : hasRoomUnits
+            ? messages.productOptionsSection.titles.roomUnits
+            : messages.productOptionsSection.titles.units;
+    const unitsDescription = isPersonOnly
+        ? messages.productOptionsSection.descriptions.personUnits
+        : hasRoomUnits
+            ? messages.productOptionsSection.descriptions.roomUnits
+            : messages.productOptionsSection.descriptions.units;
+    const addUnitLabel = isPersonOnly
+        ? messages.productOptionsSection.actions.addPersonUnit
+        : hasRoomUnits
+            ? messages.productOptionsSection.actions.addRoomUnit
+            : messages.productOptionsSection.actions.addUnit;
+    const quantityColumnLabel = isPersonOnly
+        ? messages.productOptionsSection.columns.personQuantity
+        : hasRoomUnits
+            ? messages.productOptionsSection.columns.roomQuantity
+            : messages.productOptionsSection.columns.quantity;
+    return (_jsxs("div", { className: "flex flex-col gap-3", children: [_jsxs("div", { className: "flex items-center justify-between", children: [_jsxs("div", { children: [_jsx("p", { className: "text-xs font-medium uppercase tracking-wide text-muted-foreground", children: unitsTitle }), _jsx("p", { className: "text-xs text-muted-foreground", children: unitsDescription })] }), _jsxs(Button, { variant: "outline", size: "sm", onClick: () => {
                             setEditingUnit(undefined);
                             setDialogOpen(true);
-                        }, children: [_jsx(Plus, { className: "mr-2 size-3.5", "aria-hidden": "true" }), messages.productOptionsSection.actions.addUnit] })] }), isPending ? (_jsx("div", { className: "flex min-h-20 items-center justify-center rounded-md border bg-background", children: _jsx(Loader2, { className: "size-4 animate-spin text-muted-foreground" }) })) : isError ? (_jsx("p", { className: "text-sm text-destructive", children: messages.productOptionsSection.loadingError.units })) : units.length === 0 ? (_jsx("p", { className: "rounded-md border bg-background px-3 py-4 text-sm text-muted-foreground", children: messages.productOptionsSection.empty.units })) : (_jsx("div", { className: "rounded-md border bg-background", children: _jsxs(Table, { children: [_jsx(TableHeader, { children: _jsxs(TableRow, { children: [_jsx(TableHead, { children: messages.productOptionsSection.columns.unitType }), _jsx(TableHead, { children: messages.productOptionsSection.columns.unitName }), _jsx(TableHead, { children: messages.productOptionsSection.columns.quantity }), _jsx(TableHead, { children: messages.productOptionsSection.columns.age }), _jsx(TableHead, { children: messages.productOptionsSection.columns.occupancy }), _jsx(TableHead, { className: "w-[88px] text-right", children: messages.productOptionsSection.columns.actions })] }) }), _jsx(TableBody, { children: units.map((unit) => (_jsxs(TableRow, { children: [_jsx(TableCell, { children: _jsx(Badge, { variant: "outline", children: messages.common.optionUnitTypeLabels[unit.unitType] }) }), _jsxs(TableCell, { children: [_jsx("div", { className: "font-medium", children: unit.name }), unit.code ? (_jsx("div", { className: "font-mono text-xs text-muted-foreground", children: unit.code })) : null] }), _jsx(TableCell, { className: "font-mono text-xs", children: formatRange(unit.minQuantity, unit.maxQuantity) }), _jsx(TableCell, { className: "font-mono text-xs", children: formatRange(unit.minAge, unit.maxAge) }), _jsx(TableCell, { className: "font-mono text-xs", children: formatRange(unit.occupancyMin, unit.occupancyMax) }), _jsx(TableCell, { className: "text-right", children: _jsxs("div", { className: "flex items-center justify-end gap-1", children: [_jsx(Button, { variant: "ghost", size: "icon-sm", onClick: () => {
+                        }, children: [_jsx(Plus, { className: "mr-2 size-3.5", "aria-hidden": "true" }), addUnitLabel] })] }), isPending ? (_jsx("div", { className: "flex min-h-20 items-center justify-center rounded-md border bg-background", children: _jsx(Loader2, { className: "size-4 animate-spin text-muted-foreground" }) })) : isError ? (_jsx("p", { className: "text-sm text-destructive", children: messages.productOptionsSection.loadingError.units })) : units.length === 0 ? (_jsx("p", { className: "rounded-md border bg-background px-3 py-4 text-sm text-muted-foreground", children: messages.productOptionsSection.empty.units })) : (_jsx("div", { className: "rounded-md border bg-background", children: _jsxs(Table, { children: [_jsx(TableHeader, { children: _jsxs(TableRow, { children: [_jsx(TableHead, { children: messages.productOptionsSection.columns.unitType }), _jsx(TableHead, { children: messages.productOptionsSection.columns.unitName }), _jsx(TableHead, { children: quantityColumnLabel }), showAge ? (_jsx(TableHead, { children: messages.productOptionsSection.columns.age })) : null, showOccupancy ? (_jsx(TableHead, { children: messages.productOptionsSection.columns.occupancy })) : null, _jsx(TableHead, { className: "w-[88px] text-right", children: messages.productOptionsSection.columns.actions })] }) }), _jsx(TableBody, { children: units.map((unit) => (_jsxs(TableRow, { children: [_jsx(TableCell, { children: _jsx(Badge, { variant: "outline", children: messages.common.optionUnitTypeLabels[unit.unitType] }) }), _jsxs(TableCell, { children: [_jsx("div", { className: "font-medium", children: unit.name }), unit.code ? (_jsx("div", { className: "font-mono text-xs text-muted-foreground", children: unit.code })) : null] }), _jsx(TableCell, { children: _jsx("div", { className: "text-xs", children: formatInventory(unit, messages.productOptionsSection) }) }), showAge ? (_jsx(TableCell, { className: "font-mono text-xs", children: formatRange(unit.minAge, unit.maxAge) })) : null, showOccupancy ? (_jsx(TableCell, { children: _jsx("div", { className: "text-xs", children: formatOccupancyText(unit, messages.productOptionsSection) }) })) : null, _jsx(TableCell, { className: "text-right", children: _jsxs("div", { className: "flex items-center justify-end gap-1", children: [_jsx(Button, { variant: "ghost", size: "icon-sm", onClick: () => {
                                                         setEditingUnit(unit);
                                                         setDialogOpen(true);
                                                     }, "aria-label": messages.productOptionsSection.actions.edit, children: _jsx(Pencil, { className: "size-4", "aria-hidden": "true" }) }), _jsx(Button, { variant: "ghost", size: "icon-sm", onClick: () => {

package/dist/i18n/en.d.ts

@@ -742,14 +742,20 @@ export declare const productsUiEn: {
         titles: {
             default: string;
             units: string;
+            personUnits: string;
+            roomUnits: string;
         };
         descriptions: {
             default: string;
             units: string;
+            personUnits: string;
+            roomUnits: string;
         };
         actions: {
             addOption: string;
             addUnit: string;
+            addPersonUnit: string;
+            addRoomUnit: string;
             duplicate: string;
             edit: string;
             delete: string;
@@ -762,6 +768,10 @@ export declare const productsUiEn: {
             options: string;
             units: string;
         };
+        configurationWarnings: {
+            roomOptionsTitle: string;
+            roomOptionsDescription: string;
+        };
         deleteConfirm: {
             option: string;
             unit: string;
@@ -770,10 +780,21 @@ export declare const productsUiEn: {
             unitType: string;
             unitName: string;
             quantity: string;
+            personQuantity: string;
+            roomQuantity: string;
             age: string;
             occupancy: string;
             actions: string;
         };
+        unitSummaries: {
+            range: string;
+            rooms: string;
+            roomsWithCount: string;
+            vehicles: string;
+            vehiclesWithCount: string;
+            sleeps: string;
+            sleepsRange: string;
+        };
         badges: {
             defaultOption: string;
         };

package/dist/i18n/en.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../src/i18n/en.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+wBK,CAAA"}
+{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../src/i18n/en.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0yBK,CAAA"}