@deenruv/reviews-plugin 1.0.0

package/dist/plugin-ui/locales/en/reviews.json

@@ -0,0 +1,107 @@
+{
+    "dialog": {
+        "bulkStateChangeTitle": "Bulk change review state",
+        "bulkStateChangeDescription": "Are you sure you want to change the state of the selected reviews?",
+        "bulkStateChangeSelectLabel": "Select review state",
+        "bulkStateChangeSelectPlaceholder": "Select review state",
+        "bulkStateChangeSuccess": "Review state has been changed",
+        "bulkStateChangeError": "An error occurred while changing the review state",
+        "bulkStateChangeCancelled": "Bulk change of review state has been cancelled",
+        "bulkStateChangeNoSelection": "No reviews selected for state change",
+        "singleStateChangeTitle": "Single change review state",
+        "singleStateChangeDescription": "Are you sure you want to change the state of this review?",
+        "singleStateChangeSelectLabel": "Select review state",
+        "singleStateChangeSelectPlaceholder": "Select review state",
+        "singleStateChangeSuccess": "Review state has been changed",
+        "singleStateChangeError": "An error occurred while changing the review state",
+        "singleStateChangeCancelled": "Single change of review state has been cancelled",
+        "singleStateChangeNoSelection": "No review selected for state change",
+        "cancel": "Cancel",
+        "submit": "Submit",
+        "selectError": "Please select a review state"
+    },
+    "state": {
+        "pending": "Pending",
+        "accepted": "Accepted",
+        "declined": "Declined"
+    },
+    "detail": {
+        "viewCustomer": "View customer",
+        "id": "Review {{id}}",
+        "changeState": "Change review state",
+        "changeStateSuccess": "Review state has been changed",
+        "changeStateError": "An error occurred while changing the review state",
+        "cancel": "Cancel",
+        "confirm": "Confirm",
+        "selectState": "Select review state",
+        "businessResponsePlaceholder": "Optional response to the review",
+        "businessResponse": "Business response",
+        "createdAt": "Created at",
+        "updatedAt": "Updated at",
+        "noFound": "No review found",
+        "reviewTranslations": "Translations",
+        "reviewContent": "Review content",
+        "generateAllMissingTranslations": "Generate all missing translations",
+        "generateAllMissingTranslationsSuccess": "All missing translations have been generated",
+        "generateAllMissingTranslationsError": "An error occurred while generating missing translations",
+        "updateReview": "Update review",
+        "noTranslation": "No translation available",
+        "generateTranslation": "Generate translation",
+        "manualTranslation": "Create manual translation",
+        "reviewBody": "Review body",
+        "review": "{{review}} out of 5",
+        "stateRequired": "Review state is required",
+        "rating": "Rating {{rating}} out of 5",
+        "assets": "Attachments",
+        "manualTranslationPlaceholder": "Manual translation body",
+        "generatedTranslationBody": "Generated translation body"
+    },
+    "productInfo": {
+        "productReview": "Product review",
+        "viewProduct": "View product",
+        "productId": "Product ID",
+        "productName": "Product name",
+        "variantName": "Variant name"
+    },
+    "orderInfo": {
+        "orderReview": "Order review",
+        "viewOrder": "View order",
+        "orderId": "Order ID",
+        "orderCode": "Order code",
+        "orderTotal": "Order total",
+        "totalItems": "Total items"
+    },
+    "reviewOrder": {
+        "title": "Order review",
+        "titleWithId": "Order review #{{orderId}}"
+    },
+    "productReviewSidebar": {
+        "averageRating": "Average rating",
+        "noAverageRating": "No average rating",
+        "totalReviews": "Total reviews",
+        "noTotalReviews": "No total reviews",
+        "totalReviewsForProduct": "Total reviews for product",
+        "noTotalReviewsForProduct": "No total reviews for product",
+        "viewAllReviews": "See all reviews for this product"
+    },
+    "nav": {
+        "reviews": "Reviews",
+        "reviewsList": "Reviews List"
+    },
+    "list": {
+        "bulkStateChange": "Bulk change state",
+        "stateChange": "Change state",
+        "productId": "Product ID",
+        "orderId": "Order ID",
+        "customerId": "Customer ID",
+        "reviewFor": "Review for",
+        "shopReview": "Review for shop",
+        "orderReview": "Review for order #{{orderId}}",
+        "responseDate": "Response date",
+        "state": "State",
+        "rating": "Rating",
+        "noResponse": "No response",
+        "responseCreatedAt": "Response created at",
+        "responseCreatedAtValue": "Responded {{date}}"
+    }
+}

