@withpotter/components 0.13.0-next.101

package/dist/content-type-page.js

@@ -0,0 +1,798 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState, useEffect, useMemo, useCallback, useRef } from "react";
+import { useAuth } from "@withpotter/lib/auth-context";
+import {
+  useCurrentTemplate,
+  useTemplates
+} from "@withpotter/lib/template-context";
+import { bookingsApi } from "@withpotter/lib/api/bookings";
+import { contentApi } from "@withpotter/lib/api/content";
+import { tenantApi } from "@withpotter/lib/api/tenant";
+import { waitlistApi } from "@withpotter/lib/api/waitlist";
+import {
+  useBookingActions
+} from "@withpotter/components/behaviors";
+import { useProductFormState } from "@withpotter/hooks/use-product-form-state";
+import { useApiDispatch } from "@withpotter/hooks/use-api-dispatch";
+import { useMoneyVisibility } from "@withpotter/lib/use-money-visibility";
+import { datedCsvFilename, downloadCsv } from "@withpotter/lib/csv";
+import { FallbackContentList } from "@withpotter/components/content-type-page/fallback-content-list";
+import { ContentEditorOverlays } from "@withpotter/components/content-type-page/content-editor-overlays";
+import { ConfiguredContentList } from "@withpotter/components/content-type-page/configured-content-list";
+import { ContentTypePageState } from "@withpotter/components/content-type-page/content-type-page-state";
+import { useContentListModel } from "@withpotter/components/content-type-page/use-content-list-model";
+function kebabToCamel(str) {
+  return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function ContentTypePage({
+  contentTypeKey,
+  backHref = "/dashboard",
+  resolvedContentType
+}) {
+  const { tenant, refreshTenant } = useAuth();
+  const { canSeeEarnings } = useMoneyVisibility();
+  const { template, loading: templateLoading } = useCurrentTemplate(
+    tenant?.templateId
+  );
+  const { loadTemplateSchema } = useTemplates();
+  const categorySyncAttempted = useRef(false);
+  const normalizedKey = kebabToCamel(contentTypeKey);
+  const contentType = resolvedContentType || template?.contentTypes[contentTypeKey] || // Try original key first (e.g., "treatments")
+  template?.contentTypes[normalizedKey] || // Try camelCase version
+  template?.contentTypes[contentTypeKey.toLowerCase()] || // Try lowercase
+  // Try to find by matching the name or singularName
+  Object.values(template?.contentTypes || {}).find(
+    (ct) => ct.name?.toLowerCase() === contentTypeKey.toLowerCase() || ct.singularName?.toLowerCase() === contentTypeKey.toLowerCase()
+  );
+  const [items, setItems] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [saving, setSaving] = useState(false);
+  const [searchQuery, setSearchQuery] = useState("");
+  const [selectedItem, setSelectedItem] = useState(null);
+  const [isEditing, setIsEditing] = useState(false);
+  const [isCreating, setIsCreating] = useState(false);
+  const [formValues, setFormValues] = useState({});
+  const [menuOpen, setMenuOpen] = useState(null);
+  const [confirmingDelete, setConfirmingDelete] = useState(null);
+  const [menuPosition, setMenuPosition] = useState(null);
+  const apiEndpoint = contentType?.apiEndpoint || contentType?.contentTypeKey || normalizedKey;
+  const isBookings = apiEndpoint === "bookings";
+  const TRANSACTIONAL_BEHAVIORS = [
+    "sellable",
+    "bookable",
+    "shippable",
+    "subscribable",
+    "downloadable",
+    "rentable",
+    "ticketed",
+    "addable"
+  ];
+  const isTransactional = contentType?.behaviors?.some((b) => TRANSACTIONAL_BEHAVIORS.includes(b)) ?? false;
+  const productFormState = useProductFormState({
+    contentType: isTransactional ? contentType ?? null : null,
+    product: isTransactional && selectedItem ? selectedItem : null
+  });
+  const { save: apiDispatchSave } = useApiDispatch();
+  const bookingActions = useBookingActions({
+    tenantSlug: tenant?.slug || "",
+    onSuccess: () => fetchContent(),
+    onError: (err) => setError(err.message)
+  });
+  const fetchContent = useCallback(async () => {
+    if (!tenant?.slug || !contentType) return;
+    setLoading(true);
+    setError(null);
+    try {
+      let contentItems = [];
+      if (apiEndpoint === "bookings") {
+        const response = await bookingsApi.list(tenant.slug);
+        contentItems = (response.data || []).map((booking) => {
+          const metadata = booking.metadata || {};
+          return {
+            id: booking.id,
+            tenantId: booking.tenantId,
+            type: booking.type,
+            title: booking.customerName || booking.bookingNumber,
+            slug: booking.bookingNumber,
+            isActive: booking.status === "confirmed" || booking.status === "completed",
+            featured: false,
+            sortOrder: 0,
+            createdAt: booking.createdAt,
+            updatedAt: booking.updatedAt,
+            data: {
+              // Core booking fields
+              bookingNumber: booking.bookingNumber,
+              bookingStatus: booking.status,
+              status: booking.status,
+              // Also expose as 'status' for template columns
+              type: booking.type,
+              date: booking.date,
+              startTime: booking.startTime,
+              endTime: booking.endTime,
+              customerName: booking.customerName,
+              customerEmail: booking.customerEmail,
+              customerPhone: booking.customerPhone,
+              customerNote: booking.customerNote,
+              durationMinutes: booking.durationMinutes,
+              // Include treatment/content info - price comes from the related content
+              treatmentTitle: metadata.treatmentTitle || booking.content?.title,
+              treatmentPrice: metadata.treatmentPrice || booking.content?.price,
+              // Spread all metadata - API enriches with fallbacks (e.g., treatmentTitle from content.title)
+              ...metadata
+            }
+          };
+        });
+      } else if (apiEndpoint === "waitlist") {
+        const response = await waitlistApi.list(tenant.slug);
+        contentItems = (response.data || []).map((entry) => ({
+          id: entry.id,
+          tenantId: tenant?.id ?? "",
+          type: "waitlist",
+          title: entry.customerName || entry.customerEmail,
+          slug: entry.id,
+          isActive: entry.status === "converted",
+          featured: false,
+          sortOrder: entry.position ?? 0,
+          createdAt: entry.createdAt,
+          updatedAt: entry.createdAt,
+          data: {
+            customerName: entry.customerName,
+            customerEmail: entry.customerEmail,
+            customerPhone: entry.customerPhone,
+            preferredDate: entry.requestedDate,
+            requestedStartTime: entry.requestedStartTime,
+            requestedEndTime: entry.requestedEndTime,
+            offeredDate: entry.offeredDate,
+            offeredStartTime: entry.offeredStartTime,
+            offeredEndTime: entry.offeredEndTime,
+            offerExpiresAt: entry.offerExpiresAt,
+            status: entry.status,
+            position: entry.position,
+            priority: entry.priority,
+            partySize: entry.partySize
+          }
+        }));
+      } else {
+        const apiContentType = contentType.contentTypeKey || normalizedKey;
+        const response = await contentApi.list(tenant.slug, apiContentType);
+        contentItems = Array.isArray(response) ? response : response.data || [];
+      }
+      setItems(contentItems);
+    } catch (err) {
+      console.error("Failed to fetch content:", err);
+      setError(err instanceof Error ? err.message : "Failed to load content");
+      setItems([]);
+    } finally {
+      setLoading(false);
+    }
+  }, [tenant?.slug, tenant?.id, contentType, normalizedKey, apiEndpoint]);
+  useEffect(() => {
+    if (contentType && tenant?.slug) {
+      fetchContent();
+    } else if (!templateLoading && contentType) {
+      setLoading(false);
+    }
+  }, [contentType, tenant?.slug, fetchContent, templateLoading]);
+  const tenantCurrency = tenant?.settings?.currency || "NGN";
+  const {
+    tenantCategories,
+    effectiveListView,
+    mergedFields,
+    deduplicatedMergedFields,
+    filteredItems,
+    enrichedFilters,
+    formatCurrency
+  } = useContentListModel({
+    contentType,
+    template: template ?? void 0,
+    tenantSlug: tenant?.slug,
+    tenantSettings: tenant?.settings,
+    tenantCurrency,
+    items,
+    searchQuery,
+    isTransactional
+  });
+  useEffect(() => {
+    if (categorySyncAttempted.current) return;
+    if (!tenant?.templateId || !tenant?.slug) return;
+    const existingCategories = tenant?.settings?.categories;
+    if (existingCategories && Object.keys(existingCategories).length > 0)
+      return;
+    categorySyncAttempted.current = true;
+    loadTemplateSchema(tenant.templateId).then(async (schema) => {
+      if (!schema?.siteSettings) return;
+      const defaultCategories = {};
+      for (const [, section] of Object.entries(schema.siteSettings)) {
+        const sectionData = section;
+        if (sectionData?.type === "categoryManager" && sectionData.defaults) {
+          defaultCategories[sectionData.contentTypeKey] = [
+            ...sectionData.defaults
+          ];
+        }
+      }
+      if (Object.keys(defaultCategories).length === 0) return;
+      try {
+        const existingSettings = tenant.settings || {};
+        await tenantApi.update(tenant.slug, {
+          settings: {
+            ...existingSettings,
+            categories: defaultCategories
+          }
+        });
+        await refreshTenant();
+      } catch (err) {
+        console.error("Failed to auto-sync default categories:", err);
+      }
+    });
+  }, [
+    tenant?.templateId,
+    tenant?.slug,
+    tenant?.settings,
+    loadTemplateSchema,
+    refreshTenant
+  ]);
+  const savedCustomFieldDefinitions = useMemo(() => {
+    const settings = tenant?.settings;
+    return settings?.customFieldDefinitions ?? [];
+  }, [tenant?.settings]);
+  const handleSaveCustomFieldDefinition = useCallback(
+    async (def) => {
+      if (!tenant?.slug) return;
+      const existing = savedCustomFieldDefinitions.filter(
+        (d) => d.key !== def.key
+      );
+      const updated = [...existing, def];
+      try {
+        await tenantApi.update(tenant.slug, {
+          settings: {
+            ...tenant.settings,
+            customFieldDefinitions: updated
+          }
+        });
+        await refreshTenant();
+      } catch (err) {
+        console.error("Failed to save custom field definition:", err);
+      }
+    },
+    [
+      tenant?.slug,
+      tenant?.settings,
+      savedCustomFieldDefinitions,
+      refreshTenant
+    ]
+  );
+  const handleRemoveCustomFieldDefinition = useCallback(
+    async (key) => {
+      if (!tenant?.slug) return;
+      const updated = savedCustomFieldDefinitions.filter((d) => d.key !== key);
+      try {
+        await tenantApi.update(tenant.slug, {
+          settings: {
+            ...tenant.settings,
+            customFieldDefinitions: updated
+          }
+        });
+        await refreshTenant();
+      } catch (err) {
+        console.error("Failed to remove custom field definition:", err);
+      }
+    },
+    [
+      tenant?.slug,
+      tenant?.settings,
+      savedCustomFieldDefinitions,
+      refreshTenant
+    ]
+  );
+  const getDisplayValue = (item, fieldName) => {
+    const field = contentType?.fields.find(
+      (f) => f.name === fieldName || f.name === `metadata.${fieldName}`
+    );
+    const cleanFieldName = fieldName.replace("metadata.", "");
+    const value = item[cleanFieldName] ?? item.data?.[cleanFieldName];
+    if (value === void 0 || value === null) return "\u2014";
+    switch (field?.type) {
+      case "currency":
+        return formatCurrency(value);
+      case "boolean":
+      case "toggle":
+        return value ? "\u2713 Yes" : "\u2717 No";
+      case "select":
+        return field.options?.find((o) => o.value === value)?.label || String(value);
+      case "multiselect": {
+        const vals = value;
+        return vals.map((v) => field.options?.find((o) => o.value === v)?.label || v).join(", ");
+      }
+      case "date":
+        return new Date(value).toLocaleDateString();
+      case "image":
+        return "\u{1F4F7} Image";
+      default:
+        return String(value);
+    }
+  };
+  const handleSave = async () => {
+    if (!tenant?.slug || !contentType) {
+      return;
+    }
+    setSaving(true);
+    setError(null);
+    try {
+      const apiContentType = contentType.contentTypeKey || normalizedKey;
+      if (isTransactional) {
+        const title2 = formValues.title || productFormState.title;
+        const slug2 = formValues.slug || productFormState.slug;
+        if (!title2?.trim()) {
+          setError("Title is required");
+          setSaving(false);
+          return;
+        }
+        await apiDispatchSave(
+          {
+            title: title2.trim(),
+            slug: slug2?.trim() || "",
+            description: formValues.description || productFormState.description || void 0,
+            featured: productFormState.featured,
+            isActive: productFormState.isActive,
+            heroImage: productFormState.heroImage,
+            galleryItems: productFormState.galleryItems,
+            price: productFormState.price,
+            compareAtPrice: productFormState.compareAtPrice,
+            costPrice: productFormState.costPrice,
+            currency: productFormState.tenantCurrency,
+            trackInventory: productFormState.trackInventory,
+            quantity: typeof productFormState.quantity === "number" ? productFormState.quantity : 0,
+            lowStockThreshold: typeof productFormState.lowStockThreshold === "number" ? productFormState.lowStockThreshold : 5,
+            productType: productFormState.productType,
+            behaviorConfigs: productFormState.behaviorConfigs,
+            gatedBy: productFormState.gatedBy,
+            gatedByPlanIds: productFormState.gatedByPlanIds,
+            templateValues: { ...formValues },
+            allCollections: productFormState.allCollections,
+            selectedCollectionIds: productFormState.selectedCollectionIds,
+            resourceRequirements: productFormState.resourceRequirements
+          },
+          apiContentType,
+          selectedItem?.id
+        );
+        await fetchContent();
+        setIsCreating(false);
+        setIsEditing(false);
+        setSelectedItem(null);
+        setFormValues({});
+        setSaving(false);
+        return;
+      }
+      const hasCustomStatusField = contentType.fields?.some(
+        (f) => f.name === "status" && f.type === "select"
+      );
+      const {
+        title,
+        slug,
+        description,
+        isActive,
+        status,
+        featured,
+        sortOrder,
+        price,
+        images,
+        ...rest
+      } = formValues;
+      const dataWithStatus = hasCustomStatusField ? { ...rest, status } : rest;
+      const payload = {
+        title: title || "Untitled",
+        slug,
+        description,
+        isActive: hasCustomStatusField ? true : isActive !== void 0 ? Boolean(isActive) : status === "published" || status === void 0,
+        featured: featured || false,
+        sortOrder: sortOrder || 0,
+        price,
+        images,
+        data: dataWithStatus
+        // Template-specific fields go in data
+      };
+      if (isCreating) {
+        if (apiEndpoint === "team") {
+          const imageVal = formValues.image;
+          const photo = imageVal ? typeof imageVal === "string" ? { url: imageVal } : imageVal.url ? { url: imageVal.url, alternativeText: imageVal.alt } : void 0 : void 0;
+          const teamPayload = {
+            name: formValues.name || "Untitled",
+            slug: formValues.slug,
+            role: formValues.role,
+            bio: formValues.bio,
+            photo,
+            socialLinks: {
+              instagram: formValues.instagram,
+              twitter: formValues.twitter,
+              linkedin: formValues.linkedin,
+              email: formValues.email
+            },
+            specialties: formValues.specialties,
+            featured: formValues.featured || false,
+            sortOrder: formValues.sortOrder || 0,
+            isActive: true
+          };
+          const response = await contentApi.create(
+            tenant.slug,
+            "team",
+            teamPayload
+          );
+          const newItem = response.data || response;
+          setItems([newItem, ...items]);
+        } else {
+          const response = await contentApi.create(
+            tenant.slug,
+            apiContentType,
+            payload
+          );
+          const newItem = response.data || response;
+          setItems([newItem, ...items]);
+        }
+      } else if (selectedItem) {
+        let updatedItem;
+        if (apiEndpoint === "bookings") {
+          const bookingPayload = {
+            status: formValues.status,
+            customerName: formValues.customerName,
+            customerEmail: formValues.customerEmail,
+            customerPhone: formValues.customerPhone,
+            customerNote: formValues.customerNote,
+            date: formValues.date,
+            startTime: formValues.startTime,
+            endTime: formValues.endTime,
+            // Include metadata for therapist and other custom fields
+            metadata: {
+              therapistName: formValues.therapistName,
+              therapistId: formValues.therapistId,
+              treatmentTitle: formValues.treatmentTitle,
+              treatmentPrice: formValues.treatmentPrice
+            }
+          };
+          await bookingsApi.update(
+            tenant.slug,
+            selectedItem.id,
+            bookingPayload
+          );
+          updatedItem = {
+            ...selectedItem,
+            data: {
+              ...selectedItem.data,
+              ...bookingPayload,
+              ...bookingPayload.metadata,
+              bookingStatus: bookingPayload.status
+            }
+          };
+        } else if (apiEndpoint === "team") {
+          const imageVal = formValues.image;
+          const photo = imageVal ? typeof imageVal === "string" ? { url: imageVal } : imageVal.url ? { url: imageVal.url, alternativeText: imageVal.alt } : void 0 : void 0;
+          const teamPayload = {
+            name: formValues.name || selectedItem.title || "Untitled",
+            slug: formValues.slug,
+            role: formValues.role,
+            bio: formValues.bio,
+            photo,
+            socialLinks: {
+              instagram: formValues.instagram,
+              twitter: formValues.twitter,
+              linkedin: formValues.linkedin,
+              email: formValues.email
+            },
+            specialties: formValues.specialties,
+            featured: formValues.featured || false,
+            sortOrder: formValues.sortOrder || 0
+          };
+          const response = await contentApi.update(
+            tenant.slug,
+            "team",
+            selectedItem.id,
+            teamPayload
+          );
+          updatedItem = response.data || response;
+        } else {
+          const response = await contentApi.update(
+            tenant.slug,
+            apiContentType,
+            selectedItem.id,
+            payload
+          );
+          updatedItem = response.data || response;
+        }
+        setItems(
+          items.map(
+            (item) => item.id === selectedItem.id ? updatedItem : item
+          )
+        );
+      }
+      setIsCreating(false);
+      setIsEditing(false);
+      setSelectedItem(null);
+      setFormValues({});
+    } catch (err) {
+      console.error("Failed to save:", err);
+      setError(err instanceof Error ? err.message : "Failed to save content");
+    } finally {
+      setSaving(false);
+    }
+  };
+  const handleDelete = async (id) => {
+    if (!tenant?.slug || !contentType) return;
+    try {
+      if (isBookings) {
+        await bookingsApi.cancel(tenant.slug, id);
+      } else {
+        const apiContentType = contentType.contentTypeKey || normalizedKey;
+        await contentApi.delete(tenant.slug, apiContentType, id);
+      }
+      setItems(items.filter((item) => item.id !== id));
+    } catch (err) {
+      console.error("Failed to delete:", err);
+      setError(err instanceof Error ? err.message : "Failed to delete");
+    }
+    setMenuOpen(null);
+  };
+  const handleBookingAction = async (action, item) => {
+    setMenuOpen(null);
+    if (action === "reschedule") {
+      bookingActions.openRescheduleModal(item);
+      return;
+    }
+    if (action === "cancel") {
+      bookingActions.openCancelModal(item);
+      return;
+    }
+    await bookingActions.executeAction(action, item);
+  };
+  const handleRescheduleConfirm = async (data) => {
+    if (!bookingActions.rescheduleItem) return;
+    const success = await bookingActions.executeAction(
+      "reschedule",
+      bookingActions.rescheduleItem,
+      data
+    );
+    if (success) {
+      bookingActions.closeRescheduleModal();
+    }
+  };
+  const handleCancelConfirm = async (reason) => {
+    if (!bookingActions.cancelItem) return;
+    const success = await bookingActions.executeAction(
+      "cancel",
+      bookingActions.cancelItem,
+      reason
+    );
+    if (success) {
+      bookingActions.closeCancelModal();
+    }
+  };
+  const openEditor = (item) => {
+    if (item) {
+      setSelectedItem(item);
+      const flatValues = {
+        title: item.title,
+        slug: item.slug,
+        description: item.description,
+        isActive: item.isActive,
+        featured: item.featured,
+        sortOrder: item.sortOrder,
+        price: item.price,
+        images: item.images,
+        ...item.data || {}
+        // Spread template-specific data (includes metadata fields)
+      };
+      setFormValues(flatValues);
+      setIsEditing(true);
+    } else {
+      setSelectedItem(null);
+      setFormValues(
+        contentType?.fields.reduce((acc, field) => {
+          if (field.defaultValue !== void 0) {
+            acc[field.name] = field.defaultValue;
+          }
+          return acc;
+        }, {}) || {}
+      );
+      setIsCreating(true);
+    }
+  };
+  if (templateLoading || !contentType?.name) {
+    return /* @__PURE__ */ jsx(
+      ContentTypePageState,
+      {
+        templateLoading,
+        contentType,
+        normalizedKey,
+        availableContentTypeKeys: Object.keys(template?.contentTypes || {}),
+        backHref
+      }
+    );
+  }
+  const ContentTypeIcon = contentType.icon;
+  const listFields = contentType.listFields || contentType.fields.slice(0, 4).map((f) => f.name.replace("metadata.", ""));
+  const handleFallbackExport = () => {
+    downloadCsv(
+      datedCsvFilename(contentType.name.toLowerCase().replace(/\s+/g, "-")),
+      listFields.map(
+        (fieldName) => contentType.fields.find(
+          (field) => field.name.replace("metadata.", "") === fieldName
+        )?.label || fieldName
+      ),
+      filteredItems.map(
+        (item) => listFields.map((fieldName) => getDisplayValue(item, fieldName))
+      )
+    );
+  };
+  const dataItems = items.map((item) => {
+    const flattened = { id: item.id, ...item.data };
+    Object.entries(item).forEach(([key, value]) => {
+      if (key !== "data" && value !== null && value !== void 0) {
+        flattened[key] = value;
+      }
+    });
+    flattened.id = item.id;
+    if (isBookings && item.data?.bookingStatus) {
+      flattened.status = item.data.bookingStatus;
+    }
+    return flattened;
+  });
+  const productMode = isTransactional ? {
+    price: productFormState.price,
+    compareAtPrice: productFormState.compareAtPrice,
+    costPrice: productFormState.costPrice,
+    onPriceChange: productFormState.setPrice,
+    onCompareAtPriceChange: productFormState.setCompareAtPrice,
+    onCostPriceChange: productFormState.setCostPrice,
+    showProfitability: canSeeEarnings,
+    currencySymbol: productFormState.currencySymbol,
+    trackInventory: productFormState.trackInventory,
+    onTrackInventoryChange: productFormState.setTrackInventory,
+    quantity: productFormState.quantity,
+    onQuantityChange: productFormState.setQuantity,
+    lowStockThreshold: productFormState.lowStockThreshold,
+    onLowStockThresholdChange: productFormState.setLowStockThreshold,
+    heroImage: productFormState.heroImage,
+    onHeroImageChange: productFormState.setHeroImage,
+    galleryItems: productFormState.galleryItems,
+    onGalleryItemsChange: productFormState.setGalleryItems,
+    behaviorConfigs: productFormState.behaviorConfigs,
+    setBehaviorConfigs: productFormState.setBehaviorConfigs,
+    availableBehaviors: productFormState.availableBehaviors,
+    behaviorLabelOverrides: productFormState.behaviorLabelOverrides,
+    gatedBy: productFormState.gatedBy,
+    setGatedBy: productFormState.setGatedBy,
+    gatedByPlanIds: productFormState.gatedByPlanIds,
+    setGatedByPlanIds: productFormState.setGatedByPlanIds,
+    activePlans: productFormState.activePlans,
+    linkedPlanName: productFormState.linkedPlanName,
+    updateBookableConfig: productFormState.updateBookableConfig,
+    updateShippableConfig: productFormState.updateShippableConfig,
+    updateSubscribableConfig: productFormState.updateSubscribableConfig,
+    updateDownloadableConfig: productFormState.updateDownloadableConfig,
+    updateRentableConfig: productFormState.updateRentableConfig,
+    updateTicketedConfig: productFormState.updateTicketedConfig,
+    updateGiftCardConfig: productFormState.updateGiftCardConfig,
+    resourceCategories: productFormState.resourceCategories,
+    resourceRequirements: productFormState.resourceRequirements,
+    onResourceRequirementsChange: productFormState.setResourceRequirements,
+    allCollections: productFormState.allCollections,
+    selectedCollectionIds: productFormState.selectedCollectionIds,
+    onSelectedCollectionIdsChange: productFormState.setSelectedCollectionIds,
+    collectionsLoading: productFormState.collectionsLoading
+  } : void 0;
+  const editorOverlays = /* @__PURE__ */ jsx(
+    ContentEditorOverlays,
+    {
+      editorOpen: isEditing || isCreating,
+      stepperProps: {
+        contentType,
+        mergedFields: isTransactional ? deduplicatedMergedFields : mergedFields,
+        formValues,
+        setFormValues,
+        tenantCurrency,
+        tenantCategories,
+        tenantSlug: tenant?.slug,
+        template,
+        isCreating,
+        saving,
+        selectedItem,
+        onSave: handleSave,
+        productMode,
+        savedCustomFieldDefinitions,
+        onSaveCustomFieldDefinition: handleSaveCustomFieldDefinition,
+        onRemoveCustomFieldDefinition: handleRemoveCustomFieldDefinition
+      },
+      onEditorClose: () => {
+        setIsCreating(false);
+        setIsEditing(false);
+        setSelectedItem(null);
+        setFormValues({});
+      },
+      rescheduleItem: bookingActions.rescheduleItem,
+      isRescheduling: bookingActions.isRescheduling,
+      onRescheduleClose: bookingActions.closeRescheduleModal,
+      onRescheduleConfirm: handleRescheduleConfirm,
+      cancelItem: bookingActions.cancelItem,
+      isCancelling: bookingActions.isCancelling,
+      onCancelClose: bookingActions.closeCancelModal,
+      onCancelConfirm: handleCancelConfirm,
+      bookingActionLoading: bookingActions.loading
+    }
+  );
+  if (effectiveListView) {
+    const listView = effectiveListView;
+    return /* @__PURE__ */ jsxs("div", { className: "p-4 lg:p-6 max-w-7xl mx-auto", children: [
+      /* @__PURE__ */ jsx(
+        ConfiguredContentList,
+        {
+          contentType,
+          ContentTypeIcon,
+          listView,
+          items,
+          dataItems,
+          loading,
+          error,
+          enrichedFilters,
+          fetchContent,
+          openEditor,
+          handleDelete,
+          formatCurrency,
+          isBookings,
+          bookingActionsLoading: bookingActions.loading,
+          handleBookingAction
+        }
+      ),
+      editorOverlays
+    ] });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: "p-4 lg:p-6 max-w-7xl mx-auto", children: [
+    /* @__PURE__ */ jsx(
+      FallbackContentList,
+      {
+        contentType,
+        ContentTypeIcon,
+        items,
+        filteredItems,
+        listFields,
+        loading,
+        error,
+        searchQuery,
+        setSearchQuery,
+        fetchContent,
+        openEditor,
+        getDisplayValue,
+        menuOpen,
+        setMenuOpen,
+        menuPosition,
+        setMenuPosition,
+        confirmingDelete,
+        setConfirmingDelete,
+        handleDelete,
+        isBookings,
+        bookingActionsLoading: bookingActions.loading,
+        handleBookingAction,
+        onExport: handleFallbackExport,
+        duplicateItem: (item) => {
+          const duplicateValues = {
+            title: `${item.title} (Copy)`,
+            description: item.description,
+            isActive: false,
+            featured: item.featured,
+            sortOrder: item.sortOrder,
+            price: item.price,
+            images: item.images,
+            ...item.data
+          };
+          setFormValues(duplicateValues);
+          setSelectedItem(null);
+          setIsCreating(true);
+        }
+      }
+    ),
+    editorOverlays
+  ] });
+}
+export {
+  ContentTypePage
+};
+//# sourceMappingURL=content-type-page.js.map