@nocobase/flow-engine 2.1.0-beta.42 → 2.1.0-beta.43

package/lib/runjs-context/contexts/elementDoc.js

@@ -0,0 +1,152 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var elementDoc_exports = {};
+__export(elementDoc_exports, {
+  createElementPropertyDoc: () => createElementPropertyDoc,
+  createZhCNElementPropertyDoc: () => createZhCNElementPropertyDoc
+});
+module.exports = __toCommonJS(elementDoc_exports);
+const elementProperties = {
+  innerHTML: "Sanitized inner HTML string.",
+  outerHTML: "Sanitized outer HTML string.",
+  textContent: "Text content.",
+  style: "Inline style declaration.",
+  classList: "DOMTokenList for CSS classes.",
+  appendChild: {
+    type: "function",
+    description: "Append a DOM node or text.",
+    detail: "(child: Node | string) => void",
+    completion: { insertText: `ctx.element.appendChild('text')` }
+  },
+  setAttribute: {
+    type: "function",
+    description: "Set an HTML attribute.",
+    detail: "(name: string, value: string) => void",
+    completion: { insertText: `ctx.element.setAttribute('data-key', 'value')` }
+  },
+  getAttribute: {
+    type: "function",
+    description: "Read an HTML attribute.",
+    detail: "(name: string) => string | null",
+    completion: { insertText: `ctx.element.getAttribute('data-key')` }
+  },
+  querySelector: {
+    type: "function",
+    description: "Find the first matching descendant.",
+    detail: "(selectors: string) => Element | null",
+    completion: { insertText: `ctx.element.querySelector('.selector')` }
+  },
+  querySelectorAll: {
+    type: "function",
+    description: "Find all matching descendants.",
+    detail: "(selectors: string) => NodeListOf<Element>",
+    completion: { insertText: `ctx.element.querySelectorAll('.selector')` }
+  },
+  addEventListener: {
+    type: "function",
+    description: "Attach an event listener to the element.",
+    detail: "(type: string, listener: EventListener) => void",
+    completion: { insertText: `ctx.element.addEventListener('click', (event) => {})` }
+  },
+  removeEventListener: {
+    type: "function",
+    description: "Remove an event listener from the element.",
+    detail: "(type: string, listener: EventListener) => void",
+    completion: { insertText: `ctx.element.removeEventListener('click', handler)` }
+  }
+};
+const zhCNElementProperties = {
+  innerHTML: "\u5DF2\u6D88\u6BD2\u7684 innerHTML \u5B57\u7B26\u4E32\u3002",
+  outerHTML: "\u5DF2\u6D88\u6BD2\u7684 outerHTML \u5B57\u7B26\u4E32\u3002",
+  textContent: "\u6587\u672C\u5185\u5BB9\u3002",
+  style: "\u5185\u8054\u6837\u5F0F\u58F0\u660E\u3002",
+  classList: "CSS class \u5217\u8868\u3002",
+  appendChild: {
+    type: "function",
+    description: "\u8FFD\u52A0 DOM \u8282\u70B9\u6216\u6587\u672C\u3002",
+    detail: "(child: Node | string) => void",
+    completion: { insertText: `ctx.element.appendChild('text')` }
+  },
+  setAttribute: {
+    type: "function",
+    description: "\u8BBE\u7F6E HTML \u5C5E\u6027\u3002",
+    detail: "(name: string, value: string) => void",
+    completion: { insertText: `ctx.element.setAttribute('data-key', 'value')` }
+  },
+  getAttribute: {
+    type: "function",
+    description: "\u8BFB\u53D6 HTML \u5C5E\u6027\u3002",
+    detail: "(name: string) => string | null",
+    completion: { insertText: `ctx.element.getAttribute('data-key')` }
+  },
+  querySelector: {
+    type: "function",
+    description: "\u67E5\u8BE2\u7B2C\u4E00\u4E2A\u5339\u914D\u7684\u540E\u4EE3\u5143\u7D20\u3002",
+    detail: "(selectors: string) => Element | null",
+    completion: { insertText: `ctx.element.querySelector('.selector')` }
+  },
+  querySelectorAll: {
+    type: "function",
+    description: "\u67E5\u8BE2\u6240\u6709\u5339\u914D\u7684\u540E\u4EE3\u5143\u7D20\u3002",
+    detail: "(selectors: string) => NodeListOf<Element>",
+    completion: { insertText: `ctx.element.querySelectorAll('.selector')` }
+  },
+  addEventListener: {
+    type: "function",
+    description: "\u7ED9\u5143\u7D20\u6DFB\u52A0\u4E8B\u4EF6\u76D1\u542C\u3002",
+    detail: "(type: string, listener: EventListener) => void",
+    completion: { insertText: `ctx.element.addEventListener('click', (event) => {})` }
+  },
+  removeEventListener: {
+    type: "function",
+    description: "\u79FB\u9664\u5143\u7D20\u4E8B\u4EF6\u76D1\u542C\u3002",
+    detail: "(type: string, listener: EventListener) => void",
+    completion: { insertText: `ctx.element.removeEventListener('click', handler)` }
+  }
+};
+function createElementPropertyDoc(description = "Current DOM container for this RunJS context. Usually an ElementProxy.") {
+  return {
+    description,
+    detail: "HTMLElement | ElementProxy",
+    properties: elementProperties
+  };
+}
+__name(createElementPropertyDoc, "createElementPropertyDoc");
+function createZhCNElementPropertyDoc(description = "\u5F53\u524D RunJS \u4E0A\u4E0B\u6587\u7684 DOM \u5BB9\u5668\uFF0C\u901A\u5E38\u4E3A ElementProxy\u3002") {
+  return {
+    description,
+    detail: "HTMLElement | ElementProxy",
+    properties: zhCNElementProperties
+  };
+}
+__name(createZhCNElementPropertyDoc, "createZhCNElementPropertyDoc");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createElementPropertyDoc,
+  createZhCNElementPropertyDoc
+});

