@fieldnotes/core 0.44.0 → 0.46.0

package/dist/index.cjs

@@ -29,9 +29,12 @@ __export(index_exports, {
   HandTool: () => HandTool,
   HistoryStack: () => HistoryStack,
   ImageTool: () => ImageTool,
+  IndexedDBAdapter: () => IndexedDBAdapter,
   LaserTool: () => LaserTool,
   LayerManager: () => LayerManager,
+  LocalStorageAdapter: () => LocalStorageAdapter,
   MeasureTool: () => MeasureTool,
+  MemoryAdapter: () => MemoryAdapter,
   NoteTool: () => NoteTool,
   PencilTool: () => PencilTool,
   SelectTool: () => SelectTool,
@@ -368,6 +371,22 @@ function migrateElement(obj) {
   }
 }
 
+// src/core/storage/local-storage-adapter.ts
+var LocalStorageAdapter = class {
+  async load(key) {
+    if (typeof localStorage === "undefined") return null;
+    return localStorage.getItem(key);
+  }
+  async save(key, value) {
+    if (typeof localStorage === "undefined") return;
+    localStorage.setItem(key, value);
+  }
+  async clear(key) {
+    if (typeof localStorage === "undefined") return;
+    localStorage.removeItem(key);
+  }
+};
+
 // src/core/auto-save.ts
 var DEFAULT_KEY = "fieldnotes-autosave";
 var DEFAULT_DEBOUNCE_MS = 1e3;
@@ -378,14 +397,18 @@ var AutoSave = class {
     this.key = options.key ?? DEFAULT_KEY;
     this.debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
     this.layerManager = options.layerManager;
+    this.adapter = options.adapter ?? new LocalStorageAdapter();
     this.onError = options.onError;
   }
   key;
   debounceMs;
   layerManager;
+  adapter;
   timerId = null;
   unsubscribers = [];
   onError;
+  saving = false;
+  pendingSave = false;
   start() {
     const schedule = () => this.scheduleSave();
     this.unsubscribers = [
@@ -403,9 +426,8 @@ var AutoSave = class {
     this.unsubscribers.forEach((fn) => fn());
     this.unsubscribers = [];
   }
-  load() {
-    if (typeof localStorage === "undefined") return null;
-    const json = localStorage.getItem(this.key);
+  async load() {
+    const json = await this.adapter.load(this.key);
     if (!json) return null;
     try {
       return parseState(json);
@@ -413,13 +435,12 @@ var AutoSave = class {
       return null;
     }
   }
-  clear() {
-    if (typeof localStorage === "undefined") return;
-    localStorage.removeItem(this.key);
+  async clear() {
+    await this.adapter.clear(this.key);
   }
   scheduleSave() {
     this.cancelPending();
-    this.timerId = setTimeout(() => this.save(), this.debounceMs);
+    this.timerId = setTimeout(() => void this.save(), this.debounceMs);
   }
   cancelPending() {
     if (this.timerId !== null) {
@@ -427,19 +448,108 @@ var AutoSave = class {
       this.timerId = null;
     }
   }
-  save() {
-    if (typeof localStorage === "undefined") return;
-    const layers = this.layerManager?.snapshot() ?? [];
-    const state = exportState(this.store.snapshot(), this.camera, layers);
+  async save() {
+    if (this.saving) {
+      this.pendingSave = true;
+      return;
+    }
+    this.saving = true;
     try {
-      localStorage.setItem(this.key, JSON.stringify(state));
+      const layers = this.layerManager?.snapshot() ?? [];
+      const state = exportState(this.store.snapshot(), this.camera, layers);
+      await this.adapter.save(this.key, JSON.stringify(state));
     } catch (e) {
-      console.warn("Auto-save failed: storage quota exceeded. State too large for localStorage.");
       this.onError?.(e instanceof Error ? e : new Error(String(e)));
+    } finally {
+      this.saving = false;
+      if (this.pendingSave) {
+        this.pendingSave = false;
+        void this.save();
+      }
     }
   }
 };
 
+// src/core/storage/memory-adapter.ts
+var MemoryAdapter = class {
+  store = /* @__PURE__ */ new Map();
+  async load(key) {
+    return this.store.get(key) ?? null;
+  }
+  async save(key, value) {
+    this.store.set(key, value);
+  }
+  async clear(key) {
+    this.store.delete(key);
+  }
+};
+
+// src/core/storage/indexeddb-adapter.ts
+var DEFAULT_DB = "fieldnotes";
+var DEFAULT_STORE = "state";
+var IndexedDBAdapter = class {
+  dbName;
+  storeName;
+  idb;
+  dbPromise = null;
+  constructor(options = {}) {
+    this.dbName = options.dbName ?? DEFAULT_DB;
+    this.storeName = options.storeName ?? DEFAULT_STORE;
+    this.idb = options.indexedDB ?? (typeof indexedDB !== "undefined" ? indexedDB : null);
+  }
+  open() {
+    const idb = this.idb;
+    if (!idb) return Promise.reject(new Error("IndexedDB unavailable"));
+    if (!this.dbPromise) {
+      const storeName = this.storeName;
+      this.dbPromise = new Promise((resolve, reject) => {
+        const req = idb.open(this.dbName, 1);
+        req.onupgradeneeded = () => {
+          const db = req.result;
+          if (!db.objectStoreNames.contains(storeName)) db.createObjectStore(storeName);
+        };
+        req.onsuccess = () => resolve(req.result);
+        req.onerror = () => reject(req.error ?? new Error("IndexedDB open failed"));
+      });
+    }
+    return this.dbPromise;
+  }
+  async load(key) {
+    if (!this.idb) return null;
+    const db = await this.open();
+    return new Promise((resolve, reject) => {
+      const req = db.transaction(this.storeName, "readonly").objectStore(this.storeName).get(key);
+      req.onsuccess = () => {
+        const v = req.result;
+        resolve(typeof v === "string" ? v : null);
+      };
+      req.onerror = () => reject(req.error ?? new Error("IndexedDB read failed"));
+    });
+  }
+  async save(key, value) {
+    if (!this.idb) return;
+    const db = await this.open();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.storeName, "readwrite");
+      tx.objectStore(this.storeName).put(value, key);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error ?? new Error("IndexedDB write failed"));
+      tx.onabort = () => reject(tx.error ?? new Error("IndexedDB write aborted"));
+    });
+  }
+  async clear(key) {
+    if (!this.idb) return;
+    const db = await this.open();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.storeName, "readwrite");
+      tx.objectStore(this.storeName).delete(key);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error ?? new Error("IndexedDB delete failed"));
+      tx.onabort = () => reject(tx.error ?? new Error("IndexedDB delete aborted"));
+    });
+  }
+};
+
 // src/canvas/camera.ts
 var DEFAULT_MIN_ZOOM = 0.1;
 var DEFAULT_MAX_ZOOM = 10;
