@textcortex/slidewise 1.0.1 → 1.2.0

package/src/lib/__tests__/history.test.ts

@@ -0,0 +1,164 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { createEditorStore } from "../store";
+import { CURRENT_DECK_VERSION } from "../schema/migrate";
+import type { Deck } from "../types";
+
+const baseElement = { rotation: 0, z: 1 } as const;
+
+function fixtureDeck(): Deck {
+  return {
+    version: CURRENT_DECK_VERSION,
+    title: "Hist test",
+    slides: [
+      {
+        id: "s1",
+        background: "#FFFFFF",
+        elements: [
+          {
+            ...baseElement,
+            id: "t1",
+            type: "text",
+            x: 100,
+            y: 100,
+            w: 400,
+            h: 80,
+            text: "Hello",
+            fontFamily: "Inter",
+            fontSize: 24,
+            fontWeight: 400,
+            italic: false,
+            underline: false,
+            strike: false,
+            color: "#000000",
+            align: "left",
+            vAlign: "top",
+            lineHeight: 1.2,
+            letterSpacing: 0,
+          },
+        ],
+      },
+    ],
+  };
+}
+
+describe("editor store history", () => {
+  beforeEach(() => {
+    vi.useFakeTimers({ now: 1_000_000 });
+  });
+
+  it("undo reverts an updateElement", () => {
+    const store = createEditorStore(fixtureDeck());
+    expect(store.getState().canUndo()).toBe(false);
+
+    store.getState().updateElement("t1", { x: 200 });
+    expect(store.getState().canUndo()).toBe(true);
+    const slide = () => store.getState().deck.slides[0];
+    expect((slide().elements[0] as { x: number }).x).toBe(200);
+
+    store.getState().undo();
+    expect((slide().elements[0] as { x: number }).x).toBe(100);
+    expect(store.getState().canUndo()).toBe(false);
+    expect(store.getState().canRedo()).toBe(true);
+  });
+
+  it("undo reverts a setTitle", () => {
+    const store = createEditorStore(fixtureDeck());
+    store.getState().setTitle("Renamed");
+    expect(store.getState().deck.title).toBe("Renamed");
+    store.getState().undo();
+    expect(store.getState().deck.title).toBe("Hist test");
+  });
+
+  it("coalesces a typing burst into one undo step", () => {
+    const store = createEditorStore(fixtureDeck());
+    // simulate keystrokes within the idle window
+    store.getState().updateElement("t1", { x: 110 });
+    vi.advanceTimersByTime(50);
+    store.getState().updateElement("t1", { x: 120 });
+    vi.advanceTimersByTime(50);
+    store.getState().updateElement("t1", { x: 130 });
+
+    expect(store.getState().history.length).toBe(1);
+
+    store.getState().undo();
+    const elX = (store.getState().deck.slides[0].elements[0] as { x: number }).x;
+    expect(elX).toBe(100);
+  });
+
+  it("starts a new history step after the idle window expires", () => {
+    const store = createEditorStore(fixtureDeck());
+    store.getState().updateElement("t1", { x: 110 });
+    expect(store.getState().history.length).toBe(1);
+
+    // advance past the 500ms idle window
+    vi.advanceTimersByTime(600);
+
+    store.getState().updateElement("t1", { x: 120 });
+    expect(store.getState().history.length).toBe(2);
+
+    store.getState().undo();
+    expect((store.getState().deck.slides[0].elements[0] as { x: number }).x).toBe(110);
+
+    store.getState().undo();
+    expect((store.getState().deck.slides[0].elements[0] as { x: number }).x).toBe(100);
+  });
+
+  it("endCoalesce starts a fresh step on the next mutation", () => {
+    const store = createEditorStore(fixtureDeck());
+    store.getState().updateElement("t1", { x: 110 });
+    store.getState().updateElement("t1", { x: 120 });
+    expect(store.getState().history.length).toBe(1);
+
+    store.getState().endCoalesce();
+    store.getState().updateElement("t1", { x: 130 });
+    expect(store.getState().history.length).toBe(2);
+  });
+
+  it("different patch keys on the same element start a fresh step", () => {
+    const store = createEditorStore(fixtureDeck());
+    store.getState().updateElement("t1", { x: 110 });
+    store.getState().updateElement("t1", { y: 110 });
+    // Different keys → different coalesce key → second step pushed.
+    expect(store.getState().history.length).toBe(2);
+  });
+
+  it("setDeck clears history", () => {
+    const store = createEditorStore(fixtureDeck());
+    store.getState().updateElement("t1", { x: 200 });
+    expect(store.getState().history.length).toBe(1);
+
+    store.getState().setDeck(fixtureDeck());
+    expect(store.getState().history.length).toBe(0);
+    expect(store.getState().future.length).toBe(0);
+    expect(store.getState().canUndo()).toBe(false);
+  });
+
+  it("undo/redo update canUndo/canRedo correctly", () => {
+    const store = createEditorStore(fixtureDeck());
+    store.getState().updateElement("t1", { x: 200 });
+    expect(store.getState().canUndo()).toBe(true);
+    expect(store.getState().canRedo()).toBe(false);
+
+    store.getState().undo();
+    expect(store.getState().canUndo()).toBe(false);
+    expect(store.getState().canRedo()).toBe(true);
+
+    store.getState().redo();
+    expect(store.getState().canUndo()).toBe(true);
+    expect(store.getState().canRedo()).toBe(false);
+  });
+
+  it("undo replaces the deck reference (so subscribers see a change)", () => {
+    const store = createEditorStore(fixtureDeck());
+    const before = store.getState().deck;
+    store.getState().updateElement("t1", { x: 200 });
+    const afterEdit = store.getState().deck;
+    expect(afterEdit).not.toBe(before);
+
+    store.getState().undo();
+    const afterUndo = store.getState().deck;
+    expect(afterUndo).not.toBe(afterEdit);
+    // value matches the pre-edit deck even if the reference is a clone
+    expect((afterUndo.slides[0].elements[0] as { x: number }).x).toBe(100);
+  });
+});

