@deenruv/replicate-plugin 1.0.0

package/dist/plugin-server/zeus/typedDocumentNode.d.ts

@@ -0,0 +1,3 @@
+import { TypedDocumentNode } from '@graphql-typed-document-node/core';
+import { ValueTypes, GenericOperation, OperationOptions, GraphQLTypes, InputType, ScalarDefinition, ThunderGraphQLOptions, ExtractVariables } from './index.js';
+export declare const typedGql: <O extends "query" | "mutation", SCLR extends ScalarDefinition, R extends keyof ValueTypes = GenericOperation<O>>(operation: O, graphqlOptions?: ThunderGraphQLOptions<SCLR> | undefined) => <Z extends ValueTypes[R]>(o: Z & { [P in keyof Z]: P extends keyof ValueTypes[R] ? Z[P] : never; }, ops?: OperationOptions) => TypedDocumentNode<InputType<GraphQLTypes[R], Z, SCLR>, ExtractVariables<Z>>;

package/dist/plugin-server/zeus/typedDocumentNode.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typedGql = void 0;
+const graphql_tag_1 = require("graphql-tag");
+const index_js_1 = require("./index.js");
+const typedGql = (operation, graphqlOptions) => (o, ops) => {
+    const str = (0, index_js_1.Zeus)(operation, o, {
+        operationOptions: ops,
+        scalars: graphqlOptions === null || graphqlOptions === void 0 ? void 0 : graphqlOptions.scalars,
+    });
+    return (0, graphql_tag_1.gql)(str);
+};
+exports.typedGql = typedGql;

package/dist/plugin-ui/components/Replicate.d.ts

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

package/dist/plugin-ui/components/Replicate.js

