@arronqzy/vue-view 0.1.15 → 0.1.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arronqzy/vue-view",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "Vue 3 visual view editor for Abuilder (Ant Design Vue)",
   "license": "MIT",
   "type": "module",
@@ -24,10 +24,10 @@
     "uuid": "^13.0.0",
     "vue": "^3.5.13",
     "@arronqzy/blueprint-dsl": "1.0.14",
-    "@arronqzy/i18n": "0.1.11",
-    "@arronqzy/rx-store": "1.0.8",
+    "@arronqzy/i18n": "0.1.12",
     "@arronqzy/view-scene3d": "0.1.5",
     "@arronqzy/view-table": "0.1.8",
+    "@arronqzy/rx-store": "1.0.8",
     "@arronqzy/vue-blueprint": "0.1.12",
     "@arronqzy/vue-rx-store": "0.1.6"
   },

package/src/panel/VueViewPanel.vue

@@ -583,8 +583,14 @@ async function handleBlueprintImportFile(file: File) {
 }
 
 async function handleWorkspaceCreateProject() {
-  const result = await workspaceProjects.handleCreateProject();
-  if (result?.name) message.success(panelMessages().workspaceCreated(result.name));
+  try {
+    const result = await workspaceProjects.handleCreateProject();
+    if (result?.name) message.success(panelMessages().workspaceCreated(result.name));
+  } catch (error) {
+    message.error(
+      error instanceof Error ? error.message : panelMessages().createWorkspaceFailed
+    );
+  }
 }
 
 async function handleWorkspaceOpenProject(id: string) {
@@ -609,8 +615,14 @@ async function handleWorkspaceSyncProject() {
 }
 
 async function handleWorkspaceDeleteProject(id: string) {
-  await workspaceProjects.handleDeleteProject(id);
-  message.success(panelMessages().workspaceDeleted);
+  try {
+    await workspaceProjects.handleDeleteProject(id);
+    message.success(panelMessages().workspaceDeleted);
+  } catch (error) {
+    message.error(
+      error instanceof Error ? error.message : panelMessages().deleteWorkspaceFailed
+    );
+  }
 }
 
 async function openOnlinePreviewForProject(

package/src/panel/components/PanelConfigSidebar.vue

@@ -1,6 +1,6 @@
 <script setup lang="ts">
 import { useI18n } from "@arronqzy/i18n/vue";
-import { computed, onMounted, provide, ref, watch } from "vue";
+import { computed, nextTick, onMounted, onUnmounted, provide, ref, watch } from "vue";
 import { Empty, Input } from "ant-design-vue";
 import type { PanelElement, PanelLayer, ReferenceCopyMode } from "../types";
 import { CHART_TYPES } from "../utils/chartOptionBuilder";
@@ -60,6 +60,8 @@ const props = withDefaults(
 const configSearch = ref("");
 const isSearchCollapsed = ref(false);
 const sidebarScrollRef = ref<HTMLElement | null>(null);
+const configScrollPosById = new Map<string, number>();
+const activeConfigScrollKey = ref<string | null>(null);
 
 const expandedSections = ref<Record<string, boolean>>({
   nodeInfo: true,
@@ -88,6 +90,49 @@ const effectiveSelectedElements = computed(() => {
 
 const isMultiSelectMode = computed(() => effectiveSelectedElements.value.length > 1);
 
+const configScrollKey = computed(() => {
+  if (isMultiSelectMode.value || !props.selectedElement) return null;
+  return props.selectedElement.id;
+});
+
+function onConfigSidebarScroll() {
+  const el = sidebarScrollRef.value;
+  const key = activeConfigScrollKey.value;
+  if (!el || !key) return;
+  configScrollPosById.set(key, el.scrollTop);
+}
+
+function restoreConfigScroll(key: string | null) {
+  const el = sidebarScrollRef.value;
+  if (!el) return;
+  const top = key != null ? (configScrollPosById.get(key) ?? 0) : 0;
+  el.scrollTop = top;
+}
+
+watch(
+  configScrollKey,
+  (nextKey, prevKey) => {
+    const el = sidebarScrollRef.value;
+    if (el && prevKey && prevKey !== nextKey) {
+      configScrollPosById.set(prevKey, el.scrollTop);
+    }
+    activeConfigScrollKey.value = nextKey;
+    void nextTick(() => restoreConfigScroll(nextKey));
+  },
+  { flush: "post" }
+);
+
+onMounted(() => {
+  activeConfigScrollKey.value = configScrollKey.value;
+  const el = sidebarScrollRef.value;
+  el?.addEventListener("scroll", onConfigSidebarScroll, { passive: true });
+  restoreConfigScroll(configScrollKey.value);
+});
+
+onUnmounted(() => {
+  sidebarScrollRef.value?.removeEventListener("scroll", onConfigSidebarScroll);
+});
+
 const selectedLayer = computed(() => {
   if (!props.selectedElement) return null;
   return props.layers.find((l) => l.id === props.selectedElement?.layerId) ?? null;

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

@@ -1047,7 +1047,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,
+      });
+    }
   }
 
   function importPanelData(nextState: State) {

package/src/panel/hooks/useWorkspaceProjects.ts

@@ -23,6 +23,7 @@ import {
   workspaceSnapshotsEqual,
   type WorkspaceSnapshot,
 } from "../library/workspace-snapshot";
+import { mapWorkspaceStorageError } from "../library/workspace-storage-error";
 import { runBusyTask } from "../utils/async-work";
 import { createEmptyPanelState, normalizeImportedPanelState } from "../utils/panelStateIO";
 import { AbuilderEvents, emitAbuilderEvent } from "../library/event-subscription";
@@ -125,7 +126,11 @@ export function useWorkspaceProjects(options: UseWorkspaceProjectsOptions) {
   }
 
   async function refreshProjects() {
-    projects.value = await listWorkspaceProjects(nameSpace());
+    try {
+      projects.value = await listWorkspaceProjects(nameSpace());
+    } catch (error) {
+      console.warn("[abuilder] listWorkspaceProjects failed", error);
+    }
   }
 
   watch(
@@ -262,35 +267,48 @@ export function useWorkspaceProjects(options: UseWorkspaceProjectsOptions) {
     name: string;
     createdAt?: number;
   }) {
-    const snapshot = cloneWorkspaceSnapshot(buildCurrentSnapshot());
-    const now = Date.now();
-    const id = persistOptions.id ?? createWorkspaceProjectId();
-    const createdAt = persistOptions.createdAt ?? now;
-    const name = (persistOptions.name ?? "").trim() || resolveProjectName();
-
-    const record: WorkspaceProjectRecord = {
-      id,
-      name,
-      createdAt,
-      updatedAt: now,
-      panelState: options.exportPanelData(),
-      blueprintDocument: snapshot.blueprintDocument,
-      blueprintMeta: snapshot.blueprintMeta,
-      productName:
-        typeof snapshot.productName === "string" ? snapshot.productName : resolveProjectName(),
-      titleIconDataUrl: snapshot.titleIconDataUrl || undefined,
-    };
+    try {
+      const snapshot = cloneWorkspaceSnapshot(buildCurrentSnapshot());
+      const now = Date.now();
+      const id = persistOptions.id ?? createWorkspaceProjectId();
+      const createdAt = persistOptions.createdAt ?? now;
+      const name = (persistOptions.name ?? "").trim() || resolveProjectName();
 
-    await putWorkspaceProject(record, nameSpace());
-    writeWorkspacePreviewCache(record, nameSpace());
-    broadcastWorkspaceProjectUpdate(id, now, nameSpace());
-    activeProjectId.value = id;
-    activeProjectName.value = name;
-    syncedSnapshotRef.value = snapshot;
-    syncedPanelRevision = toValue(options.panelRevision);
-    pendingRevisionSync = false;
-    await refreshProjects();
-    return record;
+      let panelState: State;
+      try {
+        panelState = options.exportPanelData();
+      } catch (error) {
+        throw mapWorkspaceStorageError(error, t);
+      }
+
+      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());
+      activeProjectId.value = id;
+      activeProjectName.value = name;
+      syncedSnapshotRef.value = snapshot;
+      syncedPanelRevision = toValue(options.panelRevision);
+      pendingRevisionSync = false;
+      await refreshProjects();
+      return record;
+    } catch (error) {
+      throw mapWorkspaceStorageError(error, t);
+    }
   }
 
   async function handleCreateProject() {
@@ -320,14 +338,18 @@ export function useWorkspaceProjects(options: UseWorkspaceProjectsOptions) {
   }
 
   async function handleOpenProject(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);
+    }
   }
 
   async function handleSyncProject() {
@@ -355,17 +377,21 @@ export function useWorkspaceProjects(options: UseWorkspaceProjectsOptions) {
   }
 
   async function handleDeleteProject(id: string) {
-    await runBusyTask(t("common.deletingWorkspace"), async () => {
-      await deleteWorkspaceProject(id, nameSpace());
-      if (activeProjectId.value === id) {
-        activeProjectId.value = null;
-        activeProjectName.value = null;
-        syncedSnapshotRef.value = null;
-      }
-      previewWindows.delete(id);
-      refreshPreviewing();
-      await refreshProjects();
-    });
+    try {
+      await runBusyTask(t("common.deletingWorkspace"), async () => {
+        await deleteWorkspaceProject(id, nameSpace());
+        if (activeProjectId.value === id) {
+          activeProjectId.value = null;
+          activeProjectName.value = null;
+          syncedSnapshotRef.value = null;
+        }
+        previewWindows.delete(id);
+        refreshPreviewing();
+        await refreshProjects();
+      });
+    } catch (error) {
+      throw mapWorkspaceStorageError(error, t);
+    }
   }
 
   async function handlePreviewProject(id: string, previewOptions?: { syncFirst?: boolean }) {

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

@@ -5,6 +5,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;
@@ -25,10 +26,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)) {
@@ -36,8 +104,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>(
@@ -48,27 +143,74 @@ 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) {
+          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) => {
+    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 {
@@ -102,11 +244,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"));
     };
   });
@@ -128,8 +268,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;
+}

package/src/panel/utils/chartOptionBuilder.ts

@@ -2,6 +2,7 @@ import type { EChartsOption } from "echarts";
 import type { PanelChartConfig, PanelElement } from "../types";
 
 const DEFAULT_CHART_VALUES = [12, 18, 9, 24];
+const DEFAULT_CHART_LABELS = ["A", "B", "C", "D"];
 
 export function getChartValuesDisplayText(chart?: PanelChartConfig): string {
   if (chart?.valuesText !== undefined) return chart.valuesText;
@@ -13,10 +14,26 @@ export function getChartLabelsDisplayText(chart?: PanelChartConfig): string {
   return (chart?.labels ?? []).join(",");
 }
 
+export function parseChartLabelsFromText(
+  text: string | undefined,
+  fallback: string[] = DEFAULT_CHART_LABELS
+): string[] {
+  if (text === undefined) return fallback;
+  const trimmed = text.trim();
+  if (!trimmed) return fallback;
+  const parts = trimmed.split(",").map((s) => s.trim()).filter(Boolean);
+  if (!parts.length) return fallback;
+  return parts;
+}
+
 export function resolveChartLabels(element: PanelElement): string[] {
   const chart = element.chart;
+  if (chart?.labelsText !== undefined) {
+    const parsed = parseChartLabelsFromText(chart.labelsText, []);
+    return parsed.length ? parsed : DEFAULT_CHART_LABELS;
+  }
   if (chart?.labels?.length) return chart.labels;
-  return ["A", "B", "C", "D"];
+  return DEFAULT_CHART_LABELS;
 }
 
 export function parseChartValuesFromText(