@textcortex/slidewise 1.3.0 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@textcortex/slidewise",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Embeddable React PPTX editor.",
   "license": "MIT",
   "type": "module",

package/src/SlidewiseEditor.tsx

@@ -4,6 +4,7 @@ import {
   type SlidewiseRootHandle,
   type SlidewiseRootProps,
   type HistoryState,
+  type SelectionSnapshot,
 } from "./compound/SlidewiseRoot";
 import { TopBar } from "./compound/topbar";
 import {
@@ -40,6 +41,18 @@ export interface SlidewiseEditorProps {
    * Undo and Redo buttons reactively without polling `api.canUndo()`.
    */
   onHistoryChange?: (state: HistoryState) => void;
+  /** Fires when the active slide changes (user click, programmatic goToSlide). */
+  onActiveSlideChange?: (slideId: string) => void;
+  /** Fires when the selected element ids change. */
+  onSelectionChange?: (selection: SelectionSnapshot) => void;
+  /** Fires when the canvas zoom level changes. */
+  onZoomChange?: (scale: number) => void;
+  /** Fires immediately before the host's `onSave` is invoked. */
+  onSaveStart?: () => void;
+  /** Fires after the host's `onSave` resolves successfully. */
+  onSaveSuccess?: () => void;
+  /** Fires when the host's `onSave` throws. The error still propagates. */
+  onSaveError?: (err: Error) => void;
   /** Reserved for future use; not enforced yet. */
   readOnly?: boolean;
   /** "light" or "dark"; defaults to "light". Ignored after first render. */
@@ -97,6 +110,12 @@ export const SlidewiseEditor = forwardRef<
     onExport,
     onDirtyChange,
     onHistoryChange,
+    onActiveSlideChange,
+    onSelectionChange,
+    onZoomChange,
+    onSaveStart,
+    onSaveSuccess,
+    onSaveError,
     readOnly,
     theme,
     initialSlideId,
@@ -116,6 +135,12 @@ export const SlidewiseEditor = forwardRef<
     onExport,
     onDirtyChange,
     onHistoryChange,
+    onActiveSlideChange,
+    onSelectionChange,
+    onZoomChange,
+    onSaveStart,
+    onSaveSuccess,
+    onSaveError,
     readOnly,
     theme,
     initialSlideId,

package/src/SlidewiseFileEditor.tsx

@@ -10,7 +10,7 @@ import { SlidewiseEditor, type SlidewiseEditorHandle } from "./SlidewiseEditor";
 import { parsePptx, serializeDeck } from "@/lib/pptx";
 import type { Deck } from "@/lib/types";
 import type { SlidewiseIcons } from "./compound/IconContext";
-import type { HistoryState } from "./compound/SlidewiseRoot";
+import type { HistoryState, SelectionSnapshot } from "./compound/SlidewiseRoot";
 
 export interface SlidewiseFileEditorProps {
   /**
@@ -55,6 +55,18 @@ export interface SlidewiseFileEditorProps {
    * `api.canUndo()` / `api.canRedo()`.
    */
   onHistoryChange?: (state: HistoryState) => void;
+  /** Fires when the active slide changes (user click, programmatic goToSlide). */
+  onActiveSlideChange?: (slideId: string) => void;
+  /** Fires when the selected element ids change. */
+  onSelectionChange?: (selection: SelectionSnapshot) => void;
+  /** Fires when the canvas zoom level changes. */
+  onZoomChange?: (scale: number) => void;
+  /** Fires immediately before the host's `saveBlob` is invoked. */
+  onSaveStart?: () => void;
+  /** Fires after `saveBlob` resolves successfully. */
+  onSaveSuccess?: () => void;
+  /** Fires when `saveBlob` throws. The error still propagates. */
+  onSaveError?: (err: Error) => void;
   /**
    * Fires when `loadBlob` or `parse` throws on mount. The default render
    * still shows an in-editor "Could not open file" message, but hosts that
@@ -114,6 +126,37 @@ export interface SlidewiseFileEditorApi {
    * handles typical typing/drag bursts automatically.
    */
   endCoalesce(): void;
+
+  /** Switch the active slide. No-op when `slideId` is not in the deck. */
+  goToSlide(slideId: string): void;
+  /** Advance to the next slide. No-op past the last slide. */
+  nextSlide(): void;
+  /** Step back to the previous slide. No-op past the first. */
+  prevSlide(): void;
+
+  /** Zoom out by one step. */
+  zoomOut(): void;
+  /** Zoom in by one step. */
+  zoomIn(): void;
+  /** Set absolute zoom (1 = 100%); clamped to [0.1, 4]. */
+  setZoom(scale: number): void;
+
+  /**
+   * Insert a blank slide after `afterId`, or at the end. Returns the new
+   * slide's id. The new slide becomes active.
+   */
+  addSlide(afterId?: string): string | null;
+  /**
+   * Duplicate `slideId`. Returns the new slide's id, or `null` if not
+   * found. The duplicate becomes active.
+   */
+  duplicateSlide(slideId: string): string | null;
+  /** Delete `slideId`. No-op when the deck would be left empty. */
+  deleteSlide(slideId: string): void;
+
+  /** Current selection snapshot (slide id + selected element ids). */
+  getSelection(): SelectionSnapshot;
+
   /** Live deck snapshot. Hosts use this for header badges (slide count, etc.). */
   getDeck(): Deck | null;
   getInitialSha256(): string | null;
@@ -138,6 +181,12 @@ export const SlidewiseFileEditor = forwardRef<
     onDirtyChange,
     onLoadError,
     onHistoryChange,
+    onActiveSlideChange,
+    onSelectionChange,
+    onZoomChange,
+    onSaveStart,
+    onSaveSuccess,
+    onSaveError,
     theme,
     initialSlideId,
     showTopBar,
@@ -211,6 +260,23 @@ export const SlidewiseFileEditor = forwardRef<
       getHistorySize: () =>
         editorRef.current?.getHistorySize() ?? { undo: 0, redo: 0 },
       endCoalesce: () => editorRef.current?.endCoalesce(),
+      goToSlide: (slideId: string) => editorRef.current?.goToSlide(slideId),
+      nextSlide: () => editorRef.current?.nextSlide(),
+      prevSlide: () => editorRef.current?.prevSlide(),
+      zoomIn: () => editorRef.current?.zoomIn(),
+      zoomOut: () => editorRef.current?.zoomOut(),
+      setZoom: (scale: number) => editorRef.current?.setZoom(scale),
+      addSlide: (afterId?: string) =>
+        editorRef.current?.addSlide(afterId) ?? null,
+      duplicateSlide: (slideId: string) =>
+        editorRef.current?.duplicateSlide(slideId) ?? null,
+      deleteSlide: (slideId: string) =>
+        editorRef.current?.deleteSlide(slideId),
+      getSelection: () =>
+        editorRef.current?.getSelection() ?? {
+          slideId: state.deck.slides[0]?.id ?? "",
+          elementIds: [],
+        },
       getDeck: () => editorRef.current?.getDeck() ?? state.deck,
       getInitialSha256: () => initialSha256,
     };
@@ -241,6 +307,24 @@ export const SlidewiseFileEditor = forwardRef<
       getHistorySize: () =>
         editorRef.current?.getHistorySize() ?? { undo: 0, redo: 0 },
       endCoalesce: () => editorRef.current?.endCoalesce(),
+      goToSlide: (slideId: string) => editorRef.current?.goToSlide(slideId),
+      nextSlide: () => editorRef.current?.nextSlide(),
+      prevSlide: () => editorRef.current?.prevSlide(),
+      zoomIn: () => editorRef.current?.zoomIn(),
+      zoomOut: () => editorRef.current?.zoomOut(),
+      setZoom: (scale: number) => editorRef.current?.setZoom(scale),
+      addSlide: (afterId?: string) =>
+        editorRef.current?.addSlide(afterId) ?? null,
+      duplicateSlide: (slideId: string) =>
+        editorRef.current?.duplicateSlide(slideId) ?? null,
+      deleteSlide: (slideId: string) =>
+        editorRef.current?.deleteSlide(slideId),
+      getSelection: () =>
+        editorRef.current?.getSelection() ?? {
+          slideId:
+            state.status === "ready" ? state.deck.slides[0]?.id ?? "" : "",
+          elementIds: [],
+        },
       getDeck: () =>
         state.status === "ready"
           ? editorRef.current?.getDeck() ?? state.deck
@@ -287,6 +371,12 @@ export const SlidewiseFileEditor = forwardRef<
           onDirtyChangeRef.current?.(d);
         }}
         onHistoryChange={onHistoryChange}
