@nocobase/flow-engine 2.0.0-beta.2 → 2.0.0-beta.20

package/src/flowSettings.ts

@@ -32,6 +32,7 @@ import {
   shouldHideStepInSettings,
 } from './utils';
 import { FlowStepContext } from './hooks/useFlowStep';
+import { GLOBAL_EMBED_CONTAINER_ID, EMBED_REPLACING_DATA_KEY } from './views';
 
 const Panel = Collapse.Panel;
 
@@ -682,14 +683,10 @@ export class FlowSettings {
       typeof resolvedUiMode === 'object' && resolvedUiMode ? resolvedUiMode.props || {} : {};
 
     if (modeType === 'embed') {
-      const target = document.querySelector<HTMLDivElement>('#nocobase-embed-container');
+      const target = document.querySelector<HTMLDivElement>(`#${GLOBAL_EMBED_CONTAINER_ID}`);
       const onOpen = modeProps.onOpen;
       const onClose = modeProps.onClose;
 
-      if (target) {
-        target.innerHTML = ''; // 清空容器内原有内容
-      }
-
       modeProps = {
         target,
         styles: {
@@ -699,15 +696,19 @@ export class FlowSettings {
         },
         ...modeProps,
         onOpen() {
-          target.style.width = modeProps.width || '33.3%';
-          target.style.maxWidth = modeProps.maxWidth || '800px';
-          target.style.minWidth = modeProps.minWidth || '0px';
+          if (target) {
+            target.style.width = modeProps.width || '33.3%';
+            target.style.maxWidth = modeProps.maxWidth || '800px';
+            target.style.minWidth = modeProps.minWidth || '0px';
+          }
           onOpen?.();
         },
         onClose() {
-          target.style.width = 'auto';
-          target.style.maxWidth = 'none';
-          target.style.minWidth = 'auto';
+          if (target && target.dataset[EMBED_REPLACING_DATA_KEY] !== '1') {
+            target.style.width = 'auto';
+            target.style.maxWidth = 'none';
+            target.style.minWidth = 'auto';
+          }
           onClose?.();
         },
       };

package/src/index.ts

@@ -13,6 +13,8 @@ export * from './types';
 // 工具函数
 export * from './utils';
 export { compileRunJs } from './utils/jsxTransform';
+export { registerRunJSLib } from './runjsLibs';
+export type { RunJSLibCache, RunJSLibLoader } from './runjsLibs';
 
 // 资源类
 export * from './resources';
@@ -42,6 +44,14 @@ export { setupRunJSContexts } from './runjs-context/setup';
 export { getSnippetBody, listSnippetsForContext } from './runjs-context/snippets';
 
 export * from './views';
+export {
+  DATA_SOURCE_DIRTY_EVENT,
+  ENGINE_SCOPE_KEY,
+  getEmitterViewActivatedVersion,
+  VIEW_ACTIVATED_EVENT,
+  VIEW_ACTIVATED_VERSION,
+  VIEW_ENGINE_SCOPE,
+} from './views/viewEvents';
 
 export * from './FlowDefinition';
 export { createViewScopedEngine } from './ViewScopedFlowEngine';

package/src/models/CollectionFieldModel.tsx

@@ -190,7 +190,7 @@ export class CollectionFieldModel<T extends DefaultStructure = DefaultStructure>
     }
 
     // Filter the mappings based on the `when` condition
-    const bindings = this.bindings.get(interfaceName);
+    const bindings = this.bindings.get(interfaceName).sort((a, b) => a.order - b.order);
     return bindings.filter(
       (binding) => ctx.engine.getModelClass(binding.modelName) && binding.when(ctx, collectionField),
     );
@@ -261,6 +261,7 @@ export class CollectionFieldModel<T extends DefaultStructure = DefaultStructure>
     interfaceName: string | string[],
     options: {
       isDefault?: boolean;
+      order?: number;
       defaultProps?: object | ((ctx: FlowEngineContext, fieldInstance: CollectionField) => object);
       when?: (ctx: FlowEngineContext, fieldInstance: CollectionField) => boolean;
     } = {},
@@ -281,6 +282,7 @@ export class CollectionFieldModel<T extends DefaultStructure = DefaultStructure>
       isDefault: options.isDefault || false,
       defaultProps: options.defaultProps || null,
       when: options.when || defaultWhen,
+      order: options.order,
     });
 
     // Update the map

