@hyperframes/studio 0.8.75 → 0.8.77

package/src/utils/editHistory.ts

@@ -1,236 +0,0 @@
-export type EditHistoryKind = "manual" | "motion" | "timeline" | "source";
-
-export interface EditHistoryFileSnapshot {
-  before: string;
-  after: string;
-  beforeHash: string;
-  afterHash: string;
-}
-
-export interface EditHistoryEntry {
-  id: string;
-  projectId: string;
-  label: string;
-  kind: EditHistoryKind;
-  coalesceKey?: string;
-  /** Per-entry coalesce window override (ms). Falls back to the reducer default. */
-  coalesceMs?: number;
-  createdAt: number;
-  files: Record<string, EditHistoryFileSnapshot>;
-}
-
-export interface EditHistoryState {
-  version: 1;
-  updatedAt: number;
-  undo: EditHistoryEntry[];
-  redo: EditHistoryEntry[];
-}
-
-export interface EditHistoryOptions {
-  maxEntries?: number;
-  coalesceMs?: number;
-}
-
-export interface BuildEditHistoryEntryInput {
-  id: string;
-  projectId: string;
-  label: string;
-  kind?: EditHistoryKind;
-  coalesceKey?: string;
-  coalesceMs?: number;
-  now: number;
-  files: Record<string, { before: string; after: string }>;
-}
-
-export type EditHistoryDirection = "undo" | "redo";
-
-export type EditHistoryApplyCheck =
-  | { ok: true }
-  | { ok: false; reason: "content-mismatch"; path: string };
-
-export type EditHistoryTransitionResult =
-  | {
-      ok: true;
-      state: EditHistoryState;
-      entry: EditHistoryEntry;
-      filesToWrite: Record<string, string>;
-    }
-  | {
-      ok: false;
-      reason: "empty" | "content-mismatch";
-      state: EditHistoryState;
-      filesToWrite: Record<string, string>;
-      path?: string;
-    };
-
-const DEFAULT_MAX_ENTRIES = 100;
-const DEFAULT_COALESCE_MS = 300;
-
-export function hashEditHistoryContent(content: string): string {
-  let hash = 2166136261;
-  for (let index = 0; index < content.length; index += 1) {
-    hash ^= content.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-
-export function createEmptyEditHistory(_options?: EditHistoryOptions): EditHistoryState {
-  return {
-    version: 1,
-    updatedAt: 0,
-    undo: [],
-    redo: [],
-  };
-}
-
-export function buildEditHistoryEntry(input: BuildEditHistoryEntryInput): EditHistoryEntry {
-  const files: Record<string, EditHistoryFileSnapshot> = {};
-  for (const [path, snapshot] of Object.entries(input.files)) {
-    if (snapshot.before === snapshot.after) continue;
-    files[path] = {
-      before: snapshot.before,
-      after: snapshot.after,
-      beforeHash: hashEditHistoryContent(snapshot.before),
-      afterHash: hashEditHistoryContent(snapshot.after),
-    };
-  }
-
-  return {
-    id: input.id,
-    projectId: input.projectId,
-    label: input.label,
-    kind: input.kind ?? "manual",
-    coalesceKey: input.coalesceKey,
-    coalesceMs: input.coalesceMs,
-    createdAt: input.now,
-    files,
-  };
-}
-
-export function pushEditHistoryEntry(
-  state: EditHistoryState,
-  entry: EditHistoryEntry,
-  options?: EditHistoryOptions,
-): EditHistoryState {
-  if (Object.keys(entry.files).length === 0) return state;
-
-  // The incoming entry's own window wins so a caller can guarantee a merge even when a
-  // slow async step (e.g. a server GSAP rewrite) sits between the two records.
-  const coalesceMs = entry.coalesceMs ?? options?.coalesceMs ?? DEFAULT_COALESCE_MS;
-  const maxEntries = options?.maxEntries ?? DEFAULT_MAX_ENTRIES;
-  const previous = state.undo[state.undo.length - 1];
-  let undo = state.undo;
-
-  if (
-    previous &&
-    previous.coalesceKey &&
-    previous.coalesceKey === entry.coalesceKey &&
-    entry.createdAt - previous.createdAt <= coalesceMs &&
-    // A shared key/window is not enough: bytes from an external writer may
-    // have landed between the two Studio-owned edits. Only fold a path when
-    // the follow-up starts from the exact output the previous entry recorded.
-    // Otherwise keep both entries so undo restores the foreign bytes first and
-    // the older entry's content check safely blocks at that ownership boundary.
-    Object.entries(entry.files).every(([path, snapshot]) => {
-      const previousSnapshot = previous.files[path];
-      return !previousSnapshot || previousSnapshot.after === snapshot.before;
-    })
-  ) {
-    // A follow-up may touch only a subset of the files in the original edit
-    // (for example, only one file in a multi-file timing move has GSAP). Keep
-    // previous-only paths in the single coalesced undo entry.
-    const files: Record<string, EditHistoryFileSnapshot> = { ...previous.files };
-    for (const [path, snapshot] of Object.entries(entry.files)) {
-      const previousSnapshot = previous.files[path];
-      files[path] = previousSnapshot
-        ? {
-            before: previousSnapshot.before,
-            after: snapshot.after,
-            beforeHash: previousSnapshot.beforeHash,
-            afterHash: snapshot.afterHash,
-          }
-        : snapshot;
-    }
-    undo = [...state.undo.slice(0, -1), { ...entry, files }];
-  } else {
-    undo = [...state.undo, entry];
-  }
-
-  return {
-    version: 1,
-    updatedAt: entry.createdAt,
-    undo: undo.slice(Math.max(0, undo.length - maxEntries)),
-    redo: [],
-  };
-}
-
-export function canApplyEditHistoryEntry(
-  entry: EditHistoryEntry,
-  direction: EditHistoryDirection,
-  currentHashes: Record<string, string>,
-): EditHistoryApplyCheck {
-  for (const [path, snapshot] of Object.entries(entry.files)) {
-    const expected = direction === "undo" ? snapshot.afterHash : snapshot.beforeHash;
-    if (currentHashes[path] !== expected) {
-      return { ok: false, reason: "content-mismatch", path };
-    }
-  }
-  return { ok: true };
-}
-
-export function undoEditHistory(
-  state: EditHistoryState,
-  currentHashes: Record<string, string>,
-  now: number,
-): EditHistoryTransitionResult {
-  const entry = state.undo[state.undo.length - 1];
-  if (!entry) return { ok: false, reason: "empty", state, filesToWrite: {} };
-
-  const check = canApplyEditHistoryEntry(entry, "undo", currentHashes);
-  if (!check.ok) {
-    return { ok: false, reason: check.reason, path: check.path, state, filesToWrite: {} };
-  }
-
-  return {
-    ok: true,
-    entry,
-    filesToWrite: Object.fromEntries(
-      Object.entries(entry.files).map(([path, snapshot]) => [path, snapshot.before]),
-    ),
-    state: {
-      version: 1,
-      updatedAt: now,
-      undo: state.undo.slice(0, -1),
-      redo: [...state.redo, entry],
-    },
-  };
-}
-
-export function redoEditHistory(
-  state: EditHistoryState,
-  currentHashes: Record<string, string>,
-  now: number,
-): EditHistoryTransitionResult {
-  const entry = state.redo[state.redo.length - 1];
-  if (!entry) return { ok: false, reason: "empty", state, filesToWrite: {} };
-
-  const check = canApplyEditHistoryEntry(entry, "redo", currentHashes);
-  if (!check.ok) {
-    return { ok: false, reason: check.reason, path: check.path, state, filesToWrite: {} };
-  }
-
-  return {
-    ok: true,
-    entry,
-    filesToWrite: Object.fromEntries(
-      Object.entries(entry.files).map(([path, snapshot]) => [path, snapshot.after]),
-    ),
-    state: {
-      version: 1,
-      updatedAt: now,
-      undo: [...state.undo, entry],
-      redo: state.redo.slice(0, -1),
-    },
-  };
-}

package/src/utils/editHistoryStorage.test.ts

@@ -1,37 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import { buildEditHistoryEntry, createEmptyEditHistory, pushEditHistoryEntry } from "./editHistory";
-import {
-  createMemoryEditHistoryStorage,
-  loadEditHistoryState,
-  saveEditHistoryState,
-} from "./editHistoryStorage";
-
-describe("edit history storage", () => {
-  let storage: ReturnType<typeof createMemoryEditHistoryStorage>;
-
-  beforeEach(() => {
-    storage = createMemoryEditHistoryStorage();
-  });
-
-  it("returns empty history for projects without persisted state", async () => {
-    const state = await loadEditHistoryState(storage, "project-1");
-
-    expect(state).toEqual(createEmptyEditHistory());
-  });
-
-  it("saves and loads history per project", async () => {
-    const entry = buildEditHistoryEntry({
-      id: "entry-1",
-      projectId: "project-1",
-      label: "Move layer",
-      files: { "index.html": { before: "a", after: "b" } },
-      now: 100,
-    });
-    const state = pushEditHistoryEntry(createEmptyEditHistory(), entry);
-
-    await saveEditHistoryState(storage, "project-1", state);
-
-    expect(await loadEditHistoryState(storage, "project-1")).toEqual(state);
-    expect(await loadEditHistoryState(storage, "project-2")).toEqual(createEmptyEditHistory());
-  });
-});

package/src/utils/editHistoryStorage.ts

@@ -1,99 +0,0 @@
-import { createEmptyEditHistory, type EditHistoryState } from "./editHistory";
-
-export interface EditHistoryStorageAdapter {
-  get(projectId: string): Promise<EditHistoryState | null>;
-  set(projectId: string, state: EditHistoryState): Promise<void>;
-  delete(projectId: string): Promise<void>;
-}
-
-const DB_NAME = "hyperframes-studio-edit-history";
-const DB_VERSION = 1;
-const STORE_NAME = "project-history";
-
-export function createMemoryEditHistoryStorage(): EditHistoryStorageAdapter {
-  const states = new Map<string, EditHistoryState>();
-  return {
-    async get(projectId) {
-      return states.get(projectId) ?? null;
-    },
-    async set(projectId, state) {
-      states.set(projectId, structuredClone(state));
-    },
-    async delete(projectId) {
-      states.delete(projectId);
-    },
-  };
-}
-
-function openEditHistoryDb(): Promise<IDBDatabase> {
-  return new Promise((resolve, reject) => {
-    if (!globalThis.indexedDB) {
-      reject(new Error("IndexedDB is not available"));
-      return;
-    }
-
-    const request = globalThis.indexedDB.open(DB_NAME, DB_VERSION);
-    request.onupgradeneeded = () => {
-      const db = request.result;
-      if (!db.objectStoreNames.contains(STORE_NAME)) {
-        db.createObjectStore(STORE_NAME);
-      }
-    };
-    request.onerror = () => reject(request.error ?? new Error("Failed to open edit history db"));
-    request.onsuccess = () => resolve(request.result);
-  });
-}
-
-function withStore<T>(
-  mode: IDBTransactionMode,
-  callback: (store: IDBObjectStore) => IDBRequest<T>,
-): Promise<T> {
-  return openEditHistoryDb().then(
-    (db) =>
-      new Promise<T>((resolve, reject) => {
-        const tx = db.transaction(STORE_NAME, mode);
-        const request = callback(tx.objectStore(STORE_NAME));
-        request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed"));
-        request.onsuccess = () => resolve(request.result);
-        tx.oncomplete = () => db.close();
-        tx.onerror = () => {
-          db.close();
-          reject(tx.error ?? new Error("IndexedDB transaction failed"));
-        };
-      }),
-  );
-}
-
-export function createIndexedDbEditHistoryStorage(): EditHistoryStorageAdapter {
-  return {
-    async get(projectId) {
-      return (
-        (await withStore<EditHistoryState | undefined>("readonly", (store) =>
-          store.get(projectId),
-        )) ?? null
-      );
-    },
-    async set(projectId, state) {
-      await withStore<IDBValidKey>("readwrite", (store) => store.put(state, projectId));
-    },
-    async delete(projectId) {
-      await withStore<undefined>("readwrite", (store) => store.delete(projectId));
-    },
-  };
-}
-
-export async function loadEditHistoryState(
-  storage: EditHistoryStorageAdapter,
-  projectId: string,
-): Promise<EditHistoryState> {
-  const state = await storage.get(projectId);
-  return state ?? createEmptyEditHistory();
-}
-
-export async function saveEditHistoryState(
-  storage: EditHistoryStorageAdapter,
-  projectId: string,
-  state: EditHistoryState,
-): Promise<void> {
-  await storage.set(projectId, state);
-}