@parhelia/core 0.1.10884 → 0.1.10978

package/dist/editor/reviews/DecisionsMatrix.js

@@ -1,60 +1,190 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useState } from "react";
+import { useState, useEffect, useMemo, useCallback } from "react";
 import { SimpleToolbar } from "../ui/SimpleToolbar";
 import { SimpleIconButton } from "../ui/SimpleIconButton";
 import { Button } from "../../components/ui/button";
-import { Check, X, Clock, Filter, Plus, Trash2 } from "lucide-react";
+import { Checkbox } from "../../components/ui/checkbox";
+import { Check, X, Clock, Filter, Plus, Trash2, MessageSquare, Lightbulb, } from "lucide-react";
 import { formatDate } from "../utils";
 import { Badge } from "../../components/ui/badge";
-import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter, } from "../../components/ui/dialog";
 import { Popover, PopoverContent, PopoverTrigger, } from "../../components/ui/popover";
 import { Loader2 } from "lucide-react";
 import { ItemTreeSelector } from "./ItemTreeSelector";
 import { useEditContext } from "../client/editContext";
-export function DecisionsMatrix({ items, assignments, onMakeDecision, loading, reviewId, language, finalDecision, onSetFinalDecision, onAddPages, onRemovePages, allReviewersResponded, selectedReviewerId, currentUserEmail, }) {
+import { getComments } from "../services/reviewsService";
+import { getSuggestedEdits } from "../services/suggestedEditsService";
+export function DecisionsMatrix({ items, assignments, onMakeDecision, loading, reviewId, language, finalDecision, onSetFinalDecision, onAddPages, onRemovePages, allReviewersResponded, selectedReviewerId, currentUserEmail, requiredApprovals = 1, }) {
     const [filter, setFilter] = useState("all");
-    const [isFinalDecisionDialogOpen, setIsFinalDecisionDialogOpen] = useState(false);
     const [isAddPopoverOpen, setIsAddPopoverOpen] = useState(false);
     const [selectedItems, setSelectedItems] = useState([]);
+    const [selectedPagesForRemoval, setSelectedPagesForRemoval] = useState(new Set());
     const editContext = useEditContext();
+    const isLimitedPreviewUser = editContext?.user?.isLimitedPreviewUser ?? false;
+    const [commentsData, setCommentsData] = useState(new Map());
+    const [suggestionsData, setSuggestionsData] = useState(new Map());
+    const [loadingCounts, setLoadingCounts] = useState(false);
+    const [itemDetailsCache, setItemDetailsCache] = useState(new Map());
     // Filter assignments based on selection
-    const displayAssignments = selectedReviewerId
-        ? assignments.filter((a) => a.assignmentId === selectedReviewerId)
-        : assignments;
-    // Check if current user can make decisions
-    const selectedAssignment = selectedReviewerId
-        ? assignments.find((a) => a.assignmentId === selectedReviewerId)
-        : null;
-    const canMakeDecisions = selectedAssignment &&
-        currentUserEmail &&
-        selectedAssignment.reviewerEmail.toLowerCase() === currentUserEmail.toLowerCase();
+    // For limited preview users, only show their own assignment
+    const displayAssignments = (() => {
+        let filtered = assignments;
+        // If limited preview user, only show their own assignment
+        if (isLimitedPreviewUser && currentUserEmail) {
+            filtered = filtered.filter((a) => a.reviewerEmail.toLowerCase() === currentUserEmail.toLowerCase());
+        }
+        // Apply reviewer selection filter if specified
+        if (selectedReviewerId) {
+            filtered = filtered.filter((a) => a.assignmentId === selectedReviewerId);
+        }
+        return filtered;
+    })();
+    // Combine items from the original items list AND items that have decisions
+    const allItemsWithDecisions = useMemo(() => {
+        const itemsMap = new Map();
+        // Add all original items
+        items.forEach((item) => {
+            const key = `${item.itemId}-${item.language}`;
+            itemsMap.set(key, item);
+        });
+        // Add items from decisions that aren't already in the list
+        assignments.forEach((assignment) => {
+            assignment.decisions?.forEach((decision) => {
+                const key = `${decision.itemId}-${decision.itemLanguage}`;
+                if (!itemsMap.has(key)) {
+                    // Check if we have cached details for this item
+                    const cachedDetails = itemDetailsCache.get(key);
+                    // Create a synthetic item entry for this decision
+                    itemsMap.set(key, {
+                        itemId: decision.itemId,
+                        language: decision.itemLanguage,
+                        includeSubitems: false,
+                        name: cachedDetails?.name,
+                        path: cachedDetails?.path,
+                    });
+                }
+            });
+        });
+        return Array.from(itemsMap.values());
+    }, [items, assignments, itemDetailsCache]);
+    // Fetch item details for synthetic items that don't have names/paths
+    useEffect(() => {
+        const fetchItemDetails = async () => {
+            if (!editContext?.itemsRepository)
+                return;
+            const itemsToFetch = [];
+            // Find synthetic items that need details
+            assignments.forEach((assignment) => {
+                assignment.decisions?.forEach((decision) => {
+                    const key = `${decision.itemId}-${decision.itemLanguage}`;
+                    // Check if this item is not in the original items list
+                    const isOriginalItem = items.some((item) => item.itemId === decision.itemId &&
+                        item.language === decision.itemLanguage);
+                    // Check if we already have cached details
+                    const hasCachedDetails = itemDetailsCache.has(key);
+                    // Only fetch if it's not an original item and we don't have cached details
+                    if (!isOriginalItem && !hasCachedDetails) {
+                        itemsToFetch.push({
+                            key,
+                            descriptor: {
+                                id: decision.itemId,
+                                language: decision.itemLanguage,
+                                version: 0,
+                            },
+                        });
+                    }
+                });
+            });
+            if (itemsToFetch.length === 0)
+                return;
+            try {
+                // Fetch items in batches
+                const fetchedItems = await Promise.all(itemsToFetch.map(({ descriptor }) => editContext.itemsRepository.getItem(descriptor)));
+                // Update cache with fetched details
+                const newCache = new Map(itemDetailsCache);
+                itemsToFetch.forEach(({ key }, index) => {
+                    const fetchedItem = fetchedItems[index];
+                    if (fetchedItem) {
+                        newCache.set(key, {
+                            name: fetchedItem.name,
+                            path: fetchedItem.path,
+                        });
+                    }
+                });
+                if (newCache.size > itemDetailsCache.size) {
+                    setItemDetailsCache(newCache);
+                }
+            }
+            catch (err) {
+                console.error("Failed to fetch item details:", err);
+            }
+        };
+        fetchItemDetails();
+    }, [assignments, items, itemDetailsCache, editContext?.itemsRepository]);
     const getDecision = (assignment, itemId, itemLanguage) => {
         return assignment.decisions?.find((d) => d.itemId === itemId && d.itemLanguage === itemLanguage);
     };
+    // Calculate approval count for an item
+    const getApprovalCount = (itemId, itemLanguage) => {
+        return assignments.filter((assignment) => {
+            const decision = getDecision(assignment, itemId, itemLanguage);
+            return decision?.decision === "Approved";
+        }).length;
+    };
+    // Get approval status for an item
+    const getItemApprovalStatus = (itemId, itemLanguage) => {
+        const approvalCount = getApprovalCount(itemId, itemLanguage);
+        const rejectionCount = assignments.filter((assignment) => {
+            const decision = getDecision(assignment, itemId, itemLanguage);
+            return decision?.decision === "Rejected";
+        }).length;
+        const totalReviewers = assignments.length;
+        const pendingCount = totalReviewers - approvalCount - rejectionCount;
+        if (approvalCount >= requiredApprovals) {
+            return "approved";
+        }
+        // If it's impossible to reach the threshold, mark as rejected
+        if (approvalCount + pendingCount < requiredApprovals) {
+            return "rejected";
+        }
+        return "pending";
+    };
     const handleLoadItem = (itemId, itemLanguage) => {
+        console.log("[DecisionsMatrix.handleLoadItem] Loading item from decisions matrix:", {
+            itemId,
+            itemLanguage,
+            isLimitedPreviewUser,
+            currentUserEmail,
+            timestamp: new Date().toISOString(),
+        });
         if (editContext?.loadItem) {
+            // Handle "*" language (All Languages mode) - use default language
+            const languageToLoad = itemLanguage === "*"
+                ? editContext?.currentItemDescriptor?.language || "en"
+                : itemLanguage;
             editContext.loadItem({
                 id: itemId,
-                language: itemLanguage,
+                language: languageToLoad,
                 version: 0,
             });
         }
+        else {
+            console.error("[DecisionsMatrix.handleLoadItem] editContext.loadItem is not available");
+        }
     };
     const getDecisionCell = (assignment, item) => {
         const decision = getDecision(assignment, item.itemId, item.language);
         if (decision) {
             if (decision.decision === "Approved") {
-                return (_jsxs("div", { className: "flex flex-col items-center justify-center p-2", children: [_jsx(Check, { className: "h-5 w-5 text-green-500" }), _jsx("span", { className: "text-xs text-gray-500", children: formatDate(new Date(decision.decisionDate)) })] }));
+                return (_jsx("div", { className: "flex items-center justify-center p-1", children: _jsxs("div", { className: "flex flex-col items-center gap-0.5", children: [_jsxs("div", { className: "flex items-center gap-1", children: [_jsx(Check, { className: "h-3.5 w-3.5 text-green-500" }), _jsx("span", { className: "text-xs leading-tight text-gray-500", children: formatDate(new Date(decision.decisionDate)) })] }), decision.itemVersion !== undefined && (_jsxs("span", { className: "text-xs leading-tight text-gray-400", children: ["v", decision.itemVersion] }))] }) }));
             }
             else {
-                return (_jsxs("div", { className: "flex flex-col items-center justify-center p-2", children: [_jsx(X, { className: "h-5 w-5 text-red-500" }), _jsx("span", { className: "text-xs text-gray-500", children: formatDate(new Date(decision.decisionDate)) })] }));
+                return (_jsx("div", { className: "flex items-center justify-center p-1", children: _jsxs("div", { className: "flex items-center gap-1", children: [_jsx(X, { className: "h-3.5 w-3.5 text-red-500" }), _jsx("span", { className: "text-xs leading-tight text-gray-500", children: formatDate(new Date(decision.decisionDate)) })] }) }));
             }
         }
-        // Show action buttons for pending decisions (if current user is the reviewer)
-        // For now, show pending indicator
-        return (_jsx("div", { className: "flex items-center justify-center p-2", children: _jsx(Clock, { className: "h-4 w-4 text-gray-400" }) }));
+        // Show pending indicator
+        return (_jsx("div", { className: "flex items-center justify-center p-1", children: _jsx(Clock, { className: "h-3.5 w-3.5 text-gray-400" }) }));
     };
-    const filteredItems = items.filter((item) => {
+    const filteredItems = allItemsWithDecisions.filter((item) => {
         if (filter === "all")
             return true;
         if (filter === "pending") {
@@ -69,9 +199,57 @@ export function DecisionsMatrix({ items, assignments, onMakeDecision, loading, r
         return true;
     });
     const handleMakeDecision = async (assignmentId, itemId, itemLanguage, decision) => {
-        // Find the item to get version if available
-        const item = items.find((i) => i.itemId === itemId && i.language === itemLanguage);
-        await onMakeDecision(assignmentId, itemId, itemLanguage, undefined, decision);
+        // Try to get the version of the item being decided on
+        let itemVersion = undefined;
+        // First, check if the current item matches
+        const currentItem = editContext?.currentItemDescriptor;
+        if (currentItem &&
+            currentItem.id === itemId &&
+            (currentItem.language === itemLanguage ||
+                itemLanguage === "*" ||
+                currentItem.language === "*")) {
+            itemVersion = currentItem.version;
+        }
+        else {
+            // Try to fetch the item to get its version
+            if (editContext?.itemsRepository) {
+                try {
+                    const item = await editContext.itemsRepository.getItem({
+                        id: itemId,
+                        language: itemLanguage === "*" ? "en" : itemLanguage,
+                        version: 0, // Get latest version
+                    });
+                    if (item) {
+                        itemVersion = item.version;
+                    }
+                }
+                catch (err) {
+                    console.warn(`Failed to fetch item version for ${itemId}:`, err);
+                    // Continue with undefined version (version-null decision)
+                }
+            }
+        }
+        await onMakeDecision(assignmentId, itemId, itemLanguage, itemVersion, decision);
+    };
+    const handleApproveCurrentPage = async () => {
+        const currentItem = editContext?.currentItemDescriptor;
+        if (!currentItem || !currentUserEmail)
+            return;
+        // Find current user's assignment
+        const userAssignment = assignments.find((a) => a.reviewerEmail.toLowerCase() === currentUserEmail.toLowerCase());
+        if (!userAssignment)
+            return;
+        await handleMakeDecision(userAssignment.assignmentId, currentItem.id, currentItem.language || "en", "Approved");
+    };
+    const handleRejectCurrentPage = async () => {
+        const currentItem = editContext?.currentItemDescriptor;
+        if (!currentItem || !currentUserEmail)
+            return;
+        // Find current user's assignment
+        const userAssignment = assignments.find((a) => a.reviewerEmail.toLowerCase() === currentUserEmail.toLowerCase());
+        if (!userAssignment)
+            return;
+        await handleMakeDecision(userAssignment.assignmentId, currentItem.id, currentItem.language || "en", "Rejected");
     };
     const handleItemsChange = (descriptors) => {
         setSelectedItems(descriptors);
@@ -88,28 +266,474 @@ export function DecisionsMatrix({ items, assignments, onMakeDecision, loading, r
         }
     };
     const handleRemovePage = async (itemId, itemLanguage) => {
-        await onRemovePages([
-            {
-                id: itemId,
-                language: itemLanguage,
-                version: 1,
+        const item = allItemsWithDecisions.find((i) => i.itemId === itemId && i.language === itemLanguage);
+        const itemName = item?.name || item?.path || itemId;
+        editContext?.confirm({
+            header: "Remove Page",
+            message: `Are you sure you want to remove "${itemName}" from this review?`,
+            acceptLabel: "Remove",
+            showCancel: true,
+            accept: async () => {
+                await onRemovePages([
+                    {
+                        id: itemId,
+                        language: itemLanguage,
+                        version: 1,
+                    },
+                ]);
             },
-        ]);
+        });
+    };
+    const togglePageSelection = (itemId, language) => {
+        const key = `${itemId}-${language}`;
+        const newSelection = new Set(selectedPagesForRemoval);
+        if (newSelection.has(key)) {
+            newSelection.delete(key);
+        }
+        else {
+            newSelection.add(key);
+        }
+        setSelectedPagesForRemoval(newSelection);
+    };
+    const handleRemoveSelectedPages = async () => {
+        if (selectedPagesForRemoval.size === 0)
+            return;
+        const pagesToRemove = Array.from(selectedPagesForRemoval)
+            .map((key) => {
+            const [itemId, language] = key.split("-");
+            return { itemId, language };
+        })
+            .filter(({ itemId, language }) => itemId && language);
+        const itemDescriptors = pagesToRemove.map(({ itemId, language }) => ({
+            id: itemId,
+            language: language,
+            version: 1,
+        }));
+        const pageNames = pagesToRemove.map(({ itemId, language }) => {
+            const item = allItemsWithDecisions.find((i) => i.itemId === itemId && i.language === language);
+            return item?.name || item?.path || itemId;
+        });
+        const message = selectedPagesForRemoval.size === 1
+            ? `Are you sure you want to remove "${pageNames[0]}" from this review?`
+            : `Are you sure you want to remove ${selectedPagesForRemoval.size} pages from this review?`;
+        editContext?.confirm({
+            header: "Remove Pages",
+            message,
+            acceptLabel: "Remove",
+            showCancel: true,
+            accept: async () => {
+                await onRemovePages(itemDescriptors);
+                setSelectedPagesForRemoval(new Set());
+            },
+        });
+    };
+    const hasSelectedPages = selectedPagesForRemoval.size > 0;
+    // Helper function to refresh counts for a specific item
+    const refreshItemCounts = useCallback(async (itemId, itemLanguage) => {
+        const key = `${itemId}-${itemLanguage}`;
+        // Check if this item is in our review
+        const itemInReview = allItemsWithDecisions.some((item) => item.itemId === itemId &&
+            (item.language === itemLanguage ||
+                item.language === "*" ||
+                itemLanguage === "*"));
+        if (!itemInReview) {
+            return;
+        }
+        try {
+            // Fetch updated comments
+            const commentsResult = await getComments(itemId, itemLanguage === "*" ? "en" : itemLanguage, 0, reviewId);
+            if (commentsResult.data) {
+                setCommentsData((prev) => {
+                    const newMap = new Map(prev);
+                    newMap.set(key, commentsResult.data);
+                    return newMap;
+                });
+            }
+            // Fetch updated suggestions
+            const suggestionsResult = await getSuggestedEdits(itemId, itemLanguage === "*" ? "en" : itemLanguage, 0, reviewId);
+            if (suggestionsResult.data) {
+                setSuggestionsData((prev) => {
+                    const newMap = new Map(prev);
+                    newMap.set(key, suggestionsResult.data);
+                    return newMap;
+                });
+            }
+        }
+        catch (err) {
+            console.error(`Failed to refresh counts for ${key}:`, err);
+        }
+    }, [allItemsWithDecisions, reviewId]);
+    // Fetch comments and suggestions for all items
+    useEffect(() => {
+        const fetchCounts = async () => {
+            if (allItemsWithDecisions.length === 0) {
+                setCommentsData(new Map());
+                setSuggestionsData(new Map());
+                return;
+            }
+            setLoadingCounts(true);
+            const commentsMap = new Map();
+            const suggestionsMap = new Map();
+            try {
+                await Promise.all(allItemsWithDecisions.map(async (item) => {
+                    const key = `${item.itemId}-${item.language}`;
+                    // Fetch comments (using version 0 as default, or we could track version)
+                    // Pass reviewId to filter server-side by review creation date
+                    try {
+                        const commentsResult = await getComments(item.itemId, item.language, 0, reviewId);
+                        if (commentsResult.data) {
+                            commentsMap.set(key, commentsResult.data);
+                        }
+                    }
+                    catch (err) {
+                        console.error(`Failed to fetch comments for ${key}:`, err);
+                    }
+                    // Fetch suggestions
+                    // Pass reviewId to filter server-side by review creation date
+                    try {
+                        const suggestionsResult = await getSuggestedEdits(item.itemId, item.language, 0, reviewId);
+                        if (suggestionsResult.data) {
+                            suggestionsMap.set(key, suggestionsResult.data);
+                        }
+                    }
+                    catch (err) {
+                        console.error(`Failed to fetch suggestions for ${key}:`, err);
+                    }
+                }));
+                setCommentsData(commentsMap);
+                setSuggestionsData(suggestionsMap);
+            }
+            catch (err) {
+                console.error("Failed to fetch counts:", err);
+            }
+            finally {
+                setLoadingCounts(false);
+            }
+        };
+        fetchCounts();
+    }, [allItemsWithDecisions, reviewId]);
+    // Listen for websocket messages to update counts in real-time
+    useEffect(() => {
+        if (!editContext?.addSocketMessageListener) {
+            return;
+        }
+        const unsubscribe = editContext.addSocketMessageListener((message) => {
+            try {
+                // Handle comment updates
+                if (message.type === "comment-updated" && message.payload?.comment) {
+                    const comment = message.payload.comment;
+                    const itemId = comment.mainItemId;
+                    const itemLanguage = comment.language || "en";
+                    // Refresh counts for this item
+                    refreshItemCounts(itemId, itemLanguage);
+                }
+                // Handle comment deletions
+                if (message.type === "comment-deleted" && message.payload?.commentId) {
+                    // Find which item(s) this comment belonged to by checking our cache
+                    const deletedCommentId = message.payload.commentId;
+                    const itemsToRefresh = new Set();
+                    commentsData.forEach((comments, key) => {
+                        if (comments.some((c) => c.id === deletedCommentId)) {
+                            itemsToRefresh.add(key);
+                        }
+                    });
+                    // If we found the comment in our cache, refresh only those items
+                    if (itemsToRefresh.size > 0) {
+                        itemsToRefresh.forEach((key) => {
+                            const parts = key.split("-");
+                            if (parts.length >= 2) {
+                                const itemId = parts[0];
+                                const itemLanguage = parts.slice(1).join("-"); // Handle language codes with dashes
+                                refreshItemCounts(itemId, itemLanguage);
+                            }
+                        });
+                    }
+                    else {
+                        // If not found in cache, refresh all items to be safe
+                        allItemsWithDecisions.forEach((item) => {
+                            refreshItemCounts(item.itemId, item.language);
+                        });
+                    }
+                }
+                // Handle suggested edit updates
+                if (message.type === "suggested-edit-updated" &&
+                    message.payload?.suggestedEdit) {
+                    const suggestion = message.payload.suggestedEdit;
+                    const itemId = suggestion.mainItemId;
+                    const itemLanguage = suggestion.mainItemLanguage || "en";
+                    // Refresh counts for this item
+                    refreshItemCounts(itemId, itemLanguage);
+                }
+                // Handle suggested edit deletions
+                if (message.type === "suggested-edit-deleted" && message.payload?.id) {
+                    // Find which item(s) this suggestion belonged to by checking our cache
+                    const deletedSuggestionId = message.payload.id;
+                    const itemsToRefresh = new Set();
+                    suggestionsData.forEach((suggestions, key) => {
+                        if (suggestions.some((s) => s.id === deletedSuggestionId)) {
+                            itemsToRefresh.add(key);
+                        }
+                    });
+                    // If we found the suggestion in our cache, refresh only those items
+                    if (itemsToRefresh.size > 0) {
+                        itemsToRefresh.forEach((key) => {
+                            const parts = key.split("-");
+                            if (parts.length >= 2) {
+                                const itemId = parts[0];
+                                const itemLanguage = parts.slice(1).join("-"); // Handle language codes with dashes
+                                refreshItemCounts(itemId, itemLanguage);
+                            }
+                        });
+                    }
+                    else {
+                        // If not found in cache, refresh all items to be safe
+                        allItemsWithDecisions.forEach((item) => {
+                            refreshItemCounts(item.itemId, item.language);
+                        });
+                    }
+                }
+            }
+            catch (err) {
+                console.error("Error handling websocket message:", err);
+            }
+        });
+        return () => {
+            unsubscribe();
+        };
+    }, [
+        editContext?.addSocketMessageListener,
+        refreshItemCounts,
+        allItemsWithDecisions,
+        commentsData,
+        suggestionsData,
+    ]);
+    // Helper function to get comment count for an item by reviewer email
+    const getCommentCount = (itemId, itemLanguage, reviewerEmail) => {
+        const key = `${itemId}-${itemLanguage}`;
+        const comments = commentsData.get(key) || [];
+        return comments.filter((c) => c.author?.toLowerCase() === reviewerEmail.toLowerCase()).length;
     };
-    return (_jsxs("div", { className: "flex h-full flex-col", children: [_jsxs(SimpleToolbar, { children: [_jsxs(Popover, { open: isAddPopoverOpen, onOpenChange: setIsAddPopoverOpen, children: [_jsx(PopoverTrigger, { asChild: true, children: _jsx(SimpleIconButton, { label: "Add Pages", icon: _jsx(Plus, { className: "h-4 w-4" }), onClick: () => setIsAddPopoverOpen(true) }) }), _jsx(PopoverContent, { className: "m-2 w-[600px] p-0", align: "start", children: _jsxs("div", { className: "flex flex-col gap-2 p-2", children: [_jsx("div", { className: "text-sm font-medium", children: "Select Pages" }), _jsx(ItemTreeSelector, { selectedItems: selectedItems, onItemsChange: handleItemsChange, language: language, height: "350px" }), _jsxs("div", { className: "flex justify-end gap-2 border-t pt-2", children: [_jsx(Button, { variant: "outline", size: "sm", onClick: () => {
+    // Helper function to get suggestion count for an item by reviewer email
+    const getSuggestionCount = (itemId, itemLanguage, reviewerEmail) => {
+        const key = `${itemId}-${itemLanguage}`;
+        const suggestions = suggestionsData.get(key) || [];
+        return suggestions.filter((s) => s.author?.toLowerCase() === reviewerEmail.toLowerCase()).length;
+    };
+    // Helper function to get total comment count for an item
+    const getTotalCommentCount = (itemId, itemLanguage) => {
+        const key = `${itemId}-${itemLanguage}`;
+        const comments = commentsData.get(key) || [];
+        return comments.length;
+    };
+    // Helper function to get total suggestion count for an item
+    const getTotalSuggestionCount = (itemId, itemLanguage) => {
+        const key = `${itemId}-${itemLanguage}`;
+        const suggestions = suggestionsData.get(key) || [];
+        return suggestions.length;
+    };
+    const currentItem = editContext?.currentItemDescriptor;
+    const currentFullItem = editContext?.contentEditorItem; // FullItem has path and parentId
+    const userAssignment = assignments.find((a) => currentUserEmail &&
+        a.reviewerEmail.toLowerCase() === currentUserEmail.toLowerCase());
+    const currentItemDecision = userAssignment && currentItem
+        ? getDecision(userAssignment, currentItem.id, currentItem.language || "en")
+        : undefined;
+    // Check if current page is in the review (either directly or as a subitem)
+    const isCurrentPageInReview = useMemo(() => {
+        if (!currentItem || !currentFullItem) {
+            console.log("[DecisionsMatrix] No current item or full item");
+            return false;
+        }
+        const currentPath = currentFullItem.path;
+        const currentId = currentItem.id;
+        const currentLanguage = currentItem.language || "en";
+        console.log("[DecisionsMatrix] Checking if current page is in review:", {
+            currentItemId: currentId,
+            currentItemPath: currentPath,
+            currentItemLanguage: currentLanguage,
+            parentId: currentFullItem.parentId,
+            itemsCount: items.length,
+            items: items.map((i) => ({
+                id: i.itemId,
+                path: i.path,
+                includeSubitems: i.includeSubitems,
+                language: i.language,
+            })),
+        });
+        // Check if current item is directly in the items list
+        const isDirectMatch = items.some((item) => item.itemId === currentId &&
+            (item.language === currentLanguage ||
+                item.language === "*" ||
+                currentLanguage === "*"));
+        console.log("[DecisionsMatrix] Is direct match:", isDirectMatch);
+        if (isDirectMatch) {
+            console.log("[DecisionsMatrix] Current item is directly in review");
+            return true;
+        }
+        // Check if it's a subitem of any item with includeSubitems: true
+        const isSubitem = items.some((item) => {
+            if (!item.includeSubitems) {
+                return false;
+            }
+            console.log(`[DecisionsMatrix] Checking if ${currentId} is subitem of ${item.itemId}`, {
+                currentPath: currentPath,
+                itemPath: item.path,
+                currentParentId: currentFullItem.parentId,
+                itemId: item.itemId,
+            });
+            // Method 1: Check by path if both are available
+            if (currentPath && item.path) {
+                // Normalize paths - remove trailing slashes and ensure consistent format
+                const normalizedCurrentPath = currentPath
+                    .replace(/\/$/, "")
+                    .replace(/\\$/, "");
+                const normalizedItemPath = item.path
+                    .replace(/\/$/, "")
+                    .replace(/\\$/, "");
+                // Check if current path starts with item path and is deeper
+                const isSubPath = normalizedCurrentPath.startsWith(normalizedItemPath + "/") ||
+                    normalizedCurrentPath.startsWith(normalizedItemPath + "\\");
+                if (isSubPath && normalizedCurrentPath !== normalizedItemPath) {
+                    console.log(`[DecisionsMatrix] Found subitem match by path: ${normalizedCurrentPath} is under ${normalizedItemPath}`);
+                    return true;
+                }
+            }
+            // Method 2: Check if current item's parent ID matches the review item ID
+            if (currentFullItem.parentId &&
+                item.itemId === currentFullItem.parentId) {
+                console.log(`[DecisionsMatrix] Found subitem match by parent ID: ${currentId} has parent ${currentFullItem.parentId} which matches ${item.itemId}`);
+                return true;
+            }
+            // Method 3: Check if item ID is in the current path
+            if (currentPath && item.itemId) {
+                const pathContainsId = currentPath.includes(`/${item.itemId}/`) ||
+                    currentPath.includes(`\\${item.itemId}\\`) ||
+                    currentPath.endsWith(`/${item.itemId}`) ||
+                    currentPath.endsWith(`\\${item.itemId}`);
+                if (pathContainsId && currentId !== item.itemId) {
+                    console.log(`[DecisionsMatrix] Found subitem match by ID in path: ${currentPath} contains ${item.itemId}`);
+                    return true;
+                }
+            }
+            return false;
+        });
+        console.log("[DecisionsMatrix] Is in review result:", isDirectMatch || isSubitem);
+        return isDirectMatch || isSubitem;
+    }, [currentItem, currentFullItem, items]);
+    const showCurrentPageButtons = currentItem && userAssignment && isCurrentPageInReview;
+    // Debug logging
+    useEffect(() => {
+        console.log("[DecisionsMatrix] Button visibility check:", {
+            isLimitedPreviewUser,
+            hasCurrentItem: !!currentItem,
+            hasCurrentFullItem: !!currentFullItem,
+            hasUserAssignment: !!userAssignment,
+            isCurrentPageInReview,
+            showCurrentPageButtons,
+            currentItem: currentItem
+                ? {
+                    id: currentItem.id,
+                    path: currentItem.path,
+                    language: currentItem.language,
+                }
+                : null,
+            currentFullItem: currentFullItem
+                ? {
+                    id: currentFullItem.id,
+                    path: currentFullItem.path,
+                    parentId: currentFullItem.parentId,
+                }
+                : null,
+            userAssignment: userAssignment
+                ? {
+                    assignmentId: userAssignment.assignmentId,
+                    reviewerEmail: userAssignment.reviewerEmail,
+                }
+                : null,
+        });
+    }, [
+        isLimitedPreviewUser,
+        currentItem,
+        currentFullItem,
+        userAssignment,
+        isCurrentPageInReview,
+        showCurrentPageButtons,
+    ]);
+    return (_jsxs("div", { className: "flex h-full flex-col", children: [_jsxs(SimpleToolbar, { children: [!isLimitedPreviewUser && (_jsxs(Popover, { open: isAddPopoverOpen, onOpenChange: setIsAddPopoverOpen, children: [_jsx(PopoverTrigger, { asChild: true, children: _jsx(SimpleIconButton, { label: "Add Pages", icon: _jsx(Plus, { className: "h-4 w-4" }), onClick: () => setIsAddPopoverOpen(true) }) }), _jsx(PopoverContent, { className: "m-2 w-[600px] p-0", align: "start", children: _jsxs("div", { className: "flex flex-col gap-2 p-2", children: [_jsx("div", { className: "text-sm font-medium", children: "Select Pages" }), _jsx(ItemTreeSelector, { selectedItems: selectedItems, onItemsChange: handleItemsChange, language: language, height: "350px" }), _jsxs("div", { className: "flex justify-end gap-2 border-t pt-2", children: [_jsx(Button, { variant: "outline", size: "sm", onClick: () => {
                                                         setSelectedItems([]);
                                                         setIsAddPopoverOpen(false);
-                                                    }, children: "Cancel" }), _jsxs(Button, { size: "sm", onClick: handleAddSelectedPages, disabled: selectedItems.length === 0 || loading, children: [_jsx(Plus, { className: "mr-2 h-4 w-4" }), "Add ", selectedItems.length > 0 ? `${selectedItems.length} ` : "", "Page", selectedItems.length !== 1 ? "s" : ""] })] })] }) })] }), _jsxs("div", { className: "flex items-center gap-2", children: [_jsx(Filter, { className: "h-4 w-4" }), _jsxs("select", { value: filter, onChange: (e) => setFilter(e.target.value), className: "rounded border px-2 py-1 text-xs", children: [_jsx("option", { value: "all", children: "All Items" }), _jsx("option", { value: "pending", children: "Pending" }), _jsx("option", { value: "rejected", children: "Rejected" }), _jsx("option", { value: "approved", children: "All Approved" })] })] }), allReviewersResponded && !finalDecision && (_jsx(Button, { size: "sm", onClick: () => setIsFinalDecisionDialogOpen(true), className: "ml-auto", children: "Set Final Decision" })), finalDecision && (_jsx(Badge, { variant: finalDecision === "Approved" ? "default" : "destructive", className: "ml-auto", children: finalDecision === "Approved" ? (_jsxs(_Fragment, { children: [_jsx(Check, { className: "mr-1 h-3 w-3" }), "Final: Approved"] })) : (_jsxs(_Fragment, { children: [_jsx(X, { className: "mr-1 h-3 w-3" }), "Final: Rejected"] })) }))] }), _jsx("div", { className: "flex-1 overflow-auto", children: items.length === 0 ? (_jsx("div", { className: "flex h-full items-center justify-center text-sm text-gray-500", children: "No items in review" })) : (_jsx("div", { className: "overflow-x-auto", children: _jsxs("table", { className: "w-full border-collapse text-xs", children: [_jsx("thead", { className: "sticky top-0 bg-white border-b", children: _jsxs("tr", { children: [_jsx("th", { className: "border p-2 text-left font-medium", children: "Item" }), displayAssignments.map((assignment) => (_jsx("th", { className: "border p-2 text-center font-medium min-w-[120px]", children: _jsxs("div", { className: "flex flex-col", children: [_jsx("span", { className: "font-medium", children: assignment.reviewerName }), _jsx("span", { className: "text-xs text-gray-500 font-normal", children: assignment.reviewerEmail })] }) }, assignment.assignmentId))), _jsx("th", { className: "border p-2 text-center font-medium w-16", children: "Actions" })] }) }), _jsx("tbody", { children: filteredItems.map((item, itemIndex) => (_jsxs("tr", { children: [_jsx("td", { className: "border p-2", children: _jsxs("div", { className: "flex flex-col cursor-pointer hover:bg-gray-50 rounded p-1 -m-1", onClick: () => handleLoadItem(item.itemId, item.language), title: "Click to load item", children: [_jsx("span", { className: "font-medium", children: item.name || item.path || item.itemId }), item.includeSubitems && (_jsx("span", { className: "text-xs text-gray-500", children: "(with subitems)" }))] }) }), displayAssignments.map((assignment) => {
-                                            const decision = getDecision(assignment, item.itemId, item.language);
-                                            const isCurrentUserReviewer = currentUserEmail &&
-                                                assignment.reviewerEmail.toLowerCase() === currentUserEmail.toLowerCase();
-                                            return (_jsx("td", { className: "border p-1 text-center", children: decision ? (getDecisionCell(assignment, item)) : isCurrentUserReviewer ? (_jsxs("div", { className: "flex items-center justify-center gap-1", children: [_jsx(Button, { size: "sm", variant: "outline", className: "h-6 text-xs", onClick: () => handleMakeDecision(assignment.assignmentId, item.itemId, item.language, "Approved"), disabled: loading, children: _jsx(Check, { className: "h-3 w-3" }) }), _jsx(Button, { size: "sm", variant: "outline", className: "h-6 text-xs", onClick: () => handleMakeDecision(assignment.assignmentId, item.itemId, item.language, "Rejected"), disabled: loading, children: _jsx(X, { className: "h-3 w-3" }) })] })) : (_jsx("div", { className: "flex items-center justify-center p-2", children: _jsx(Clock, { className: "h-4 w-4 text-gray-400" }) })) }, assignment.assignmentId));
-                                        }), _jsx("td", { className: "border p-1 text-center", children: _jsx(Button, { size: "sm", variant: "ghost", className: "h-6 w-6 p-0", onClick: () => handleRemovePage(item.itemId, item.language), disabled: loading, title: "Remove page", children: _jsx(Trash2, { className: "h-3 w-3" }) }) })] }, `${item.itemId}-${item.language}-${itemIndex}`))) })] }) })) }), _jsx(Dialog, { open: isFinalDecisionDialogOpen, onOpenChange: setIsFinalDecisionDialogOpen, children: _jsxs(DialogContent, { children: [_jsx(DialogHeader, { children: _jsx(DialogTitle, { children: "Set Final Decision" }) }), _jsx("div", { className: "py-4", children: _jsx("p", { className: "text-sm text-gray-600 mb-4", children: "All reviewers have responded. Set the final decision for this review." }) }), _jsxs(DialogFooter, { children: [_jsx(Button, { variant: "outline", onClick: () => setIsFinalDecisionDialogOpen(false), children: "Cancel" }), _jsx(Button, { variant: "destructive", onClick: async () => {
-                                        await onSetFinalDecision("Rejected");
-                                        setIsFinalDecisionDialogOpen(false);
-                                    }, disabled: loading, children: loading ? (_jsxs(_Fragment, { children: [_jsx(Loader2, { className: "mr-2 h-4 w-4 animate-spin" }), "Setting..."] })) : (_jsxs(_Fragment, { children: [_jsx(X, { className: "mr-2 h-4 w-4" }), "Reject Review"] })) }), _jsx(Button, { onClick: async () => {
-                                        await onSetFinalDecision("Approved");
-                                        setIsFinalDecisionDialogOpen(false);
-                                    }, disabled: loading, children: loading ? (_jsxs(_Fragment, { children: [_jsx(Loader2, { className: "mr-2 h-4 w-4 animate-spin" }), "Setting..."] })) : (_jsxs(_Fragment, { children: [_jsx(Check, { className: "mr-2 h-4 w-4" }), "Approve Review"] })) })] })] }) })] }));
+                                                    }, children: "Cancel" }), _jsxs(Button, { size: "sm", onClick: handleAddSelectedPages, disabled: selectedItems.length === 0 || loading, children: [_jsx(Plus, { className: "mr-2 h-4 w-4" }), "Add", " ", selectedItems.length > 0 ? `${selectedItems.length} ` : "", "Page", selectedItems.length !== 1 ? "s" : ""] })] })] }) })] })), _jsxs("div", { className: "flex items-center gap-2", children: [_jsx(Filter, { className: "h-4 w-4" }), _jsxs("select", { value: filter, onChange: (e) => setFilter(e.target.value), className: "rounded border px-2 py-1 text-xs", children: [_jsx("option", { value: "all", children: "All Items" }), _jsx("option", { value: "pending", children: "Pending" }), _jsx("option", { value: "rejected", children: "Rejected" }), _jsx("option", { value: "approved", children: "All Approved" })] })] }), hasSelectedPages && (_jsx(SimpleIconButton, { label: "Remove Selected", icon: _jsx(Trash2, { className: "h-4 w-4" }), onClick: handleRemoveSelectedPages, disabled: loading })), showCurrentPageButtons && (_jsxs("div", { className: "ml-auto flex items-center gap-2", children: [_jsx("div", { className: "mx-1 h-6 border-l border-gray-300" }), _jsx(SimpleIconButton, { label: `Approve Current Page`, icon: _jsx(Check, { className: "h-4 w-4" }), onClick: handleApproveCurrentPage, disabled: loading, className: currentItemDecision?.decision === "Approved"
+                                    ? "text-green-600"
+                                    : "" }), _jsx(SimpleIconButton, { label: `Reject Current Page`, icon: _jsx(X, { className: "h-4 w-4" }), onClick: handleRejectCurrentPage, disabled: loading, className: currentItemDecision?.decision === "Rejected"
+                                    ? "text-red-600"
+                                    : "" })] }))] }), _jsx("div", { className: "flex-1 overflow-auto", children: allItemsWithDecisions.length === 0 ? (_jsx("div", { className: "flex h-full items-center justify-center text-sm text-gray-500", children: "No items in review" })) : (_jsx("div", { className: "overflow-x-auto", children: _jsxs("table", { className: "w-full border-collapse text-xs", children: [_jsx("thead", { className: "sticky top-0 border-b bg-white", children: _jsxs("tr", { children: [!isLimitedPreviewUser && (_jsx("th", { className: "w-12 border p-2 text-center font-medium", children: _jsx(Checkbox, { checked: filteredItems.length > 0 &&
+                                                    filteredItems.every((item) => selectedPagesForRemoval.has(`${item.itemId}-${item.language}`)), onCheckedChange: (checked) => {
+                                                    const newSelection = new Set();
+                                                    if (checked) {
+                                                        filteredItems.forEach((item) => {
+                                                            newSelection.add(`${item.itemId}-${item.language}`);
+                                                        });
+                                                    }
+                                                    setSelectedPagesForRemoval(newSelection);
+                                                }, className: "h-4 w-4" }) })), _jsx("th", { className: "border p-2 text-left font-medium", children: "Item" }), displayAssignments.map((assignment) => (_jsx("th", { className: "min-w-[120px] border p-2 text-center font-medium", children: _jsxs("div", { className: "flex flex-col", children: [_jsx("span", { className: "font-medium", children: assignment.reviewerName }), _jsx("span", { className: "text-xs font-normal text-gray-500", children: assignment.reviewerEmail })] }) }, assignment.assignmentId))), _jsx("th", { className: "min-w-[60px] border p-2 text-center font-medium", children: _jsxs("div", { className: "flex items-center justify-center gap-1.5", children: [_jsx("div", { title: "Total comments", children: _jsx(MessageSquare, { className: "h-3.5 w-3.5" }) }), _jsx("div", { title: "Total suggestions", children: _jsx(Lightbulb, { className: "h-3.5 w-3.5" }) })] }) }), _jsx("th", { className: "min-w-[120px] border p-2 text-center font-medium", children: _jsx("span", { children: "Actions" }) })] }) }), _jsx("tbody", { children: filteredItems.map((item, itemIndex) => {
+                                    const itemKey = `${item.itemId}-${item.language}`;
+                                    const isSelected = selectedPagesForRemoval.has(itemKey);
+                                    const currentItemLanguage = currentItem?.language || "en";
+                                    const itemLanguage = item.language === "*" ? currentItemLanguage : item.language;
+                                    const isCurrentItem = currentItem &&
+                                        currentItem.id === item.itemId &&
+                                        currentItemLanguage === itemLanguage;
+                                    return (_jsxs("tr", { className: isCurrentItem ? "bg-blue-50" : "", children: [!isLimitedPreviewUser && (_jsx("td", { className: "border p-1 text-center", children: _jsx(Checkbox, { checked: isSelected, onCheckedChange: () => togglePageSelection(item.itemId, item.language), onClick: (e) => e.stopPropagation(), className: "h-4 w-4" }) })), _jsx("td", { className: "border p-2", children: _jsxs("div", { className: "-m-1 flex cursor-pointer flex-col rounded p-1 hover:bg-gray-50", onClick: () => handleLoadItem(item.itemId, item.language), title: "Click to load item", children: [_jsxs("div", { className: "flex items-center gap-2", children: [_jsx("span", { className: "font-medium", children: item.name || item.path || item.itemId }), item.language === "*" ? (_jsx(Badge, { variant: "outline", className: "text-xs", children: "All Languages" })) : (_jsx("span", { className: "text-xs text-gray-500", children: item.language.toUpperCase() }))] }), item.includeSubitems && (_jsx("span", { className: "text-xs text-gray-500", children: "(with subitems)" })), !isLimitedPreviewUser &&
+                                                            (() => {
+                                                                const approvalCount = getApprovalCount(item.itemId, item.language);
+                                                                const status = getItemApprovalStatus(item.itemId, item.language);
+                                                                return (_jsxs("div", { className: "mt-1 flex items-center gap-1", children: [_jsxs("span", { className: `text-xs ${status === "approved"
+                                                                                ? "font-semibold text-green-600"
+                                                                                : status === "rejected"
+                                                                                    ? "font-semibold text-red-600"
+                                                                                    : "text-gray-500"}`, children: [approvalCount, "/", requiredApprovals, " ", "approvals"] }), status === "approved" && (_jsx(Check, { className: "h-3 w-3 text-green-600" })), status === "rejected" && (_jsx(X, { className: "h-3 w-3 text-red-600" }))] }));
+                                                            })()] }) }), displayAssignments.map((assignment) => {
+                                                return (_jsx("td", { className: "border p-1 text-center", children: getDecisionCell(assignment, item) }, assignment.assignmentId));
+                                            }), _jsx("td", { className: "border p-1 text-center", children: loadingCounts ? (_jsx(Loader2, { className: "mx-auto h-3 w-3 animate-spin" })) : (_jsx("div", { className: "flex items-center justify-center gap-2 text-xs", children: (() => {
+                                                        // If a reviewer is selected, filter counts by that reviewer
+                                                        // Otherwise, show total counts for all reviewers
+                                                        let commentCount;
+                                                        let suggestionCount;
+                                                        if (selectedReviewerId) {
+                                                            // Find the selected reviewer's assignment
+                                                            const selectedAssignment = assignments.find((a) => a.assignmentId === selectedReviewerId);
+                                                            if (selectedAssignment) {
+                                                                commentCount = getCommentCount(item.itemId, item.language, selectedAssignment.reviewerEmail);
+                                                                suggestionCount = getSuggestionCount(item.itemId, item.language, selectedAssignment.reviewerEmail);
+                                                            }
+                                                            else {
+                                                                // Fallback to total counts if assignment not found
+                                                                commentCount = getTotalCommentCount(item.itemId, item.language);
+                                                                suggestionCount = getTotalSuggestionCount(item.itemId, item.language);
+                                                            }
+                                                        }
+                                                        else {
+                                                            // No reviewer selected, show total counts
+                                                            commentCount = getTotalCommentCount(item.itemId, item.language);
+                                                            suggestionCount = getTotalSuggestionCount(item.itemId, item.language);
+                                                        }
+                                                        return (_jsxs(_Fragment, { children: [commentCount > 0 && (_jsxs("div", { className: "flex items-center gap-0.5", title: `${commentCount} comment${commentCount !== 1 ? "s" : ""}`, children: [_jsx(MessageSquare, { className: "h-3 w-3" }), _jsx("span", { children: commentCount })] })), suggestionCount > 0 && (_jsxs("div", { className: "flex items-center gap-0.5", title: `${suggestionCount} suggestion${suggestionCount !== 1 ? "s" : ""}`, children: [_jsx(Lightbulb, { className: "h-3 w-3" }), _jsx("span", { children: suggestionCount })] })), commentCount === 0 &&
+                                                                    suggestionCount === 0 && (_jsx("span", { className: "text-xs text-gray-400", children: "-" }))] }));
+                                                    })() })) }), _jsx("td", { className: "border p-1 text-center", children: _jsxs("div", { className: "flex items-center justify-center gap-1", children: [(() => {
+                                                            // Find the current user's assignment for this item (check all assignments, not just displayed ones)
+                                                            const currentUserAssignment = assignments.find((a) => currentUserEmail &&
+                                                                a.reviewerEmail.toLowerCase() ===
+                                                                    currentUserEmail.toLowerCase());
+                                                            if (currentUserAssignment) {
+                                                                const decision = getDecision(currentUserAssignment, item.itemId, item.language);
+                                                                return (_jsxs(_Fragment, { children: [_jsx(SimpleIconButton, { label: "Approve", icon: _jsx(Check, { className: "h-4 w-4" }), onClick: () => handleMakeDecision(currentUserAssignment.assignmentId, item.itemId, item.language, "Approved"), disabled: loading, className: decision?.decision === "Approved"
+                                                                                ? "text-green-600"
+                                                                                : "" }), _jsx(SimpleIconButton, { label: "Reject", icon: _jsx(X, { className: "h-4 w-4" }), onClick: () => handleMakeDecision(currentUserAssignment.assignmentId, item.itemId, item.language, "Rejected"), disabled: loading, className: decision?.decision === "Rejected"
+                                                                                ? "text-red-600"
+                                                                                : "" })] }));
+                                                            }
+                                                            return null;
+                                                        })(), !isLimitedPreviewUser && (_jsx(Button, { size: "sm", variant: "ghost", className: "h-6 w-6 p-0", onClick: () => handleRemovePage(item.itemId, item.language), disabled: loading, title: "Remove page", children: _jsx(Trash2, { className: "h-3 w-3" }) }))] }) })] }, `${item.itemId}-${item.language}-${itemIndex}`));
+                                }) })] }) })) })] }));
 }
 //# sourceMappingURL=DecisionsMatrix.js.map