@e-llm-studio/feedback-flow 0.0.0-stage → 0.1.31

package/dist/useFeedbackPersistence.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFeedbackPersistence = useFeedbackPersistence;
+const react_1 = require("react");
+const feedbackApi_1 = require("./feedbackApi");
+function draftKey(submission) {
+    return JSON.stringify({
+        rating: submission.rating,
+        timeSavedMinutes: submission.timeSavedMinutes ?? null,
+        mostUseful: submission.mostUseful?.trim() ?? "",
+        usefulDetailShown: submission.usefulDetailShown ?? false,
+        gaps: submission.gaps.map((gap) => ({
+            description: gap.description.trim(),
+            severity: gap.severity ?? null,
+            detailRequested: gap.detailRequested ?? false,
+            screenshots: gap.screenshots.map((file) => ({
+                name: file.name,
+                type: file.type,
+                size: file.size,
+                lastModified: file.lastModified,
+            })),
+        })),
+    });
+}
+/** Loads saved feedback and saves new/reviewed answers through an interchangeable API. */
+function useFeedbackPersistence(flow, metadata, onSubmit, api = feedbackApi_1.mockFeedbackApi) {
+    const userEmail = String(metadata?.userEmail ?? metadata?.owner ?? "");
+    const [isLoading, setIsLoading] = (0, react_1.useState)(true);
+    const [isSaving, setIsSaving] = (0, react_1.useState)(false);
+    const [saveError, setSaveError] = (0, react_1.useState)(false);
+    const savedRecordRef = (0, react_1.useRef)(null);
+    const loadPromiseRef = (0, react_1.useRef)(null);
+    const saveQueueRef = (0, react_1.useRef)(Promise.resolve());
+    const uploadedFilesRef = (0, react_1.useRef)(new WeakMap());
+    const lastQueuedDraftRef = (0, react_1.useRef)(null);
+    const lastSavedDraftRef = (0, react_1.useRef)(null);
+    (0, react_1.useEffect)(() => {
+        let cancelled = false;
+        setIsLoading(true);
+        savedRecordRef.current = null;
+        lastQueuedDraftRef.current = null;
+        lastSavedDraftRef.current = null;
+        const loading = api.getFeedback((0, feedbackApi_1.feedbackLookup)({ requestId: flow.requestId, featureId: flow.featureId, metadata }))
+            .then((saved) => {
+            if (!cancelled)
+                savedRecordRef.current = saved;
+            if (!cancelled && saved) {
+                const submission = (0, feedbackApi_1.fromFeedbackRecord)(saved);
+                lastSavedDraftRef.current = draftKey(submission);
+                if (lastQueuedDraftRef.current === null)
+                    lastQueuedDraftRef.current = lastSavedDraftRef.current;
+                flow.loadSavedSubmission(submission);
+            }
+        })
+            .catch((error) => console.error("Could not load saved feedback", error))
+            .finally(() => { if (!cancelled)
+            setIsLoading(false); });
+        loadPromiseRef.current = loading;
+        return () => {
+            cancelled = true;
+        };
+    }, [api, flow.requestId, flow.featureId, flow.loadSavedSubmission, userEmail, metadata?.queryId, metadata?.sessionId]);
+    const persist = (0, react_1.useCallback)((submission, nextStep, completed, final = false) => {
+        const key = draftKey(submission);
+        lastQueuedDraftRef.current = key;
+        const operation = saveQueueRef.current.catch(() => undefined).then(async () => {
+            if (final)
+                setIsSaving(true);
+            setSaveError(false);
+            try {
+                await loadPromiseRef.current;
+                const gaps = await Promise.all(submission.gaps.map(async (gap) => ({
+                    ...gap,
+                    screenshots: await Promise.all(gap.screenshots.map(async (screenshot) => {
+                        if ("attachmentId" in screenshot || !api.uploadAttachment)
+                            return screenshot;
+                        const cached = uploadedFilesRef.current.get(screenshot);
+                        if (cached)
+                            return cached;
+                        const uploaded = await api.uploadAttachment(screenshot);
+                        const reference = {
+                            attachmentId: globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random()}`,
+                            gcsUrl: typeof uploaded === "string" ? uploaded : uploaded.gcsUrl,
+                            ...(typeof uploaded === "string" || !uploaded.publicUrl ? {} : { publicUrl: uploaded.publicUrl }),
+                            name: screenshot.name,
+                            type: screenshot.type,
+                            size: screenshot.size,
+                            lastModified: screenshot.lastModified,
+                        };
+                        uploadedFilesRef.current.set(screenshot, reference);
+                        return reference;
+                    })),
+                })));
+                const snapshot = {
+                    ...submission,
+                    gaps,
+                    metadata: { ...submission.metadata, feedbackProgress: { nextStep, completed } },
+                };
+                const saved = await api.upsertFeedback((0, feedbackApi_1.toFeedbackRecord)(snapshot, savedRecordRef.current));
+                savedRecordRef.current = saved;
+                lastSavedDraftRef.current = key;
+                const gapsWithIds = gaps.map((gap, index) => ({
+                    ...gap,
+                    negativeId: saved.gaps[index]?.negative_id ?? gap.negativeId,
+                }));
+                flow.setGaps((current) => current.map((gap, index) => gap === submission.gaps[index] ? gapsWithIds[index] ?? gap : gap));
+                if (final)
+                    await onSubmit?.(snapshot);
+            }
+            catch (error) {
+                if (lastQueuedDraftRef.current === key)
+                    lastQueuedDraftRef.current = lastSavedDraftRef.current;
+                setSaveError(true);
+                throw error;
+            }
+            finally {
+                if (final)
+                    setIsSaving(false);
+            }
+        });
+        saveQueueRef.current = operation;
+        return operation;
+    }, [api, onSubmit, flow.setGaps]);
+    const saveFeedback = (0, react_1.useCallback)((submission) => persist(submission, "success", true, true), [persist]);
+    const saveProgress = (0, react_1.useCallback)((submission, nextStep) => persist(submission, nextStep, false), [persist]);
+    const saveOnDismiss = (0, react_1.useCallback)((submission, nextStep, completed) => lastQueuedDraftRef.current === draftKey(submission)
+        ? Promise.resolve()
+        : persist(submission, nextStep, completed), [persist]);
+    return { saveFeedback, saveProgress, saveOnDismiss, isLoading, isSaving, saveError };
+}

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "@e-llm-studio/feedback-flow",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.31",
+  "private": false,
+  "description": "Reusable configurable feedback rating and progressive feedback screens",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "sideEffects": [
+    "dist/feedback.css"
+  ],
+  "peerDependencies": {
+    "lucide-react": ">=0.474.0",
+    "react": ">=18.0.0 <20.0.0",
+    "react-dom": ">=18.0.0 <20.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
+    "typescript": "~5.6.2"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && cp src/feedback.css dist/feedback.css",
+    "dev": "tsc --watch --preserveWatchOutput",
+    "check-types": "tsc -p tsconfig.json --noEmit"
+  }
 }