207 lines
6.5 KiB
TypeScript
207 lines
6.5 KiB
TypeScript
"use client";
|
|
|
|
import { createContext, useCallback, useContext, useMemo, useState } from "react";
|
|
|
|
import type {
|
|
DocumentRewriteStage,
|
|
} from "@/open-canvas/hooks/useDocumentRewrite";
|
|
import type { DocumentRewriteSummary } from "@/open-canvas/api/rewrite";
|
|
import { createClientId } from "@/lib/client-id";
|
|
|
|
export type DocumentRewritePresentation = {
|
|
id: string;
|
|
threadId: string;
|
|
/** A report regeneration is a new document, not an edit of the current one. */
|
|
operation: "rewrite" | "generate";
|
|
source: {
|
|
kind: "artifact" | "deep_research_report";
|
|
id: string;
|
|
path?: string;
|
|
};
|
|
fileName: string;
|
|
instruction: string;
|
|
style: string;
|
|
modelName: string | null;
|
|
generateImages: boolean;
|
|
maxGeneratedImages: number;
|
|
generatedImageCount: number;
|
|
illustrationTarget: string;
|
|
stage: DocumentRewriteStage;
|
|
originalCharCount: number;
|
|
writtenCharCount: number;
|
|
/** Short model-generated plan, streamed while it understands the request. */
|
|
requirementsPlan: string;
|
|
/** Ephemeral thought trace. Never included in the Markdown draft or persisted job state. */
|
|
thinkingText: string;
|
|
warnings: string[];
|
|
summary: DocumentRewriteSummary | null;
|
|
/** Kept in-memory for the line-level compare dialog; backend job hydration refills it. */
|
|
originalContent: string;
|
|
rewrittenContent: string | null;
|
|
versionId: string | null;
|
|
/** Hash of the currently committed rewrite, used by the local undo fallback. */
|
|
committedHash: string | null;
|
|
/** A browser-only undo backup is available because the server snapshot failed. */
|
|
localFallbackAvailable: boolean;
|
|
/** Inverse snapshot created by a safe undo; enables a one-click reapply. */
|
|
redoVersionId: string | null;
|
|
revertedAt: string | null;
|
|
error: string | null;
|
|
createdAt: string;
|
|
updatedAt: string;
|
|
};
|
|
|
|
type CreatePresentationInput = Omit<
|
|
DocumentRewritePresentation,
|
|
| "id"
|
|
| "stage"
|
|
| "operation"
|
|
| "generateImages"
|
|
| "maxGeneratedImages"
|
|
| "generatedImageCount"
|
|
| "illustrationTarget"
|
|
| "originalCharCount"
|
|
| "writtenCharCount"
|
|
| "requirementsPlan"
|
|
| "thinkingText"
|
|
| "warnings"
|
|
| "summary"
|
|
| "originalContent"
|
|
| "rewrittenContent"
|
|
| "versionId"
|
|
| "committedHash"
|
|
| "localFallbackAvailable"
|
|
| "redoVersionId"
|
|
| "revertedAt"
|
|
| "error"
|
|
| "createdAt"
|
|
| "updatedAt"
|
|
> & {
|
|
operation?: DocumentRewritePresentation["operation"];
|
|
originalContent?: string;
|
|
rewrittenContent?: string | null;
|
|
committedHash?: string | null;
|
|
localFallbackAvailable?: boolean;
|
|
requirementsPlan?: string;
|
|
generateImages?: boolean;
|
|
maxGeneratedImages?: number;
|
|
};
|
|
|
|
type DocumentRewritePresentationContextValue = {
|
|
create: (input: CreatePresentationInput) => string;
|
|
update: (
|
|
id: string,
|
|
patch: Partial<Omit<DocumentRewritePresentation, "id" | "threadId" | "createdAt">>,
|
|
) => void;
|
|
forThread: (threadId: string) => DocumentRewritePresentation[];
|
|
};
|
|
|
|
const DocumentRewritePresentationContext =
|
|
createContext<DocumentRewritePresentationContextValue | null>(null);
|
|
|
|
function createId() {
|
|
return createClientId("drw-ui");
|
|
}
|
|
|
|
export function DocumentRewritePresentationProvider({
|
|
children,
|
|
}: {
|
|
children: React.ReactNode;
|
|
}) {
|
|
const [presentations, setPresentations] = useState<DocumentRewritePresentation[]>([]);
|
|
|
|
const create = useCallback((input: CreatePresentationInput) => {
|
|
const id = createId();
|
|
const now = new Date().toISOString();
|
|
setPresentations((previous) => [
|
|
...previous.slice(-29),
|
|
{
|
|
...input,
|
|
id,
|
|
stage: "snapshot",
|
|
operation: input.operation ?? "rewrite",
|
|
generateImages: input.generateImages === true,
|
|
maxGeneratedImages: Math.min(Math.max(input.maxGeneratedImages ?? 2, 1), 4),
|
|
generatedImageCount: 0,
|
|
illustrationTarget: "",
|
|
originalCharCount: 0,
|
|
writtenCharCount: 0,
|
|
requirementsPlan: input.requirementsPlan ?? "",
|
|
thinkingText: "",
|
|
warnings: [],
|
|
summary: null,
|
|
originalContent: input.originalContent ?? "",
|
|
rewrittenContent: input.rewrittenContent ?? null,
|
|
versionId: null,
|
|
committedHash: input.committedHash ?? null,
|
|
localFallbackAvailable: input.localFallbackAvailable === true,
|
|
redoVersionId: null,
|
|
revertedAt: null,
|
|
error: null,
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
},
|
|
]);
|
|
return id;
|
|
}, []);
|
|
|
|
const update = useCallback(
|
|
(
|
|
id: string,
|
|
patch: Partial<Omit<DocumentRewritePresentation, "id" | "threadId" | "createdAt">>,
|
|
) => {
|
|
setPresentations((previous) => {
|
|
const index = previous.findIndex((item) => item.id === id);
|
|
if (index < 0) return previous;
|
|
|
|
const current = previous[index];
|
|
const changed = Object.entries(patch).some(
|
|
([key, value]) => current[key as keyof DocumentRewritePresentation] !== value,
|
|
);
|
|
// Do not create a new context value for an identical update. Stream
|
|
// subscribers can legitimately receive an already-hydrated snapshot;
|
|
// treating it as a state change makes effect-based synchronisation
|
|
// vulnerable to update loops.
|
|
if (!changed) return previous;
|
|
|
|
const next = [...previous];
|
|
next[index] = { ...current, ...patch, updatedAt: new Date().toISOString() };
|
|
return next;
|
|
});
|
|
},
|
|
[],
|
|
);
|
|
|
|
const value = useMemo<DocumentRewritePresentationContextValue>(
|
|
() => ({
|
|
create,
|
|
update,
|
|
forThread: (threadId) =>
|
|
presentations.filter((item) => item.threadId === threadId),
|
|
}),
|
|
[create, presentations, update],
|
|
);
|
|
|
|
return (
|
|
<DocumentRewritePresentationContext.Provider value={value}>
|
|
{children}
|
|
</DocumentRewritePresentationContext.Provider>
|
|
);
|
|
}
|
|
|
|
export function useDocumentRewritePresentation() {
|
|
return useContext(DocumentRewritePresentationContext);
|
|
}
|
|
|
|
/** Browser event consumed by the open sandbox after an in-feed undo succeeds. */
|
|
export const DOCUMENT_REWRITE_UNDONE_EVENT = "deerflow:document-rewrite-undone";
|
|
|
|
/** Synchronous guard used before a browser-only undo writes back the original text. */
|
|
export const DOCUMENT_REWRITE_LOCAL_UNDO_GUARD_EVENT = "deerflow:document-rewrite-local-undo-guard";
|
|
|
|
/** Sent after the user confirms a rewrite so the conversation can reveal its new step card. */
|
|
export const DOCUMENT_REWRITE_STARTED_EVENT = "deerflow:document-rewrite-started";
|
|
|
|
/** A completed structural-regeneration card requests an in-place rewrite of that new report. */
|
|
export const DEEP_RESEARCH_REPORT_REWRITE_REQUESTED_EVENT = "deerflow:deep-research-report-rewrite-requested";
|