package/dist/plugin-ui/locales/pl/index.d.ts

@@ -0,0 +1,108 @@
+declare const _default: {
+    dialog: {
+        bulkStateChangeTitle: string;
+        bulkStateChangeDescription: string;
+        bulkStateChangeSelectLabel: string;
+        bulkStateChangeSelectPlaceholder: string;
+        bulkStateChangeSuccess: string;
+        bulkStateChangeError: string;
+        bulkStateChangeCancelled: string;
+        bulkStateChangeNoSelection: string;
+        singleStateChangeTitle: string;
+        singleStateChangeDescription: string;
+        singleStateChangeSelectLabel: string;
+        singleStateChangeSelectPlaceholder: string;
+        singleStateChangeSuccess: string;
+        singleStateChangeError: string;
+        singleStateChangeCancelled: string;
+        singleStateChangeNoSelection: string;
+        cancel: string;
+        submit: string;
+        selectError: string;
+    };
+    state: {
+        pending: string;
+        accepted: string;
+        declined: string;
+    };
+    detail: {
+        viewCustomer: string;
+        id: string;
+        changeState: string;
+        changeStateSuccess: string;
+        changeStateError: string;
+        cancel: string;
+        confirm: string;
+        selectState: string;
+        businessResponsePlaceholder: string;
+        businessResponse: string;
+        createdAt: string;
+        updatedAt: string;
+        noFound: string;
+        reviewTranslations: string;
+        reviewContent: string;
+        generateAllMissingTranslations: string;
+        generateAllMissingTranslationsSuccess: string;
+        generateAllMissingTranslationsError: string;
+        updateReview: string;
+        noTranslation: string;
+        generateTranslation: string;
+        manualTranslation: string;
+        reviewBody: string;
+        review: string;
+        stateRequired: string;
+        rating: string;
+        assets: string;
+        manualTranslationPlaceholder: string;
+        generatedTranslationBody: string;
+    };
+    productInfo: {
+        productReview: string;
+        viewProduct: string;
+        productId: string;
+        productName: string;
+        variantName: string;
+    };
+    orderInfo: {
+        orderReview: string;
+        viewOrder: string;
+        orderId: string;
+        orderCode: string;
+        orderTotal: string;
+        totalItems: string;
+    };
+    reviewOrder: {
+        title: string;
+        titleWithId: string;
+    };
+    productReviewSidebar: {
+        averageRating: string;
+        noAverageRating: string;
+        totalReviews: string;
+        noTotalReviews: string;
+        totalReviewsForProduct: string;
+        noTotalReviewsForProduct: string;
+        viewAllReviews: string;
+    };
+    nav: {
+        reviews: string;
+        reviewsList: string;
+    };
+    list: {
+        bulkStateChange: string;
+        stateChange: string;
+        productId: string;
+        orderId: string;
+        customerId: string;
+        reviewFor: string;
+        shopReview: string;
+        orderReview: string;
+        responseDate: string;
+        state: string;
+        rating: string;
+        noResponse: string;
+        responseCreatedAt: string;
+        responseCreatedAtValue: string;
+    };
+}[];
+export default _default;

package/dist/plugin-ui/locales/pl/index.js

@@ -0,0 +1,2 @@
+import reviews from "./reviews.json";
+export default [reviews];

package/dist/plugin-ui/locales/pl/reviews.json

