@nocobase/client-v2 2.2.0-alpha.4 → 2.2.0-alpha.6

package/src/flow/admin-shell/admin-layout/AdminLayoutComponent.tsx

@@ -285,13 +285,44 @@ function SetIsMobileLayout(props: { isMobile: boolean; children: any; model?: Ad
   const flowEngine = useFlowEngine();
   const adminLayoutModel = props.model || flowEngine.getModel<AdminLayoutModel>(ADMIN_LAYOUT_MODEL_UID);
 
-  useEffect(() => {
+  useLayoutEffect(() => {
     adminLayoutModel?.setIsMobileLayout(props.isMobile);
   }, [adminLayoutModel, props.isMobile]);
 
   return props.children;
 }
 
+function AdminLayoutContentWithMobileState(props: {
+  isMobile: boolean;
+  model?: AdminLayoutModel;
+  designable?: boolean;
+  layout?: AdminLayoutModel['layout'];
+  onContentElementChange?: (element: HTMLDivElement | null) => void;
+}) {
+  const modelRef = useRef(props.model);
+  const isMobileRef = useRef(props.isMobile);
+  const onContentElementChangeRef = useRef(props.onContentElementChange);
+
+  modelRef.current = props.model;
+  isMobileRef.current = props.isMobile;
+  onContentElementChangeRef.current = props.onContentElementChange;
+
+  const handleContentElementChange = useCallback((element: HTMLDivElement | null) => {
+    if (element) {
+      modelRef.current?.setIsMobileLayout(isMobileRef.current);
+    }
+    onContentElementChangeRef.current?.(element);
+  }, []);
+
+  return (
+    <AdminLayoutContent
+      designable={props.designable}
+      layout={props.layout}
+      onContentElementChange={handleContentElementChange}
+    />
+  );
+}
+
 const DesignerButtonMenuItem: FC<{ item: AdminLayoutMenuNode; fallbackParentRoute?: NocoBaseDesktopRoute }> = (
   props,
 ) => {
@@ -410,8 +441,8 @@ export const AdminLayoutComponent = observer((props: any) => {
   );
   const designable = !isMobileSider && preferredFlowSettingsEnabled;
   const { styles } = useHeaderStyle();
-  const { appList } = useApplications();
-  const appListRender = useAppListRender();
+  const { appList, appSwitcherModel } = useApplications(adminLayoutModel);
+  const appListRender = useAppListRender(appSwitcherModel);
   const flowSettingsSyncRef = useRef(0);
   const desiredFlowSettingsEnabledRef = useRef(false);
   const handleLayoutContentElementChange = useCallback(
@@ -634,6 +665,10 @@ export const AdminLayoutComponent = observer((props: any) => {
         z-index: 2000 !important;
       }
 
+      .ant-pro-layout-apps-popover .ant-popover-content {
+        margin-top: 12px;
+      }
+
       .ant-pro-layout-apps-icon {
         color: ${customToken.colorTextHeaderMenu || 'rgba(255, 255, 255, 0.85)'};
       }
@@ -717,7 +752,9 @@ export const AdminLayoutComponent = observer((props: any) => {
                     <SetIsMobileLayout isMobile={isMobile} model={adminLayoutModel}>
                       <ConfigProvider theme={isMobile ? mobileTheme : theme}>
                         <GlobalStyle />
-                        <AdminLayoutContent
+                        <AdminLayoutContentWithMobileState
+                          isMobile={isMobile}
+                          model={adminLayoutModel}
                           designable={designable}
                           layout={adminLayoutModel?.layout}
                           onContentElementChange={handleLayoutContentElementChange}

package/src/flow/admin-shell/admin-layout/AppListRender.tsx

@@ -10,17 +10,28 @@
 import type { AppListProps } from '@ant-design/pro-layout/es/components/AppsLogoComponents/types';
 import { css } from '@emotion/css';
 import { Card, Typography, theme } from 'antd';
+import { observer } from '@nocobase/flow-engine';
 import React from 'react';
+import type { AppSwitcherActionPanelModel } from './AppSwitcherActionPanelModel';
 
 function renderIcon(icon: React.ReactNode | (() => React.ReactNode)) {
   return typeof icon === 'function' ? icon() : icon;
 }
 
-export function useAppListRender() {
+const AppSwitcherActionsContent = observer(
+  (props: { model: AppSwitcherActionPanelModel }) => <>{props.model.renderContent()}</>,
+  { displayName: 'AppSwitcherActionsContent' },
+);
+
+export function useAppListRender(appSwitcherModel?: AppSwitcherActionPanelModel) {
   const { token } = theme.useToken();
 
   return React.useCallback(
     (appList: AppListProps) => {
+      if (appSwitcherModel?.hasActions() || appSwitcherModel?.context.flowSettingsEnabled) {
+        return <AppSwitcherActionsContent model={appSwitcherModel} />;
+      }
+
       const columnCount = Math.min(Math.max(appList.length, 1), 2);
 
       return (
@@ -134,6 +145,6 @@ export function useAppListRender() {
         </div>
       );
     },
-    [token],
+    [appSwitcherModel, token],
   );
 }

package/src/flow/admin-shell/admin-layout/AppSwitcherActionPanelModel.tsx

@@ -0,0 +1,289 @@
+/**
+ * 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 { SettingOutlined } from '@ant-design/icons';
+import { css } from '@emotion/css';
+import { Icon } from '../../../components';
+import { ActionModel } from '../../models/base';
+import {
+  AddSubModelButton,
+  DndProvider,
+  DragHandler,
+  Droppable,
+  FlowModel,
+  FlowModelRenderer,
+  FlowSettingsButton,
+  mergeSubModelItems,
+  observer,
+  type SubModelItem,
+  type SubModelItemsType,
+} from '@nocobase/flow-engine';
+import { Avatar, Button, Card, Tooltip, Typography } from 'antd';
+import React from 'react';
+
+const defaultIconColors = ['#3d8bff', '#00a8b5', '#35b26b', '#f5a623', '#ff7a45', '#e85d75', '#9254de', '#597ef7'];
+
+function getDefaultIconColor(title?: React.ReactNode) {
+  const source = typeof title === 'string' ? title : '';
+  const hash = Array.from(source).reduce((sum, char) => sum + char.charCodeAt(0), 0);
+  return defaultIconColors[hash % defaultIconColors.length];
+}
+
+type AppSwitcherActionPanelStructure = {
+  subModels: {
+    actions?: ActionModel[];
+  };
+};
+
+function isRenderableActionModel(action: unknown): action is ActionModel {
+  if (!action || typeof action !== 'object') {
+    return false;
+  }
+
+  const candidate = action as Partial<ActionModel>;
+  return typeof candidate.getTitle === 'function' && typeof candidate.onClick === 'function';
+}
+
+type EntryActionAvailability = {
+  isEntryActionAvailable?: () => boolean;
+  getEntryActionUnavailableMessage?: () => string | undefined;
+};
+
+function isEntryActionUnavailable(action: ActionModel) {
+  const candidate = action as ActionModel & EntryActionAvailability;
+  return typeof candidate.isEntryActionAvailable === 'function' && !candidate.isEntryActionAvailable();
+}
+
+function getEntryActionUnavailableMessage(action: ActionModel) {
+  const candidate = action as ActionModel & EntryActionAvailability;
+  return candidate.getEntryActionUnavailableMessage?.();
+}
+
+export class AppSwitcherActionPanelModel extends FlowModel<AppSwitcherActionPanelStructure> {
+  getConfigureActionsItems(): SubModelItemsType {
+    const linkAction: SubModelItem = {
+      key: 'app-switcher:link',
+      label: this.context.t('Link'),
+      createModelOptions: {
+        use: 'LinkActionModel',
+      },
+    };
+    const jsAction: SubModelItem = {
+      key: 'app-switcher:js-action',
+      label: this.context.t('JS action'),
+      createModelOptions: {
+        use: 'JSActionModel',
+      },
+    };
+
+    return mergeSubModelItems([[linkAction], this.context.app.entryActionManager.getItems('app-switcher'), [jsAction]]);
+  }
+
+  renderConfigureActions() {
+    return <AppSwitcherConfigureActionsButton model={this} />;
+  }
+
+  private getRenderableActions(options: { includeHidden?: boolean; includeUnavailable?: boolean } = {}) {
+    return this.mapSubModels('actions', (action) => action)
+      .filter(isRenderableActionModel)
+      .filter((action) => options.includeUnavailable || !isEntryActionUnavailable(action))
+      .filter((action) => options.includeHidden || !action.hidden);
+  }
+
+  hasActions() {
+    return this.getRenderableActions().length > 0;
+  }
+
+  renderContent() {
+    const token = this.context.themeToken;
+    const designable = !!this.context.flowSettingsEnabled;
+    const actions = this.getRenderableActions({ includeHidden: designable, includeUnavailable: designable });
+    const columnCount = Math.min(Math.max(actions.length || 1, 1), 2);
+    const buttonResetClass = css`
+      &.ant-btn {
+        display: block;
+        width: 100%;
+        height: 100%;
+        padding: 0;
+        border: none;
+        box-shadow: none;
+        background: none;
+        color: ${token.colorText};
+        text-align: left;
+      }
+      &.ant-btn > span {
+        display: block;
+        width: 100%;
+        height: 100%;
+      }
+      .ant-btn-icon {
+        display: none;
+      }
+    `;
+    const contentClass = css`
+      max-width: calc(100vw - 48px);
+      max-height: calc(100vh - 48px);
+      overflow: auto;
+      padding: ${token.paddingXS}px;
+    `;
+    const listClass = css`
+      display: grid;
+      grid-template-columns: repeat(${columnCount}, 260px);
+      gap: ${token.marginXXS}px;
+      margin: 0;
+      padding: 0;
+      list-style: none;
+    `;
+
+    return (
+      <div className={contentClass}>
+        {actions.length ? (
+          <DndProvider>
+            <ul className={listClass}>
+              {actions.map((action) => {
+                const { icon = 'AppstoreOutlined', color } = action.props;
+                const title = action.getTitle();
+                const entryActionUnavailable = isEntryActionUnavailable(action);
+                const renderActionContent = (compact = false) => (
+                  <Card
+                    bordered={false}
+                    className={css`
+                      height: 56px;
+                      border-radius: ${token.borderRadius}px;
+                      box-shadow: none !important;
+                      opacity: ${compact ? token.opacityLoading : 1};
+
+                      &:hover {
+                        background: ${token.colorBgTextHover};
+                        box-shadow: none !important;
+                      }
+
+                      .ant-card-body {
+                        height: 100%;
+                        padding: ${token.paddingXS}px;
+                        display: flex;
+                        align-items: center;
+                        gap: ${token.marginXS}px;
+                      }
+                    `}
+                    styles={{ body: { background: 'transparent' } }}
+                  >
+                    <Avatar
+                      size={32}
+                      shape="square"
+                      icon={<Icon type={icon as string} />}
+                      style={{
+                        flex: '0 0 auto',
+                        borderRadius: 6,
+                        background: color || getDefaultIconColor(title),
+                      }}
+                    />
+                    <Typography.Text
+                      ellipsis
+                      title={typeof title === 'string' ? title : undefined}
+                      style={{
+                        minWidth: 0,
+                        color: token.colorText,
+                        fontSize: token.fontSize,
+                        lineHeight: token.lineHeight,
+                      }}
+                    >
+                      {title}
+                    </Typography.Text>
+                  </Card>
+                );
+                action.enableEditDanger = false;
+                action.enableEditType = false;
+                action.enableEditIconOnly = false;
+                action.enableEditColor = true;
+                action.renderButton = () => {
+                  if (entryActionUnavailable) {
+                    return (
+                      <Tooltip title={getEntryActionUnavailableMessage(action)}>
+                        <Button className={buttonResetClass} onClick={action.onClick.bind(action)}>
+                          {renderActionContent(true)}
+                        </Button>
+                      </Tooltip>
+                    );
+                  }
+                  return (
+                    <Button className={buttonResetClass} onClick={action.onClick.bind(action)}>
+                      {renderActionContent()}
+                    </Button>
+                  );
+                };
+                action.renderHiddenInConfig = () => (
+                  <Tooltip
+                    title={
+                      entryActionUnavailable
+                        ? getEntryActionUnavailableMessage(action)
+                        : this.context.t('The button is hidden and only visible when the UI Editor is active')
+                    }
+                  >
+                    <Button className={buttonResetClass} onClick={action.onClick.bind(action)}>
+                      {renderActionContent(true)}
+                    </Button>
+                  </Tooltip>
+                );
+
+                return (
+                  <li key={action.uid} style={{ width: 260, height: 56, listStyle: 'none' }}>
+                    <Droppable model={action}>
+                      <FlowModelRenderer
+                        model={action}
+                        showFlowSettings={{ showBackground: false, showBorder: false, toolbarPosition: 'above' }}
+                        extraToolbarItems={
+                          designable
+                            ? [
+                                {
+                                  key: 'drag-handler',
+                                  component: DragHandler,
+                                  sort: 1,
+                                },
+                              ]
+                            : []
+                        }
+                      />
+                    </Droppable>
+                  </li>
+                );
+              })}
+            </ul>
+          </DndProvider>
+        ) : (
+          <div style={{ width: 260, minHeight: token.marginXS }} />
+        )}
+        {designable && <div style={{ marginTop: token.marginXS }}>{this.renderConfigureActions()}</div>}
+      </div>
+    );
+  }
+}
+
+AppSwitcherActionPanelModel.define({
+  label: 'App switcher actions',
+  children: false,
+  createModelOptions: {
+    use: 'AppSwitcherActionPanelModel',
+  },
+});
+
+const AppSwitcherConfigureActionsButton = observer(({ model }: { model: AppSwitcherActionPanelModel }) => {
+  const entryActionsRevision = model.context.app.entryActionManager.revision;
+  return (
+    <AddSubModelButton
+      key={`app-switcher-add-actions-${entryActionsRevision}`}
+      model={model}
+      items={model.getConfigureActionsItems()}
+      subModelKey="actions"
+      keepDropdownOpen
+    >
+      <FlowSettingsButton icon={<SettingOutlined />}>{model.context.t('Actions')}</FlowSettingsButton>
+    </AddSubModelButton>
+  );
+});