+        onActiveSlideChange={onActiveSlideChange}
+        onSelectionChange={onSelectionChange}
+        onZoomChange={onZoomChange}
+        onSaveStart={onSaveStart}
+        onSaveSuccess={onSaveSuccess}
+        onSaveError={onSaveError}
         onSave={async (next) => {
           const blob = await serialize(next);
           await saveBlob(blob);

package/src/compound/SlidewiseRoot.tsx

@@ -43,6 +43,18 @@ export interface SlidewiseRootProps {
    * "Undo"/"Redo" button enabled state without polling `canUndo()`/`canRedo()`.
    */
   onHistoryChange?: (state: HistoryState) => void;
+  /** Fires when the active slide changes (user click, programmatic goToSlide). */
+  onActiveSlideChange?: (slideId: string) => void;
+  /** Fires when the selected element ids change. */
+  onSelectionChange?: (selection: SelectionSnapshot) => void;
+  /** Fires when the canvas zoom level changes. */
+  onZoomChange?: (scale: number) => void;
+  /** Fires immediately before the host's `onSave` is invoked. */
+  onSaveStart?: () => void;
+  /** Fires after the host's `onSave` resolves successfully. */
+  onSaveSuccess?: () => void;
+  /** Fires when the host's `onSave` throws. The error still propagates. */
+  onSaveError?: (err: Error) => void;
   /**
    * Hide editing affordances (save / undo / redo) and disable canvas
    * mutations. Use this when the host viewer doesn't have write access.
@@ -74,6 +86,12 @@ export interface HistoryState {
   redoSize: number;
 }
 
+/** Snapshot of the current selection, scoped to the active slide. */
+export interface SelectionSnapshot {
+  slideId: string;
+  elementIds: string[];
+}
+
 export interface SlidewiseRootHandle {
   play(): void;
   stop(): void;
@@ -92,6 +110,44 @@ export interface SlidewiseRootHandle {
    * window handles typical typing/drag bursts.
    */
   endCoalesce(): void;
+
+  // ---- Navigation ----
+  /** Switch the active slide. No-op when `slideId` is not in the deck. */
+  goToSlide(slideId: string): void;
+  /** Advance to the slide after the current one. No-op past the last slide. */
+  nextSlide(): void;
+  /** Step back to the slide before the current one. No-op past the first. */
+  prevSlide(): void;
+
+  // ---- Zoom ----
+  /** Zoom out by one step (×0.8), clamped to the editor's min zoom. */
+  zoomOut(): void;
+  /** Zoom in by one step (×1.25), clamped to the editor's max zoom. */
+  zoomIn(): void;
+  /** Set the absolute zoom (1 = 100%); clamped to [0.1, 4]. */
+  setZoom(scale: number): void;
+
+  // ---- Slide CRUD ----
+  /**
+   * Insert a blank slide after `afterId`, or at the end if `afterId` is
+   * omitted. Returns the new slide's id. The new slide becomes active.
+   */
+  addSlide(afterId?: string): string;
+  /**
+   * Insert a copy of `slideId` immediately after it. Returns the new
+   * slide's id, or `null` if `slideId` wasn't found. The copy becomes
+   * active.
+   */
+  duplicateSlide(slideId: string): string | null;
+  /**
+   * Delete a slide. No-op when the deck would be left with zero slides.
+   */
+  deleteSlide(slideId: string): void;
+
+  // ---- Selection ----
+  /** Current selection snapshot (slide id + selected element ids). */
+  getSelection(): SelectionSnapshot;
+
   getDeck(): Deck;
   isDirty(): boolean;
   resetDirty(): void;
@@ -124,6 +180,12 @@ function RootInner({
   onExport,
   onDirtyChange,
   onHistoryChange: props_onHistoryChange,
+  onActiveSlideChange,
+  onSelectionChange,
+  onZoomChange,
+  onSaveStart,
+  onSaveSuccess,
+  onSaveError,
   readOnly = false,
   theme,
   initialSlideId,
@@ -145,6 +207,12 @@ function RootInner({
   const onSaveRef = useRef(onSave);
   const onExportRef = useRef(onExport);
   const onHistoryChangeRef = useRef(props_onHistoryChange);
+  const onActiveSlideChangeRef = useRef(onActiveSlideChange);
+  const onSelectionChangeRef = useRef(onSelectionChange);
+  const onZoomChangeRef = useRef(onZoomChange);
+  const onSaveStartRef = useRef(onSaveStart);
+  const onSaveSuccessRef = useRef(onSaveSuccess);
+  const onSaveErrorRef = useRef(onSaveError);
 
   useEffect(() => {
     onChangeRef.current = onChange;
@@ -152,7 +220,25 @@ function RootInner({
     onSaveRef.current = onSave;
     onExportRef.current = onExport;
     onHistoryChangeRef.current = props_onHistoryChange;
-  }, [onChange, onDirtyChange, onSave, onExport, props_onHistoryChange]);
+    onActiveSlideChangeRef.current = onActiveSlideChange;
+    onSelectionChangeRef.current = onSelectionChange;
+    onZoomChangeRef.current = onZoomChange;
+    onSaveStartRef.current = onSaveStart;
+    onSaveSuccessRef.current = onSaveSuccess;
+    onSaveErrorRef.current = onSaveError;
+  }, [
+    onChange,
+    onDirtyChange,
+    onSave,
+    onExport,
+    props_onHistoryChange,
+    onActiveSlideChange,
+    onSelectionChange,
+    onZoomChange,
+    onSaveStart,
+    onSaveSuccess,
+    onSaveError,
+  ]);
 
   useEffect(() => {
     if (theme) {
@@ -207,6 +293,29 @@ function RootInner({
           redoSize: nextFut,
         });
       }
+
+      // Active slide changes (click in rail, programmatic goToSlide).
+      if (state.currentSlideId !== prev.currentSlideId) {
+        onActiveSlideChangeRef.current?.(state.currentSlideId);
+      }
+
+      // Selection — shallow compare ids since the array is rebuilt on
+      // every selectElement call. Same slideId + same ids = no emit.
+      if (
+        state.selectedIds !== prev.selectedIds &&
+        !shallowEqualIds(state.selectedIds, prev.selectedIds)
+      ) {
+        onSelectionChangeRef.current?.({
+          slideId: state.currentSlideId,
+          elementIds: state.selectedIds,
+        });
+      }
+
+      // Zoom.
+      if (state.zoom !== prev.zoom) {
+        onZoomChangeRef.current?.(state.zoom);
+      }
+
       if (state.deck === prev.deck) return;
       onChangeRef.current?.(state.deck);
       const nextDirty = state.deck !== savedDeckRef.current;
@@ -239,12 +348,54 @@ function RootInner({
         return { undo: s.history.length, redo: s.future.length };
       },
       endCoalesce: () => store.getState().endCoalesce(),
+
+      goToSlide: (slideId: string) => {
+        const s = store.getState();
+        if (s.deck.slides.some((sl) => sl.id === slideId)) {
+          s.selectSlide(slideId);
+        }
+      },
+      nextSlide: () => {
+        const s = store.getState();
+        const idx = s.deck.slides.findIndex(
+          (sl) => sl.id === s.currentSlideId
+        );
+        const next = s.deck.slides[idx + 1];
+        if (next) s.selectSlide(next.id);
+      },
+      prevSlide: () => {
+        const s = store.getState();
+        const idx = s.deck.slides.findIndex(
+          (sl) => sl.id === s.currentSlideId
+        );
+        const prev = s.deck.slides[idx - 1];
+        if (prev) s.selectSlide(prev.id);
+      },
+
+      zoomIn: () => store.getState().zoomIn(),
+      zoomOut: () => store.getState().zoomOut(),
+      setZoom: (scale: number) => store.getState().setZoom(scale),
+
+      addSlide: (afterId?: string) => store.getState().addSlide(afterId),
+      duplicateSlide: (slideId: string) =>
+        store.getState().duplicateSlide(slideId),
+      deleteSlide: (slideId: string) => store.getState().deleteSlide(slideId),
+
+      getSelection: (): SelectionSnapshot => {
+        const s = store.getState();
+        return {
+          slideId: s.currentSlideId,
+          elementIds: [...s.selectedIds],
+        };
+      },
+
       getDeck: () => store.getState().deck,
       isDirty: () => dirtyRef.current,
       resetDirty: () => {
         savedDeckRef.current = store.getState().deck;
         if (dirtyRef.current) {
           dirtyRef.current = false;
+          setDirty(false);
           onDirtyChangeRef.current?.(false);
         }
       },
@@ -252,15 +403,28 @@ function RootInner({
     [store]
   );
 
-  // Wrap host save with dirty-flag reset so any TopBar.Save / imperative save
-  // path that funnels through here clears the dirty state on success.
+  // Wrap host save with:
+  //   - onSaveStart / onSaveSuccess / onSaveError lifecycle hooks
+  //   - dirty-flag reset on success
+  // The error still propagates so TopBar.Save's local "Saving…" → "idle"
+  // transition kicks in correctly.
   const wrappedSave = onSave
     ? async (d: Deck) => {
-        await onSaveRef.current!(d);
-        savedDeckRef.current = d;
-        if (dirtyRef.current) {
-          dirtyRef.current = false;
-          onDirtyChangeRef.current?.(false);
+        onSaveStartRef.current?.();
+        try {
+          await onSaveRef.current!(d);
+          savedDeckRef.current = d;
+          if (dirtyRef.current) {
+            dirtyRef.current = false;
+            setDirty(false);
+            onDirtyChangeRef.current?.(false);
+          }
+          onSaveSuccessRef.current?.();
+        } catch (err) {
+          onSaveErrorRef.current?.(
+            err instanceof Error ? err : new Error(String(err))
+          );
+          throw err;
         }
       }
     : undefined;
@@ -330,3 +494,12 @@ function RootShell({
     </div>
   );
 }
+
+function shallowEqualIds(a: readonly string[], b: readonly string[]): boolean {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}

package/src/compound/index.ts

@@ -37,6 +37,7 @@ export {
   type SlidewiseRootProps,
   type SlidewiseRootHandle,
   type HistoryState,
+  type SelectionSnapshot,
 } from "./SlidewiseRoot";
 export {
   SlideRail,

package/src/index.ts

@@ -60,6 +60,7 @@ export {
   type SlidewiseRootProps,
   type SlidewiseRootHandle,
   type HistoryState,
+  type SelectionSnapshot,
   type SlidewiseHostCallbacks,
   type SlidewiseIcons,
   type RegionProps,

package/src/lib/__tests__/api-extensions.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect } from "vitest";
+import { createEditorStore } from "../store";
+import { CURRENT_DECK_VERSION } from "../schema/migrate";
+import type { Deck } from "../types";
+
+function makeDeck(slideCount = 3): Deck {
+  return {
+    version: CURRENT_DECK_VERSION,
+    title: "fixture",
+    slides: Array.from({ length: slideCount }, (_, i) => ({
+      id: `s${i + 1}`,
+      background: "#FFFFFF",
+      elements: [],
+    })),
+  };
+}
+
+describe("store: zoom actions", () => {
+  it("zoomIn multiplies the current zoom by 1.25 (clamped to 4)", () => {
+    const store = createEditorStore(makeDeck());
+    store.getState().setZoom(1);
+    store.getState().zoomIn();
+    expect(store.getState().zoom).toBeCloseTo(1.25);
+  });
+
+  it("zoomOut multiplies by 0.8 (clamped to 0.1)", () => {
+    const store = createEditorStore(makeDeck());
+    store.getState().setZoom(1);
+    store.getState().zoomOut();
+    expect(store.getState().zoom).toBeCloseTo(0.8);
+  });
+
+  it("setZoom clamps the zoom to the valid range", () => {
+    const store = createEditorStore(makeDeck());
+    store.getState().setZoom(999);
+    expect(store.getState().zoom).toBe(4);
+    store.getState().setZoom(0);
+    expect(store.getState().zoom).toBe(0.1);
+  });
+});
+
+describe("store: slide CRUD return ids", () => {
+  it("addSlide returns the new slide's id and inserts after the target", () => {
+    const store = createEditorStore(makeDeck(2));
+    const newId = store.getState().addSlide("s1");
+    expect(typeof newId).toBe("string");
+    const slides = store.getState().deck.slides;
+    expect(slides).toHaveLength(3);
+    expect(slides[1].id).toBe(newId);
+    expect(store.getState().currentSlideId).toBe(newId);
+  });
+
+  it("addSlide() with no afterId appends at the end", () => {
+    const store = createEditorStore(makeDeck(2));
+    const newId = store.getState().addSlide();
+    expect(store.getState().deck.slides[2].id).toBe(newId);
+  });
+
+  it("duplicateSlide returns the new slide id and inserts after the original", () => {
+    const store = createEditorStore(makeDeck(2));
+    const copyId = store.getState().duplicateSlide("s1");
+    expect(typeof copyId).toBe("string");
+    expect(copyId).not.toBe("s1");
+    const slides = store.getState().deck.slides;
+    expect(slides).toHaveLength(3);
+    expect(slides[1].id).toBe(copyId);
+  });
+
+  it("duplicateSlide returns null when slide id is not found", () => {
+    const store = createEditorStore(makeDeck(2));
+    expect(store.getState().duplicateSlide("does-not-exist")).toBeNull();
+    expect(store.getState().deck.slides).toHaveLength(2);
+  });
+});

package/src/lib/store.ts

@@ -68,12 +68,18 @@ export interface EditorState {
   setTool: (t: Tool) => void;
   setTitle: (t: string) => void;
   setZoom: (z: number) => void;
+  /** Multiplicative zoom-in step (×1.25), clamped to the same range as setZoom. */
+  zoomIn: () => void;
+  /** Multiplicative zoom-out step (×0.8), clamped to the same range as setZoom. */
+  zoomOut: () => void;
   setFitMode: (f: "fit" | "fill" | "manual") => void;
   selectSlide: (id: string) => void;
   selectElement: (id: string | null, additive?: boolean) => void;
   clearSelection: () => void;
-  addSlide: (afterId?: string) => void;
-  duplicateSlide: (id: string) => void;
+  /** Returns the id of the newly inserted slide. */
+  addSlide: (afterId?: string) => string;
+  /** Returns the id of the newly inserted duplicate, or null if `id` wasn't found. */
+  duplicateSlide: (id: string) => string | null;
   deleteSlide: (id: string) => void;
   reorderSlide: (id: string, toIndex: number) => void;
   addElement: (partial: ElementDraft) => string;
@@ -194,6 +200,8 @@ export function createEditorStore(initialDeck: Deck): EditorStore {
     },
     setZoom: (z) =>
       set({ zoom: Math.max(0.1, Math.min(4, z)), fitMode: "manual" }),
+    zoomIn: () => get().setZoom(get().zoom * 1.25),
+    zoomOut: () => get().setZoom(get().zoom * 0.8),
     setFitMode: (f) => set({ fitMode: f }),
 
     selectSlide: (id) =>
@@ -215,8 +223,8 @@ export function createEditorStore(initialDeck: Deck): EditorStore {
 
     addSlide: (afterId) => {
       get().pushHistory();
+      const slide = blankSlide();
       set((s) => {
-        const slide = blankSlide();
         const slides = [...s.deck.slides];
         const idx = afterId
           ? slides.findIndex((sl) => sl.id === afterId)
@@ -228,26 +236,28 @@ export function createEditorStore(initialDeck: Deck): EditorStore {
           selectedIds: [],
         };
       });
+      return slide.id;
     },
 
     duplicateSlide: (id) => {
+      const orig = get().deck.slides.find((sl) => sl.id === id);
+      if (!orig) return null;
       get().pushHistory();
+      const copy: Slide = {
+        ...structuredClone(orig),
+        id: nanoid(8),
+        elements: orig.elements.map((e) => ({ ...e, id: nanoid(8) })),
+      };
       set((s) => {
         const slides = [...s.deck.slides];
         const idx = slides.findIndex((sl) => sl.id === id);
-        if (idx < 0) return s;
-        const orig = slides[idx];
-        const copy: Slide = {
-          ...structuredClone(orig),
-          id: nanoid(8),
-          elements: orig.elements.map((e) => ({ ...e, id: nanoid(8) })),
-        };
         slides.splice(idx + 1, 0, copy);
         return {
           deck: { ...s.deck, slides },
           currentSlideId: copy.id,
         };
       });
+      return copy.id;
     },
 
     deleteSlide: (id) => {