@@ -0,0 +1,107 @@
+{
+    "dialog": {
+        "bulkStateChangeTitle": "Zmiana stanu opinii",
+        "bulkStateChangeDescription": "Czy na pewno chcesz zmienić stan zaznaczonych opinii?",
+        "bulkStateChangeSelectLabel": "Wybierz stan opinii",
+        "bulkStateChangeSelectPlaceholder": "Wybierz stan opinii",
+        "bulkStateChangeSuccess": "Stan opinii został zmieniony",
+        "bulkStateChangeError": "Wystąpił błąd podczas zmiany stanu opinii",
+        "bulkStateChangeCancelled": "Zmiana stanu opinii została anulowana",
+        "bulkStateChangeNoSelection": "Nie wybrano opinii do zmiany stanu",
+        "singleStateChangeTitle": "Zmiana stanu opinii",
+        "singleStateChangeDescription": "Czy na pewno chcesz zmienić stan tej opinii?",
+        "singleStateChangeSelectLabel": "Wybierz stan opinii",
+        "singleStateChangeSelectPlaceholder": "Wybierz stan opinii",
+        "singleStateChangeSuccess": "Stan opinii został zmieniony",
+        "singleStateChangeError": "Wystąpił błąd podczas zmiany stanu opinii",
+        "singleStateChangeCancelled": "Zmiana stanu opinii została anulowana",
+        "singleStateChangeNoSelection": "Nie wybrano opinii do zmiany stanu",
+        "cancel": "Anuluj",
+        "submit": "Zatwierdź",
+        "selectError": "Wybierz stan opinii"
+    },
+    "state": {
+        "pending": "Oczekująca",
+        "accepted": "Zaakceptowana",
+        "declined": "Odrzucona"
+    },
+    "detail": {
+        "viewCustomer": "Zobacz klienta",
+        "id": "Opinia {{id}}",
+        "changeState": "Zmień stan opinii",
+        "changeStateSuccess": "Stan opinii został zmieniony",
+        "changeStateError": "Wystąpił błąd podczas zmiany stanu opinii",
+        "cancel": "Anuluj",
+        "confirm": "Potwierdź",
+        "selectState": "Wybierz stan opinii",
+        "businessResponsePlaceholder": "Opcjonalna odpowiedź na opinię",
+        "businessResponse": "Odpowiedź firmy",
+        "createdAt": "Utworzono",
+        "updatedAt": "Zaktualizowano",
+        "noFound": "Nie znaleziono opinii",
+        "reviewTranslations": "Tłumaczenia",
+        "reviewContent": "Treść opinii",
+        "generateAllMissingTranslations": "Generuj brakujące tłumaczenia",
+        "generateAllMissingTranslationsSuccess": "Wszystkie brakujące tłumaczenia zostały wygenerowane",
+        "generateAllMissingTranslationsError": "Wystąpił błąd podczas generowania brakujących tłumaczeń",
+        "updateReview": "Zaktualizuj opinię",
+        "noTranslation": "Brak dostępnego tłumaczenia",
+        "generateTranslation": "Generuj tłumaczenie",
+        "manualTranslation": "Utwórz ręczne tłumaczenie",
+        "reviewBody": "Treść opinii",
+        "review": "{{review}} z 5",
+        "stateRequired": "Stan opinii jest wymagany",
+        "rating": "Ocena {{rating}} z 5",
+        "assets": "Załączniki",
+        "manualTranslationPlaceholder": "Ręczne tłumaczenie treści",
+        "generatedTranslationBody": "Wygenerowana treść tłumaczenia"
+    },
+    "productInfo": {
+        "productReview": "Recenzja produktu",
+        "viewProduct": "Zobacz produkt",
+        "productId": "ID produktu",
+        "productName": "Nazwa produktu",
+        "variantName": "Nazwa wariantu"
+    },
+    "orderInfo": {
+        "orderReview": "Recenzja zamówienia",
+        "viewOrder": "Zobacz zamówienie",
+        "orderId": "ID zamówienia",
+        "orderCode": "Kod zamówienia",
+        "orderTotal": "Łączna kwota zamówienia",
+        "totalItems": "Łączna liczba przedmiotów"
+    },
+    "reviewOrder": {
+        "title": "Recenzja zamówienia",
+        "titleWithId": "Recenzja zamówienia #{{orderId}}"
+    },
+    "productReviewSidebar": {
+        "averageRating": "Średnia ocena",
+        "noAverageRating": "Brak średniej oceny",
+        "totalReviews": "Łączna liczba ocen",
+        "noTotalReviews": "Brak ocen",
+        "totalReviewsForProduct": "Łączna liczba ocen dla produktu",
+        "noTotalReviewsForProduct": "Brak ocen dla produktu",
+        "viewAllReviews": "Zobacz wszystkie opinie o produkcie"
+    },
+    "nav": {
+        "reviews": "Oceny",
+        "reviewsList": "Lista ocen"
+    },
+    "list": {
+        "bulkStateChange": "Zmiana stanu dla wielu",
+        "stateChange": "Zmień stan",
+        "productId": "ID produktu",
+        "orderId": "ID zamówienia",
+        "customerId": "ID klienta",
+        "reviewFor": "Recenzja dla",
+        "shopReview": "Recenzja sklepu",
+        "orderReview": "Recenzja zamówienia #{{orderId}}",
+        "responseDate": "Data odpowiedzi",
+        "state": "Stan",
+        "rating": "Ocena",
+        "noResponse": "Nie zareagowano",
+        "responseCreatedAt": "Odpowiedź utworzona",
+        "responseCreatedAtValue": "Zareagowano {{date}}"
+    }
+}

