@arronqzy/react-blueprint 1.0.12 → 1.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arronqzy/react-blueprint",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "",
   "files": [
     "index.ts",
@@ -18,10 +18,10 @@
     "dayjs": "^1.11.13",
     "react-dom": "^19",
     "@xyflow/react": "^12.9.3",
-    "@arronqzy/blueprint-dsl": "1.0.10",
-    "@arronqzy/react-rx-store": "1.1.5",
-    "@arronqzy/ui": "1.0.6",
-    "@arronqzy/i18n": "0.1.8"
+    "@arronqzy/blueprint-dsl": "1.0.12",
+    "@arronqzy/i18n": "0.1.9",
+    "@arronqzy/react-rx-store": "1.1.6",
+    "@arronqzy/ui": "1.0.7"
   },
   "devDependencies": {
     "@types/react": "^19.0.1",

package/src/graph/index.ts

@@ -1,4 +1,5 @@
 export * from "./document";
+export * from "./parse-blueprint-data";
 export * from "./node-types";
 export * from "./blueprint-graph";
 export * from "./react-flow-adapter";

package/src/graph/parse-blueprint-data.ts

@@ -0,0 +1,106 @@
+import {
+  sanitizeBlueprintDocument,
+  type BlueprintDocument,
+  type BlueprintGraphEdge,
+  type BlueprintGraphNode,
+  type BlueprintNodeRole,
+} from "./document";
+
+export type ParseCheckResult = {
+  ok: boolean;
+  error?: string;
+};
+
+const NODE_ROLES = new Set<BlueprintNodeRole>([
+  "blueprint",
+  "logic",
+  "and",
+  "lifecycle",
+  "fetch",
+  "json",
+  "storage",
+  "clock",
+  "event",
+]);
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function extractBlueprintDocument(data: unknown): unknown {
+  if (!isRecord(data)) return data;
+  if (isRecord(data.blueprintDocument)) return data.blueprintDocument;
+  if (isRecord(data.document) && Array.isArray(data.document.nodes)) {
+    return data.document;
+  }
+  return data;
+}
+
+function isFiniteNumber(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+function isBlueprintNode(value: unknown): value is BlueprintGraphNode {
+  if (!isRecord(value)) return false;
+  if (typeof value.id !== "string" || !value.id) return false;
+  if (typeof value.role !== "string" || !NODE_ROLES.has(value.role as BlueprintNodeRole)) {
+    return false;
+  }
+  if (!isRecord(value.position) || !isFiniteNumber(value.position.x) || !isFiniteNumber(value.position.y)) {
+    return false;
+  }
+  return true;
+}
+
+function isBlueprintEdge(value: unknown): value is BlueprintGraphEdge {
+  if (!isRecord(value)) return false;
+  return (
+    typeof value.id === "string" &&
+    value.id.length > 0 &&
+    typeof value.source === "string" &&
+    value.source.length > 0 &&
+    typeof value.target === "string" &&
+    value.target.length > 0
+  );
+}
+
+/**
+ * 校验数据能否被蓝图解析（工作区 `blueprintDocument`、蓝图导出 JSON 或裸文档均可）。
+ */
+export function parseBlueprintData(
+  data: unknown
+): ParseCheckResult & { value?: BlueprintDocument } {
+  if (data == null) {
+    return { ok: false, error: "empty" };
+  }
+  const raw = extractBlueprintDocument(data);
+  if (!isRecord(raw)) {
+    return { ok: false, error: "invalid-blueprint-data" };
+  }
+  if (!Array.isArray(raw.nodes) || !Array.isArray(raw.edges)) {
+    return { ok: false, error: "invalid-blueprint-data" };
+  }
+  if (!raw.nodes.every(isBlueprintNode) || !raw.edges.every(isBlueprintEdge)) {
+    return { ok: false, error: "invalid-blueprint-data" };
+  }
+  try {
+    const value = sanitizeBlueprintDocument({
+      id: typeof raw.id === "string" && raw.id ? raw.id : "default",
+      name: typeof raw.name === "string" ? raw.name : undefined,
+      nodes: raw.nodes as BlueprintGraphNode[],
+      edges: raw.edges as BlueprintGraphEdge[],
+      allowFalseSignalPropagation:
+        typeof raw.allowFalseSignalPropagation === "boolean"
+          ? raw.allowFalseSignalPropagation
+          : undefined,
+    });
+    return { ok: true, value };
+  } catch {
+    return { ok: false, error: "invalid-blueprint-data" };
+  }
+}
+
+export function validateBlueprintData(data: unknown): ParseCheckResult {
+  const parsed = parseBlueprintData(data);
+  return parsed.ok ? { ok: true } : { ok: false, error: parsed.error };
+}

package/src/hooks/useBlueprintDebugSession.ts

@@ -46,6 +46,8 @@ export type UseBlueprintDebugSessionOptions = {
     viewElementIds: string[],
     scope: unknown
   ) => void;
+  /** 隔离 IndexedDB / localStorage；空则用全局库 */
+  nameSpace?: string | null;
 };
 
 function buildNodeLabelMap(graph: BlueprintGraph): Record<string, string> {
@@ -66,6 +68,7 @@ export function useBlueprintDebugSession({
   libraryNameById,
   onExecutionBlocked,
   onViewScopeUpdate,
+  nameSpace = null,
 }: UseBlueprintDebugSessionOptions) {
   const runnerRef = useRef<BlueprintGraphRunner | null>(null);
   const runIdRef = useRef<string | null>(null);
@@ -79,8 +82,12 @@ export function useBlueprintDebugSession({
   const [logPanelOpen, setLogPanelOpen] = useState(false);
   const [running, setRunning] = useState(false);
   const [settings, setSettings] = useState<ExecutionLogSettings>(() =>
-    readExecutionLogSettings()
+    readExecutionLogSettings(nameSpace)
   );
+
+  useEffect(() => {
+    setSettings(readExecutionLogSettings(nameSpace));
+  }, [nameSpace]);
   const [savedRuns, setSavedRuns] = useState<ExecutionRunRecord[]>([]);
   const [totalSavedRunCount, setTotalSavedRunCount] = useState(0);
 
@@ -172,13 +179,13 @@ export function useBlueprintDebugSession({
   ]);
 
   const refreshSavedRuns = useCallback(async () => {
-    const all = await listExecutionRunRecords();
+    const all = await listExecutionRunRecords(undefined, nameSpace);
     setTotalSavedRunCount(all.length);
     const items = blueprintId
       ? all.filter((item) => item.blueprintId === blueprintId)
       : all;
     setSavedRuns(items);
-  }, [blueprintId]);
+  }, [blueprintId, nameSpace]);
 
   useEffect(() => {
     if (!logPanelOpen) return;
@@ -187,19 +194,19 @@ export function useBlueprintDebugSession({
 
   const enforceSavedRunLimits = useCallback(async () => {
     const cutoff = retentionCutoffMs(settings.retentionDays);
-    await purgeExecutionRunsOlderThan(cutoff);
-    await trimExecutionRunRecordsToMax(settings.maxSavedRuns);
+    await purgeExecutionRunsOlderThan(cutoff, nameSpace);
+    await trimExecutionRunRecordsToMax(settings.maxSavedRuns, nameSpace);
     await refreshSavedRuns();
-  }, [refreshSavedRuns, settings.maxSavedRuns, settings.retentionDays]);
+  }, [nameSpace, refreshSavedRuns, settings.maxSavedRuns, settings.retentionDays]);
 
   const applyRetention = enforceSavedRunLimits;
 
   const clearAllSavedRuns = useCallback(async () => {
-    const removed = await clearAllExecutionRunRecords();
+    const removed = await clearAllExecutionRunRecords(nameSpace);
     setSavedRuns([]);
     setTotalSavedRunCount(0);
     return removed;
-  }, []);
+  }, [nameSpace]);
 
   const buildRunRecord = useCallback(
     (
@@ -229,10 +236,10 @@ export function useBlueprintDebugSession({
   const persistRunIfNeeded = useCallback(
     async (record: ExecutionRunRecord) => {
       if (!settings.autoSave) return;
-      await putExecutionRunRecord(record);
+      await putExecutionRunRecord(record, nameSpace);
       await enforceSavedRunLimits();
     },
-    [enforceSavedRunLimits, settings.autoSave]
+    [enforceSavedRunLimits, nameSpace, settings.autoSave]
   );
 
   const beginRun = useCallback(() => {
@@ -420,9 +427,9 @@ export function useBlueprintDebugSession({
       runnerRef.current?.isDebugQueueEmpty() ? "completed" : "paused",
       entries
     );
-    await putExecutionRunRecord(record);
+    await putExecutionRunRecord(record, nameSpace);
     await enforceSavedRunLimits();
-  }, [buildRunRecord, enforceSavedRunLimits, entries]);
+  }, [buildRunRecord, enforceSavedRunLimits, entries, nameSpace]);
 
   const exportCurrentRun = useCallback(() => {
     if (entries.length === 0) return;
@@ -437,17 +444,17 @@ export function useBlueprintDebugSession({
     (patch: Partial<ExecutionLogSettings>) => {
       setSettings((prev) => {
         const next = { ...prev, ...patch };
-        writeExecutionLogSettings(next);
+        writeExecutionLogSettings(next, nameSpace);
         return next;
       });
       if (patch.maxSavedRuns !== undefined) {
         const maxSavedRuns = Math.max(1, Math.floor(patch.maxSavedRuns));
-        void trimExecutionRunRecordsToMax(maxSavedRuns).then(() =>
+        void trimExecutionRunRecordsToMax(maxSavedRuns, nameSpace).then(() =>
           refreshSavedRuns()
         );
       }
     },
-    [refreshSavedRuns]
+    [nameSpace, refreshSavedRuns]
   );
 
   const resetSession = useCallback(() => {

package/src/library/blueprint-library-db.ts

@@ -1,3 +1,4 @@
+import { appStorageKey } from "@arronqzy/blueprint-dsl";
 import type {
   BlueprintLibraryListItem,
   BlueprintLibraryRecord,
@@ -7,9 +8,9 @@ const DB_NAME = "arronqzy-blueprint-library";
 const DB_VERSION = 1;
 const STORE_NAME = "blueprints";
 
-function openDb(): Promise<IDBDatabase> {
+function openDb(nameSpace?: string | null): Promise<IDBDatabase> {
   return new Promise((resolve, reject) => {
-    const request = indexedDB.open(DB_NAME, DB_VERSION);
+    const request = indexedDB.open(appStorageKey(DB_NAME, nameSpace), DB_VERSION);
     request.onerror = () => reject(request.error ?? new Error("indexeddb-open-failed"));
     request.onupgradeneeded = () => {
       const db = request.result;
@@ -25,9 +26,10 @@ function openDb(): Promise<IDBDatabase> {
 
 function runTransaction<T>(
   mode: IDBTransactionMode,
-  runner: (store: IDBObjectStore) => IDBRequest<T>
+  runner: (store: IDBObjectStore) => IDBRequest<T>,
+  nameSpace?: string | null
 ): Promise<T> {
-  return openDb().then(
+  return openDb(nameSpace).then(
     (db) =>
       new Promise<T>((resolve, reject) => {
         const tx = db.transaction(STORE_NAME, mode);
@@ -53,9 +55,13 @@ function runTransaction<T>(
   );
 }
 
-export async function listBlueprintLibrary(): Promise<BlueprintLibraryListItem[]> {
-  const records = await runTransaction<BlueprintLibraryRecord[]>("readonly", (store) =>
-    store.getAll()
+export async function listBlueprintLibrary(
+  nameSpace?: string | null
+): Promise<BlueprintLibraryListItem[]> {
+  const records = await runTransaction<BlueprintLibraryRecord[]>(
+    "readonly",
+    (store) => store.getAll(),
+    nameSpace
   );
   return records
     .map((record) => ({
@@ -69,26 +75,31 @@ export async function listBlueprintLibrary(): Promise<BlueprintLibraryListItem[]
 }
 
 export async function getBlueprintLibraryRecord(
-  id: string
+  id: string,
+  nameSpace?: string | null
 ): Promise<BlueprintLibraryRecord | null> {
-  const record = await runTransaction<BlueprintLibraryRecord | undefined>("readonly", (store) =>
-    store.get(id)
+  const record = await runTransaction<BlueprintLibraryRecord | undefined>(
+    "readonly",
+    (store) => store.get(id),
+    nameSpace
   );
   return record ?? null;
 }
 
 export async function putBlueprintLibraryRecord(
-  record: BlueprintLibraryRecord
+  record: BlueprintLibraryRecord,
+  nameSpace?: string | null
 ): Promise<BlueprintLibraryRecord> {
-  await runTransaction<IDBValidKey>("readwrite", (store) => store.put(record));
+  await runTransaction<IDBValidKey>("readwrite", (store) => store.put(record), nameSpace);
   return record;
 }
 
 export async function updateBlueprintLibraryMeta(
   id: string,
-  patch: { name?: string; remark?: string }
+  patch: { name?: string; remark?: string },
+  nameSpace?: string | null
 ): Promise<BlueprintLibraryRecord | null> {
-  const existing = await getBlueprintLibraryRecord(id);
+  const existing = await getBlueprintLibraryRecord(id, nameSpace);
   if (!existing) return null;
 
   const name = patch.name?.trim() || existing.name;
@@ -103,10 +114,13 @@ export async function updateBlueprintLibraryMeta(
     },
   };
 
-  await putBlueprintLibraryRecord(record);
+  await putBlueprintLibraryRecord(record, nameSpace);
   return record;
 }
 
-export async function deleteBlueprintLibraryRecord(id: string): Promise<void> {
-  await runTransaction<undefined>("readwrite", (store) => store.delete(id));
+export async function deleteBlueprintLibraryRecord(
+  id: string,
+  nameSpace?: string | null
+): Promise<void> {
+  await runTransaction<undefined>("readwrite", (store) => store.delete(id), nameSpace);
 }

package/src/library/execution-log-db.ts

@@ -1,12 +1,13 @@
+import { appStorageKey } from "@arronqzy/blueprint-dsl";
 import type { ExecutionRunRecord } from "@arronqzy/blueprint-dsl";
 
 const DB_NAME = "arronqzy-blueprint-execution-log";
 const DB_VERSION = 1;
 const STORE_NAME = "runs";
 
-function openDb(): Promise<IDBDatabase> {
+function openDb(nameSpace?: string | null): Promise<IDBDatabase> {
   return new Promise((resolve, reject) => {
-    const request = indexedDB.open(DB_NAME, DB_VERSION);
+    const request = indexedDB.open(appStorageKey(DB_NAME, nameSpace), DB_VERSION);
     request.onerror = () => reject(request.error ?? new Error("indexeddb-open-failed"));
     request.onupgradeneeded = () => {
       const db = request.result;
@@ -22,9 +23,10 @@ function openDb(): Promise<IDBDatabase> {
 
 function runTransaction<T>(
   mode: IDBTransactionMode,
-  runner: (store: IDBObjectStore) => IDBRequest<T>
+  runner: (store: IDBObjectStore) => IDBRequest<T>,
+  nameSpace?: string | null
 ): Promise<T> {
-  return openDb().then(
+  return openDb(nameSpace).then(
     (db) =>
       new Promise<T>((resolve, reject) => {
         const tx = db.transaction(STORE_NAME, mode);
@@ -50,28 +52,55 @@ function runTransaction<T>(
   );
 }
 
+function deleteMany(ids: string[], nameSpace?: string | null): Promise<void> {
+  return openDb(nameSpace).then(
+    (db) =>
+      new Promise<void>((resolve, reject) => {
+        const tx = db.transaction(STORE_NAME, "readwrite");
+        const store = tx.objectStore(STORE_NAME);
+        for (const id of ids) {
+          store.delete(id);
+        }
+        tx.oncomplete = () => {
+          db.close();
+          resolve();
+        };
+        tx.onerror = () => {
+          db.close();
+          reject(tx.error ?? new Error("indexeddb-transaction-failed"));
+        };
+      })
+  );
+}
+
 export async function putExecutionRunRecord(
-  record: ExecutionRunRecord
+  record: ExecutionRunRecord,
+  nameSpace?: string | null
 ): Promise<ExecutionRunRecord> {
-  await runTransaction<IDBValidKey>("readwrite", (store) => store.put(record));
+  await runTransaction<IDBValidKey>("readwrite", (store) => store.put(record), nameSpace);
   return record;
 }
 
 export async function getExecutionRunRecord(
-  runId: string
+  runId: string,
+  nameSpace?: string | null
 ): Promise<ExecutionRunRecord | null> {
   const record = await runTransaction<ExecutionRunRecord | undefined>(
     "readonly",
-    (store) => store.get(runId)
+    (store) => store.get(runId),
+    nameSpace
   );
   return record ?? null;
 }
 
 export async function listExecutionRunRecords(
-  blueprintId?: string | null
+  blueprintId?: string | null,
+  nameSpace?: string | null
 ): Promise<ExecutionRunRecord[]> {
-  const records = await runTransaction<ExecutionRunRecord[]>("readonly", (store) =>
-    store.getAll()
+  const records = await runTransaction<ExecutionRunRecord[]>(
+    "readonly",
+    (store) => store.getAll(),
+    nameSpace
   );
   const filtered = blueprintId
     ? records.filter((item) => item.blueprintId === blueprintId)
@@ -79,27 +108,37 @@ export async function listExecutionRunRecords(
   return filtered.sort((a, b) => b.startedAt - a.startedAt);
 }
 
-export async function deleteExecutionRunRecord(runId: string): Promise<void> {
-  await runTransaction<undefined>("readwrite", (store) => store.delete(runId));
+export async function deleteExecutionRunRecord(
+  runId: string,
+  nameSpace?: string | null
+): Promise<void> {
+  await runTransaction<undefined>("readwrite", (store) => store.delete(runId), nameSpace);
 }
 
-export async function clearAllExecutionRunRecords(): Promise<number> {
-  const records = await runTransaction<ExecutionRunRecord[]>("readonly", (store) =>
-    store.getAll()
+export async function clearAllExecutionRunRecords(
+  nameSpace?: string | null
+): Promise<number> {
+  const records = await runTransaction<ExecutionRunRecord[]>(
+    "readonly",
+    (store) => store.getAll(),
+    nameSpace
   );
   if (records.length === 0) return 0;
 
-  await runTransaction<undefined>("readwrite", (store) => store.clear());
+  await runTransaction<undefined>("readwrite", (store) => store.clear(), nameSpace);
   return records.length;
 }
 
 export async function trimExecutionRunRecordsToMax(
-  maxCount: number
+  maxCount: number,
+  nameSpace?: string | null
 ): Promise<number> {
   if (!Number.isFinite(maxCount) || maxCount < 1) return 0;
 
-  const records = await runTransaction<ExecutionRunRecord[]>("readonly", (store) =>
-    store.getAll()
+  const records = await runTransaction<ExecutionRunRecord[]>(
+    "readonly",
+    (store) => store.getAll(),
+    nameSpace
   );
   if (records.length <= maxCount) return 0;
 
@@ -107,52 +146,29 @@ export async function trimExecutionRunRecordsToMax(
   const overflow = sorted.slice(maxCount);
   if (overflow.length === 0) return 0;
 
-  await openDb().then(
-    (db) =>
-      new Promise<void>((resolve, reject) => {
-        const tx = db.transaction(STORE_NAME, "readwrite");
-        const store = tx.objectStore(STORE_NAME);
-        for (const item of overflow) {
-          store.delete(item.runId);
-        }
-        tx.oncomplete = () => {
-          db.close();
-          resolve();
-        };
-        tx.onerror = () => {
-          db.close();
-          reject(tx.error ?? new Error("indexeddb-transaction-failed"));
-        };
-      })
+  await deleteMany(
+    overflow.map((item) => item.runId),
+    nameSpace
   );
 
   return overflow.length;
 }
 
-export async function purgeExecutionRunsOlderThan(cutoffMs: number): Promise<number> {
-  const records = await runTransaction<ExecutionRunRecord[]>("readonly", (store) =>
-    store.getAll()
+export async function purgeExecutionRunsOlderThan(
+  cutoffMs: number,
+  nameSpace?: string | null
+): Promise<number> {
+  const records = await runTransaction<ExecutionRunRecord[]>(
+    "readonly",
+    (store) => store.getAll(),
+    nameSpace
   );
   const stale = records.filter((item) => item.startedAt < cutoffMs);
   if (stale.length === 0) return 0;
 
-  await openDb().then(
-    (db) =>
-      new Promise<void>((resolve, reject) => {
-        const tx = db.transaction(STORE_NAME, "readwrite");
-        const store = tx.objectStore(STORE_NAME);
-        for (const item of stale) {
-          store.delete(item.runId);
-        }
-        tx.oncomplete = () => {
-          db.close();
-          resolve();
-        };
-        tx.onerror = () => {
-          db.close();
-          reject(tx.error ?? new Error("indexeddb-transaction-failed"));
-        };
-      })
+  await deleteMany(
+    stale.map((item) => item.runId),
+    nameSpace
   );
 
   return stale.length;

package/src/library/execution-log-settings.ts

@@ -1,3 +1,5 @@
+import { appStorageKey } from "@arronqzy/blueprint-dsl";
+
 export type ExecutionLogSettings = {
   retentionDays: number;
   autoSave: boolean;
@@ -13,9 +15,11 @@ export const DEFAULT_EXECUTION_LOG_SETTINGS: ExecutionLogSettings = {
   maxSavedRuns: 80,
 };
 
-export function readExecutionLogSettings(): ExecutionLogSettings {
+export function readExecutionLogSettings(
+  nameSpace?: string | null
+): ExecutionLogSettings {
   try {
-    const raw = localStorage.getItem(SETTINGS_KEY);
+    const raw = localStorage.getItem(appStorageKey(SETTINGS_KEY, nameSpace));
     if (!raw) return { ...DEFAULT_EXECUTION_LOG_SETTINGS };
     const parsed = JSON.parse(raw) as Partial<ExecutionLogSettings>;
     return {
@@ -37,9 +41,15 @@ export function readExecutionLogSettings(): ExecutionLogSettings {
   }
 }
 
-export function writeExecutionLogSettings(settings: ExecutionLogSettings) {
+export function writeExecutionLogSettings(
+  settings: ExecutionLogSettings,
+  nameSpace?: string | null
+) {
   try {
-    localStorage.setItem(SETTINGS_KEY, JSON.stringify(settings));
+    localStorage.setItem(
+      appStorageKey(SETTINGS_KEY, nameSpace),
+      JSON.stringify(settings)
+    );
   } catch {
     // ignore storage errors
   }