package/src/lib/store.ts

@@ -29,6 +29,17 @@ interface HistorySnapshot {
 type Theme = "light" | "dark";
 type View = "editor" | "grid";
 
+/**
+ * Idle window in ms during which consecutive mutations with the same coalesce
+ * key collapse into a single history step. After this many ms with no edit,
+ * the next edit starts a fresh step. Drags on a single element typically run
+ * 60+ frames in well under this window; typing pauses around word boundaries
+ * usually exceed it. Hosts that want stricter granularity can call
+ * `endCoalesce()` explicitly (e.g. on mouseup or input blur).
+ */
+const COALESCE_IDLE_MS = 500;
+const HISTORY_LIMIT = 50;
+
 export interface EditorState {
   deck: Deck;
   currentSlideId: string;
@@ -41,6 +52,14 @@ export interface EditorState {
   view: View;
   history: HistorySnapshot[];
   future: HistorySnapshot[];
+  /**
+   * Coalesce key for the in-flight mutation burst. Two consecutive mutations
+   * with the same key (within `COALESCE_IDLE_MS`) collapse into one history
+   * step. `null` means "no burst in progress" — the next edit pushes a fresh
+   * snapshot.
+   */
+  _coalesceKey: string | null;
+  _coalesceUntil: number;
 
   // selectors
   currentSlide: () => Slide;
@@ -68,6 +87,23 @@ export interface EditorState {
   undo: () => void;
   redo: () => void;
   pushHistory: () => void;
+  /**
+   * Push a history snapshot, but only if `key` differs from the in-flight
+   * coalesce key OR more than `COALESCE_IDLE_MS` have passed since the last
+   * mutation. Use this for high-frequency edits (text typing, drag) so the
+   * burst collapses into one undo step.
+   */
+  pushHistoryCoalesced: (key: string) => void;
+  /**
+   * End the current coalesce burst. Hosts call this on natural commit
+   * boundaries (mouseup after a drag, blur on a text input) so the next
+   * mutation starts a fresh history step even within `COALESCE_IDLE_MS`.
+   */
+  endCoalesce: () => void;
+  /** True iff there's at least one snapshot to undo back to. */
+  canUndo: () => boolean;
+  /** True iff there's at least one snapshot to redo forward to. */
+  canRedo: () => boolean;
   setDeck: (deck: Deck) => void;
   setTheme: (t: Theme) => void;
   toggleTheme: () => void;
@@ -107,6 +143,8 @@ export function createEditorStore(initialDeck: Deck): EditorStore {
     view: "editor",
     history: [],
     future: [],
+    _coalesceKey: null,
+    _coalesceUntil: 0,
 
     currentSlide: () => {
       const s = get();
@@ -118,20 +156,48 @@ export function createEditorStore(initialDeck: Deck): EditorStore {
 
     pushHistory: () => {
       set((s) => ({
-        history: [...s.history, snap(s)].slice(-50),
+        history: [...s.history, snap(s)].slice(-HISTORY_LIMIT),
         future: [],
+        _coalesceKey: null,
+        _coalesceUntil: 0,
       }));
     },
 
+    pushHistoryCoalesced: (key) => {
+      const now = Date.now();
+      set((s) => {
+        // Same burst within the idle window → don't push, just extend.
+        if (s._coalesceKey === key && now < s._coalesceUntil) {
+          return { _coalesceUntil: now + COALESCE_IDLE_MS };
+        }
+        // New burst — snapshot the pre-mutation state and start coalescing.
+        return {
+          history: [...s.history, snap(s)].slice(-HISTORY_LIMIT),
+          future: [],
+          _coalesceKey: key,
+          _coalesceUntil: now + COALESCE_IDLE_MS,
+        };
+      });
+    },
+
+    endCoalesce: () => {
+      set({ _coalesceKey: null, _coalesceUntil: 0 });
+    },
+
+    canUndo: () => get().history.length > 0,
+    canRedo: () => get().future.length > 0,
+
     setTool: (t) => set({ tool: t }),
     setTitle: (t) => {
+      get().pushHistoryCoalesced("setTitle");
       set((s) => ({ deck: { ...s.deck, title: t } }));
     },
     setZoom: (z) =>
       set({ zoom: Math.max(0.1, Math.min(4, z)), fitMode: "manual" }),
     setFitMode: (f) => set({ fitMode: f }),
 
-    selectSlide: (id) => set({ currentSlideId: id, selectedIds: [] }),
+    selectSlide: (id) =>
+      set({ currentSlideId: id, selectedIds: [], _coalesceKey: null }),
     selectElement: (id, additive) =>
       set((s) => {
         if (id == null) return { selectedIds: [] };
@@ -228,6 +294,11 @@ export function createEditorStore(initialDeck: Deck): EditorStore {
     },
 
     updateElement: (id, patch) => {
+      // Coalesce key: same element, same patch shape = same burst.
+      // Drag (x,y) coalesces; resize (w,h) starts a new burst even on the
+      // same element; switching elements also starts fresh.
+      const key = `updateElement:${id}:${Object.keys(patch).sort().join(",")}`;
+      get().pushHistoryCoalesced(key);
       set((s) => {
         const slides = s.deck.slides.map((sl) => {
           if (sl.id !== s.currentSlideId) return sl;
@@ -320,8 +391,10 @@ export function createEditorStore(initialDeck: Deck): EditorStore {
           deck: last.deck,
           currentSlideId: last.currentSlideId,
           history: s.history.slice(0, -1),
-          future: [...s.future, snapshot].slice(-50),
+          future: [...s.future, snapshot].slice(-HISTORY_LIMIT),
           selectedIds: survivingIds,
+          _coalesceKey: null,
+          _coalesceUntil: 0,
         };
       });
     },
@@ -342,9 +415,11 @@ export function createEditorStore(initialDeck: Deck): EditorStore {
         return {
           deck: next.deck,
           currentSlideId: next.currentSlideId,
-          history: [...s.history, snapshot].slice(-50),
+          history: [...s.history, snapshot].slice(-HISTORY_LIMIT),
           future: s.future.slice(0, -1),
           selectedIds: survivingIds,
+          _coalesceKey: null,
+          _coalesceUntil: 0,
         };
       });
     },
@@ -357,6 +432,8 @@ export function createEditorStore(initialDeck: Deck): EditorStore {
         selectedIds: [],
         history: [],
         future: [],
+        _coalesceKey: null,
+        _coalesceUntil: 0,
       });
     },
 

package/README.md

@@ -1,112 +0,0 @@
-# Slidewise
-
-Embeddable React PPTX editor. PPTX import + canvas editor + PPTX export, in
-one component.
-
-```bash
-pnpm add @textcortex/slidewise
-```
-
-Peer dependencies: `react >=19`, `react-dom >=19`.
-
-## Quick start
-
-`SlidewiseFileEditor` wraps the editor with PPTX load/save plumbing — give it
-async `loadBlob` and `saveBlob` callbacks and it handles parsing, dirty
-tracking, and serialisation.
-
-```tsx
-import {
-  SlidewiseFileEditor,
-  type SlidewiseFileEditorApi,
-} from "@textcortex/slidewise";
-import "@textcortex/slidewise/style.css";
-import { useRef } from "react";
-
-export function PresentationsRoute({ fileId }: { fileId: string }) {
-  const apiRef = useRef<SlidewiseFileEditorApi | null>(null);
-
-  return (
-    <SlidewiseFileEditor
-      onEditorApiChange={(api) => (apiRef.current = api)}
-      loadBlob={async () => {
-        const res = await fetch(`/api/files/${fileId}`);
-        return res.blob();
-      }}
-      saveBlob={async (pptx) => {
-        await fetch(`/api/files/${fileId}`, { method: "PUT", body: pptx });
-      }}
-    />
-  );
-}
-```
-
-The host owns transport and conflict detection; Slidewise owns parsing,
-editing, and serialisation. Call `apiRef.current.save()` to trigger a save
-from outside the editor's top bar; call `apiRef.current.isDirty()` to gate
-"unsaved changes" UI.
-
-## Lower-level entry point
-
-If your host already has a `Deck` in memory (e.g. you're storing the JSON
-shape in your own database rather than `.pptx` blobs), mount
-`SlidewiseEditor` directly:
-
-```tsx
-import { SlidewiseEditor, type Deck } from "@textcortex/slidewise";
-import "@textcortex/slidewise/style.css";
-
-<SlidewiseEditor
-  deck={deck}
-  onChange={(next) => setDeck(next)}
-  onSave={(next) => persist(next)}
-/>;
-```
-
-## Working with decks programmatically
-
-Slidewise persists slides as a versioned JSON `Deck`. The schema is the
-canonical contract — undo/redo, exports, AI features, and persistence all
-key off it.
-
-```ts
-import {
-  parsePptx,
-  serializeDeck,
-  migrate,
-  CURRENT_DECK_VERSION,
-  type Deck,
-} from "@textcortex/slidewise";
-
-const deck: Deck = await parsePptx(blob); // import
-const pptx: Blob = await serializeDeck(deck); // export
-const safe: Deck = migrate(unknownDeckJson); // normalise an external deck
-```
-
-`migrate()` runs every external deck (PPTX import, JSON import, localStorage
-hydration, host props) through the schema migration chain so the rest of the
-editor only sees current-shape decks. It throws if the input was written by a
-newer Slidewise than the host has installed — pin the version range you can
-support.
-
-## Releasing
-
-Versioning and publishing run through
-[changesets](https://github.com/changesets/changesets).
-
-```bash
-pnpm changeset            # describe the impact of your change
-pnpm version-packages     # bump versions + update CHANGELOG (CI usually does this)
-pnpm release              # build + publish (CI does this on merge)
-```
-
-CI (`.github/workflows/release.yml`) opens a "Version Packages" PR whenever
-there are pending changesets and publishes to npm when that PR merges.
-
-## Repo layout
-
-- `src/SlidewiseEditor.tsx` / `src/SlidewiseFileEditor.tsx` — public entry components
-- `src/components/editor/` — top bar, slide rail, canvas, panels
-- `src/lib/pptx/` — PPTX import (`pptxToDeck`) and export (`deckToPptx`)
-- `src/lib/schema/` — `Deck` schema versioning + migrator
-- `src/lib/types.ts` — `Deck` / `Slide` / `SlideElement` shapes (the contract)

package/dist/file.svg

@@ -1 +0,0 @@
-<svg fill="none" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg"><path d="M14.5 13.5V5.41a1 1 0 0 0-.3-.7L9.8.29A1 1 0 0 0 9.08 0H1.5v13.5A2.5 2.5 0 0 0 4 16h8a2.5 2.5 0 0 0 2.5-2.5m-1.5 0v-7H8v-5H3v12a1 1 0 0 0 1 1h8a1 1 0 0 0 1-1M9.5 5V2.12L12.38 5zM5.13 5h-.62v1.25h2.12V5zm-.62 3h7.12v1.25H4.5zm.62 3h-.62v1.25h7.12V11z" clip-rule="evenodd" fill="#666" fill-rule="evenodd"/></svg>

package/dist/globe.svg

@@ -1 +0,0 @@
-<svg fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><g clip-path="url(#a)"><path fill-rule="evenodd" clip-rule="evenodd" d="M10.27 14.1a6.5 6.5 0 0 0 3.67-3.45q-1.24.21-2.7.34-.31 1.83-.97 3.1M8 16A8 8 0 1 0 8 0a8 8 0 0 0 0 16m.48-1.52a7 7 0 0 1-.96 0H7.5a4 4 0 0 1-.84-1.32q-.38-.89-.63-2.08a40 40 0 0 0 3.92 0q-.25 1.2-.63 2.08a4 4 0 0 1-.84 1.31zm2.94-4.76q1.66-.15 2.95-.43a7 7 0 0 0 0-2.58q-1.3-.27-2.95-.43a18 18 0 0 1 0 3.44m-1.27-3.54a17 17 0 0 1 0 3.64 39 39 0 0 1-4.3 0 17 17 0 0 1 0-3.64 39 39 0 0 1 4.3 0m1.1-1.17q1.45.13 2.69.34a6.5 6.5 0 0 0-3.67-3.44q.65 1.26.98 3.1M8.48 1.5l.01.02q.41.37.84 1.31.38.89.63 2.08a40 40 0 0 0-3.92 0q.25-1.2.63-2.08a4 4 0 0 1 .85-1.32 7 7 0 0 1 .96 0m-2.75.4a6.5 6.5 0 0 0-3.67 3.44 29 29 0 0 1 2.7-.34q.31-1.83.97-3.1M4.58 6.28q-1.66.16-2.95.43a7 7 0 0 0 0 2.58q1.3.27 2.95.43a18 18 0 0 1 0-3.44m.17 4.71q-1.45-.12-2.69-.34a6.5 6.5 0 0 0 3.67 3.44q-.65-1.27-.98-3.1" fill="#666"/></g><defs><clipPath id="a"><path fill="#fff" d="M0 0h16v16H0z"/></clipPath></defs></svg>

package/dist/types/SlidewiseEditor.d.ts

@@ -1,47 +0,0 @@
-import { type CSSProperties } from "react";
-import type { Deck } from "@/lib/types";
-import "./SlidewiseEditor.css";
-export interface SlidewiseEditorProps {
-    /**
-     * The deck to edit. Loaded into the editor on mount. If a different
-     * Deck reference is later passed, the editor's internal state is reset
-     * to it (dirty flag reset). Do NOT pass a new reference on every
-     * `onChange` — that would loop. Hold the deck in a stable ref, and
-     * only pass a new one when you intentionally want to reset the editor
-     * (e.g. discard changes, load a different file).
-     */
-    deck: Deck;
-    /** Fires after every committed mutation; receives the updated deck. */
-    onChange?: (deck: Deck) => void;
-    /** Fires when the user clicks "Save" in the top bar. */
-    onSave?: (deck: Deck) => void | Promise<void>;
-    /** Optional override for the default `.slidewise.json` export. */
-    onExport?: (deck: Deck) => void;
-    /** Fires when the dirty flag flips. Useful for "unsaved changes" banners. */
-    onDirtyChange?: (dirty: boolean) => void;
-    /** Reserved for future use; not enforced yet. */
-    readOnly?: boolean;
-    /** "light" or "dark"; defaults to "light". Ignored after first render. */
-    theme?: "light" | "dark";
-    /** Slide id to land on; falls back to the first slide. */
-    initialSlideId?: string;
-    /** Render the built-in top bar (title, undo/redo, save, play). Default true. */
-    showTopBar?: boolean;
-    /** Override the bundled Geist font; sets `--font-geist-sans` on the root. */
-    fontFamily?: string;
-    /** Extra class names appended to the editor root. */
-    className?: string;
-    /** Inline style applied to the editor root. */
-    style?: CSSProperties;
-}
-export interface SlidewiseEditorHandle {
-    play(): void;
-    stop(): void;
-    undo(): void;
-    redo(): void;
-    getDeck(): Deck;
-    isDirty(): boolean;
-    resetDirty(): void;
-}
-export declare const SlidewiseEditor: import("react").ForwardRefExoticComponent<SlidewiseEditorProps & import("react").RefAttributes<SlidewiseEditorHandle>>;
-export default SlidewiseEditor;

package/dist/types/SlidewiseFileEditor.d.ts

@@ -1,54 +0,0 @@
-import { type CSSProperties } from "react";
-import type { Deck } from "@/lib/types";
-export interface SlidewiseFileEditorProps {
-    /**
-     * Async loader for the file's bytes. Host is responsible for fetching the
-     * blob (e.g. via the platform's `getFile(fileId, { preview: true })`).
-     * Called once on mount.
-     */
-    loadBlob: () => Promise<Blob | ArrayBuffer>;
-    /**
-     * Async saver for a serialized PPTX blob. Host is responsible for the
-     * upload and conflict handling (e.g. via `saveFileContent(fileId, …)`).
-     * Called when `save()` is invoked on the imperative API.
-     */
-    saveBlob: (blob: Blob) => Promise<void>;
-    /** Disables editing affordances (TODO: not yet enforced). */
-    editable?: boolean;
-    /**
-     * The sha256 of the file's contents at load time, if the host wants to do
-     * conflict detection. Stored verbatim and surfaced via `getInitialSha256()`
-     * — Slidewise itself doesn't read it; the host's saveBlob implementation does.
-     */
-    initialSha256?: string | null;
-    /**
-     * Receives an imperative API for save / dirty-tracking / play once the
-     * editor is mounted. Called with `null` on unmount.
-     */
-    onEditorApiChange?: (api: SlidewiseFileEditorApi | null) => void;
-    theme?: "light" | "dark";
-    className?: string;
-    style?: CSSProperties;
-    /**
-     * Optional override for how the file is parsed. Default uses Slidewise's
-     * built-in PPTX parser. Useful for testing or for hosting a different
-     * binary deck format on top of the editor.
-     */
-    parse?: (blob: Blob | ArrayBuffer) => Promise<Deck>;
-    /**
-     * Optional override for how the file is serialized. Default uses
-     * Slidewise's built-in PPTX writer.
-     */
-    serialize?: (deck: Deck) => Promise<Blob>;
-}
-export interface SlidewiseFileEditorApi {
-    save(): Promise<void>;
-    isDirty(): boolean;
-    play(): void;
-    stop(): void;
-    undo(): void;
-    redo(): void;
-    getInitialSha256(): string | null;
-}
-export declare const SlidewiseFileEditor: import("react").ForwardRefExoticComponent<SlidewiseFileEditorProps & import("react").RefAttributes<SlidewiseFileEditorApi>>;
-export default SlidewiseFileEditor;

package/dist/types/components/editor/BottomToolbar.d.ts

@@ -1 +0,0 @@
-export declare function BottomToolbar(): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/editor/Canvas.d.ts

@@ -1 +0,0 @@
-export declare function Canvas(): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/editor/Editor.d.ts

@@ -1,8 +0,0 @@
-import type { Deck } from "@/lib/types";
-interface EditorProps {
-    showTopBar?: boolean;
-    onSave?: (deck: Deck) => void | Promise<void>;
-    onExport?: (deck: Deck) => void;
-}
-export declare function Editor({ showTopBar, onSave, onExport }?: EditorProps): import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/types/components/editor/ElementView.d.ts

@@ -1,6 +0,0 @@
-import type { SlideElement, TextRun } from "@/lib/types";
-export declare function ElementView({ el, editing, onTextCommit, }: {
-    el: SlideElement;
-    editing?: boolean;
-    onTextCommit?: (text: string, runs?: TextRun[]) => void;
-}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/editor/FloatingToolbar.d.ts

@@ -1,6 +0,0 @@
-import type { SlideElement } from "@/lib/types";
-export declare function FloatingToolbar({ element, scale, surfaceRef, }: {
-    element: SlideElement;
-    scale: number;
-    surfaceRef: React.RefObject<HTMLDivElement | null>;
-}): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/editor/GridView.d.ts

@@ -1 +0,0 @@
-export declare function GridView(): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/editor/PlayMode.d.ts

@@ -1 +0,0 @@
-export declare function PlayMode(): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/editor/SelectionFrame.d.ts

@@ -1,8 +0,0 @@
-import type { SlideElement } from "@/lib/types";
-export declare function SelectionFrame({ el, scale, editing, onChange, onCommitStart, }: {
-    el: SlideElement;
-    scale: number;
-    editing?: boolean;
-    onChange: (patch: Partial<SlideElement>) => void;
-    onCommitStart: () => void;
-}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/editor/SlideRail.d.ts

@@ -1 +0,0 @@
-export declare function SlideRail(): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/editor/SlideView.d.ts

@@ -1,5 +0,0 @@
-import type { Slide } from "@/lib/types";
-export declare function SlideView({ slide, scale, }: {
-    slide: Slide;
-    scale?: number;
-}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/editor/TopBar.d.ts

@@ -1,7 +0,0 @@
-import type { Deck } from "@/lib/types";
-interface TopBarProps {
-    onSave?: (deck: Deck) => void | Promise<void>;
-    onExport?: (deck: Deck) => void;
-}
-export declare function TopBar({ onSave: onSaveProp, onExport: onExportProp }?: TopBarProps): import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/types/index.d.ts

@@ -1,7 +0,0 @@
-export { SlidewiseEditor, type SlidewiseEditorProps, type SlidewiseEditorHandle, } from "./SlidewiseEditor";
-export { SlidewiseFileEditor, type SlidewiseFileEditorProps, type SlidewiseFileEditorApi, } from "./SlidewiseFileEditor";
-export { parsePptx, serializeDeck } from "./lib/pptx";
-export type { ParseDiagnostics, ParseResult } from "./lib/pptx/types";
-export { migrate, CURRENT_DECK_VERSION } from "./lib/schema/migrate";
-export type { Deck, Slide, SlideElement, ElementType, EnterAnim, BaseElement, TextElement, ShapeElement, ShapeKind, ImageElement, LineElement, TableElement, IconElement, EmbedElement, UnknownElement, ElementDraft, } from "./lib/types";
-export { SLIDE_W, SLIDE_H } from "./lib/types";

package/dist/types/lib/StoreProvider.d.ts

@@ -1,8 +0,0 @@
-import { type PropsWithChildren } from "react";
-import { type EditorState, type EditorStore } from "./store";
-import type { Deck } from "./types";
-export declare function EditorStoreProvider({ initialDeck, children, }: PropsWithChildren<{
-    initialDeck: Deck;
-}>): import("react/jsx-runtime").JSX.Element;
-export declare function useEditorStore(): EditorStore;
-export declare function useEditor<T>(selector: (s: EditorState) => T): T;

package/dist/types/lib/fonts.d.ts

@@ -1,9 +0,0 @@
-import type { Deck } from "@/lib/types";
-export declare function collectFontFamilies(deck: Deck): string[];
-export declare function buildGoogleFontsHref(families: string[]): string | null;
-/**
- * Inject a <link rel="stylesheet"> for the given families. Idempotent per
- * `instanceId` — calling again with a different family set replaces the
- * previous link. Returns a disposer.
- */
-export declare function ensureGoogleFontsLoaded(instanceId: string, families: string[]): () => void;

package/dist/types/lib/pptx/deckToPptx.d.ts

@@ -1,9 +0,0 @@
-import type { Deck } from "@/lib/types";
-/**
- * Serialize a Slidewise Deck to a real PPTX blob. Round-trips well for the
- * element types Slidewise natively supports (text, shape, image, line,
- * table, icon, embed). UnknownElement and entrance animations are dropped
- * with a warning — proper preservation requires bypassing pptxgenjs and
- * is out of scope for v1.
- */
-export declare function serializeDeck(deck: Deck): Promise<Blob>;

package/dist/types/lib/pptx/index.d.ts

@@ -1,3 +0,0 @@
-export { parsePptx } from "./pptxToDeck";
-export { serializeDeck } from "./deckToPptx";
-export type { ParseDiagnostics, ParseResult } from "./types";