@arronqzy/react-view 1.0.28 → 1.0.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arronqzy/react-view",
-  "version": "1.0.28",
+  "version": "1.0.29",
   "files": [
     "src",
     "dist",
@@ -31,13 +31,13 @@
     "@codemirror/theme-one-dark": "^6.1.2",
     "@codemirror/view": "^6.36.2",
     "@arronqzy/ui": "1.0.9",
-    "@arronqzy/react-blueprint": "1.0.16",
     "@arronqzy/blueprint-dsl": "1.0.14",
-    "@arronqzy/i18n": "0.1.11",
+    "@arronqzy/i18n": "0.1.12",
+    "@arronqzy/react-blueprint": "1.0.16",
     "@arronqzy/rx-store": "1.0.8",
+    "@arronqzy/view-table": "0.1.8",
     "@arronqzy/view-scene3d": "0.1.5",
-    "@arronqzy/webllm-assistant": "0.1.16",
-    "@arronqzy/view-table": "0.1.8"
+    "@arronqzy/webllm-assistant": "0.1.16"
   },
   "devDependencies": {
     "@types/react": "^19.0.1",
@@ -46,8 +46,8 @@
     "eslint": "^8.57.0",
     "typescript": "^5.5.4",
     "@arronqzy/eslint-config": "0.0.0",
-    "@arronqzy/tailwind": "1.0.2",
-    "@arronqzy/typescript-config": "1.0.0"
+    "@arronqzy/typescript-config": "1.0.0",
+    "@arronqzy/tailwind": "1.0.2"
   },
   "scripts": {
     "lint": "eslint \"src/**/*.{ts,tsx}\"",

package/src/panel/ReactViewPanel.tsx

@@ -1079,11 +1079,18 @@ function ReactViewPanelInner({
   );
 
   const handleWorkspaceCreateProject = useCallback(async () => {
-    const result = await workspaceProjects.handleCreateProject();
-    if (result?.name) {
-      toast({ title: messages.workspaceCreated(result.name) });
+    try {
+      const result = await workspaceProjects.handleCreateProject();
+      if (result?.name) {
+        toast({ title: messages.workspaceCreated(result.name) });
+      }
+      return result;
+    } catch (error) {
+      toast({
+        title: error instanceof Error ? error.message : t("panel.messages.createWorkspaceFailed"),
+      });
+      throw error;
     }
-    return result;
   }, [workspaceProjects]);
 
   const handleWorkspaceOpenProject = useCallback(
@@ -1121,8 +1128,16 @@ function ReactViewPanelInner({
 
   const handleWorkspaceDeleteProject = useCallback(
     async (id: string) => {
-      await workspaceProjects.handleDeleteProject(id);
-      toast({ title: t("panel.messages.workspaceDeleted") });
+      try {
+        await workspaceProjects.handleDeleteProject(id);
+        toast({ title: t("panel.messages.workspaceDeleted") });
+      } catch (error) {
+        toast({
+          title:
+            error instanceof Error ? error.message : t("panel.messages.deleteWorkspaceFailed"),
+        });
+        throw error;
+      }
     },
     [workspaceProjects]
   );

package/src/panel/components/PanelConfigSidebar.tsx

@@ -1,5 +1,6 @@
 import React, {
   useEffect,
+  useLayoutEffect,
   useMemo,
   useRef,
   useState,
@@ -146,6 +147,37 @@ export function PanelConfigSidebar({
     return selectedElement ? [selectedElement] : [];
   }, [selectedElement, selectedElements]);
   const isMultiSelectMode = effectiveSelectedElements.length > 1;
+  const configScrollKey =
+    !isMultiSelectMode && selectedElement ? selectedElement.id : null;
+  const configScrollPosByIdRef = useRef(new Map<string, number>());
+  const activeConfigScrollKeyRef = useRef<string | null>(null);
+
+  useEffect(() => {
+    const el = sidebarScrollRef.current;
+    if (!el) return;
+    const onScroll = () => {
+      const key = activeConfigScrollKeyRef.current;
+      if (!key) return;
+      configScrollPosByIdRef.current.set(key, el.scrollTop);
+    };
+    el.addEventListener("scroll", onScroll, { passive: true });
+    return () => el.removeEventListener("scroll", onScroll);
+  }, []);
+
+  useLayoutEffect(() => {
+    const el = sidebarScrollRef.current;
+    const prevKey = activeConfigScrollKeyRef.current;
+    if (el && prevKey && prevKey !== configScrollKey) {
+      configScrollPosByIdRef.current.set(prevKey, el.scrollTop);
+    }
+    activeConfigScrollKeyRef.current = configScrollKey;
+    if (!el) return;
+    const top =
+      configScrollKey != null
+        ? (configScrollPosByIdRef.current.get(configScrollKey) ?? 0)
+        : 0;
+    el.scrollTop = top;
+  }, [configScrollKey]);
 
   useEffect(() => {
     if (!selectedElement) return;

package/src/panel/constants/messages.ts

@@ -52,7 +52,9 @@ export function getPanelMessages(t: TranslateFn) {
     workspaceLoaded: t("panel.messages.workspaceLoaded"),
     workspaceLoadedDesc: t("panel.messages.workspaceLoadedDesc"),
     openWorkspaceFailed: t("panel.messages.openWorkspaceFailed"),
+    createWorkspaceFailed: t("panel.messages.createWorkspaceFailed"),
     syncFailed: t("panel.messages.syncFailed"),
+    deleteWorkspaceFailed: t("panel.messages.deleteWorkspaceFailed"),
     workspaceDeleted: t("panel.messages.workspaceDeleted"),
     openPreviewFailed: t("panel.messages.openPreviewFailed"),
     clearedBlueprintLogs: (removed: number) =>

package/src/panel/hooks/usePanelElements.ts

@@ -1077,7 +1077,14 @@ export function usePanelElements() {
         /* fall through */
       }
     }
-    return JSON.parse(JSON.stringify(current)) as State;
+    try {
+      return JSON.parse(JSON.stringify(current)) as State;
+    } catch (error) {
+      throw Object.assign(new Error("indexeddb-serialize-failed"), {
+        name: "DataCloneError",
+        cause: error,
+      });
+    }
   }, []);
 
   const importPanelData = useCallback((nextState: State) => {

package/src/panel/hooks/useWorkspaceProjects.ts

@@ -19,6 +19,7 @@ import {
   workspaceSnapshotsEqual,
   type WorkspaceSnapshot,
 } from "../library/workspace-snapshot";
+import { mapWorkspaceStorageError } from "../library/workspace-storage-error";
 import { runBusyTask } from "../utils/async-work";
 import { AbuilderEvents, emitAbuilderEvent } from "../library/event-subscription";
 import { parseBlueprintData } from "@arronqzy/react-blueprint";
@@ -145,8 +146,13 @@ export function useWorkspaceProjects({
   }, [blueprintDocument, blueprintMeta, productName, titleIconDataUrl]);
 
   const refreshProjects = useCallback(async () => {
-    const items = await listWorkspaceProjects(nameSpace);
-    setProjects(items);
+    try {
+      const items = await listWorkspaceProjects(nameSpace);
+      setProjects(items);
+    } catch (error) {
+      // Listing failure should not brick the editor; create/sync still surface errors.
+      console.warn("[abuilder] listWorkspaceProjects failed", error);
+    }
   }, [nameSpace]);
 
   useEffect(() => {
@@ -272,37 +278,58 @@ export function useWorkspaceProjects({
 
   const persistProject = useCallback(
     async (options: { id?: string; name: string; createdAt?: number }) => {
-      const snapshot = cloneWorkspaceSnapshot(buildCurrentSnapshot());
-      const now = Date.now();
-      const id = options.id ?? createWorkspaceProjectId();
-      const createdAt = options.createdAt ?? now;
-      const name = (options.name ?? "").trim() || resolveProjectName();
+      try {
+        const snapshot = cloneWorkspaceSnapshot(buildCurrentSnapshot());
+        const now = Date.now();
+        const id = options.id ?? createWorkspaceProjectId();
+        const createdAt = options.createdAt ?? now;
+        const name = (options.name ?? "").trim() || resolveProjectName();
 
-      const record: WorkspaceProjectRecord = {
-        id,
-        name,
-        createdAt,
-        updatedAt: now,
-        panelState: exportPanelData(),
-        blueprintDocument: snapshot.blueprintDocument,
-        blueprintMeta: snapshot.blueprintMeta,
-        productName:
-          typeof snapshot.productName === "string" ? snapshot.productName : resolveProjectName(),
-        titleIconDataUrl: snapshot.titleIconDataUrl || undefined,
-      };
+        let panelState: State;
+        try {
+          panelState = exportPanelData();
+        } catch (error) {
+          throw mapWorkspaceStorageError(error, t);
+        }
 
-      await putWorkspaceProject(record, nameSpace);
-      writeWorkspacePreviewCache(record, nameSpace);
-      broadcastWorkspaceProjectUpdate(id, now, nameSpace);
-      setActiveProjectId(id);
-      setActiveProjectName(name);
-      syncedSnapshotRef.current = snapshot;
-      syncedPanelRevisionRef.current = panelRevision;
-      pendingRevisionSyncRef.current = false;
-      await refreshProjects();
-      return record;
+        const record: WorkspaceProjectRecord = {
+          id,
+          name,
+          createdAt,
+          updatedAt: now,
+          panelState,
+          blueprintDocument: snapshot.blueprintDocument,
+          blueprintMeta: snapshot.blueprintMeta,
+          productName:
+            typeof snapshot.productName === "string"
+              ? snapshot.productName
+              : resolveProjectName(),
+          titleIconDataUrl: snapshot.titleIconDataUrl || undefined,
+        };
+
+        await putWorkspaceProject(record, nameSpace);
+        writeWorkspacePreviewCache(record, nameSpace);
+        broadcastWorkspaceProjectUpdate(id, now, nameSpace);
+        setActiveProjectId(id);
+        setActiveProjectName(name);
+        syncedSnapshotRef.current = snapshot;
+        syncedPanelRevisionRef.current = panelRevision;
+        pendingRevisionSyncRef.current = false;
+        await refreshProjects();
+        return record;
+      } catch (error) {
+        throw mapWorkspaceStorageError(error, t);
+      }
     },
-    [buildCurrentSnapshot, exportPanelData, nameSpace, panelRevision, resolveProjectName, refreshProjects]
+    [
+      buildCurrentSnapshot,
+      exportPanelData,
+      nameSpace,
+      panelRevision,
+      resolveProjectName,
+      refreshProjects,
+      t,
+    ]
   );
 
   const handleCreateProject = useCallback(async () => {
@@ -332,14 +359,18 @@ export function useWorkspaceProjects({
 
   const handleOpenProject = useCallback(
     async (id: string) => {
-      await runBusyTask(t("common.loadingWorkspace"), async () => {
-        const record = await getWorkspaceProject(id, nameSpace);
-        if (!record) {
-          await refreshProjects();
-          throw new Error(t("panel.messages.workspaceNotFound"));
-        }
-        applyProjectRecord(record);
-      });
+      try {
+        await runBusyTask(t("common.loadingWorkspace"), async () => {
+          const record = await getWorkspaceProject(id, nameSpace);
+          if (!record) {
+            await refreshProjects();
+            throw new Error(t("panel.messages.workspaceNotFound"));
+          }
+          applyProjectRecord(record);
+        });
+      } catch (error) {
+        throw mapWorkspaceStorageError(error, t);
+      }
     },
     [applyProjectRecord, nameSpace, refreshProjects, t]
   );
@@ -370,17 +401,21 @@ export function useWorkspaceProjects({
 
   const handleDeleteProject = useCallback(
     async (id: string) => {
-      await runBusyTask(t("common.deletingWorkspace"), async () => {
-        await deleteWorkspaceProject(id, nameSpace);
-        if (activeProjectId === id) {
-          setActiveProjectId(null);
-          setActiveProjectName(null);
-          syncedSnapshotRef.current = null;
-        }
-        previewWindowsRef.current.delete(id);
-        refreshPreviewing();
-        await refreshProjects();
-      });
+      try {
+        await runBusyTask(t("common.deletingWorkspace"), async () => {
+          await deleteWorkspaceProject(id, nameSpace);
+          if (activeProjectId === id) {
+            setActiveProjectId(null);
+            setActiveProjectName(null);
+            syncedSnapshotRef.current = null;
+          }
+          previewWindowsRef.current.delete(id);
+          refreshPreviewing();
+          await refreshProjects();
+        });
+      } catch (error) {
+        throw mapWorkspaceStorageError(error, t);
+      }
     },
     [activeProjectId, nameSpace, refreshPreviewing, refreshProjects, t]
   );

package/src/panel/library/workspace-project-db.ts

@@ -6,6 +6,7 @@ import { appStorageKey } from "@arronqzy/blueprint-dsl";
 const DB_NAME = "arronqzy-workspace-projects";
 const DB_VERSION = 1;
 const STORE_NAME = "projects";
+const OPEN_TIMEOUT_MS = 10_000;
 
 export type WorkspaceProjectListItem = {
   id: string;
@@ -26,10 +27,77 @@ export type WorkspaceProjectRecord = {
   titleIconDataUrl?: string;
 };
 
+const dbPromises = new Map<string, Promise<IDBDatabase>>();
+
+function getIndexedDb(): IDBFactory {
+  if (typeof indexedDB === "undefined" || !indexedDB) {
+    throw Object.assign(new Error("indexeddb-unavailable"), {
+      name: "IndexedDbUnavailable",
+    });
+  }
+  return indexedDB;
+}
+
+/** Make a value safe for IndexedDB structured clone (drops non-cloneable fields). */
+export function cloneForIndexedDb<T>(value: T): T {
+  if (typeof structuredClone === "function") {
+    try {
+      return structuredClone(value);
+    } catch {
+      /* fall through to JSON */
+    }
+  }
+  try {
+    return JSON.parse(JSON.stringify(value)) as T;
+  } catch (error) {
+    throw Object.assign(new Error("indexeddb-serialize-failed"), {
+      name: "DataCloneError",
+      cause: error,
+    });
+  }
+}
+
 function openDb(nameSpace?: string | null): Promise<IDBDatabase> {
-  return new Promise((resolve, reject) => {
-    const request = indexedDB.open(appStorageKey(DB_NAME, nameSpace), DB_VERSION);
-    request.onerror = () => reject(request.error ?? new Error("indexeddb-open-failed"));
+  const key = appStorageKey(DB_NAME, nameSpace);
+  const cached = dbPromises.get(key);
+  if (cached) return cached;
+
+  const promise = new Promise<IDBDatabase>((resolve, reject) => {
+    let settled = false;
+    const fail = (error: unknown) => {
+      if (settled) return;
+      settled = true;
+      dbPromises.delete(key);
+      reject(
+        error instanceof Error
+          ? error
+          : Object.assign(new Error("indexeddb-open-failed"), { cause: error })
+      );
+    };
+
+    let request: IDBOpenDBRequest;
+    try {
+      request = getIndexedDb().open(key, DB_VERSION);
+    } catch (error) {
+      fail(error);
+      return;
+    }
+
+    const timer = setTimeout(() => {
+      fail(
+        Object.assign(new Error("indexeddb-open-timeout"), {
+          name: "TimeoutError",
+        })
+      );
+    }, OPEN_TIMEOUT_MS);
+
+    request.onerror = () => {
+      clearTimeout(timer);
+      fail(request.error ?? new Error("indexeddb-open-failed"));
+    };
+    request.onblocked = () => {
+      // Wait for onsuccess / timeout; another tab may be holding an older connection.
+    };
     request.onupgradeneeded = () => {
       const db = request.result;
       if (!db.objectStoreNames.contains(STORE_NAME)) {
@@ -37,8 +105,35 @@ function openDb(nameSpace?: string | null): Promise<IDBDatabase> {
         store.createIndex("updatedAt", "updatedAt", { unique: false });
       }
     };
-    request.onsuccess = () => resolve(request.result);
+    request.onsuccess = () => {
+      clearTimeout(timer);
+      if (settled) {
+        try {
+          request.result.close();
+        } catch {
+          /* ignore */
+        }
+        return;
+      }
+      settled = true;
+      const db = request.result;
+      db.onversionchange = () => {
+        try {
+          db.close();
+        } catch {
+          /* ignore */
+        }
+        dbPromises.delete(key);
+      };
+      db.onclose = () => {
+        dbPromises.delete(key);
+      };
+      resolve(db);
+    };
   });
+
+  dbPromises.set(key, promise);
+  return promise;
 }
 
 function runTransaction<T>(
@@ -49,27 +144,76 @@ function runTransaction<T>(
   return openDb(nameSpace).then(
     (db) =>
       new Promise<T>((resolve, reject) => {
-        const tx = db.transaction(STORE_NAME, mode);
+        let tx: IDBTransaction;
+        try {
+          tx = db.transaction(STORE_NAME, mode);
+        } catch (error) {
+          // Stale connection (e.g. Safari closed it); reopen once.
+          dbPromises.delete(appStorageKey(DB_NAME, nameSpace));
+          reject(error);
+          return;
+        }
         const store = tx.objectStore(STORE_NAME);
         const request = runner(store);
         let result!: T;
+        let settled = false;
+
+        const fail = (error: unknown) => {
+          if (settled) return;
+          settled = true;
+          reject(
+            error instanceof Error
+              ? error
+              : Object.assign(new Error("indexeddb-transaction-failed"), {
+                  cause: error,
+                })
+          );
+        };
 
         request.onerror = () =>
-          reject(request.error ?? new Error("indexeddb-request-failed"));
+          fail(request.error ?? new Error("indexeddb-request-failed"));
         request.onsuccess = () => {
           result = request.result as T;
         };
 
         tx.oncomplete = () => {
-          db.close();
+          if (settled) return;
+          settled = true;
           resolve(result);
         };
-        tx.onerror = () => {
-          db.close();
-          reject(tx.error ?? new Error("indexeddb-transaction-failed"));
-        };
+        tx.onerror = () => fail(tx.error ?? new Error("indexeddb-transaction-failed"));
+        tx.onabort = () => fail(tx.error ?? new Error("indexeddb-transaction-aborted"));
       })
-  );
+  ).catch(async (error) => {
+    // One retry after connection reset (common on iOS/Safari when DB was closed).
+    const message = error instanceof Error ? error.message : String(error);
+    const name = error instanceof DOMException ? error.name : "";
+    if (
+      name === "InvalidStateError" ||
+      message.includes("InvalidStateError") ||
+      message.includes("closing")
+    ) {
+      dbPromises.delete(appStorageKey(DB_NAME, nameSpace));
+      const db = await openDb(nameSpace);
+      return new Promise<T>((resolve, reject) => {
+        const tx = db.transaction(STORE_NAME, mode);
+        const store = tx.objectStore(STORE_NAME);
+        const request = runner(store);
+        let result!: T;
+        request.onerror = () =>
+          reject(request.error ?? new Error("indexeddb-request-failed"));
+        request.onsuccess = () => {
+          result = request.result as T;
+        };
+        tx.oncomplete = () => resolve(result);
+        tx.onerror = () =>
+          reject(tx.error ?? new Error("indexeddb-transaction-failed"));
+        tx.onabort = () =>
+          reject(tx.error ?? new Error("indexeddb-transaction-aborted"));
+      });
+    }
+    throw error;
+  });
 }
 
 export function createWorkspaceProjectId(): string {
@@ -103,11 +247,9 @@ export async function listWorkspaceProjects(
       cursor.continue();
     };
     tx.oncomplete = () => {
-      db.close();
       resolve(items.sort((a, b) => b.updatedAt - a.updatedAt));
     };
     tx.onerror = () => {
-      db.close();
       reject(tx.error ?? new Error("indexeddb-transaction-failed"));
     };
   });
@@ -129,8 +271,13 @@ export async function putWorkspaceProject(
   record: WorkspaceProjectRecord,
   nameSpace?: string | null
 ): Promise<WorkspaceProjectRecord> {
-  await runTransaction<IDBValidKey>("readwrite", (store) => store.put(record), nameSpace);
-  return record;
+  const safeRecord = cloneForIndexedDb(record);
+  await runTransaction<IDBValidKey>(
+    "readwrite",
+    (store) => store.put(safeRecord),
+    nameSpace
+  );
+  return safeRecord;
 }
 
 export async function deleteWorkspaceProject(

package/src/panel/library/workspace-storage-error.ts

@@ -0,0 +1,60 @@
+/**
+ * Map IndexedDB / clone failures to localized workspace messages.
+ * Used by create / sync / open / delete so device-specific DOMExceptions
+ * show actionable copy instead of opaque browser English.
+ */
+export function mapWorkspaceStorageError(
+  error: unknown,
+  t: (key: string) => string
+): Error {
+  const raw = error instanceof Error ? error : new Error(String(error));
+  const name =
+    (error as { name?: string } | null)?.name ||
+    (raw as { name?: string }).name ||
+    "";
+  const message = raw.message || "";
+
+  if (
+    name === "IndexedDbUnavailable" ||
+    name === "SecurityError" ||
+    message.includes("indexeddb-unavailable") ||
+    /indexedDB is not available|Access is denied|The operation is insecure/i.test(
+      message
+    )
+  ) {
+    return new Error(t("panel.messages.workspaceStorageUnavailable"));
+  }
+
+  if (
+    name === "TimeoutError" ||
+    message.includes("indexeddb-open-timeout")
+  ) {
+    return new Error(t("panel.messages.workspaceStorageTimeout"));
+  }
+
+  if (
+    name === "QuotaExceededError" ||
+    /QuotaExceeded|quota|storage.*full|exceeded the quota/i.test(message)
+  ) {
+    return new Error(t("panel.messages.workspaceStorageQuotaExceeded"));
+  }
+
+  if (
+    name === "DataCloneError" ||
+    message.includes("indexeddb-serialize-failed") ||
+    /could not be cloned|DataCloneError|circular/i.test(message)
+  ) {
+    return new Error(t("panel.messages.workspaceStorageSerializeFailed"));
+  }
+
+  if (
+    message.includes("indexeddb-open-failed") ||
+    message.includes("indexeddb-transaction-failed") ||
+    message.includes("indexeddb-request-failed") ||
+    message.includes("indexeddb-transaction-aborted")
+  ) {
+    return new Error(t("panel.messages.workspaceStorageFailed"));
+  }
+
+  return raw;
+}