@nocobase/client-v2 2.2.0-beta.7 → 2.2.0-beta.9

package/src/entry-actions/EntryActionManager.ts

@@ -0,0 +1,76 @@
+/**
+ * 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 {
+  define,
+  observable,
+  type FlowModelContext,
+  type SubModelItem,
+  type SubModelItemsType,
+} from '@nocobase/flow-engine';
+
+export type EntryActionScope = 'action-panel' | 'app-switcher' | string;
+
+export type EntryActionProvider = (ctx: FlowModelContext) => SubModelItem[] | Promise<SubModelItem[]>;
+
+type ProviderRecord = {
+  name: string;
+  scope: EntryActionScope;
+  provider: EntryActionProvider;
+  sort: number;
+};
+
+export class EntryActionManager {
+  private readonly providers = new Map<string, ProviderRecord>();
+  revision = 0;
+
+  constructor() {
+    define(this, {
+      revision: observable.ref,
+    });
+  }
+
+  register(name: string, options: { scope: EntryActionScope; provider: EntryActionProvider; sort?: number }) {
+    this.providers.set(name, {
+      name,
+      scope: options.scope,
+      provider: options.provider,
+      sort: options.sort ?? 0,
+    });
+    this.invalidate();
+  }
+
+  unregister(name: string) {
+    this.providers.delete(name);
+    this.invalidate();
+  }
+
+  invalidate() {
+    this.revision += 1;
+  }
+
+  getItems(scope: EntryActionScope): SubModelItemsType {
+    return async (ctx) => {
+      const providers = [...this.providers.values()]
+        .filter((item) => item.scope === scope)
+        .sort((a, b) => a.sort - b.sort);
+      const groups = await Promise.all(
+        providers.map(async (item) => {
+          try {
+            return await item.provider(ctx);
+          } catch (error) {
+            console.error(`[NocoBase] Failed to load entry action provider "${item.name}".`, error);
+            return [];
+          }
+        }),
+      );
+      return groups.flat();
+    };
+  }
+}

package/src/entry-actions/index.ts

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ */
+
+export * from './EntryActionManager';

package/src/flow/FlowPage.tsx

@@ -14,7 +14,7 @@ import {
   useFlowModelById,
   useFlowViewContext,
 } from '@nocobase/flow-engine';
-import type { FlowModel, FlowModelRendererProps, ModelConstructor } from '@nocobase/flow-engine';
+import type { FlowEngineContext, FlowModel, FlowModelRendererProps, ModelConstructor } from '@nocobase/flow-engine';
 import { useRequest } from 'ahooks';
 import React from 'react';
 import FlowRoute from './components/FlowRoute';
@@ -57,10 +57,36 @@ type FlowPageProps = {
   showFlowSettings?: FlowModelRendererProps['showFlowSettings'];
 };
 
