@thorprovider/blocks 4.1.0 → 4.3.0

package/dist/blocks/designs/customer-favorites/components/customer-favorites.mjs

@@ -0,0 +1,874 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from "react";
+import { Button } from "@thorprovider/blocks";
+import {
+  collectionCounts,
+  collectionRows,
+  identityMemberships,
+  mergeCartResults,
+  organizationLists,
+  personalLists,
+  prepareCart,
+  resolveViewState
+} from "../engine.mjs";
+import { listActions } from "../permissions.mjs";
+import { ConfirmDialog } from "./confirm-dialog.mjs";
+import { CartFeedback } from "./cart-feedback.mjs";
+import { BulkListsDialog } from "./bulk-lists-dialog.mjs";
+import { FavoriteListDetail } from "./favorite-list-detail.mjs";
+import { FavoriteProductCard } from "./favorite-product-card.mjs";
+import { FavoritesHeader } from "./favorites-header.mjs";
+import { FavoritesNavigation } from "./favorites-navigation.mjs";
+import { FavoritesStatus } from "./favorites-status.mjs";
+import { ListDialog } from "./list-dialog.mjs";
+import { ManageListsDialog } from "./manage-lists-dialog.mjs";
+import { OrganizeDialog } from "./organize-dialog.mjs";
+import { VariantDialog } from "./variant-dialog.mjs";
+function CustomerFavorites({
+  source,
+  capabilities,
+  labels,
+  session,
+  lang,
+  initialCollection,
+  cart,
+  onAddToCart,
+  onSignIn,
+  onExploreProducts,
+  onOpenProduct,
+  onShareList,
+  onRetry
+}) {
+  const [snapshot, setSnapshot] = useState(null);
+  const [status, setStatus] = useState("loading");
+  const [reloadKey, setReloadKey] = useState(0);
+  const [active, setActive] = useState(initialCollection ?? "all");
+  const [query, setQuery] = useState("");
+  const [sort, setSort] = useState("recent");
+  const [savingKey, setSavingKey] = useState(null);
+  const [saveErrorKey, setSaveErrorKey] = useState(null);
+  const [pendingRemoval, setPendingRemoval] = useState(null);
+  const [manageOpen, setManageOpen] = useState(false);
+  const [listDialog, setListDialog] = useState(null);
+  const [dialogError, setDialogError] = useState(null);
+  const [organizeRow, setOrganizeRow] = useState(null);
+  const [organizeSelected, setOrganizeSelected] = useState([]);
+  const [deleteTarget, setDeleteTarget] = useState(null);
+  const [shareTarget, setShareTarget] = useState(null);
+  const [selected, setSelected] = useState([]);
+  const [selecting, setSelecting] = useState(false);
+  const [bulkLists, setBulkLists] = useState(null);
+  const [bulkDeleteOpen, setBulkDeleteOpen] = useState(false);
+  const [cartBusy, setCartBusy] = useState(false);
+  const [cartOutcome, setCartOutcome] = useState(null);
+  const [cartError, setCartError] = useState(null);
+  const [lastCart, setLastCart] = useState(null);
+  const [variantRequest, setVariantRequest] = useState(null);
+  useEffect(() => {
+    const controller = new AbortController();
+    setStatus("loading");
+    source.load(controller.signal).then((next) => {
+      if (controller.signal.aborted) return;
+      setSnapshot(next);
+      setStatus("ready");
+    }).catch((error) => {
+      if (error instanceof Error && error.name === "AbortError") return;
+      setStatus("error");
+    });
+    return () => controller.abort();
+  }, [source, reloadKey]);
+  useEffect(() => {
+    setSelected([]);
+  }, [active]);
+  useEffect(() => {
+    if (!selecting) setSelected([]);
+  }, [selecting]);
+  useEffect(() => {
+    if (!capabilities.namedLists && active.startsWith("list:")) setActive("all");
+  }, [capabilities.namedLists, active]);
+  const rows = useMemo(() => {
+    if (!snapshot) return [];
+    return collectionRows(snapshot, active, {
+      variantFavorites: capabilities.variantFavorites,
+      query: capabilities.search ? query : "",
+      sort: capabilities.sorting ? sort : "recent"
+    });
+  }, [snapshot, active, capabilities.variantFavorites, capabilities.search, capabilities.sorting, query, sort]);
+  useEffect(() => {
+    const keys = new Set(rows.map((row) => row.key));
+    setSelected((current) => current.filter((key) => keys.has(key)));
+  }, [rows]);
+  const counts = useMemo(
+    () => snapshot ? collectionCounts(snapshot, capabilities.variantFavorites) : {},
+    [snapshot, capabilities.variantFavorites]
+  );
+  const selectedRows = rows.filter((row) => selected.includes(row.key));
+  const authenticated = session === "authenticated" && (snapshot?.viewer.authenticated ?? true);
+  const state = resolveViewState({
+    status,
+    enabled: capabilities.enabled,
+    authenticated,
+    collection: active,
+    collectionTotal: counts[active] ?? 0,
+    visibleRows: rows.length,
+    query: capabilities.search ? query : ""
+  });
+  const personal = snapshot ? personalLists(snapshot) : [];
+  const organization = snapshot && capabilities.organizationLists ? organizationLists(snapshot) : [];
+  const collections = [
+    { id: "all", label: labels.collections.all, count: counts.all ?? 0, group: "personal" },
+    {
+      id: "unlisted",
+      label: labels.collections.unlisted,
+      count: counts.unlisted ?? 0,
+      group: "personal"
+    },
+    ...capabilities.namedLists ? personal.slice(0, 5).map((list) => ({
+      id: `list:${list.id}`,
+      label: list.name,
+      count: counts[`list:${list.id}`] ?? 0,
+      group: "personal"
+    })) : [],
+    ...capabilities.namedLists ? organization.map((list) => ({
+      id: `list:${list.id}`,
+      label: list.name,
+      count: counts[`list:${list.id}`] ?? 0,
+      group: "organization"
+    })) : []
+  ];
+  const retry = () => {
+    setReloadKey((value) => value + 1);
+    onRetry?.();
+  };
+  const activeListId = active.startsWith("list:") ? active.slice("list:".length) : null;
+  const activeList = snapshot?.lists.find((list) => list.id === activeListId) ?? null;
+  const activeActions = activeList ? listActions(activeList) : null;
+  const personalIds = new Set(personal.map((list) => list.id));
+  const fullMembershipsFor = (row) => snapshot ? identityMemberships(snapshot, row.product.productId, row.variant?.id, {
+    variantFavorites: capabilities.variantFavorites
+  }) : [];
+  const personalCountFor = (row) => fullMembershipsFor(row).filter((entry) => personalIds.has(entry.listId)).length;
+  const mutate = async (key, action) => {
+    setSavingKey(key);
+    setSaveErrorKey(null);
+    try {
+      setSnapshot(await action());
+      return true;
+    } catch {
+      setSaveErrorKey(key);
+      return false;
+    } finally {
+      setSavingKey(null);
+    }
+  };
+  const toggleFavorite = (row) => {
+    if (!authenticated) {
+      onSignIn?.();
+      return;
+    }
+    if (savingKey) return;
+    if (row.favorite) {
+      if (personalCountFor(row) > 0) {
+        setPendingRemoval(row);
+        return;
+      }
+      const favoriteId = row.favorite.id;
+      void mutate(row.key, () => source.removeFavorite(favoriteId));
+      return;
+    }
+    void mutate(
+      row.key,
+      () => source.saveFavorite({
+        productId: row.product.productId,
+        ...capabilities.variantFavorites && row.variant?.id ? { variantId: row.variant.id } : {}
+      })
+    );
+  };
+  const removalListNames = pendingRemoval ? fullMembershipsFor(pendingRemoval).filter((entry) => personalIds.has(entry.listId)).map((entry) => snapshot?.lists.find((list) => list.id === entry.listId)?.name).filter((name) => Boolean(name)) : [];
+  const sharedInfo = shareTarget ? snapshot?.shared.find((entry) => entry.listId === shareTarget.id) : void 0;
+  const shareBody = shareTarget ? [
+    labels.dialogs.shareBody,
+    sharedInfo ? sharedInfo.mode === "link" ? labels.dialogs.shareModeLink : labels.dialogs.shareModePeople : null,
+    sharedInfo ? labels.dialogs.shareMembers.replace("{count}", String(sharedInfo.members)) : null,
+    labels.dialogs.shareRole.replace("{role}", labels.demo.roles[shareTarget.role])
+  ].filter((part) => Boolean(part)).join(" ") : "";
+  const confirmRemoval = () => {
+    if (!pendingRemoval?.favorite) return;
+    const favoriteId = pendingRemoval.favorite.id;
+    void mutate("remove", () => source.removeFavorite(favoriteId)).then((ok) => {
+      if (ok) setPendingRemoval(null);
+    });
+  };
+  const removeFromList = (row) => {
+    if (!activeListId) return;
+    const listIds = fullMembershipsFor(row).filter((entry) => entry.listId !== activeListId).map((entry) => entry.listId);
+    void mutate(
+      row.key,
+      () => source.setMemberships({
+        productId: row.product.productId,
+        ...row.variant?.id ? { variantId: row.variant.id } : {},
+        listIds,
+        productLevel: !capabilities.variantFavorites
+      })
+    );
+  };
+  const changeQuantity = (row, quantity) => {
+    if (!activeListId) return;
+    const membership = row.memberships.find((entry) => entry.listId === activeListId);
+    if (!membership) return;
+    void mutate(row.key, () => source.setQuantity({ membershipId: membership.id, quantity }));
+  };
+  const editablePersonal = personal.filter((list) => listActions(list).editItems);
+  const editableOrganization = organization.filter((list) => listActions(list).editItems);
+  const manageEntries = snapshot ? snapshot.lists.filter((list) => capabilities.organizationLists || list.scope !== "organization").map((list) => ({
+    list,
+    count: counts[`list:${list.id}`] ?? 0,
+    actions: listActions(list)
+  })) : [];
+  const openCreate = () => {
+    setDialogError(null);
+    setListDialog({ mode: "create" });
+  };
+  const openRename = (list) => {
+    setDialogError(null);
+    setListDialog({ mode: "rename", target: list });
+  };
+  const submitList = async (input) => {
+    if (!listDialog) return;
+    const previousIds = new Set(snapshot?.lists.map((list) => list.id) ?? []);
+    setSavingKey("dialog");
+    setDialogError(null);
+    try {
+      const next = listDialog.mode === "rename" && listDialog.target ? await source.renameList({
+        listId: listDialog.target.id,
+        name: input.name,
+        description: input.description ?? ""
+      }) : await source.createList(input);
+      setSnapshot(next);
+      if (listDialog.mode === "create" && organizeRow) {
+        const created = next.lists.find((list) => !previousIds.has(list.id));
+        if (created) setOrganizeSelected((current) => [...current, created.id]);
+      }
+      setListDialog(null);
+    } catch {
+      setDialogError(labels.errors.validation);
+    } finally {
+      setSavingKey(null);
+    }
+  };
+  const openOrganize = (row) => {
+    const editable = new Set(
+      [...editablePersonal, ...editableOrganization].map((list) => list.id)
+    );
+    setOrganizeSelected(
+      fullMembershipsFor(row).filter((entry) => editable.has(entry.listId)).map((entry) => entry.listId)
+    );
+    setOrganizeRow(row);
+  };
+  const toggleOrganize = (listId) => {
+    setOrganizeSelected((current) => {
+      if (!capabilities.multipleListsPerItem) return listId ? [listId] : [];
+      if (!listId) return [];
+      return current.includes(listId) ? current.filter((id) => id !== listId) : [...current, listId];
+    });
+  };
+  const saveOrganize = async () => {
+    if (!organizeRow) return;
+    setSavingKey("organize");
+    setDialogError(null);
+    try {
+      const next = await source.setMemberships({
+        productId: organizeRow.product.productId,
+        ...organizeRow.variant?.id ? { variantId: organizeRow.variant.id } : {},
+        listIds: organizeSelected,
+        productLevel: !capabilities.variantFavorites
+      });
+      setSnapshot(next);
+      setOrganizeRow(null);
+    } catch {
+      setDialogError(labels.errors.unavailable);
+    } finally {
+      setSavingKey(null);
+    }
+  };
+  const confirmDelete = async () => {
+    if (!deleteTarget) return;
+    setSavingKey("delete");
+    setDialogError(null);
+    try {
+      const next = await source.deleteList(deleteTarget.id);
+      setSnapshot(next);
+      if (active === `list:${deleteTarget.id}`) setActive("all");
+      setDeleteTarget(null);
+    } catch {
+      setDialogError(labels.errors.forbidden);
+    } finally {
+      setSavingKey(null);
+    }
+  };
+  const confirmShare = () => {
+    if (!shareTarget) return;
+    onShareList?.(shareTarget.id);
+    void source.shareList?.(shareTarget.id).catch(() => void 0);
+    setShareTarget(null);
+  };
+  const submitCart = async (lines, rejected) => {
+    setCartBusy(true);
+    setCartError(null);
+    setLastCart({ lines, rejected });
+    try {
+      const result = cart ? await cart.add({ lines }) : { lines: lines.map((line) => ({ status: "accepted", line })) };
+      const allRejected = mergeCartResults(rejected, result);
+      const accepted = result.lines.filter((line) => line.status === "accepted").length;
+      setCartOutcome({ accepted, rejected: allRejected });
+      onAddToCart?.(result);
+    } catch {
+      setCartOutcome(null);
+      setCartError(labels.states.cartError);
+    } finally {
+      setCartBusy(false);
+    }
+  };
+  const addRows = (targetRows) => {
+    if (!snapshot || targetRows.length === 0 || cartBusy) return;
+    const prepared = prepareCart(snapshot, targetRows, {
+      collection: active,
+      quantities: capabilities.quantities
+    });
+    const pendingIndex = prepared.rejected.findIndex((entry) => entry.reason === "variant-required");
+    if (pendingIndex >= 0) {
+      const pending = prepared.rejected[pendingIndex];
+      const row = targetRows.find(
+        (entry) => entry.product.productId === pending.line.productId && (entry.variant?.id ?? void 0) === (pending.line.variantId ?? void 0)
+      );
+      if (row) {
+        const rest = prepared.rejected.filter((_, index) => index !== pendingIndex);
+        setCartError(null);
+        setVariantRequest({ row, line: pending.line });
+        if (prepared.lines.length > 0) void submitCart(prepared.lines, rest);
+        else setCartOutcome({ accepted: 0, rejected: rest });
+        return;
+      }
+    }
+    if (prepared.lines.length === 0) {
+      setCartOutcome({ accepted: 0, rejected: prepared.rejected });
+      return;
+    }
+    void submitCart(prepared.lines, prepared.rejected);
+  };
+  const retryCart = () => {
+    if (!lastCart) return;
+    void submitCart(lastCart.lines, lastCart.rejected);
+  };
+  const rowForLine = (entry) => rows.find(
+    (row) => row.product.productId === entry.line.productId && (row.variant?.id ?? void 0) === (entry.line.variantId ?? void 0)
+  );
+  const fixVariant = (entry) => {
+    const row = rowForLine(entry);
+    if (!row) {
+      setCartError(labels.errors.unavailable);
+      return;
+    }
+    setVariantRequest({ row, line: entry.line });
+  };
+  const fixQuantity = (entry) => {
+    const max = Math.max(1, entry.maxQuantity ?? 1);
+    void submitCart(
+      [{ ...entry.line, quantity: max }],
+      (cartOutcome?.rejected ?? []).filter((item) => item !== entry)
+    );
+  };
+  const confirmVariant = (variantId) => {
+    const request = variantRequest;
+    setVariantRequest(null);
+    if (!request) return;
+    const remaining = (cartOutcome?.rejected ?? []).filter(
+      (entry) => !(entry.line.productId === request.line.productId && (entry.line.variantId ?? void 0) === (request.line.variantId ?? void 0))
+    );
+    void submitCart(
+      [
+        {
+          ...request.line,
+          productId: request.row.product.productId,
+          variantId
+        }
+      ],
+      remaining
+    );
+  };
+  const bulkEntries = [...editablePersonal, ...editableOrganization].filter(
+    (list) => bulkLists?.mode !== "move" || list.id !== activeListId
+  );
+  const toggleBulkList = (listId) => {
+    setBulkLists((current) => {
+      if (!current) return current;
+      if (current.mode === "move") {
+        return { ...current, selected: current.selected.includes(listId) ? [] : [listId] };
+      }
+      return {
+        ...current,
+        selected: current.selected.includes(listId) ? current.selected.filter((id) => id !== listId) : [...current.selected, listId]
+      };
+    });
+  };
+  const applyBulkLists = async () => {
+    if (!bulkLists || !snapshot) return;
+    const targets = bulkLists.selected;
+    if (targets.length === 0) return;
+    const editable = new Set(
+      [...editablePersonal, ...editableOrganization].map((list) => list.id)
+    );
+    setSavingKey("bulk-lists");
+    setDialogError(null);
+    try {
+      let next = snapshot;
+      for (const row of selectedRows) {
+        const current = fullMembershipsFor(row).filter((entry) => editable.has(entry.listId)).map((entry) => entry.listId);
+        const base = bulkLists.mode === "move" && activeListId ? current.filter((id) => id !== activeListId) : current;
+        next = await source.setMemberships({
+          productId: row.product.productId,
+          ...row.variant?.id ? { variantId: row.variant.id } : {},
+          listIds: [.../* @__PURE__ */ new Set([...base, ...targets])],
+          productLevel: !capabilities.variantFavorites
+        });
+      }
+      setSnapshot(next);
+      setBulkLists(null);
+      setSelecting(false);
+      setSelected([]);
+    } catch {
+      setDialogError(labels.errors.unavailable);
+    } finally {
+      setSavingKey(null);
+    }
+  };
+  const removeSelected = async () => {
+    if (!snapshot) return;
+    setSavingKey("bulk-delete");
+    setDialogError(null);
+    try {
+      let next = snapshot;
+      for (const row of selectedRows) {
+        if (row.favorite) {
+          next = await source.removeFavorite(row.favorite.id);
+          continue;
+        }
+        if (!activeListId) continue;
+        const listIds = fullMembershipsFor(row).filter((entry) => entry.listId !== activeListId).map((entry) => entry.listId);
+        next = await source.setMemberships({
+          productId: row.product.productId,
+          ...row.variant?.id ? { variantId: row.variant.id } : {},
+          listIds,
+          productLevel: !capabilities.variantFavorites
+        });
+      }
+      setSnapshot(next);
+      setBulkDeleteOpen(false);
+      setSelecting(false);
+      setSelected([]);
+    } catch {
+      setDialogError(labels.errors.unavailable);
+    } finally {
+      setSavingKey(null);
+    }
+  };
+  return /* @__PURE__ */ jsxs("div", { lang, className: "@container space-y-4 text-foreground", children: [
+    /* @__PURE__ */ jsx(
+      FavoritesHeader,
+      {
+        labels,
+        showNewList: capabilities.namedLists && authenticated && state !== "disabled" && state !== "auth-required" && state !== "loading",
+        onNewList: openCreate
+      }
+    ),
+    capabilities.namedLists && state !== "disabled" && state !== "auth-required" && state !== "loading" ? /* @__PURE__ */ jsx(
+      FavoritesNavigation,
+      {
+        collections,
+        active,
+        labels,
+        onSelect: setActive,
+        onMore: personal.length > 5 ? () => setManageOpen(true) : void 0,
+        moreLabel: personal.length > 5 ? `${labels.collections.more} (${personal.length - 5})` : void 0
+      }
+    ) : null,
+    (state === "ready" || state === "filtered-empty") && (capabilities.search || capabilities.sorting || authenticated) ? /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-end gap-2", children: [
+      capabilities.search ? /* @__PURE__ */ jsxs("div", { className: "min-w-48 flex-1", children: [
+        /* @__PURE__ */ jsx("label", { htmlFor: "favorites-search", className: "sr-only", children: labels.search.label }),
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              id: "favorites-search",
+              type: "search",
+              value: query,
+              placeholder: labels.search.placeholder,
+              "aria-label": labels.search.label,
+              onChange: (event) => setQuery(event.target.value),
+              className: "h-10 w-full rounded-md border border-input bg-background px-3 text-sm text-foreground focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-none"
+            }
+          ),
+          query ? /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              onClick: () => setQuery(""),
+              className: "min-h-10 rounded-md px-2 text-xs text-muted-foreground underline focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-none",
+              children: labels.search.clear
+            }
+          ) : null
+        ] })
+      ] }) : null,
+      capabilities.sorting ? /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("label", { htmlFor: "favorites-sort", className: "sr-only", children: labels.sort.label }),
+        /* @__PURE__ */ jsx(
+          "select",
+          {
+            id: "favorites-sort",
+            value: sort,
+            "aria-label": labels.sort.label,
+            onChange: (event) => setSort(event.target.value),
+            className: "h-10 rounded-md border border-input bg-background px-2 text-sm text-foreground",
+            children: Object.keys(labels.sort.options).map((key) => /* @__PURE__ */ jsx("option", { value: key, children: labels.sort.options[key] }, key))
+          }
+        )
+      ] }) : null,
+      authenticated ? /* @__PURE__ */ jsx(
+        Button,
+        {
+          type: "button",
+          size: "sm",
+          variant: selecting ? "secondary" : "outline",
+          onClick: () => {
+            setSelecting((current) => !current);
+            if (selecting) setSelected([]);
+          },
+          className: "min-h-10",
+          children: selecting ? labels.cart.cancelSelection : labels.cart.select
+        }
+      ) : null
+    ] }) : null,
+    /* @__PURE__ */ jsx(
+      FavoritesStatus,
+      {
+        state,
+        labels,
+        onExplore: onExploreProducts,
+        onClearSearch: () => setQuery(""),
+        onRetry: retry,
+        onSignIn,
+        onBackToAll: () => setActive("all")
+      }
+    ),
+    (state === "ready" || state === "empty-list" || state === "filtered-empty") && activeList && activeActions ? /* @__PURE__ */ jsx(
+      FavoriteListDetail,
+      {
+        list: activeList,
+        count: counts[active] ?? 0,
+        actions: activeActions,
+        labels,
+        busy: savingKey === "remove",
+        onAddAll: capabilities.addToCart && rows.length > 0 ? () => addRows(rows) : void 0,
+        onRename: () => openRename(activeList),
+        onDelete: () => setDeleteTarget(activeList),
+        onShare: capabilities.sharing ? () => setShareTarget(activeList) : void 0
+      }
+    ) : null,
+    (state === "ready" || state === "empty-list" || state === "filtered-empty") && activeList && activeActions && !activeActions.editItems ? /* @__PURE__ */ jsx(
+      "p",
+      {
+        role: "status",
+        className: "rounded-md border border-border bg-muted/30 p-2 text-sm text-muted-foreground",
+        children: labels.states.readOnly
+      }
+    ) : null,
+    selecting ? /* @__PURE__ */ jsxs("div", { className: "sticky bottom-2 z-10 flex flex-wrap items-center justify-between gap-2 rounded-lg border border-border bg-muted/80 px-2 py-1.5 shadow-sm backdrop-blur", children: [
+      /* @__PURE__ */ jsx("p", { className: "text-sm font-medium", children: labels.cart.selected.replace("{count}", String(selected.length)) }),
+      /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap gap-1.5", children: [
+        capabilities.addToCart && capabilities.bulkAddToCart ? /* @__PURE__ */ jsx(
+          Button,
+          {
+            type: "button",
+            size: "sm",
+            disabled: cartBusy || selectedRows.length === 0,
+            className: "min-h-9",
+            onClick: () => {
+              addRows(selectedRows);
+              setSelected([]);
+            },
+            children: labels.cart.addSelected.replace("{count}", String(selected.length))
+          }
+        ) : null,
+        capabilities.namedLists ? /* @__PURE__ */ jsx(
+          Button,
+          {
+            type: "button",
+            size: "sm",
+            variant: "outline",
+            disabled: selectedRows.length === 0,
+            className: "min-h-9",
+            onClick: () => setBulkLists({ mode: "add", selected: [] }),
+            children: labels.cart.addToLists
+          }
+        ) : null,
+        capabilities.namedLists && activeListId ? /* @__PURE__ */ jsx(
+          Button,
+          {
+            type: "button",
+            size: "sm",
+            variant: "outline",
+            disabled: selectedRows.length === 0,
+            className: "min-h-9",
+            onClick: () => setBulkLists({ mode: "move", selected: [] }),
+            children: labels.cart.moveToLists
+          }
+        ) : null,
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            type: "button",
+            size: "sm",
+            variant: "ghost",
+            disabled: selectedRows.length === 0,
+            className: "min-h-9 text-destructive",
+            onClick: () => {
+              setDialogError(null);
+              setBulkDeleteOpen(true);
+            },
+            children: labels.cart.removeSelected
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            type: "button",
+            size: "sm",
+            variant: "ghost",
+            className: "min-h-9",
+            onClick: () => {
+              setSelecting(false);
+              setSelected([]);
+            },
+            children: labels.cart.cancelSelection
+          }
+        )
+      ] })
+    ] }) : null,
+    state === "ready" ? /* @__PURE__ */ jsx("ul", { className: "grid grid-cols-2 gap-2 @2xl:grid-cols-3 @5xl:grid-cols-4", children: rows.map((row) => {
+      const showQuantity = capabilities.quantities && activeActions?.editQuantity === true && Boolean(activeListId) && row.memberships.length === 1 && row.quantity !== void 0;
+      return /* @__PURE__ */ jsx("li", { className: "min-w-0", children: /* @__PURE__ */ jsx(
+        FavoriteProductCard,
+        {
+          row,
+          labels,
+          capabilities,
+          saved: Boolean(row.favorite),
+          saving: savingKey === row.key,
+          saveError: saveErrorKey === row.key,
+          personalListCount: personalCountFor(row),
+          showQuantity,
+          quantityLabel: labels.quantity.label.replace("{product}", row.product.title).replace("{list}", activeList?.name ?? ""),
+          quantityMax: capabilities.maxQuantity,
+          busy: cartBusy,
+          selecting,
+          selected: selected.includes(row.key),
+          onToggleSelected: selecting ? () => setSelected(
+            (current) => current.includes(row.key) ? current.filter((key) => key !== row.key) : [...current, row.key]
+          ) : void 0,
+          onAddToCart: capabilities.addToCart ? () => addRows([row]) : void 0,
+          onToggleFavorite: () => toggleFavorite(row),
+          onOrganize: capabilities.namedLists ? () => openOrganize(row) : void 0,
+          onOpenProduct: onOpenProduct ? () => onOpenProduct(row.product.productId, row.variant?.id) : void 0,
+          onQuantityChange: showQuantity ? (quantity) => changeQuantity(row, quantity) : void 0,
+          onRemoveFromList: activeActions?.editItems ? () => removeFromList(row) : void 0
+        }
+      ) }, row.key);
+    }) }) : null,
+    /* @__PURE__ */ jsx(
+      CartFeedback,
+      {
+        open: Boolean(cartOutcome) || Boolean(cartError),
+        accepted: cartOutcome?.accepted ?? 0,
+        rejected: cartOutcome?.rejected ?? [],
+        error: cartError,
+        busy: cartBusy,
+        labels,
+        labelFor: (entry) => snapshot?.products.find((product) => product.productId === entry.line.productId)?.title ?? entry.line.productId,
+        onDismiss: () => {
+          setCartOutcome(null);
+          setCartError(null);
+        },
+        onRetry: retryCart,
+        onFixVariant: fixVariant,
+        onFixQuantity: fixQuantity
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      ConfirmDialog,
+      {
+        open: Boolean(pendingRemoval),
+        title: labels.dialogs.removeFavoriteTitle,
+        body: labels.dialogs.removeFavoriteBody.replace("{lists}", removalListNames.join(", ")),
+        confirmLabel: labels.dialogs.removeFavoriteConfirm,
+        cancelLabel: labels.dialogs.cancel,
+        destructive: true,
+        busy: savingKey === "remove",
+        onCancel: () => setPendingRemoval(null),
+        onConfirm: confirmRemoval
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      ManageListsDialog,
+      {
+        open: manageOpen,
+        entries: manageEntries,
+        labels,
+        canCreate: capabilities.namedLists && authenticated,
+        onClose: () => setManageOpen(false),
+        onSelect: (listId) => {
+          setActive(`list:${listId}`);
+          setManageOpen(false);
+        },
+        onRename: (list) => {
+          setManageOpen(false);
+          openRename(list);
+        },
+        onDelete: (list) => {
+          setManageOpen(false);
+          setDialogError(null);
+          setDeleteTarget(list);
+        },
+        onCreate: () => {
+          setManageOpen(false);
+          openCreate();
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      ListDialog,
+      {
+        open: Boolean(listDialog),
+        mode: listDialog?.mode ?? "create",
+        initialName: listDialog?.target?.name ?? "",
+        initialDescription: listDialog?.target?.description ?? "",
+        siblings: personal.map((list) => ({ id: list.id, name: list.name })),
+        currentId: listDialog?.target?.id,
+        labels,
+        saving: savingKey === "dialog",
+        error: dialogError,
+        onCancel: () => {
+          setListDialog(null);
+          setDialogError(null);
+        },
+        onSubmit: submitList
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      OrganizeDialog,
+      {
+        open: Boolean(organizeRow) && !listDialog,
+        productTitle: organizeRow?.product.title ?? "",
+        personal: editablePersonal,
+        organization: editableOrganization,
+        selected: organizeSelected,
+        multiple: capabilities.multipleListsPerItem,
+        labels,
+        saving: savingKey === "organize",
+        error: dialogError,
+        onToggle: toggleOrganize,
+        onCancel: () => {
+          setOrganizeRow(null);
+          setOrganizeSelected([]);
+          setDialogError(null);
+        },
+        onSave: () => void saveOrganize(),
+        onCreateList: () => {
+          setDialogError(null);
+          setListDialog({ mode: "create" });
+        },
+        canCreate: capabilities.namedLists && authenticated
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      ConfirmDialog,
+      {
+        open: Boolean(deleteTarget),
+        title: labels.dialogs.deleteTitle,
+        body: labels.dialogs.deleteBody,
+        confirmLabel: labels.dialogs.deleteConfirm,
+        cancelLabel: labels.dialogs.cancel,
+        destructive: true,
+        busy: savingKey === "delete",
+        error: dialogError,
+        onCancel: () => {
+          setDeleteTarget(null);
+          setDialogError(null);
+        },
+        onConfirm: () => void confirmDelete()
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      ConfirmDialog,
+      {
+        open: Boolean(shareTarget),
+        title: labels.dialogs.shareTitle,
+        body: shareBody,
+        confirmLabel: labels.dialogs.copyLink,
+        cancelLabel: labels.dialogs.cancel,
+        onCancel: () => setShareTarget(null),
+        onConfirm: confirmShare
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      BulkListsDialog,
+      {
+        open: Boolean(bulkLists),
+        mode: bulkLists?.mode ?? "add",
+        entries: bulkEntries,
+        selected: bulkLists?.selected ?? [],
+        labels,
+        saving: savingKey === "bulk-lists",
+        error: dialogError,
+        onToggle: toggleBulkList,
+        onCancel: () => {
+          setBulkLists(null);
+          setDialogError(null);
+        },
+        onConfirm: () => void applyBulkLists()
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      ConfirmDialog,
+      {
+        open: bulkDeleteOpen,
+        title: labels.dialogs.bulkRemoveTitle,
+        body: labels.dialogs.bulkRemoveBody.replace("{count}", String(selectedRows.length)),
+        confirmLabel: labels.cart.removeSelected,
+        cancelLabel: labels.dialogs.cancel,
+        destructive: true,
+        busy: savingKey === "bulk-delete",
+        error: dialogError,
+        onCancel: () => {
+          setBulkDeleteOpen(false);
+          setDialogError(null);
+        },
+        onConfirm: () => void removeSelected()
+      }
+    ),
+    variantRequest ? /* @__PURE__ */ jsx(
+      VariantDialog,
+      {
+        open: true,
+        product: variantRequest.row.product,
+        labels,
+        onCancel: () => setVariantRequest(null),
+        onConfirm: confirmVariant
+      }
+    ) : null
+  ] });
+}
+export {
+  CustomerFavorites
+};
+//# sourceMappingURL=customer-favorites.mjs.map