package/dist/plugin-ui/pages/Review.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const Review: () => React.JSX.Element;

package/dist/plugin-ui/pages/Review.js

@@ -0,0 +1,263 @@
+import { Card, CardContent, CardHeader, CardTitle, PageBlock, Textarea, useLazyQuery, useQuery, Label, Badge, Separator, formatDate, Button, useMutation, ImageWithPreview, Routes, } from "@deenruv/react-ui-devkit";
+import React, { useCallback, useEffect, useMemo, useState } from "react";
+import { ChangeReviewStateMutation, GetReviewQuery, GetReviewsConfigQuery, UpdateTranslationsReviewMutation, TranslateReviewsQuery, } from "../graphql";
+import { Link, useParams } from "react-router-dom";
+import { ArrowLeft, Calendar, Mail, Star, User } from "lucide-react";
+import { useNavigate } from "react-router-dom";
+import { OrderInfo, ProductInfo } from "../components";
+import { TRANSLATION_NAMESPACE } from "../constants";
+import { useTranslation } from "react-i18next";
+import { toast } from "sonner";
+import { ReviewStateChange } from "../components/ReviewStateChange";
+export const Review = () => {
+    const { t } = useTranslation(TRANSLATION_NAMESPACE, {
+        i18n: window.__DEENRUV_SETTINGS__.i18n,
+    });
+    const { id } = useParams();
+    const { data: config } = useQuery(GetReviewsConfigQuery);
+    const [get] = useLazyQuery(GetReviewQuery);
+    const [originalReview, setOriginalReview] = useState();
+    const [review, setReview] = useState();
+    const [updateTranslationsReview] = useMutation(UpdateTranslationsReviewMutation);
+    const [changeReviewState] = useMutation(ChangeReviewStateMutation);
+    const [translate] = useLazyQuery(TranslateReviewsQuery);
+    const navigate = useNavigate();
+    const refetch = useCallback(async () => {
+        if (!id)
+            return;
+        try {
+            const res = await get({ id });
+            setReview(res.getReview);
+            setOriginalReview(res.getReview);
+        }
+        catch (error) {
+            console.error("Error fetching review:", error);
+        }
+    }, [id]);
+    useEffect(() => {
+        if (config && id)
+            refetch();
+    }, [id, config]);
+    const getStateColor = (state) => {
+        let variant = "default";
+        if (state === "ACCEPTED" /* ReviewState.ACCEPTED */) {
+            variant = "success";
+        }
+        if (state === "DECLINED" /* ReviewState.DECLINED */) {
+            variant = "destructive";
+        }
+        return variant;
+    };
+    const renderStars = (rating) => {
+        return Array.from({ length: 5 }, (_, i) => (React.createElement(Star, { key: i, className: `w-5 h-5 ${i < rating ? "text-yellow-500" : "text-gray-300"}`, fill: i < rating ? "currentColor" : "none", stroke: "currentColor", strokeWidth: 1.5 })));
+    };
+    const handleGenerateAllMissingTranslations = async () => {
+        if (!review || !config)
+            return;
+        try {
+            const languages = config.getReviewsConfig.reviewsLanguages;
+            const existingLanguages = review.translations.map((t) => t.languageCode);
+            const missingLanguages = languages.filter((lang) => !existingLanguages.includes(lang));
+            const { translateReviews } = await translate({
+                input: { id: review.id, languages: missingLanguages },
+            });
+            const newTranslations = translateReviews.map((translation) => ({
+                id: `generate-${translation.languageCode}`,
+                languageCode: translation.languageCode,
+                body: translation.body || t("detail.generatedTranslationBody"),
+            }));
+            setReview((prev) => {
+                if (!prev)
+                    return prev;
+                return {
+                    ...prev,
+                    translations: [...(prev.translations || []), ...newTranslations],
+                };
+            });
+            toast.success(t("generateAllMissingTranslationsSuccess"));
+        }
+        catch (error) {
+            toast.error(t("generateAllMissingTranslationsError"));
+        }
+    };
+    const handleMissingTranslation = async (action, language) => {
+        if (!review || !config)
+            return;
+        let body = "";
+        if (action === "generate") {
+            const { translateReviews } = await translate({
+                input: { id: review.id, languages: [language] },
+            });
+            const translatedReview = translateReviews.find((t) => t.languageCode === language);
+            body = translatedReview?.body || t("detail.generatedTranslationBody");
+        }
+        else {
+            body = t("detail.manualTranslationPlaceholder");
+        }
+        setReview((prev) => {
+            if (!prev)
+                return prev;
+            const newTranslation = {
+                id: `${action}-${language}`,
+                languageCode: language,
+                body,
+            };
+            return {
+                ...prev,
+                translations: [...(prev.translations || []), newTranslation],
+            };
+        });
+    };
+    const handleUpdateReviewTranslation = async () => {
+        if (!review || !id)
+            return;
+        const mappedTranslations = review.translations.map((translation) => ({
+            languageCode: translation.languageCode,
+            body: translation.body,
+        }));
+        const translations = mappedTranslations.filter((translation) => translation.languageCode !== undefined &&
+            translation.body !== undefined);
+        await updateTranslationsReview({ input: { id: review.id, translations } });
+        await refetch();
+    };
+    const haveMissingTranslations = useMemo(() => {
+        if (!review || !config)
+            return false;
+        const languages = config.getReviewsConfig.reviewsLanguages;
+        const existingLanguages = review.translations.map((t) => t.languageCode);
+        return languages.some((lang) => !existingLanguages.includes(lang));
+    }, [review, config]);
+    const handleChangeReviewState = async (state, message) => {
+        if (!review || !id)
+            return;
+        try {
+            await changeReviewState({
+                input: { id: review.id, state, message },
+            });
+            toast.success(t("detail.changeStateSuccess"));
+            await refetch();
+        }
+        catch (error) {
+            console.error("Error changing review state:", error);
+            toast.error(t("detail.changeStateError"));
+        }
+    };
+    const InfoComponent = useMemo(() => {
+        if (review?.productVariant) {
+            return React.createElement(ProductInfo, { review: review });
+        }
+        else if (review?.order) {
+            return React.createElement(OrderInfo, { review: review });
+        }
+        return null;
+    }, [review]);
+    const isDirty = useMemo(() => {
+        if (!review || !originalReview)
+            return false;
+        return JSON.stringify(review) !== JSON.stringify(originalReview);
+    }, [review, originalReview]);
+    return (React.createElement(PageBlock, { className: "flex flex-col gap-4" },
+        React.createElement(Card, null,
+            React.createElement(CardHeader, null,
+                React.createElement("div", { className: "flex items-start justify-between" },
+                    React.createElement("div", { className: "flex gap-2 items-center" },
+                        React.createElement(Button, { variant: "ghost", size: "icon", onClick: () => navigate(-1) },
+                            React.createElement(ArrowLeft, { className: "w-5 h-5" })),
+                        React.createElement("p", { className: "text-md font-semibold" }, review?.id ? t("detail.id", { id: review.id }) : null)),
+                    React.createElement("div", { className: "flex flex-col gap-2 items-end" }, "PENDING" /* ReviewState.PENDING */ === review?.state && (React.createElement(ReviewStateChange, { onSubmit: handleChangeReviewState }))))),
+            React.createElement(CardContent, null, review ? (React.createElement("div", { className: "space-y-6" },
+                React.createElement("div", { className: "flex gap-4 justify-between items-start" },
+                    React.createElement(Card, { className: "w-full" },
+                        React.createElement(CardContent, { className: "flex items-center gap-4 p-4 rounded-lg" },
+                            React.createElement("div", { className: "w-12 h-12 bg-blue-100 rounded-full flex items-center justify-center" },
+                                React.createElement(User, { className: "w-6 h-6 text-blue-600" })),
+                            React.createElement("div", { className: "flex-1" },
+                                React.createElement("h3", { className: "font-semibold text-lg" }, review.authorName),
+                                React.createElement("div", { className: "flex items-center gap-2 text-sm text-gray-600" },
+                                    React.createElement(Mail, { className: "w-4 h-4" }),
+                                    review.authorEmailAddress),
+                                React.createElement("div", { className: "flex items-center gap-2 text-sm text-gray-600" },
+                                    React.createElement(Calendar, { className: "w-4 h-4" }),
+                                    formatDate(review.createdAt, {
+                                        dateStyle: "medium",
+                                        timeStyle: "short",
+                                    })),
+                                review.author?.id ? (React.createElement("div", { className: "text-sm text-gray-600" },
+                                    React.createElement(Link, { to: Routes.customers.to(review.author.id) }, t("detail.viewCustomer")))) : null),
+                            React.createElement("div", { className: "flex flex-col gap-2 items-end" },
+                                React.createElement("div", { className: "flex items-center gap-1 mb-1" }, renderStars(review.rating)),
+                                React.createElement("div", { className: "text-sm text-gray-500 text-right" }, t("detail.rating", { rating: review.rating })),
+                                React.createElement(Badge, { variant: getStateColor(review?.state), className: "mt-4 text-xs font-semibold w-fit" }, t(`state.${review.state.toLowerCase()}`))))),
+                    React.createElement("div", { className: "w-full" }, InfoComponent)),
+                React.createElement("div", { className: "space-y-4" }, review.assets?.length ? (React.createElement("div", { className: "flex flex-col gap-2" },
+                    React.createElement(Label, { className: "text-base font-semibold" }, t("detail.assets")),
+                    review.assets.map((asset) => (React.createElement("div", { key: asset.key, className: "flex flex-col items-start gap-2" },
+                        React.createElement(ImageWithPreview, { src: asset.url, alt: asset.key, imageClassName: "w-16 h-16 object-cover rounded", previewClassName: "w-full h-full object-cover rounded max-w-[400px] max-h-[400px]" })))))) : null),
+                review.response && review.responseCreatedAt && (React.createElement(React.Fragment, null,
+                    React.createElement(Separator, null),
+                    React.createElement("div", { className: "bg-primary/90 p-4 rounded-lg" },
+                        React.createElement("div", { className: "flex items-center gap-2 mb-2" },
+                            React.createElement(Label, { className: "text-base font-semibold text-secondary" }, t("detail.businessResponse")),
+                            React.createElement(Badge, { variant: "outline", className: "text-xs text-secondary" }, formatDate(review.responseCreatedAt, {
+                                dateStyle: "medium",
+                                timeStyle: "short",
+                            }))),
+                        React.createElement("p", { className: "text-secondary" }, review.response)))),
+                React.createElement("div", { className: "grid grid-cols-2 gap-4 pt-4 border-t text-sm text-gray-600" },
+                    React.createElement("div", null,
+                        React.createElement("span", { className: "font-medium" },
+                            t("detail.createdAt"),
+                            ":"),
+                        " ",
+                        formatDate(review.createdAt, {
+                            dateStyle: "medium",
+                            timeStyle: "short",
+                        })),
+                    React.createElement("div", null,
+                        React.createElement("span", { className: "font-medium" },
+                            t("detail.updatedAt"),
+                            ":"),
+                        " ",
+                        formatDate(review.updatedAt, {
+                            dateStyle: "medium",
+                            timeStyle: "short",
+                        }))))) : (React.createElement("div", { className: "text-center py-8" },
+                React.createElement("p", { className: "text-gray-500" }, t("detail.noFound")))))),
+        React.createElement(Card, null,
+            React.createElement(CardHeader, null,
+                React.createElement("div", { className: "flex items-center justify-between" },
+                    React.createElement(CardTitle, { className: "text-xl font-bold" }, config?.getReviewsConfig.reviewsLanguages &&
+                        config.getReviewsConfig.reviewsLanguages.length > 1
+                        ? t("detail.reviewTranslations")
+                        : t("detail.reviewContent")),
+                    config?.getReviewsConfig.reviewsLanguages &&
+                        config.getReviewsConfig.reviewsLanguages.length > 1 ? (React.createElement("div", { className: "flex items-center gap-4" },
+                        config?.getReviewsConfig.canTranslate ? (React.createElement(Button, { disabled: !haveMissingTranslations, variant: "secondary", onClick: handleGenerateAllMissingTranslations }, t("detail.generateAllMissingTranslations"))) : null,
+                        React.createElement(Button, { variant: "action", disabled: !isDirty, onClick: handleUpdateReviewTranslation }, t("detail.updateReview")))) : null)),
+            React.createElement(CardContent, null,
+                React.createElement("div", { className: "space-y-6" }, config?.getReviewsConfig.reviewsLanguages.map((lang, index) => {
+                    const matchingTranslation = review?.translations.find((t) => t.languageCode === lang);
+                    const isOriginal = !(matchingTranslation?.id.startsWith("manual-") ||
+                        matchingTranslation?.id.startsWith("generate-"));
+                    return (React.createElement("div", { key: lang },
+                        index > 0 && React.createElement(Separator, { className: "mb-6" }),
+                        React.createElement("div", { className: "space-y-4" },
+                            React.createElement("div", { className: "flex items-center gap-2" },
+                                React.createElement(Badge, { variant: "outline", className: "font-mono" }, lang.toUpperCase())),
+                            matchingTranslation ? (React.createElement(TranslationComponent, { language: lang, matchingTranslation: matchingTranslation, isOriginal: isOriginal })) : (React.createElement("div", { className: "text-center py-6 rounded-lg" },
+                                React.createElement("p", { className: "text-gray-500" }, t("detail.noTranslation")),
+                                React.createElement("div", { className: "flex items-center justify-center gap-4 mt-4" },
+                                    config?.getReviewsConfig.canTranslate ? (React.createElement(Button, { variant: "action", onClick: () => handleMissingTranslation("generate", lang) }, t("detail.generateTranslation"))) : null,
+                                    React.createElement(Button, { variant: "outline", onClick: () => handleMissingTranslation("manual", lang) }, t("detail.manualTranslation"))))))));
+                }))))));
+};
+const TranslationComponent = ({ language, matchingTranslation, isOriginal, }) => {
+    const { t } = useTranslation(TRANSLATION_NAMESPACE, {
+        i18n: window.__DEENRUV_SETTINGS__.i18n,
+    });
+    const [body, setBody] = useState(matchingTranslation.body);
+    return (React.createElement("div", { className: "space-y-4" },
+        React.createElement("div", null,
+            React.createElement(Label, { htmlFor: `body-${language}`, className: "text-sm font-medium" }, t("detail.reviewBody")),
+            React.createElement(Textarea, { id: `body-${language}`, value: body, readOnly: isOriginal, className: "mt-1 min-h-[100px] resize-none", onChange: (e) => setBody(e.target.value) }))));
+};

package/dist/plugin-ui/pages/Reviews.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const Reviews: () => React.JSX.Element;