@@ -2122,6 +2232,7 @@ var Background = class {
 };
 
 // src/core/event-bus.ts
+var EMPTY_META = Object.freeze({});
 var EventBus = class {
   listeners = /* @__PURE__ */ new Map();
   on(event, listener) {
@@ -2137,10 +2248,10 @@ var EventBus = class {
   off(event, listener) {
     this.listeners.get(event)?.delete(listener);
   }
-  emit(event, data) {
+  emit(event, data, meta = EMPTY_META) {
     this.listeners.get(event)?.forEach((listener) => {
       try {
-        listener(data);
+        listener(data, meta);
       } catch (err) {
         console.error(`[fieldnotes] listener error for "${String(event)}"`, err);
       }
@@ -2460,15 +2571,15 @@ var ElementStore = class {
     const angle = element.rotation ?? 0;
     return angle === 0 ? bounds : rotatedAABB(bounds, angle);
   }
-  add(element) {
+  add(element, meta) {
     this.sortedCache = null;
     this._versions.set(element.id, 0);
     this.elements.set(element.id, element);
     const bounds = this.indexBounds(element);
     if (bounds) this.spatialIndex.insert(element.id, bounds);
-    this.bus.emit("add", element);
+    this.bus.emit("add", element, meta);
   }
-  update(id, partial) {
+  update(id, partial, meta) {
     const existing = this.elements.get(id);
     if (!existing) return;
     this.sortedCache = null;
@@ -2495,28 +2606,28 @@ var ElementStore = class {
     if (newBounds) {
       this.spatialIndex.update(id, newBounds);
     }
-    this.bus.emit("update", { previous: existing, current: updated });
+    this.bus.emit("update", { previous: existing, current: updated }, meta);
   }
-  remove(id) {
+  remove(id, meta) {
     const element = this.elements.get(id);
     if (!element) return;
     this.sortedCache = null;
     this._versions.delete(id);
     this.elements.delete(id);
     this.spatialIndex.remove(id);
-    this.bus.emit("remove", element);
+    this.bus.emit("remove", element, meta);
   }
-  clear() {
+  clear(meta) {
     this.sortedCache = null;
     this._versions.clear();
     this.elements.clear();
     this.spatialIndex.clear();
-    this.bus.emit("clear", null);
+    this.bus.emit("clear", null, meta);
   }
   snapshot() {
     return this.getAll().map((el) => ({ ...el }));
   }
-  loadSnapshot(elements) {
+  loadSnapshot(elements, meta) {
     this.sortedCache = null;
     this._versions.clear();
     this.elements.clear();
@@ -2533,9 +2644,9 @@ var ElementStore = class {
         el.cachedControlPoint = getArrowControlPoint(el.from, el.to, el.bend);
       }
     }
-    this.bus.emit("clear", null);
+    this.bus.emit("clear", null, meta);
     for (const el of elements) {
-      this.bus.emit("add", el);
+      this.bus.emit("add", el, meta);
     }
   }
   bringToFront(id) {
@@ -4810,15 +4921,18 @@ var UpdateLayerCommand = class {
 };
 
 // src/history/history-recorder.ts
+function isExternalChange(meta) {
+  return meta.origin !== void 0 && meta.origin !== "local";
+}
 var HistoryRecorder = class {
   constructor(store, stack, layerManager) {
     this.store = store;
     this.stack = stack;
     this.layerManager = layerManager;
     this.unsubscribers = [
-      store.on("add", (el) => this.onAdd(el)),
-      store.on("remove", (el) => this.onRemove(el)),
-      store.on("update", ({ previous, current }) => this.onUpdate(previous, current))
+      store.on("add", (el, meta) => this.onAdd(el, meta)),
+      store.on("remove", (el, meta) => this.onRemove(el, meta)),
+      store.on("update", ({ previous, current }, meta) => this.onUpdate(previous, current, meta))
     ];
     if (layerManager) {
       this.unsubscribers.push(
@@ -4874,18 +4988,21 @@ var HistoryRecorder = class {
       this.stack.push(command);
     }
   }
-  onAdd(element) {
+  onAdd(element, meta) {
+    if (isExternalChange(meta)) return;
     if (!this.recording) return;
     this.record(new AddElementCommand(element));
   }
-  onRemove(element) {
+  onRemove(element, meta) {
+    if (isExternalChange(meta)) return;
     if (!this.recording) return;
     if (this.transaction && this.updateSnapshots.has(element.id)) {
       this.updateSnapshots.delete(element.id);
     }
     this.record(new RemoveElementCommand(element));
   }
-  onUpdate(previous, current) {
+  onUpdate(previous, current, meta) {
+    if (isExternalChange(meta)) return;
     if (!this.recording) return;
     if (this.transaction) {
       if (!this.updateSnapshots.has(current.id)) {
@@ -10057,7 +10174,7 @@ var LaserTool = class {
 };
 
 // src/index.ts
-var VERSION = "0.44.0";
+var VERSION = "0.46.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ArrowTool,
@@ -10069,9 +10186,12 @@ var VERSION = "0.44.0";
   HandTool,
   HistoryStack,
   ImageTool,
+  IndexedDBAdapter,
   LaserTool,
   LayerManager,
+  LocalStorageAdapter,
   MeasureTool,
+  MemoryAdapter,
   NoteTool,
   PencilTool,
   SelectTool,