package/lib/utils/loadedPageCache.d.ts

@@ -0,0 +1,24 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import type { FlowModel } from '../models';
+type LoadedPageOptions = {
+    parentId?: string;
+    subKey?: string;
+};
+type DirtyKeyOptions = {
+    force?: boolean;
+};
+export declare const createLoadedPageCache: () => {
+    getDirtyKeyForModel(model?: FlowModel | null, options?: DirtyKeyOptions): string | undefined;
+    markDirty(key?: string): void;
+    shouldBypass(options?: LoadedPageOptions, isFlowSettingsEnabled?: () => boolean): boolean;
+    clear(options?: LoadedPageOptions): void;
+    mountModelToParent: <T extends FlowModel<import("..").DefaultStructure> = FlowModel<import("..").DefaultStructure>>(model: T, forceReplace?: boolean) => T;
+};
+export {};

package/lib/utils/loadedPageCache.js

@@ -0,0 +1,139 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var loadedPageCache_exports = {};
+__export(loadedPageCache_exports, {
+  createLoadedPageCache: () => createLoadedPageCache
+});
+module.exports = __toCommonJS(loadedPageCache_exports);
+const getLoadedPageKey = /* @__PURE__ */ __name((options) => {
+  const parentId = options == null ? void 0 : options.parentId;
+  const subKey = options == null ? void 0 : options.subKey;
+  if (!parentId || subKey !== "page") {
+    return void 0;
+  }
+  return `${parentId}::${subKey}`;
+}, "getLoadedPageKey");
+const getLoadedPageKeyFromModel = /* @__PURE__ */ __name((model) => {
+  var _a;
+  let current = model;
+  while (current) {
+    if (current.subKey === "page" && ((_a = current.parent) == null ? void 0 : _a.uid)) {
+      return getLoadedPageKey({ parentId: current.parent.uid, subKey: current.subKey });
+    }
+    current = current.parent;
+  }
+  return void 0;
+}, "getLoadedPageKeyFromModel");
+const isFlowSettingsEnabledForContext = /* @__PURE__ */ __name((context) => {
+  try {
+    return !!(context == null ? void 0 : context.flowSettingsEnabled);
+  } catch (error) {
+    return false;
+  }
+}, "isFlowSettingsEnabledForContext");
+const isFlowSettingsEnabledForModel = /* @__PURE__ */ __name((model) => {
+  if (isFlowSettingsEnabledForContext(model == null ? void 0 : model.context)) {
+    return true;
+  }
+  const visited = /* @__PURE__ */ new Set();
+  let engine = model == null ? void 0 : model.flowEngine;
+  while (engine && !visited.has(engine)) {
+    visited.add(engine);
+    if (isFlowSettingsEnabledForContext(engine.context)) {
+      return true;
+    }
+    engine = engine.previousEngine;
+  }
+  return false;
+}, "isFlowSettingsEnabledForModel");
+const removeLoadedModelTree = /* @__PURE__ */ __name((model) => {
+  if (!(model == null ? void 0 : model.uid) || !model.flowEngine) {
+    return;
+  }
+  if (model.flowEngine.getModel(model.uid) === model) {
+    model.flowEngine.removeModelWithSubModels(model.uid);
+  }
+}, "removeLoadedModelTree");
+const mountLoadedModelToParent = /* @__PURE__ */ __name((model, forceReplace = false) => {
+  var _a;
+  if (!(model == null ? void 0 : model.parent) || !model.subKey) {
+    return model;
+  }
+  const mounted = (_a = model.parent.subModels) == null ? void 0 : _a[model.subKey];
+  const existing = forceReplace && model.subType !== "array" && mounted && !Array.isArray(mounted) ? mounted : model.parent.findSubModel(model.subKey, (m) => m.uid === model.uid);
+  if (existing) {
+    if (!forceReplace || existing === model) {
+      return model;
+    }
+    removeLoadedModelTree(existing);
+  }
+  if (model.subType === "array") {
+    model.parent.addSubModel(model.subKey, model);
+  } else {
+    model.parent.setSubModel(model.subKey, model);
+  }
+  return model;
+}, "mountLoadedModelToParent");
+const createLoadedPageCache = /* @__PURE__ */ __name(() => {
+  const dirtyKeys = /* @__PURE__ */ new Set();
+  return {
+    getDirtyKeyForModel(model, options) {
+      if (!(options == null ? void 0 : options.force) && !isFlowSettingsEnabledForModel(model)) {
+        return void 0;
+      }
+      return getLoadedPageKeyFromModel(model);
+    },
+    markDirty(key) {
+      if (key) {
+        dirtyKeys.add(key);
+      }
+    },
+    shouldBypass(options, isFlowSettingsEnabled) {
+      const key = getLoadedPageKey(options);
+      if (!key || !dirtyKeys.has(key)) {
+        return false;
+      }
+      try {
+        return !(isFlowSettingsEnabled == null ? void 0 : isFlowSettingsEnabled());
+      } catch (error) {
+        return true;
+      }
+    },
+    clear(options) {
+      const key = getLoadedPageKey(options);
+      if (key) {
+        dirtyKeys.delete(key);
+      }
+    },
+    mountModelToParent: mountLoadedModelToParent
+  };
+}, "createLoadedPageCache");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLoadedPageCache
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/flow-engine",
-  "version": "2.1.0-beta.42",
+  "version": "2.1.0-beta.43",
   "private": false,
   "description": "A standalone flow engine for NocoBase, managing workflows, models, and actions.",
   "main": "lib/index.js",
