CanvasAnvil is an open source AI diagram maker and flowchart generator - an infinite-canvas diagram editor and self-hosted drawio alternative that writes editable .drawio files. Text to diagram, then fix nodes, layout and labels in place. Also AI presentations, interior design CAD/BOM, posters and infographics.
TypeScript ai-agentsai-diagramai-presentationbomcadcanvasdiagramdiagram-generatordrawioflowchartinfographicspptppt-generatorpresentation-generatorreactsvgedittext-to-diagramtypescriptworkflow
refactor(ppt): make the slide-version resolver a tested pure function
codingFeng101bdb02daa0387
diff --git a/client/workspaces/ppt/canvas/PptCanvas.tsx b/client/workspaces/ppt/canvas/PptCanvas.tsxindex b0b2243..a8b1528 100644--- a/client/workspaces/ppt/canvas/PptCanvas.tsx+++ b/client/workspaces/ppt/canvas/PptCanvas.tsx@@ -1,4 +1,4 @@-import React, { useState, useEffect, useRef, useCallback, useReducer } from 'react';+import React, { useState, useEffect, useRef, useCallback, useMemo, useReducer } from 'react';import { motion } from "motion/react";import { useLatestRef } from "@/shared/lib/use-latest-ref";import { errorText, isRetryableBeautifyError } from "./lib/errors";@@ -6,6 +6,12 @@ import { runInParallel, sleep } from "./lib/concurrency";import { parseJsonLoose } from "./lib/parse-json";import { extractPdfPagesAsImages, isPdfFile } from "./lib/deck-source";import { getSlideshowDimensions } from "./lib/slideshow-size";+import {+ getOriginalSlideVersion as originalVersionOf,+ getTextlessBackgroundVersion as textlessBackgroundOf,+ getVisibleSlideVersions as getVisibleVersions,+ resolveSlideVersion,+} from "./lib/slide-versions";import {buildSlideMaterialsFromAutoLabels,materialLabel,@@ -68,7 +74,6 @@ import {MODEL_CONCURRENCY,REVIEW_BOX_COLOR,REVIEW_BOX_SELECTED_COLOR,- SYNTHETIC_PRIMARY_VERSION_PREFIX,} from "@/workspaces/ppt/canvas/constants";import {deriveTextElementsFromBlocks,@@ -1227,56 +1232,29 @@ export function PptCanvas({// eslint-disable-next-line react-hooks/exhaustive-deps}, [incomingEdit?.id]);- const getVisibleSlideVersions = useCallback((slideId: string) => {- const versions = imageVersions[slideId] || [];- const hasPrimaryVersion = versions.some((version) => version.type !== "derived_textless");- if (hasPrimaryVersion || !generatedImages[slideId]) return versions;- return [- {- id: `${SYNTHETIC_PRIMARY_VERSION_PREFIX}${slideId}`,- url: generatedImages[slideId],- timestamp: Date.now(),- type: "generated" as const,- instruction: tr("原始版本", "Original version"),- },- ...versions,- ];- }, [imageVersions, generatedImages, tr]);- const getSlideVersionMeta = useCallback((slideId: string) => {- const visibleVersions = getVisibleSlideVersions(slideId);- const versions = imageVersions[slideId] || [];- const requestedVersionId = currentImageVersionId[slideId] || "";- const preferredDefaultVersion =- [...visibleVersions].reverse().find((item) => item.type !== "derived_textless") ||- visibleVersions[visibleVersions.length - 1];- const resolvedVersionId =- (requestedVersionId && visibleVersions.some((item) => item.id === requestedVersionId)- ? requestedVersionId- : preferredDefaultVersion?.id) ||- requestedVersionId ||- versions[versions.length - 1]?.id ||- "";- const version = resolvedVersionId ? visibleVersions.find((x) => x.id === resolvedVersionId) : undefined;- return {- versionId: resolvedVersionId,- version,- imageUrl: version?.url || generatedImages[slideId] || "",- };- }, [getVisibleSlideVersions, imageVersions, currentImageVersionId, generatedImages]);+ // The three maps the version resolver reads, gathered once per render.+ const versionState = useMemo(+ () => ({ imageVersions, currentImageVersionId, generatedImages }),+ [imageVersions, currentImageVersionId, generatedImages],+ );+ const originalVersionLabel = tr("原始版本", "Original version");++ const getSlideVersionMeta = useCallback(+ (slideId: string) => resolveSlideVersion(slideId, versionState, originalVersionLabel),+ [versionState, originalVersionLabel],+ );+ const getVisibleSlideVersions = useCallback(+ (slideId: string) => getVisibleVersions(slideId, versionState, originalVersionLabel),+ [versionState, originalVersionLabel],+ );+ const getOriginalSlideVersion = (slideId: string) => originalVersionOf(slideId, versionState);+ const getTextlessBackgroundVersion = (slideId: string) => textlessBackgroundOf(slideId, versionState);const getSlideImageUrl = (slideId: string) => getSlideVersionMeta(slideId).imageUrl;- const getOriginalSlideVersion = (slideId: string) => {- const versions = imageVersions[slideId] || [];- return versions.find((version) => !version.sourceVersionId) || versions[0];- };const getSlideRenderLayer = useCallback((slideId: string) => {const { versionId } = getSlideVersionMeta(slideId);if (!versionId) return undefined;return renderLayers[slideId]?.[versionId];}, [getSlideVersionMeta, renderLayers]);- const getTextlessBackgroundVersion = (slideId: string) => {- const versions = imageVersions[slideId] || [];- return versions.find((version) => version.type === "derived_textless");- };const getEditableExtractionStatus = (slideId: string): EditableExtractionStatus =>editableExtractionStatusBySlideId[slideId] || "idle";const getSlideBackgroundUrl = (slideId: string) => {diff --git a/client/workspaces/ppt/canvas/lib/slide-versions.ts b/client/workspaces/ppt/canvas/lib/slide-versions.tsnew file mode 100644index 0000000..b4efbea--- /dev/null+++ b/client/workspaces/ppt/canvas/lib/slide-versions.ts@@ -0,0 +1,107 @@+import { SYNTHETIC_PRIMARY_VERSION_PREFIX } from "@/workspaces/ppt/canvas/constants";+import type { SlideImageVersion } from "@/workspaces/ppt/canvas/types";++/**+ * Which rendered image a slide is currently showing.+ *+ * A slide accumulates versions as the user regenerates and edits it, plus+ * derived textless backgrounds the editable-export path produces. Resolving+ * the wrong one shows the user a slide they thought they had replaced, or the+ * background with its text stripped out.+ */++export interface VersionState {+ /** Every version recorded for a slide, oldest first. */+ imageVersions: Record<string, SlideImageVersion[]>;+ /** The version the user picked, per slide, if any. */+ currentImageVersionId: Record<string, string>;+ /** The flat image map decks generated before versioning existed. */+ generatedImages: Record<string, string>;+}++export interface ResolvedVersion {+ versionId: string;+ version: SlideImageVersion | undefined;+ imageUrl: string;+}++/**+ * The versions worth offering for a slide.+ *+ * A deck generated before versioning, or one restored from an older+ * snapshot, has an image but no version recording it. A synthetic entry+ * stands in for it so the version picker is not empty and the textless+ * background has something to derive from.+ */+export function getVisibleSlideVersions(+ slideId: string,+ state: VersionState,+ originalVersionLabel: string,+): SlideImageVersion[] {+ const versions = state.imageVersions[slideId] || [];+ const hasPrimary = versions.some((version) => version.type !== "derived_textless");+ if (hasPrimary || !state.generatedImages[slideId]) return versions;++ return [+ {+ id: `${SYNTHETIC_PRIMARY_VERSION_PREFIX}${slideId}`,+ url: state.generatedImages[slideId],+ timestamp: Date.now(),+ type: "generated" as const,+ instruction: originalVersionLabel,+ },+ ...versions,+ ];+}++/**+ * Resolves the slide's current version, falling back in this order: the one+ * the user picked if it still exists, else the newest non-textless version,+ * else the newest of any kind. A textless background is never chosen as the+ * default -- it is a derived asset, not something the user asked to see.+ */+export function resolveSlideVersion(+ slideId: string,+ state: VersionState,+ originalVersionLabel: string,+): ResolvedVersion {+ const visible = getVisibleSlideVersions(slideId, state, originalVersionLabel);+ const versions = state.imageVersions[slideId] || [];+ const requestedVersionId = state.currentImageVersionId[slideId] || "";++ const preferredDefault =+ [...visible].reverse().find((item) => item.type !== "derived_textless") ||+ visible[visible.length - 1];++ const versionId =+ (requestedVersionId && visible.some((item) => item.id === requestedVersionId)+ ? requestedVersionId+ : preferredDefault?.id) ||+ requestedVersionId ||+ versions[versions.length - 1]?.id ||+ "";++ const version = versionId ? visible.find((item) => item.id === versionId) : undefined;+ return {+ versionId,+ version,+ imageUrl: version?.url || state.generatedImages[slideId] || "",+ };+}++/** The version a slide started from, before any edits derived from it. */+export function getOriginalSlideVersion(+ slideId: string,+ state: VersionState,+): SlideImageVersion | undefined {+ const versions = state.imageVersions[slideId] || [];+ return versions.find((version) => !version.sourceVersionId) || versions[0];+}++/** The text-stripped background the editable export derives, if one exists yet. */+export function getTextlessBackgroundVersion(+ slideId: string,+ state: VersionState,+): SlideImageVersion | undefined {+ return (state.imageVersions[slideId] || []).find((v) => v.type === "derived_textless");+}diff --git a/tests/ppt-slide-versions.test.ts b/tests/ppt-slide-versions.test.tsnew file mode 100644index 0000000..148fe6b--- /dev/null+++ b/tests/ppt-slide-versions.test.ts@@ -0,0 +1,193 @@+import assert from "node:assert/strict";+import { test } from "node:test";+import {+ getOriginalSlideVersion,+ getTextlessBackgroundVersion,+ getVisibleSlideVersions,+ resolveSlideVersion,+ type VersionState,+} from "../client/workspaces/ppt/canvas/lib/slide-versions";+import { SYNTHETIC_PRIMARY_VERSION_PREFIX } from "../client/workspaces/ppt/canvas/constants";+import type { SlideImageVersion } from "../client/workspaces/ppt/canvas/types";++/**+ * Which rendered image a slide shows. Resolving the wrong version shows the+ * user a slide they thought they had replaced, or -- worse -- the background+ * with all its text stripped out, which is a derived asset nobody asked to+ * look at.+ */++const LABEL = "Original version";++const version = (+ id: string,+ type: SlideImageVersion["type"] = "generated",+ extra: Partial<SlideImageVersion> = {},+): SlideImageVersion =>+ ({ id, url: `${id}.png`, timestamp: 1, type, ...extra }) as SlideImageVersion;++const state = (over: Partial<VersionState> = {}): VersionState => ({+ imageVersions: {},+ currentImageVersionId: {},+ generatedImages: {},+ ...over,+});++test("a slide with nothing at all resolves to nothing, not a crash", () => {+ const resolved = resolveSlideVersion("slide-1", state(), LABEL);+ assert.deepEqual(resolved, { versionId: "", version: undefined, imageUrl: "" });+});++test("the newest version wins when the user has not picked one", () => {+ const resolved = resolveSlideVersion(+ "slide-1",+ state({ imageVersions: { "slide-1": [version("v1"), version("v2"), version("v3")] } }),+ LABEL,+ );+ assert.equal(resolved.versionId, "v3");+ assert.equal(resolved.imageUrl, "v3.png");+});++test("the version the user picked wins over the newest", () => {+ const resolved = resolveSlideVersion(+ "slide-1",+ state({+ imageVersions: { "slide-1": [version("v1"), version("v2")] },+ currentImageVersionId: { "slide-1": "v1" },+ }),+ LABEL,+ );+ assert.equal(resolved.versionId, "v1");+});++test("a picked version that no longer exists falls back to the newest", () => {+ const resolved = resolveSlideVersion(+ "slide-1",+ state({+ imageVersions: { "slide-1": [version("v1")] },+ currentImageVersionId: { "slide-1": "deleted" },+ }),+ LABEL,+ );+ assert.equal(resolved.versionId, "v1", "not left pointing at a version that is gone");+});++test("a textless background is never the default", () => {+ // It is derived for the editable export; showing it would look like the+ // slide lost all its text.+ const resolved = resolveSlideVersion(+ "slide-1",+ state({+ imageVersions: {+ "slide-1": [version("v1"), version("v2"), version("bg", "derived_textless")],+ },+ }),+ LABEL,+ );+ assert.equal(resolved.versionId, "v2", "the newest real version, not the textless one");+});++test("a textless background is still shown when explicitly picked", () => {+ const resolved = resolveSlideVersion(+ "slide-1",+ state({+ imageVersions: { "slide-1": [version("v1"), version("bg", "derived_textless")] },+ currentImageVersionId: { "slide-1": "bg" },+ }),+ LABEL,+ );+ assert.equal(resolved.versionId, "bg");+});++test("a deck from before versioning gets a synthetic version for its image", () => {+ // Otherwise the version picker is empty and there is nothing to derive a+ // textless background from.+ const st = state({ generatedImages: { "slide-1": "legacy.png" } });+ const visible = getVisibleSlideVersions("slide-1", st, LABEL);+ assert.equal(visible.length, 1);+ assert.ok(visible[0].id.startsWith(SYNTHETIC_PRIMARY_VERSION_PREFIX));+ assert.equal(visible[0].url, "legacy.png");+ assert.equal(visible[0].instruction, LABEL, "labelled in the caller's language");++ const resolved = resolveSlideVersion("slide-1", st, LABEL);+ assert.equal(resolved.imageUrl, "legacy.png");+});++test("the synthetic version is not invented when a real one exists", () => {+ const visible = getVisibleSlideVersions(+ "slide-1",+ state({+ imageVersions: { "slide-1": [version("v1")] },+ generatedImages: { "slide-1": "legacy.png" },+ }),+ LABEL,+ );+ assert.deepEqual(+ visible.map((v) => v.id),+ ["v1"],+ );+});++test("a lone textless background still gets a synthetic primary alongside it", () => {+ // Only a textless version exists, so there is no real primary to show.+ const visible = getVisibleSlideVersions(+ "slide-1",+ state({+ imageVersions: { "slide-1": [version("bg", "derived_textless")] },+ generatedImages: { "slide-1": "legacy.png" },+ }),+ LABEL,+ );+ assert.equal(visible.length, 2);+ assert.ok(visible[0].id.startsWith(SYNTHETIC_PRIMARY_VERSION_PREFIX));+ assert.equal(visible[1].id, "bg");+});++test("the flat image map is the last resort for the url", () => {+ // A picked id that matches nothing leaves no version, but the legacy image+ // is still better than a blank slide.+ const resolved = resolveSlideVersion(+ "slide-1",+ state({+ imageVersions: { "slide-1": [] },+ currentImageVersionId: { "slide-1": "ghost" },+ generatedImages: { "slide-1": "legacy.png" },+ }),+ LABEL,+ );+ assert.equal(resolved.imageUrl, "legacy.png");+});++test("the original version is the one nothing was derived from", () => {+ const st = state({+ imageVersions: {+ "slide-1": [+ version("v1"),+ version("v2", "edited", { sourceVersionId: "v1" }),+ version("v3", "edited", { sourceVersionId: "v2" }),+ ],+ },+ });+ assert.equal(getOriginalSlideVersion("slide-1", st)?.id, "v1");+});++test("the original falls back to the first when every version has a source", () => {+ const st = state({+ imageVersions: {+ "slide-1": [+ version("v2", "edited", { sourceVersionId: "gone" }),+ version("v3", "edited", { sourceVersionId: "v2" }),+ ],+ },+ });+ assert.equal(getOriginalSlideVersion("slide-1", st)?.id, "v2");+ assert.equal(getOriginalSlideVersion("missing", st), undefined);+});++test("the textless background is found by type", () => {+ const st = state({+ imageVersions: { "slide-1": [version("v1"), version("bg", "derived_textless")] },+ });+ assert.equal(getTextlessBackgroundVersion("slide-1", st)?.id, "bg");+ assert.equal(getTextlessBackgroundVersion("slide-2", st), undefined);+});