package/src/models/__tests__/dispatchEvent.when.test.ts

@@ -0,0 +1,356 @@
+/**
+ * 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 { describe, test, expect } from 'vitest';
+import { FlowEngine } from '../../flowEngine';
+import { FlowModel } from '../flowModel';
+
+describe('dispatchEvent dynamic event flow phase (scheduleModelOperation integration)', () => {
+  test('default (phase undefined): instance flows run before static flows', async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      steps: {
+        a: { handler: async () => void calls.push('static-a') } as any,
+      },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+    model.registerFlow('D', {
+      on: { eventName: 'go' },
+      steps: {
+        d: { handler: async () => void calls.push('dynamic') } as any,
+      },
+    });
+
+    await model.dispatchEvent('go');
+    expect(calls).toEqual(['dynamic', 'static-a']);
+  });
+
+  test("phase='afterAllFlows': instance flow runs after static flows", async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      steps: {
+        a: { handler: async () => void calls.push('static-a') } as any,
+      },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+    model.registerFlow('D', {
+      on: { eventName: 'go', phase: 'afterAllFlows' },
+      steps: {
+        d: { handler: async () => void calls.push('dynamic') } as any,
+      },
+    });
+
+    await model.dispatchEvent('go');
+    expect(calls).toEqual(['static-a', 'dynamic']);
+  });
+
+  test("phase='beforeFlow': instance flow runs before the target static flow", async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      steps: {
+        a: { handler: async () => void calls.push('static-a') } as any,
+        b: { handler: async () => void calls.push('static-b') } as any,
+      },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+    model.registerFlow('D', {
+      on: { eventName: 'go', phase: 'beforeFlow', flowKey: 'S' },
+      steps: {
+        d: { handler: async () => void calls.push('dynamic') } as any,
+      },
+    });
+
+    await model.dispatchEvent('go');
+    expect(calls).toEqual(['dynamic', 'static-a', 'static-b']);
+  });
+
+  test("phase='afterFlow': instance flow runs after the target static flow", async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      steps: {
+        a: { handler: async () => void calls.push('static-a') } as any,
+        b: { handler: async () => void calls.push('static-b') } as any,
+      },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+    model.registerFlow('D', {
+      on: { eventName: 'go', phase: 'afterFlow', flowKey: 'S' },
+      steps: {
+        d: { handler: async () => void calls.push('dynamic') } as any,
+      },
+    });
+
+    await model.dispatchEvent('go');
+    expect(calls).toEqual(['static-a', 'static-b', 'dynamic']);
+  });
+
+  test("phase='beforeStep': instance flow runs before the target static step", async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      steps: {
+        a: { handler: async () => void calls.push('static-a') } as any,
+        b: { handler: async () => void calls.push('static-b') } as any,
+      },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+    model.registerFlow('D', {
+      on: { eventName: 'go', phase: 'beforeStep', flowKey: 'S', stepKey: 'a' },
+      steps: {
+        d: { handler: async () => void calls.push('dynamic') } as any,
+      },
+    });
+
+    await model.dispatchEvent('go');
+    expect(calls).toEqual(['dynamic', 'static-a', 'static-b']);
+  });
+
+  test("phase='afterStep': instance flow runs after the target static step", async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      steps: {
+        a: { handler: async () => void calls.push('static-a') } as any,
+        b: { handler: async () => void calls.push('static-b') } as any,
+      },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+    model.registerFlow('D', {
+      on: { eventName: 'go', phase: 'afterStep', flowKey: 'S', stepKey: 'a' },
+      steps: {
+        d: { handler: async () => void calls.push('dynamic') } as any,
+      },
+    });
+
+    await model.dispatchEvent('go');
+    expect(calls).toEqual(['static-a', 'dynamic', 'static-b']);
+  });
+
+  test("phase='beforeFlow' missing flow: falls back to afterAllFlows", async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      steps: {
+        a: { handler: async () => void calls.push('static-a') } as any,
+      },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+    model.registerFlow('D', {
+      on: { eventName: 'go', phase: 'beforeFlow', flowKey: 'missing' },
+      steps: {
+        d: { handler: async () => void calls.push('dynamic') } as any,
+      },
+    });
+
+    await model.dispatchEvent('go');
+    expect(calls).toEqual(['static-a', 'dynamic']);
+  });
+
+  test("phase='beforeStep' missing step: falls back to afterAllFlows", async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      steps: {
+        a: { handler: async () => void calls.push('static-a') } as any,
+      },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+    model.registerFlow('D', {
+      on: { eventName: 'go', phase: 'beforeStep', flowKey: 'S', stepKey: 'missing' },
+      steps: {
+        d: { handler: async () => void calls.push('dynamic') } as any,
+      },
+    });
+
+    await model.dispatchEvent('go');
+    expect(calls).toEqual(['static-a', 'dynamic']);
+  });
+
+  test('multiple flows on same anchor: executes by flow.sort asc (stable)', async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      steps: {
+        a: { handler: async () => void calls.push('static-a') } as any,
+      },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+    model.registerFlow('D5', {
+      sort: 5,
+      on: { eventName: 'go', phase: 'beforeStep', flowKey: 'S', stepKey: 'a' },
+      steps: {
+        d: { handler: async () => void calls.push('dynamic-5') } as any,
+      },
+    });
+    model.registerFlow('D0', {
+      sort: 0,
+      on: { eventName: 'go', phase: 'beforeStep', flowKey: 'S', stepKey: 'a' },
+      steps: {
+        d: { handler: async () => void calls.push('dynamic-0') } as any,
+      },
+    });
+
+    await model.dispatchEvent('go');
+    expect(calls).toEqual(['dynamic-0', 'dynamic-5', 'static-a']);
+  });
+});
+
+describe('dispatchEvent static flow phase (scheduleModelOperation integration)', () => {
+  test("phase='beforeFlow': static flow runs before the target static flow", async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      steps: {
+        a: { handler: async () => void calls.push('static-a') } as any,
+      },
+    });
+
+    M.registerFlow({
+      key: 'P',
+      on: { eventName: 'go', phase: 'beforeFlow', flowKey: 'S' },
+      steps: {
+        p: { handler: async () => void calls.push('phase') } as any,
+      },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+    await model.dispatchEvent('go');
+    expect(calls).toEqual(['phase', 'static-a']);
+  });
+
+  test("phase='afterStep': static flow runs after the target static step", async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      steps: {
+        a: { handler: async () => void calls.push('static-a') } as any,
+        b: { handler: async () => void calls.push('static-b') } as any,
+      },
+    });
+
+    M.registerFlow({
+      key: 'P',
+      on: { eventName: 'go', phase: 'afterStep', flowKey: 'S', stepKey: 'a' },
+      steps: {
+        p: { handler: async () => void calls.push('phase') } as any,
+      },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+    await model.dispatchEvent('go');
+    expect(calls).toEqual(['static-a', 'phase', 'static-b']);
+  });
+
+  test("phase='afterAllFlows': static flow runs after static flows", async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      steps: {
+        a: { handler: async () => void calls.push('static-a') } as any,
+      },
+    });
+
+    M.registerFlow({
+      key: 'P',
+      on: { eventName: 'go', phase: 'afterAllFlows' },
+      steps: {
+        p: { handler: async () => void calls.push('phase') } as any,
+      },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+    await model.dispatchEvent('go');
+    expect(calls).toEqual(['static-a', 'phase']);
+  });
+});