@@ -8,8 +8,8 @@
   "dependencies": {
     "@formily/antd-v5": "1.x",
     "@formily/reactive": "2.x",
-    "@nocobase/sdk": "2.1.0-beta.42",
-    "@nocobase/shared": "2.1.0-beta.42",
+    "@nocobase/sdk": "2.1.0-beta.43",
+    "@nocobase/shared": "2.1.0-beta.43",
     "ahooks": "^3.7.2",
     "axios": "^1.7.0",
     "dayjs": "^1.11.9",
@@ -37,5 +37,5 @@
   ],
   "author": "NocoBase Team",
   "license": "Apache-2.0",
-  "gitHead": "619b4d06c934bf3266ba7f388438db018217c87d"
+  "gitHead": "6d7750e2373bf2451d246de88cc1f62491685e18"
 }

package/src/__tests__/flowContext.test.ts

@@ -796,6 +796,29 @@ describe('FlowContext.getApiInfos', () => {
     expect((infos.bar?.ref as any)?.url).toBe('https://example.com');
   });
 
+  it('should include completion only when requested by getApiInfos()', async () => {
+    const ctx = new FlowContext();
+    ctx.defineMethod('bar', () => 2, {
+      description: 'Bar',
+      completion: { insertText: 'ctx.bar()' },
+    });
+    ctx.defineProperty('token', {
+      value: 't',
+      info: {
+        description: 'Token string',
+        completion: { insertText: 'ctx.token' },
+      },
+    });
+
+    const compact = await ctx.getApiInfos();
+    expect((compact.bar as any)?.completion).toBeUndefined();
+    expect((compact.token as any)?.completion).toBeUndefined();
+
+    const editorInfos = await ctx.getApiInfos({ includeCompletion: true });
+    expect((editorInfos.bar as any)?.completion?.insertText).toBe('ctx.bar()');
+    expect((editorInfos.token as any)?.completion?.insertText).toBe('ctx.token');
+  });
+
   it('should return property infos with completion/ref/examples', async () => {
     const ctx = new FlowContext();
     ctx.defineProperty('token', {

package/src/__tests__/runjsContext.test.ts

@@ -88,6 +88,19 @@ describe('flowRunJSContext registry and doc', () => {
       const doc = getRunJSDocFor(ctx as any, { version: 'v1' });
       expect(doc).toBeTruthy();
       expect(doc?.label).toMatch(/RunJS base/);
+      expect(doc?.properties?.element).toBeUndefined();
+    });
+
+    it('should mark element-dependent base completions with element requirement', () => {
+      const ctx: any = { model: { constructor: { name: 'UnknownModel' } } };
+      const doc = getRunJSDocFor(ctx as any, { version: 'v1' });
+
+      expect((doc?.methods?.render as any)?.completion?.requires).toContain('element');
+      expect((doc?.properties?.viewer as any)?.properties?.popover?.completion?.requires).toContain('element');
+      expect((doc?.properties?.viewer as any)?.properties?.embed?.completion?.requires).toContain('element');
+      expect(
+        (doc?.properties?.libs as any)?.properties?.ReactDOM?.properties?.createRoot?.completion?.requires,
+      ).toContain('element');
     });
 
     it('should support locale-specific doc', () => {
@@ -99,6 +112,11 @@ describe('flowRunJSContext registry and doc', () => {
       const messageText =
         typeof message === 'string' ? message : (message as any)?.description ?? (message as any)?.detail ?? '';
       expect(String(messageText)).toMatch(/Ant Design 全局消息/);
+      expect((doc?.methods?.render as any)?.completion?.requires).toContain('element');
+      expect((doc?.properties?.viewer as any)?.properties?.popover?.completion?.requires).toContain('element');
+      expect(
+        (doc?.properties?.libs as any)?.properties?.ReactDOM?.properties?.createRoot?.completion?.requires,
+      ).toContain('element');
     });
 
     it('should fallback to English when locale is not found', () => {

package/src/__tests__/runjsContextImplementations.test.ts

@@ -27,7 +27,10 @@ describe('Specific RunJSContext implementations', () => {
       const ctx: any = { model: { constructor: { name: 'JSColumnModel' } } };
       const doc = getRunJSDocFor(ctx as any, { version: 'v1' });
       expect(doc?.properties?.element).toBeTruthy();
-      expect(doc?.properties?.element).toContain('ElementProxy');
+      const elementDoc: any = doc?.properties?.element;
+      expect(elementDoc?.detail).toContain('ElementProxy');
+      expect(elementDoc?.properties?.setAttribute).toBeTruthy();
+      expect(elementDoc?.properties?.querySelector).toBeTruthy();
     });
 
     it('should have record property in doc', () => {
@@ -68,7 +71,9 @@ describe('Specific RunJSContext implementations', () => {
       (ctx as any).defineProperty('api', { value: { auth: { locale: 'zh-CN' } } });
       const doc = getRunJSDocFor(ctx as any, { version: 'v1' });
       expect(doc?.label).toMatch(/JS 列/);
-      expect(doc?.properties?.element).toContain('表格单元格');
+      const elementDoc: any = doc?.properties?.element;
+      expect(elementDoc?.description).toContain('表格单元格');
+      expect(elementDoc?.properties?.addEventListener).toBeTruthy();
     });
 
     it('should create instance successfully', () => {
@@ -162,6 +167,7 @@ describe('Specific RunJSContext implementations', () => {
       const ctx: any = { model: { constructor: { name: 'JSRecordActionModel' } } };
       const doc = getRunJSDocFor(ctx as any, { version: 'v1' });
       expect(doc?.properties?.record).toBeTruthy();
+      expect(doc?.properties?.element).toBeUndefined();
     });
 
     it('should have filterByTk property', () => {
@@ -184,6 +190,7 @@ describe('Specific RunJSContext implementations', () => {
       const ctx: any = { model: { constructor: { name: 'JSCollectionActionModel' } } };
       const doc = getRunJSDocFor(ctx as any, { version: 'v1' });
       expect(doc?.properties?.resource).toBeTruthy();
+      expect(doc?.properties?.element).toBeUndefined();
     });
 
     it('should support zh-CN locale', () => {

package/src/__tests__/runjsLocales.test.ts

@@ -12,6 +12,10 @@ import { getRunJSDocFor } from '..';
 import { setupRunJSContexts } from '../runjs-context/setup';
 import { FlowContext } from '../flowContext';
 
+function getRunJSDocText(doc: unknown) {
+  return typeof doc === 'string' ? doc : (doc as any)?.description ?? (doc as any)?.detail ?? '';
+}
+
 describe('RunJS locales patch (engine doc)', () => {
   beforeAll(async () => {
     await setupRunJSContexts();
@@ -30,10 +34,7 @@ describe('RunJS locales patch (engine doc)', () => {
     (ctx as any).defineProperty('model', { value: { constructor: { name: 'JSBlockModel' } } });
     (ctx as any).defineProperty('api', { value: { auth: { locale: 'zh-CN' } } });
     const doc = getRunJSDocFor(ctx as any, { version: 'v1' });
-    const message = doc?.properties?.message;
-    const messageText =
-      typeof message === 'string' ? message : (message as any)?.description ?? (message as any)?.detail ?? '';
-    expect(String(messageText)).toMatch(/Ant Design 全局消息 API/);
-    expect(String(doc?.methods?.t || '')).toMatch(/国际化函数/);
+    expect(String(getRunJSDocText(doc?.properties?.message))).toMatch(/Ant Design 全局消息 API/);
+    expect(String(getRunJSDocText(doc?.methods?.t))).toMatch(/国际化函数/);
   });
 });

package/src/__tests__/viewScopedFlowEngine.test.ts

@@ -18,6 +18,33 @@ import { APIClient as SDKApiClient } from '@nocobase/sdk';
 import { FlowEngine } from '../flowEngine';
 import { createViewScopedEngine } from '../ViewScopedFlowEngine';
 import { FlowModel } from '../models';
+import type { IFlowModelRepository } from '../types';
+
+const clone = <T>(value: T): T => (value == null ? value : JSON.parse(JSON.stringify(value)));
+
+class DirtyPageRepository implements IFlowModelRepository<FlowModel> {
+  public findOneCalls = 0;
+  public data: Record<string, any> | null = null;
+
+  async findOne(): Promise<Record<string, any> | null> {
+    this.findOneCalls += 1;
+    return clone(this.data);
+  }
+
+  async save(model: FlowModel): Promise<Record<string, any>> {
+    return model.serialize();
+  }
+
+  async destroy(): Promise<boolean> {
+    return true;
+  }
+
+  async move(): Promise<void> {}
+
+  async duplicate(): Promise<Record<string, any> | null> {
+    return null;
+  }
+}
 
 describe('ViewScopedFlowEngine', () => {
   it('shares global actions/events and model classes with parent', async () => {
@@ -307,4 +334,110 @@ describe('ViewScopedFlowEngine', () => {
     expect(result).not.toBeNull();
     expect(result?.uid).toBe('child-normal');
   });
+
+  it('reloads a dirty loaded page from repository and replaces stale parent reference', async () => {
+    const root = new FlowEngine();
+    const repository = new DirtyPageRepository();
+    root.setModelRepository(repository);
+
+    class ParentModel extends FlowModel {}
+    class PageModel extends FlowModel {}
+    class BlockModel extends FlowModel {}
+    root.registerModels({ ParentModel, PageModel, BlockModel });
+
+    const parent = root.createModel<ParentModel>({ use: 'ParentModel', uid: 'popup-action' });
+    const oldScoped = createViewScopedEngine(root);
+    const stalePage = oldScoped.createModel<PageModel>({
+      use: 'PageModel',
+      uid: 'popup-page',
+      parentId: parent.uid,
+      subKey: 'page',
+      subType: 'object',
+      subModels: {
+        items: [{ use: 'BlockModel', uid: 'stale-block' }],
+      },
+    });
+    const staleBlock = stalePage.findSubModel('items' as any, (item) => item.uid === 'stale-block') as FlowModel;
+    parent.setSubModel('page', stalePage);
+    oldScoped.unlinkFromStack();
+
+    repository.data = {
+      use: 'PageModel',
+      uid: 'popup-page',
+      parentId: parent.uid,
+      subKey: 'page',
+      subType: 'object',
+      subModels: {
+        items: [{ use: 'BlockModel', uid: 'fresh-block' }],
+      },
+    };
+
+    root.flowSettings.enable();
+    await staleBlock.saveStepParams();
+    root.flowSettings.disable();
+    repository.findOneCalls = 0;
+
+    const runtimeScoped = createViewScopedEngine(root);
+    const loaded = await runtimeScoped.loadOrCreateModel<PageModel>({
+      async: true,
+      parentId: parent.uid,
+      subKey: 'page',
+      subType: 'object',
+      use: 'PageModel',
+    });
+
+    expect(repository.findOneCalls).toBe(1);
+    expect(loaded).not.toBe(stalePage);
+    expect((parent.subModels as any).page).toBe(loaded);
+    expect(loaded?.mapSubModels('items' as any, (item) => item.uid)).toEqual(['fresh-block']);
+
+    repository.findOneCalls = 0;
+    const nextRuntimeScoped = createViewScopedEngine(root);
+    const loadedAgain = await nextRuntimeScoped.loadOrCreateModel<PageModel>({
+      async: true,
+      parentId: parent.uid,
+      subKey: 'page',
+      subType: 'object',
+      use: 'PageModel',
+    });
+
+    expect(repository.findOneCalls).toBe(0);
+    expect(loadedAgain?.uid).toBe('popup-page');
+  });
+
+  it('does not bypass loaded page cache after a non-config save', async () => {
+    const root = new FlowEngine();
+    const repository = new DirtyPageRepository();
+    root.setModelRepository(repository);
+
+    class ParentModel extends FlowModel {}
+    class PageModel extends FlowModel {}
+    root.registerModels({ ParentModel, PageModel });
+
+    const parent = root.createModel<ParentModel>({ use: 'ParentModel', uid: 'normal-parent' });
+    const stalePage = root.createModel<PageModel>({
+      use: 'PageModel',
+      uid: 'normal-page',
+      parentId: parent.uid,
+      subKey: 'page',
+      subType: 'object',
+    });
+    parent.setSubModel('page', stalePage);
+
+    root.flowSettings.disable();
+    await root.saveModel(stalePage);
+    repository.findOneCalls = 0;
+
+    const runtimeScoped = createViewScopedEngine(root);
+    const loaded = await runtimeScoped.loadOrCreateModel<PageModel>({
+      async: true,
+      parentId: parent.uid,
+      subKey: 'page',
+      subType: 'object',
+      use: 'PageModel',
+    });
+
+    expect(repository.findOneCalls).toBe(0);
+    expect(loaded?.uid).toBe('normal-page');
+  });
 });

package/src/components/subModel/LazyDropdown.tsx

@@ -463,6 +463,7 @@ const createSearchItem = (
   },
   activateSearchSubmenu: (key: string) => void,
   deactivateSearchSubmenu: (key: string) => void,
+  shouldActivateSearchSubmenu: boolean,
 ) => ({
   key: `${searchKey}-search`,
   type: 'group' as const,
@@ -480,28 +481,34 @@ const createSearchItem = (
         onChange={(e) => {
           e.stopPropagation();
           const value = e.target.value;
-          activateSearchSubmenu(searchKey);
+          if (shouldActivateSearchSubmenu) {
+            activateSearchSubmenu(searchKey);
+          }
           if ((e.nativeEvent as any)?.isComposing || searchHandlers.isComposing(searchKey)) {
             searchHandlers.updateInputValue(searchKey, value);
             return;
           }
-          if (!value) {
+          if (!value && shouldActivateSearchSubmenu) {
             deactivateSearchSubmenu(searchKey);
           }
           searchHandlers.updateSearchValue(searchKey, value);
         }}
         onCompositionStart={(e) => {
           e.stopPropagation();
-          activateSearchSubmenu(searchKey);
+          if (shouldActivateSearchSubmenu) {
+            activateSearchSubmenu(searchKey);
+          }
           searchHandlers.startComposition(searchKey);
         }}
         onCompositionEnd={(e) => {
           e.stopPropagation();
           const value = e.currentTarget.value;
-          if (value) {
-            activateSearchSubmenu(searchKey);
-          } else {
-            deactivateSearchSubmenu(searchKey);
+          if (shouldActivateSearchSubmenu) {
+            if (value) {
+              activateSearchSubmenu(searchKey);
+            } else {
+              deactivateSearchSubmenu(searchKey);
+            }
           }
           searchHandlers.endComposition(searchKey, value);
         }}
@@ -737,6 +744,7 @@ const LazyDropdown: React.FC<Omit<DropdownProps, 'menu'> & { menu: LazyDropdownM
     const searchKey = keyPath;
     const currentSearchValue = searchValues[searchKey] || '';
     const currentInputValue = inputValues[searchKey] ?? currentSearchValue;
+    const shouldActivateSearchSubmenu = !(item.type === 'group' && path.length === 0);
 
     // 递归过滤：当 child 为分组时，会继续向下过滤其 children；
     // 仅保留自身匹配或存在匹配子项的分组。
@@ -770,6 +778,7 @@ const LazyDropdown: React.FC<Omit<DropdownProps, 'menu'> & { menu: LazyDropdownM
       searchHandlers,
       activateSearchSubmenu,
       deactivateSearchSubmenu,
+      shouldActivateSearchSubmenu,
     );
     const dividerItem = { key: `${keyPath}-search-divider`, type: 'divider' as const };