@@ -0,0 +1,307 @@
+import { useState, useEffect, useRef } from "react";
+import { useTranslation } from "react-i18next";
+import { CircleUser, ArrowRight } from "lucide-react";
+import { cn, Routes, ScrollArea } from "@deenruv/react-ui-devkit";
+import { Button, Card, CardContent, CardDescription, CardHeader, CardTitle, Input, Label, useLazyQuery, useMutation, Badge, } from "@deenruv/react-ui-devkit";
+import { translationNS } from "../translation-ns";
+import { useForm, FormProvider } from "react-hook-form";
+import { startOrderExportToReplicateMutation } from "../graphql/mutations.js";
+import { getPredictionIDQuery, getReplicatePredictionsQuery, getPredictionItemQuery, } from "../graphql/queries.js";
+import { PredictionStatus, PredictionType, SortOrder } from "../zeus/index.js";
+import { DatePickerWithRange, copyToClipboard, exportToCsv, } from "./ReplicateUtilities.js";
+import { useLocation, useNavigate } from "react-router-dom";
+import React from "react";
+const PredictionStatusTypes = [
+    {
+        value: PredictionStatus.starting,
+        label: "In progress",
+    },
+    {
+        value: PredictionStatus.succeeded,
+        label: "Completed",
+    },
+    {
+        value: PredictionStatus.failed,
+        label: "Failed",
+    },
+];
+const MAX_RETRIES = 25;
+export const ReplicateInput = () => {
+    const { t } = useTranslation(translationNS);
+    const location = useLocation();
+    const navigate = useNavigate();
+    const methods = useForm({
+        defaultValues: {
+            num_prospects: 100,
+            start_date: "",
+            end_date: "",
+            predict_type: PredictionType.RFM_SCORE,
+            show_metrics: true,
+        },
+    });
+    const getQueryParams = (query) => {
+        if (!query || query === "")
+            return {};
+        const [key, value] = query.substring(1).split("=");
+        return key && value ? { [key]: value } : {};
+    };
+    const queryParams = getQueryParams(location.search);
+    const replicateId = queryParams.replicateId;
+    const [items, setItems] = useState([]);
+    const [totalItems, setTotalItems] = useState(0);
+    const [predictions, setPredictions] = useState([]);
+    const { register, handleSubmit } = methods;
+    const [startOrderExportToReplicate] = useMutation(startOrderExportToReplicateMutation);
+    const [getPredictionID] = useLazyQuery(getPredictionIDQuery);
+    const [getReplicatePredictions] = useLazyQuery(getReplicatePredictionsQuery);
+    const [getPredictionItem] = useLazyQuery(getPredictionItemQuery);
+    const [predictionID, setPredictionID] = useState(null);
+    const [loading, setLoading] = useState(false);
+    const [predictionEntityID, setPredictionEntityID] = useState(null);
+    const [activePredictionId, setActivePredictionId] = useState(replicateId || null);
+    const [shouldStartPolling, setShouldStartPolling] = useState(false);
+    const [isPolling, setIsPolling] = useState(true);
+    const retryCountRef = useRef(0);
+    const intervalRef = useRef(null);
+    const retryPredictionCountRef = useRef(0);
+    useEffect(() => {
+        if (activePredictionId) {
+            const newUrl = `${location.pathname}?replicateId=${activePredictionId}`;
+            navigate(newUrl, { replace: true });
+        }
+    }, [activePredictionId, navigate, location.pathname]);
+    useEffect(() => {
+        if (replicateId) {
+            setActivePredictionId(replicateId);
+            fetchPrediction(replicateId);
+        }
+    }, [predictions]);
+    useEffect(() => {
+        if (!predictionEntityID || !isPolling)
+            return;
+        intervalRef.current = setInterval(() => {
+            if (retryCountRef.current >= MAX_RETRIES) {
+                console.warn("Max retries reached. Stopping polling.");
+                clearInterval(intervalRef.current);
+                setIsPolling(false);
+                return;
+            }
+            getPredictionID({
+                prediction_entity_id: predictionEntityID,
+            })
+                .then((response) => {
+                if (response?.getPredictionID) {
+                    clearInterval(intervalRef.current);
+                    setIsPolling(false);
+                    setPredictionID(response.getPredictionID);
+                    setActivePredictionId(response.getPredictionID);
+                }
+                else {
+                    retryCountRef.current += 1;
+                }
+            })
+                .catch((error) => {
+                console.error("Error fetching prediction:", error);
+                retryCountRef.current += 1;
+            });
+        }, 5000);
+        return () => {
+            if (intervalRef.current)
+                clearInterval(intervalRef.current);
+        };
+    }, [predictionEntityID, isPolling]);
+    function fetchList() {
+        getReplicatePredictions({
+            options: { sort: { finishedAt: SortOrder.DESC } },
+        }).then((response) => {
+            if (response?.getReplicatePredictions) {
+                const predictions = response.getReplicatePredictions.items;
+                setItems(predictions);
+                setTotalItems(response.getReplicatePredictions.totalItems);
+                const startingPredictions = predictions.filter((item) => item.status === PredictionStatus.starting);
+                startingPredictions.forEach((prediction) => {
+                    getPredictionItem({
+                        id: prediction.id,
+                    }).then((response) => {
+                        if (response?.getPredictionItem) {
+                            fetchList();
+                        }
+                    });
+                });
+            }
+        });
+    }
+    useEffect(() => {
+        fetchList();
+    }, []);
+    useEffect(() => {
+        if (!shouldStartPolling)
+            return;
+        const pollInterval = 2000;
+        const maxRetries = 40;
+        let retryCount = 0;
+        const intervalId = setInterval(() => {
+            if (retryCount >= maxRetries) {
+                clearInterval(intervalId);
+                setShouldStartPolling(false);
+                return;
+            }
+            getReplicatePredictions({
+                options: { sort: { finishedAt: SortOrder.DESC } },
+            }).then((response) => {
+                if (response?.getReplicatePredictions) {
+                    const predictions = response.getReplicatePredictions.items;
+                    setItems(predictions);
+                    setTotalItems(response.getReplicatePredictions.totalItems);
+                    const startingPrediction = predictions.find((item) => item.status === PredictionStatus.starting);
+                    if (startingPrediction) {
+                        setActivePredictionId(startingPrediction.id);
+                    }
+                    if (!predictions.some((item) => item.status === PredictionStatus.starting)) {
+                        clearInterval(intervalId);
+                        setShouldStartPolling(false);
+                    }
+                }
+            });
+            retryCount++;
+        }, pollInterval);
+        return () => clearInterval(intervalId);
+    }, [shouldStartPolling]);
+    function fetchPrediction(predictionID) {
+        if (!predictionID)
+            return;
+        setActivePredictionId(predictionID);
+        getPredictionItem({
+            id: predictionID,
+        })
+            .then((response) => {
+            if (response?.getPredictionItem) {
+                if (response.getPredictionItem.status === PredictionStatus.succeeded) {
+                    setPredictions(response.getPredictionItem.predictions);
+                    setLoading(false);
+                }
+                else if (response.getPredictionItem.status === PredictionStatus.failed) {
+                    setPredictions([]);
+                    setLoading(false);
+                }
+                else if (response.getPredictionItem.status === PredictionStatus.starting) {
+                    setPredictionID(predictionID);
+                    retryPredictionCountRef.current = 0;
+                }
+            }
+            else {
+                setLoading(false);
+            }
+        })
+            .catch((error) => {
+            console.error("Error fetching prediction:", error);
+            setLoading(false);
+        });
+    }
+    const submit = async (data) => {
+        try {
+            setPredictionID(null);
+            setPredictionEntityID(null);
+            setIsPolling(true);
+            retryCountRef.current = 0;
+            retryPredictionCountRef.current = 0;
+            setLoading(true);
+            setShouldStartPolling(true);
+            const response = await startOrderExportToReplicate({
+                input: {
+                    startDate: new Date(data.start_date),
+                    endDate: new Date(data.end_date),
+                    predictType: data.predict_type,
+                    showMetrics: data.show_metrics,
+                },
+            });
+            setPredictionEntityID(response.startOrderExportToReplicate);
+        }
+        catch (error) {
+            console.log(error);
+            setLoading(false);
+        }
+    };
+    const getStatusColor = (status) => {
+        switch (status) {
+            case PredictionStatus.succeeded:
+                return "bg-green-500";
+            case PredictionStatus.failed:
+                return "bg-red-500";
+            case PredictionStatus.starting:
+                return "bg-blue-500";
+            default:
+                return "bg-gray-500";
+        }
+    };
+    return (React.createElement(FormProvider, { ...methods },
+        React.createElement("div", { className: "flex h-screen w-full gap-4 px-4 py-2 md:px-8 md:py-4" },
+            React.createElement("div", { className: "flex w-1/3 flex-col gap-4" },
+                React.createElement(Card, { className: "w-full" },
+                    React.createElement(CardHeader, null,
+                        React.createElement("div", { className: "flex w-full items-center justify-between" },
+                            React.createElement("div", { className: "flex flex-col gap-2" },
+                                React.createElement(CardTitle, null, t("Set up your model"))),
+                            React.createElement(Button, { onClick: handleSubmit((data) => submit(data)) }, t("Run model")))),
+                    React.createElement(CardContent, null,
+                        React.createElement("div", { className: "flex flex-row items-start gap-4" },
+                            React.createElement("div", { className: "flex flex-col gap-1" },
+                                React.createElement(Label, null, t("Show X the best prospects:")),
+                                React.createElement(Input, { className: "w-[175px]", ...register("num_prospects") })),
+                            React.createElement("div", { className: "flex flex-col gap-1" },
+                                React.createElement(Label, null, t("Orders data range:")),
+                                React.createElement(DatePickerWithRange, null))))),
+                React.createElement(Card, { className: "h-[calc(100vh-288px)] w-full" },
+                    React.createElement(CardHeader, null,
+                        React.createElement(CardTitle, null, t("Previous model runs"))),
+                    React.createElement(CardContent, { className: "h-[calc(100%-64px)]" },
+                        React.createElement(ScrollArea, { className: "h-full" },
+                            React.createElement("div", { className: "flex flex-col gap-3" }, items.map((item, index) => (React.createElement(Card, { key: index, className: cn("border hover:border-primary transition-colors", activePredictionId === item.id
+                                    ? "border-black border-2"
+                                    : ""), onClick: () => fetchPrediction(item.id) },
+                                React.createElement(CardContent, { className: "py-3" },
+                                    React.createElement("div", { className: "flex items-center justify-between" },
+                                        React.createElement("div", { className: "flex flex-col" },
+                                            React.createElement("div", { className: "mt-1 flex items-center gap-2" },
+                                                React.createElement("span", { className: "max-w-[200px] truncate text-sm font-medium" },
+                                                    "#",
+                                                    item.id),
+                                                React.createElement(Badge, { variant: "outline", className: cn("text-xs", getStatusColor(item.status)) }, PredictionStatusTypes.find((status) => status.value === item.status)?.label),
+                                                React.createElement("span", { className: "max-w-[200px] truncate text-sm font-medium" }, item.finishedAt
+                                                    ? new Date(item.finishedAt).toLocaleString()
+                                                    : " "))),
+                                        item.status === PredictionStatus.succeeded && (React.createElement(Button, { size: "icon", variant: "ghost", className: "size-8", onClick: () => fetchPrediction(item.id), title: t("Fetch predictions") },
+                                            React.createElement(ArrowRight, { className: "size-4" }))))))))))))),
+            React.createElement(Card, { className: "h-[calc(100vh-100px)] w-2/3" },
+                React.createElement(CardHeader, null,
+                    React.createElement("div", { className: "flex w-full items-center justify-between" },
+                        React.createElement("div", { className: "flex flex-col gap-2" },
+                            React.createElement(CardTitle, null, t("The most promising customers")),
+                            React.createElement(CardDescription, null, loading)),
+                        predictions?.length != 0 && (React.createElement("div", { className: "flex gap-1" },
+                            React.createElement(Button, { onClick: () => predictions &&
+                                    copyToClipboard("[" +
+                                        predictions
+                                            .map((predictions) => predictions.customer?.emailAddress)
+                                            .join(", ") +
+                                        "]") }, t("Copy to clipboard")),
+                            React.createElement(Button, { onClick: () => exportToCsv(predictions) }, t("Export to CSV")))))),
+                React.createElement(CardContent, { className: "h-[calc(100%-100px)]" }, loading ? (React.createElement("div", null, t("loading"))) : (React.createElement("div", { className: "flex h-full flex-col gap-2" }, predictions && (React.createElement(ScrollArea, { className: "h-full" },
+                    React.createElement("div", { className: "flex flex-col gap-3" }, (predictions ?? [])
+                        .slice(0, methods.watch("num_prospects"))
+                        .map((prediction) => (React.createElement(Card, { key: prediction.customer?.id ||
+                            Math.random().toString() },
+                        React.createElement(CardContent, { className: "py-3" },
+                            React.createElement("div", { className: "flex items-center justify-between" },
+                                React.createElement("span", { className: "flex items-center" },
+                                    React.createElement(CircleUser, { className: "mr-2" }),
+                                    prediction.customer?.firstName,
+                                    " ",
+                                    prediction.customer?.lastName,
+                                    React.createElement("span", { className: "text-muted-foreground ml-2" },
+                                        "(",
+                                        prediction.customer?.emailAddress,
+                                        ")")),
+                                React.createElement(Button, { size: "icon", variant: "ghost", className: "size-8", onClick: () => window.open(Routes.customers.to(prediction.customer?.id || "")), title: t("Go to customer profile") },
+                                    React.createElement(ArrowRight, { className: "size-4" })))))))))))))))));
+};

