Skip to content

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.

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.tsx
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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);
+});