+type FlowPageViewContext = FlowEngineContext & {
+  view?: {
+    inputArgs?: {
+      isMobileLayout?: unknown;
+    };
+  };
+};
+
+const bindViewLayoutState = (model: FlowModel, ctx?: FlowPageViewContext | null) => {
+  const hasViewMobileLayout = typeof ctx?.view?.inputArgs?.isMobileLayout === 'boolean';
+  const hasContextMobileLayout = typeof ctx?.isMobileLayout === 'boolean';
+  if (!hasViewMobileLayout && !hasContextMobileLayout) {
+    return;
+  }
+
+  model.context.defineProperty('isMobileLayout', {
+    get: () => {
+      if (typeof ctx?.isMobileLayout === 'boolean') {
+        return ctx.isMobileLayout;
+      }
+      return !!ctx?.view?.inputArgs?.isMobileLayout;
+    },
+    cache: false,
+  });
+};
+
 export const FlowPage = React.memo((props: FlowPageProps & Record<string, unknown>) => {
   const { pageModelClass = 'ChildPageModel', parentId, onModelLoaded, defaultTabTitle, ...rest } = props;
   const flowEngine = useFlowEngine();
-  const ctx = useFlowViewContext();
+  const ctx = useFlowViewContext<FlowPageViewContext>();
   const { loading, data, error } = useRequest(
     async () => {
       const ModelClass = await flowEngine.getModelClassAsync(pageModelClass);
@@ -105,6 +131,7 @@ export const FlowPage = React.memo((props: FlowPageProps & Record<string, unknow
       const data = await flowEngine.loadOrCreateModel(options, { skipSave: !flowEngine.context.flowSettingsEnabled });
       if (data?.uid && onModelLoaded) {
         data.context.addDelegate(ctx);
+        bindViewLayoutState(data, ctx);
         data.removeParentDelegate();
         onModelLoaded(data.uid, data);
       }

package/src/flow/__tests__/FlowPage.test.tsx

@@ -7,44 +7,105 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { render } from '@testing-library/react';
+import { render, waitFor } from '@testing-library/react';
 import React from 'react';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { FlowPage } from '../FlowPage';
 
-const mocks = vi.hoisted(() => ({
-  rendererProps: undefined as any,
-  model: {
+type TestContextProperty = {
+  value?: unknown;
+  get?: () => unknown;
+};
+
+type TestModelContext = {
+  isMobileLayout: boolean;
+  themeToken: {
+    marginBlock: number;
+  };
+  addDelegate: ReturnType<typeof vi.fn>;
+  defineProperty: ReturnType<typeof vi.fn>;
+};
+
+type TestPageModel = {
+  uid: string;
+  props: {
+    showFlowSettings: boolean;
+  };
+  context: TestModelContext;
+  removeParentDelegate: ReturnType<typeof vi.fn>;
+};
+
+type RendererProps = {
+  model?: TestPageModel;
+  showFlowSettings?: boolean;
+} & Record<string, unknown>;
+
+const defineContextProperty = (context: TestModelContext, key: string, property: TestContextProperty) => {
+  Object.defineProperty(context, key, {
+    configurable: true,
+    enumerable: true,
+    get: property.get || (() => property.value),
+  });
+};
+
+const createPageModel = (): TestPageModel => {
+  const context = {
+    isMobileLayout: false,
+    themeToken: {
+      marginBlock: 16,
+    },
+    addDelegate: vi.fn(),
+    defineProperty: vi.fn((key: string, property: TestContextProperty) => {
+      defineContextProperty(context, key, property);
+    }),
+  };
+
+  return {
     uid: 'public-form-page',
     props: {
       showFlowSettings: false,
     },
-    context: {
-      isMobileLayout: false,
-      themeToken: {
-        marginBlock: 16,
-      },
-    },
-  },
+    context,
+    removeParentDelegate: vi.fn(),
+  };
+};
+
+const mocks = vi.hoisted(() => ({
+  rendererMobileStates: [] as boolean[],
+  rendererProps: undefined as RendererProps | undefined,
+  model: undefined as TestPageModel | undefined,
+  viewInputMobileLayout: true as boolean | undefined,
+  contextMobileLayout: undefined as boolean | undefined,
 }));
 
 vi.mock('@nocobase/flow-engine', async () => {
-  const actual = await vi.importActual<any>('@nocobase/flow-engine');
+  const actual = await vi.importActual<typeof import('@nocobase/flow-engine')>('@nocobase/flow-engine');
   const ReactModule = await import('react');
+  class TestPageModelClass {}
 
   return {
     ...actual,
-    FlowModelRenderer: vi.fn((props: any) => {
+    FlowModelRenderer: vi.fn((props: RendererProps) => {
       mocks.rendererProps = props;
+      if (typeof props.model?.context.isMobileLayout === 'boolean') {
+        mocks.rendererMobileStates.push(props.model.context.isMobileLayout);
+      }
       return ReactModule.createElement('div', { 'data-testid': 'flow-model-renderer' });
     }),
     useFlowEngine: vi.fn(() => ({
-      getModelClassAsync: vi.fn(),
-      loadOrCreateModel: vi.fn(),
+      getModelClassAsync: vi.fn(async () => TestPageModelClass),
+      loadOrCreateModel: vi.fn(async () => mocks.model),
       context: {},
+      translate: vi.fn((value: string) => value),
     })),
     useFlowModelById: vi.fn(() => mocks.model),
     useFlowViewContext: vi.fn(() => ({
+      view: {
+        inputArgs: {
+          ...(typeof mocks.viewInputMobileLayout === 'boolean' ? { isMobileLayout: mocks.viewInputMobileLayout } : {}),
+        },
+      },
+      ...(typeof mocks.contextMobileLayout === 'boolean' ? { isMobileLayout: mocks.contextMobileLayout } : {}),
       themeToken: {
         marginBlock: 16,
       },
@@ -53,27 +114,93 @@ vi.mock('@nocobase/flow-engine', async () => {
 });
 
 vi.mock('ahooks', async () => {
-  const actual = await vi.importActual<any>('ahooks');
+  const actual = await vi.importActual<typeof import('ahooks')>('ahooks');
+  const ReactModule = await import('react');
   return {
     ...actual,
-    useRequest: vi.fn(() => ({
-      loading: false,
-      data: {
-        uid: 'public-form-page',
-      },
-      error: null,
-    })),
+    useRequest: vi.fn((service: () => Promise<unknown>) => {
+      const serviceRef = ReactModule.useRef(service);
+      const [state, setState] = ReactModule.useState<{
+        loading: boolean;
+        data?: unknown;
+        error?: unknown;
+      }>({
+        loading: true,
+      });
+
+      ReactModule.useEffect(() => {
+        let active = true;
+        serviceRef
+          .current()
+          .then((data) => {
+            if (active) {
+              setState({ loading: false, data, error: null });
+            }
+          })
+          .catch((error) => {
+            if (active) {
+              setState({ loading: false, data: undefined, error });
+            }
+          });
+
+        return () => {
+          active = false;
+        };
+      }, []);
+
+      return state;
+    }),
   };
 });
 
 describe('FlowPage', () => {
   afterEach(() => {
+    mocks.rendererMobileStates = [];
     mocks.rendererProps = undefined;
+    mocks.model = undefined;
+    mocks.viewInputMobileLayout = true;
+    mocks.contextMobileLayout = undefined;
   });
 
-  it('uses showFlowSettings from page model props', () => {
+  it('uses showFlowSettings from page model props', async () => {
+    mocks.model = createPageModel();
     render(<FlowPage />);
 
-    expect(mocks.rendererProps?.showFlowSettings).toBe(false);
+    await waitFor(() => {
+      expect((mocks.rendererProps as { showFlowSettings?: boolean } | undefined)?.showFlowSettings).toBe(false);
+    });
+  });
+
+  it('exposes mobile layout state from route-managed view inputArgs before first render', async () => {
+    mocks.model = createPageModel();
+    render(<FlowPage onModelLoaded={vi.fn()} />);
+
+    await waitFor(() => {
+      expect(mocks.rendererMobileStates.length).toBeGreaterThan(0);
+    });
+    expect(mocks.rendererMobileStates[0]).toBe(true);
   });
+
+  it.each([
+    { viewInputMobileLayout: true, contextMobileLayout: false, expected: false },
+    { viewInputMobileLayout: false, contextMobileLayout: true, expected: true },
+    { viewInputMobileLayout: undefined, contextMobileLayout: true, expected: true },
+    { viewInputMobileLayout: undefined, contextMobileLayout: false, expected: false },
+    { viewInputMobileLayout: true, contextMobileLayout: undefined, expected: true },
+    { viewInputMobileLayout: false, contextMobileLayout: undefined, expected: false },
+  ])(
+    'resolves mobile layout state from view input args and layout context %#',
+    async ({ viewInputMobileLayout, contextMobileLayout, expected }) => {
+      mocks.viewInputMobileLayout = viewInputMobileLayout;
+      mocks.contextMobileLayout = contextMobileLayout;
+      mocks.model = createPageModel();
+
+      render(<FlowPage onModelLoaded={vi.fn()} />);
+
+      await waitFor(() => {
+        expect(mocks.rendererMobileStates.length).toBeGreaterThan(0);
+      });
+      expect(mocks.rendererMobileStates[0]).toBe(expected);
+    },
+  );
 });