package/dist/plugin-ui/components/ReplicateUtilities.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+export declare function DatePickerWithRange({ className, }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+export declare function exportToCsv(predictions: any): void;
+export declare function copyToClipboard(text: string): void;

package/dist/plugin-ui/components/ReplicateUtilities.js

@@ -0,0 +1,57 @@
+import { useFormContext } from "react-hook-form";
+import React, { useEffect } from "react";
+import { format } from "date-fns";
+import { cn } from "@deenruv/react-ui-devkit";
+import { Popover, PopoverContent, PopoverTrigger, Calendar, Button, } from "@deenruv/react-ui-devkit";
+import { CalendarIcon } from "lucide-react";
+export function DatePickerWithRange({ className, }) {
+    const { setValue, watch } = useFormContext();
+    const [date, setDate] = React.useState(undefined);
+    useEffect(() => {
+        if (date?.from) {
+            setValue("start_date", format(date.from, "yyyy-MM-dd"));
+        }
+        if (date?.to) {
+            setValue("end_date", format(date.to, "yyyy-MM-dd"));
+        }
+    }, [date, setValue]);
+    const startDate = watch("start_date");
+    const endDate = watch("end_date");
+    useEffect(() => {
+        if (startDate || endDate) {
+            setDate({
+                from: startDate ? new Date(startDate) : undefined,
+                to: endDate ? new Date(endDate) : undefined,
+            });
+        }
+    }, [startDate, endDate]);
+    return (React.createElement("div", { className: cn("grid gap-2", className) },
+        React.createElement(Popover, null,
+            React.createElement(PopoverTrigger, { asChild: true },
+                React.createElement(Button, { id: "date", variant: "outline", className: cn("w-[200px] justify-start text-left font-normal", !date && "text-muted-foreground") },
+                    React.createElement(CalendarIcon, null),
+                    date?.from ? (date.to ? (React.createElement(React.Fragment, null,
+                        format(date.from, "LLL dd, y"),
+                        " -",
+                        " ",
+                        format(date.to, "LLL dd, y"))) : (format(date.from, "LLL dd, y"))) : (React.createElement("span", null, "Pick a date")))),
+            React.createElement(PopoverContent, { className: "w-auto p-0", align: "start" },
+                React.createElement(Calendar, { initialFocus: true, mode: "range", defaultMonth: date?.from, selected: date, onSelect: setDate, numberOfMonths: 2 })))));
+}
+export function exportToCsv(predictions) {
+    const rowName = "email";
+    const rowContent = predictions
+        .map((prediction) => `${prediction.customer?.emailAddress}`)
+        .join("\n");
+    const csv = `${rowName}\n${rowContent}`;
+    const blob = new Blob([csv], { type: "text/csv" });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    const timestamp = new Date().toLocaleString();
+    a.download = `predictions-${timestamp}.csv`;
+    a.click();
+}
+export function copyToClipboard(text) {
+    navigator.clipboard.writeText(text);
+}

package/dist/plugin-ui/components/index.d.ts

@@ -0,0 +1 @@
+export * from "./Replicate";

package/dist/plugin-ui/components/index.js

@@ -0,0 +1 @@
+export * from "./Replicate";

package/dist/plugin-ui/graphql/mutations.d.ts

@@ -0,0 +1,11 @@
+export declare const startOrderExportToReplicateMutation: import("@graphql-typed-document-node/core").TypedDocumentNode<{
+    startOrderExportToReplicate: string;
+}, {} & {
+    input: {
+        numLastOrder?: number | import("../zeus").Variable<any, string> | null | undefined;
+        startDate?: unknown;
+        endDate?: unknown;
+        predictType?: import("../zeus").PredictionType | import("../zeus").Variable<any, string> | null | undefined;
+        showMetrics?: boolean | import("../zeus").Variable<any, string> | null | undefined;
+    };
+}>;

package/dist/plugin-ui/graphql/mutations.js

@@ -0,0 +1,11 @@
+import { typedGql } from "../zeus/typedDocumentNode";
+import { $ } from "../zeus";
+import { scalars } from "@deenruv/admin-types";
+export const startOrderExportToReplicateMutation = typedGql("mutation", {
+    scalars,
+})({
+    startOrderExportToReplicate: [
+        { input: $("input", "StartOrderExportToReplicateInput!") },
+        true,
+    ],
+});

package/dist/plugin-ui/graphql/queries.d.ts

@@ -0,0 +1,73 @@
+export declare const getPredictionIDQuery: import("@graphql-typed-document-node/core").TypedDocumentNode<{
+    getPredictionID?: string | null | undefined;
+}, {} & {
+    prediction_entity_id: string;
+}>;
+export declare const getReplicatePredictionsQuery: import("@graphql-typed-document-node/core").TypedDocumentNode<{
+    getReplicatePredictions: {
+        items: {
+            id: string;
+            status: import("../zeus").PredictionStatus;
+            finishedAt?: string | null | undefined;
+        }[];
+        totalItems: number;
+    };
+}, {
+    options?: {
+        skip?: number | import("../zeus").Variable<any, string> | null | undefined;
+        take?: number | import("../zeus").Variable<any, string> | null | undefined;
+        sort?: {
+            id?: import("../zeus").SortOrder | import("../zeus").Variable<any, string> | null | undefined;
+            finishedAt?: import("../zeus").SortOrder | import("../zeus").Variable<any, string> | null | undefined;
+        } | import("../zeus").Variable<any, string> | null | undefined;
+        filter?: {
+            id?: {
+                eq?: string | import("../zeus").Variable<any, string> | null | undefined;
+                notEq?: string | import("../zeus").Variable<any, string> | null | undefined;
+                in?: string[] | import("../zeus").Variable<any, string> | null | undefined;
+                notIn?: string[] | import("../zeus").Variable<any, string> | null | undefined;
+                isNull?: boolean | import("../zeus").Variable<any, string> | null | undefined;
+            } | import("../zeus").Variable<any, string> | null | undefined;
+            status?: {
+                eq?: string | import("../zeus").Variable<any, string> | null | undefined;
+                notEq?: string | import("../zeus").Variable<any, string> | null | undefined;
+                contains?: string | import("../zeus").Variable<any, string> | null | undefined;
+                notContains?: string | import("../zeus").Variable<any, string> | null | undefined;
+                in?: string[] | import("../zeus").Variable<any, string> | null | undefined;
+                notIn?: string[] | import("../zeus").Variable<any, string> | null | undefined;
+                regex?: string | import("../zeus").Variable<any, string> | null | undefined;
+                isNull?: boolean | import("../zeus").Variable<any, string> | null | undefined;
+            } | import("../zeus").Variable<any, string> | null | undefined;
+            finishedAt?: {
+                eq?: unknown;
+                before?: unknown;
+                after?: unknown;
+                between?: {
+                    start: unknown;
+                    end: unknown;
+                } | import("../zeus").Variable<any, string> | null | undefined;
+                isNull?: boolean | import("../zeus").Variable<any, string> | null | undefined;
+            } | import("../zeus").Variable<any, string> | null | undefined;
+            _and?: import("../zeus").Variable<any, string> | any[] | null | undefined;
+            _or?: import("../zeus").Variable<any, string> | any[] | null | undefined;
+        } | import("../zeus").Variable<any, string> | null | undefined;
+        filterOperator?: import("../zeus").LogicalOperator | import("../zeus").Variable<any, string> | null | undefined;
+    } | undefined;
+} & {}>;
+export declare const getPredictionItemQuery: import("@graphql-typed-document-node/core").TypedDocumentNode<{
+    getPredictionItem: {
+        status: import("../zeus").PredictionStatus;
+        predictions?: {
+            id: string;
+            customer: {
+                id: string;
+                firstName: string;
+                lastName: string;
+                emailAddress: string;
+            };
+            score: number;
+        }[] | undefined;
+    };
+}, {} & {
+    id: string;
+}>;

package/dist/plugin-ui/graphql/queries.js

@@ -0,0 +1,30 @@
+import { typedGql } from "../zeus/typedDocumentNode";
+import { $ } from "../zeus";
+import { scalars } from "@deenruv/admin-types";
+import { PredictionSelector, ReplicateEntityListSelector } from "./selectors";
+export const getPredictionIDQuery = typedGql("query", { scalars })({
+    getPredictionID: [
+        {
+            input: {
+                prediction_entity_id: $("prediction_entity_id", "String!"),
+            },
+        },
+        true,
+    ],
+});
+export const getReplicatePredictionsQuery = typedGql("query", { scalars })({
+    getReplicatePredictions: [
+        {
+            options: $("options", "ReplicateEntityListOptions"),
+        },
+        ReplicateEntityListSelector,
+    ],
+});
+export const getPredictionItemQuery = typedGql("query", { scalars })({
+    getPredictionItem: [
+        {
+            id: $("id", "String!"),
+        },
+        PredictionSelector,
+    ],
+});

package/dist/plugin-ui/graphql/selectors.d.ts

@@ -0,0 +1,24 @@
+import { FromSelector } from "../zeus";
+export declare const PredictionSelector: {
+    predictions: {
+        id: true;
+        score: true;
+        customer: {
+            emailAddress: true;
+            id: true;
+            firstName: true;
+            lastName: true;
+        };
+    };
+    status: true;
+};
+export declare const ReplicateEntityListSelector: {
+    items: {
+        id: true;
+        status: true;
+        finishedAt: true;
+    };
+    totalItems: true;
+};
+export type ReplicatePredictionListType = FromSelector<typeof PredictionSelector, "PredictionResult">;
+export type ReplicateEntityListType = FromSelector<typeof ReplicateEntityListSelector, "ReplicateEntityList">;

package/dist/plugin-ui/graphql/selectors.js

@@ -0,0 +1,17 @@
+import { Selector } from "../zeus";
+export const PredictionSelector = Selector("PredictionResult")({
+    predictions: {
+        id: true,
+        score: true,
+        customer: { emailAddress: true, id: true, firstName: true, lastName: true },
+    },
+    status: true,
+});
+export const ReplicateEntityListSelector = Selector("ReplicateEntityList")({
+    items: {
+        id: true,
+        status: true,
+        finishedAt: true,
+    },
+    totalItems: true,
+});

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

@@ -0,0 +1 @@
+export declare const ReplicateUiPlugin: import("@deenruv/react-ui-devkit").DeenruvUIPlugin<Record<string, any>>;

package/dist/plugin-ui/index.js

@@ -0,0 +1,25 @@
+import { createDeenruvUIPlugin } from "@deenruv/react-ui-devkit";
+import pl from "./locales/pl";
+import en from "./locales/en";
+import { translationNS } from "./translation-ns";
+import { ReplicateInput } from "./components/Replicate";
+import React from "react";
+import { NotebookPenIcon } from "lucide-react";
+export const ReplicateUiPlugin = createDeenruvUIPlugin({
+    version: "1.0.0",
+    name: "Replicate Newsletter Plugin",
+    pages: [{ element: React.createElement(ReplicateInput, null), path: "" }],
+    navMenuLinks: [
+        {
+            groupId: "promotions-group",
+            href: "",
+            id: "newsletter-model",
+            labelId: "Newsletter Model",
+            icon: NotebookPenIcon,
+        },
+    ],
+    translations: {
+        ns: translationNS,
+        data: { en, pl },
+    },
+});

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

@@ -0,0 +1,25 @@
+{
+    "title": "Badges",
+    "description": "Badges that will be shown on product image",
+    "not-found": "No badges has been found",
+    "modal": {
+        "add": {
+            "title": "Add badge",
+            "action": "Add",
+            "success": "Added successfully"
+        },
+        "edit": {
+            "title": "Edit badge",
+            "action": "Edit",
+            "success": "Edited successfully"
+        },
+        "remove": {
+            "title": "Remove badge",
+            "description": "Are you sure you want to remove this badge?",
+            "action": "Remove",
+            "success": "Removed successfully"
+        },
+        "text-error": "Text field can't be empty",
+        "cancel": "Cancel"
+    }
+}

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

@@ -0,0 +1,26 @@
+declare const _default: {
+    title: string;
+    description: string;
+    "not-found": string;
+    modal: {
+        add: {
+            title: string;
+            action: string;
+            success: string;
+        };
+        edit: {
+            title: string;
+            action: string;
+            success: string;
+        };
+        remove: {
+            title: string;
+            description: string;
+            action: string;
+            success: string;
+        };
+        "text-error": string;
+        cancel: string;
+    };
+}[];
+export default _default;

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

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