@nocobase/client-v2 2.1.0-beta.22 → 2.1.0-beta.23

package/src/flow/models/fields/AssociationFieldModel/itemChain.ts

@@ -0,0 +1,362 @@
+/**
+ * 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 { createAssociationAwareObjectMetaFactory, createAssociationSubpathResolver } from '@nocobase/flow-engine';
+
+export type ItemChain = {
+  index?: number;
+  length?: number;
+  __is_new__?: boolean;
+  __is_stored__?: boolean;
+  value: any;
+  parentItem?: ItemChain;
+};
+
+export type ItemChainResolver = (subPath: string) => boolean;
+
+export type ParentItemAccessors = {
+  parentPropertiesAccessor: (ctx?: any) => any;
+  parentItemMetaAccessor: () => any;
+  parentItemResolverAccessor: () => ItemChainResolver | undefined;
+};
+
+export function createItemChainGetter(options: {
+  valueAccessor: () => any;
+  parentItemAccessor?: () => ItemChain | undefined;
+  indexAccessor?: () => number | undefined;
+  lengthAccessor?: () => number | undefined;
+  isNewAccessor?: () => boolean | undefined;
+  isStoredAccessor?: () => boolean | undefined;
+}): () => ItemChain {
+  return () => {
+    const value = options.valueAccessor();
+    return {
+      index: options.indexAccessor?.(),
+      length: options.lengthAccessor?.(),
+      __is_new__: options.isNewAccessor?.() ?? value?.__is_new__,
+      __is_stored__: options.isStoredAccessor?.() ?? value?.__is_stored__,
+      value,
+      parentItem: options.parentItemAccessor?.(),
+    };
+  };
+}
+
+export function createRootItemChain(formValues: any): ItemChain {
+  return {
+    index: undefined,
+    __is_new__: formValues?.__is_new__,
+    __is_stored__: formValues?.__is_stored__,
+    value: formValues,
+    parentItem: undefined,
+  };
+}
+
+export function resolveRecordPersistenceState(
+  record: any,
+  filterTargetKey: string | string[] | null | undefined,
+): {
+  record: any;
+  hasPrimaryKey: boolean;
+  isNew: boolean;
+  isStored: boolean;
+} {
+  const hasPrimaryKey = Array.isArray(filterTargetKey)
+    ? filterTargetKey.length > 0 && filterTargetKey.every((key) => record?.[key] != null)
+    : filterTargetKey
+      ? record?.[filterTargetKey] != null
+      : false;
+  const isNew = !!record?.__is_new__ || !hasPrimaryKey;
+  const isStored = !!record?.__is_stored__ || (!isNew && hasPrimaryKey);
+  return {
+    record,
+    hasPrimaryKey,
+    isNew,
+    isStored,
+  };
+}
+
+export function buildCurrentItemTitle(t: (key: string) => string, collectionField?: any, fallbackName?: string) {
+  const rawLabel =
+    (typeof collectionField?.title === 'string' && collectionField.title) ||
+    (typeof collectionField?.name === 'string' && collectionField.name) ||
+    fallbackName;
+  const label = typeof rawLabel === 'string' && rawLabel ? t(rawLabel) : '';
+  return label ? `${t('Current item')}（${label}）` : t('Current item');
+}
+
+export function createParentItemAccessorsFromContext(options: {
+  parentContextAccessor: () => any;
+  fallbackParentPropertiesAccessor?: (ctx?: any) => any;
+}): ParentItemAccessors {
+  return {
+    parentPropertiesAccessor: (ctx?: any) => {
+      return options.parentContextAccessor?.()?.item?.value ?? options.fallbackParentPropertiesAccessor?.(ctx);
+    },
+    parentItemMetaAccessor: () => options.parentContextAccessor?.()?.getPropertyOptions?.('item')?.meta,
+    parentItemResolverAccessor: () =>
+      options.parentContextAccessor?.()?.getPropertyOptions?.('item')?.resolveOnServer as ItemChainResolver | undefined,
+  };
+}
+
+export function createParentItemAccessorsFromInputArgs(inputArgsAccessor: () => any): ParentItemAccessors {
+  return {
+    parentPropertiesAccessor: () => (inputArgsAccessor?.()?.parentItem as ItemChain | undefined)?.value,
+    parentItemMetaAccessor: () => inputArgsAccessor?.()?.parentItemMeta,
+    parentItemResolverAccessor: () => inputArgsAccessor?.()?.parentItemResolver as ItemChainResolver | undefined,
+  };
+}
+
+function createScopedItemContext(ctx: any, item: any) {
+  if (!ctx || typeof ctx !== 'object') {
+    return { item };
+  }
+  const scoped = Object.create(ctx);
+  Object.defineProperty(scoped, 'item', {
+    value: item,
+    configurable: true,
+    enumerable: true,
+    writable: false,
+  });
+  return scoped;
+}
+
+async function resolveMetaFactory(metaOrFactory: any) {
+  if (!metaOrFactory) return null;
+  if (typeof metaOrFactory === 'function') {
+    return (await metaOrFactory()) || null;
+  }
+  return metaOrFactory;
+}
+
+export function createItemChainMetaFactory(options: {
+  t: (key: string) => string;
+  title: string;
+  showIndex?: boolean;
+  showParentIndex?: boolean;
+  disableValueBranch?: boolean;
+  valueBranchDisabledReason?: string;
+  collectionAccessor: () => any;
+  propertiesAccessor: (ctx: any) => any;
+  parentCollectionAccessor?: () => any;
+  parentPropertiesAccessor?: (ctx: any) => any;
+  parentItemMetaAccessor?: () => any;
+}) {
+  const {
+    t,
+    title,
+    showIndex,
+    showParentIndex,
+    disableValueBranch,
+    valueBranchDisabledReason,
+    collectionAccessor,
+    propertiesAccessor,
+    parentCollectionAccessor,
+    parentPropertiesAccessor,
+    parentItemMetaAccessor,
+  } = options;
+  const propertiesMetaFactory = createAssociationAwareObjectMetaFactory(collectionAccessor, title, propertiesAccessor);
+  const fallbackParentPropertiesMetaFactory = parentCollectionAccessor
+    ? createAssociationAwareObjectMetaFactory(
+        parentCollectionAccessor,
+        title,
+        (ctx) => parentPropertiesAccessor?.(ctx) ?? ctx?.item?.parentItem?.value,
+      )
+    : null;
+
+  const factory: any = async () => {
+    const propertiesMeta = await propertiesMetaFactory();
+    if (!propertiesMeta) return null;
+
+    const parentItemMeta = await resolveMetaFactory(parentItemMetaAccessor?.());
+    const fallbackParentPropertiesMeta = fallbackParentPropertiesMetaFactory
+      ? await fallbackParentPropertiesMetaFactory()
+      : null;
+
+    const buildVars = (propertiesMeta as any).buildVariablesParams;
+    const parentBuildVars = parentItemMeta
+      ? (parentItemMeta as any).buildVariablesParams
+      : (fallbackParentPropertiesMeta as any)?.buildVariablesParams;
+
+    const createIndexMeta = () => ({ type: 'number', title: t('Index (starts from 0)') });
+    const createLengthMeta = () => ({ type: 'number', title: t('Total count') });
+
+    const properties: Record<string, any> = {};
+    if (showIndex !== false) {
+      properties.index = createIndexMeta();
+      properties.length = createLengthMeta();
+    }
+    properties.value = {
+      ...(propertiesMeta as any),
+      title: t('Attributes'),
+      ...(disableValueBranch
+        ? {
+            disabled: true,
+            disabledReason: valueBranchDisabledReason || t('Attributes are unavailable before selecting a record'),
+          }
+        : {}),
+    };
+
+    if (parentItemMeta) {
+      properties.parentItem = {
+        ...(parentItemMeta as any),
+        title: parentItemMeta.title?.replace(t('Current item'), t('Parent item')) || t('Parent item'),
+      };
+    } else {
+      const parentProperties: Record<string, any> = {};
+      if (showParentIndex !== false) {
+        parentProperties.index = createIndexMeta();
+        parentProperties.length = createLengthMeta();
+      }
+      parentProperties.value = fallbackParentPropertiesMeta
+        ? { ...(fallbackParentPropertiesMeta as any), title: t('Attributes') }
+        : { type: 'object', title: t('Attributes') };
+      properties.parentItem = {
+        type: 'object',
+        title: parentItemMeta?.title?.replace(t('Current item'), t('Parent item')) || t('Parent item'),
+        properties: parentProperties,
+      };
+    }
+
+    const meta: any = {
+      type: 'object',
+      title,
+      properties,
+      buildVariablesParams: async (ctx: any) => {
+        const out: Record<string, any> = {};
+
+        if (!disableValueBranch && typeof buildVars === 'function') {
+          const built = await buildVars(ctx);
+          if (built && typeof built === 'object' && Object.keys(built).length) {
+            out.value = built;
+          }
+        }
+
+        if (typeof parentBuildVars === 'function') {
+          const built = await parentBuildVars(createScopedItemContext(ctx, ctx?.item?.parentItem));
+          if (built && typeof built === 'object' && Object.keys(built).length) {
+            out.parentItem = parentItemMeta ? built : { value: built };
+          }
+        }
+
+        return out;
+      },
+    };
+
+    return meta;
+  };
+
+  factory.title = title;
+  return factory;
+}
+
+export function createItemChainResolver(options: {
+  collectionAccessor: () => any;
+  disableValueBranch?: boolean;
+  propertiesAccessor?: () => unknown;
+  parentCollectionAccessor?: () => any;
+  parentPropertiesAccessor?: () => unknown;
+  parentItemResolverAccessor?: () => ((subPath: string) => boolean) | undefined;
+}): (subPath: string) => boolean {
+  const base = createAssociationSubpathResolver(options.collectionAccessor, options.propertiesAccessor);
+  const baseParent =
+    typeof options.parentCollectionAccessor === 'function'
+      ? createAssociationSubpathResolver(options.parentCollectionAccessor, options.parentPropertiesAccessor)
+      : null;
+  return (p: string) => {
+    const raw = String(p || '');
+    if (!raw) return false;
+    if (raw === 'value') return false;
+    if (raw.startsWith('value.')) {
+      if (options.disableValueBranch) return false;
+      return base(raw.slice('value.'.length));
+    }
+    if (raw === 'parentItem') return false;
+    if (raw.startsWith('parentItem.')) {
+      const parentPath = raw.slice('parentItem.'.length);
+      const parentResolver = options.parentItemResolverAccessor?.();
+      if (typeof parentResolver === 'function') {
+        return parentResolver(parentPath);
+      }
+      if (parentPath === 'value') return false;
+      if (parentPath.startsWith('value.')) {
+        return baseParent ? baseParent(parentPath.slice('value.'.length)) : false;
+      }
+      return false;
+    }
+    return false;
+  };
+}
+
+export type ItemChainMetaAndResolverOptions = {
+  metaFactoryOptions: Parameters<typeof createItemChainMetaFactory>[0];
+  resolverOptions: Parameters<typeof createItemChainResolver>[0];
+};
+
+export function createItemChainMetaAndResolver(options: ItemChainMetaAndResolverOptions) {
+  return {
+    meta: createItemChainMetaFactory(options.metaFactoryOptions),
+    resolveOnServer: createItemChainResolver(options.resolverOptions),
+  };
+}
+
+export type AssociationItemChainContextPropertyOptions = {
+  t: (key: string) => string;
+  title: string;
+  showIndex?: boolean;
+  showParentIndex?: boolean;
+  disableValueBranch?: boolean;
+  valueBranchDisabledReason?: string;
+  collectionAccessor: () => any;
+  propertiesAccessor: (ctx: any) => any;
+  resolverPropertiesAccessor?: () => unknown;
+  parentCollectionAccessor?: () => any;
+  parentAccessors?: Partial<ParentItemAccessors>;
+  useParentItemMeta?: boolean;
+  useParentItemResolver?: boolean;
+};
+
+export function createAssociationItemChainContextPropertyOptions(options: AssociationItemChainContextPropertyOptions) {
+  const parentPropertiesAccessor = options.parentAccessors?.parentPropertiesAccessor;
+  const parentItemMetaAccessor =
+    options.useParentItemMeta === false ? undefined : options.parentAccessors?.parentItemMetaAccessor;
+  const parentItemResolverAccessor =
+    options.useParentItemResolver === false ? undefined : options.parentAccessors?.parentItemResolverAccessor;
+
+  return createItemChainContextPropertyOptions({
+    metaFactoryOptions: {
+      t: options.t,
+      title: options.title,
+      showIndex: options.showIndex,
+      showParentIndex: options.showParentIndex,
+      disableValueBranch: options.disableValueBranch,
+      valueBranchDisabledReason: options.valueBranchDisabledReason,
+      collectionAccessor: options.collectionAccessor,
+      propertiesAccessor: options.propertiesAccessor,
+      parentCollectionAccessor: options.parentCollectionAccessor,
+      parentPropertiesAccessor,
+      parentItemMetaAccessor,
+    },
+    resolverOptions: {
+      collectionAccessor: options.collectionAccessor,
+      disableValueBranch: options.disableValueBranch,
+      propertiesAccessor: options.resolverPropertiesAccessor,
+      parentCollectionAccessor: options.parentCollectionAccessor,
+      parentPropertiesAccessor,
+      parentItemResolverAccessor,
+    },
+  });
+}
+
+export function createItemChainContextPropertyOptions(options: ItemChainMetaAndResolverOptions) {
+  return {
+    cache: false as const,
+    ...createItemChainMetaAndResolver(options),
+    serverOnlyWhenContextParams: true as const,
+  };
+}

package/src/flow/models/fields/AssociationFieldModel/recordSelectShared.tsx

@@ -0,0 +1,283 @@
+/**
+ * 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 {
+  createCurrentRecordMetaFactory,
+  FlowModel,
+  useFlowModel,
+  type FlowRuntimeContext,
+} from '@nocobase/flow-engine';
+import type { SelectProps } from 'antd';
+import React from 'react';
+import { omit } from 'lodash';
+
+export interface AssociationFieldNames {
+  label: string;
+  value: string;
+}
+
+const isPlaceholderFieldName = (value: unknown, fallback: 'label' | 'value') => value === fallback;
+
+const unwrapAssociationOptionRecord = (option: unknown): Record<string, unknown> | undefined => {
+  if (option && typeof option === 'object') {
+    const raw = (option as Record<string, unknown>).data;
+    if (raw && typeof raw === 'object') {
+      return raw as Record<string, unknown>;
+    }
+    return option as Record<string, unknown>;
+  }
+  return undefined;
+};
+
+function normalizeFilterTargetKey(filterTargetKey: unknown): string | undefined {
+  if (typeof filterTargetKey === 'string' && filterTargetKey) {
+    return filterTargetKey;
+  }
+  if (Array.isArray(filterTargetKey) && filterTargetKey.length === 1 && typeof filterTargetKey[0] === 'string') {
+    return filterTargetKey[0];
+  }
+  return undefined;
+}
+
+export function normalizeAssociationFieldNames(
+  fieldNames: Partial<AssociationFieldNames> | undefined,
+  targetCollection?: any,
+): AssociationFieldNames {
+  const titleCollectionFieldName =
+    typeof targetCollection?.titleCollectionField?.name === 'string'
+      ? targetCollection.titleCollectionField.name
+      : undefined;
+  const fallbackValue = normalizeFilterTargetKey(targetCollection?.filterTargetKey) || 'id';
+  const explicitValue =
+    typeof fieldNames?.value === 'string' && fieldNames.value && !isPlaceholderFieldName(fieldNames.value, 'value')
+      ? fieldNames.value
+      : undefined;
+  const explicitLabel =
+    typeof fieldNames?.label === 'string' && fieldNames.label && !isPlaceholderFieldName(fieldNames.label, 'label')
+      ? fieldNames.label
+      : undefined;
+  const value = explicitValue || fallbackValue;
+  const label = explicitLabel || titleCollectionFieldName || value;
+
+  return { label, value };
+}
+
+export type AssociationOption = Record<string, any>;
+export type PopupScrollEvent = Parameters<NonNullable<SelectProps<any>['onPopupScroll']>>[0];
+
+export function buildOpenerUids(ctx: FlowRuntimeContext, inputArgs: Record<string, unknown> = {}): string[] {
+  // Keep consistent with `packages/core/client/src/flow/actions/openView.tsx`
+  const isRouteManaged = !!(inputArgs as { navigation?: unknown }).navigation;
+  const toStringArray = (val: unknown): string[] | undefined => {
+    if (!Array.isArray(val)) return undefined;
+    return val.filter((item): item is string => typeof item === 'string' && !!item);
+  };
+  const viewOpenerUids = toStringArray(ctx.view?.inputArgs?.openerUids);
+  const inputOpenerUids = toStringArray(inputArgs.openerUids);
+  const parentOpenerUids = viewOpenerUids || inputOpenerUids || [];
+  if (isRouteManaged) {
+    return (inputOpenerUids || parentOpenerUids).filter(Boolean);
+  }
+  const viewUidFromView = (ctx.view?.inputArgs as { viewUid?: unknown } | undefined)?.viewUid;
+  const viewUidFromModel = (ctx.model.context?.inputArgs as { viewUid?: unknown } | undefined)?.viewUid;
+  const openerUid =
+    typeof viewUidFromView === 'string' && viewUidFromView
+      ? viewUidFromView
+      : typeof viewUidFromModel === 'string' && viewUidFromModel
+        ? viewUidFromModel
+        : ctx.model.uid;
+  return [...parentOpenerUids, openerUid].filter(Boolean);
+}
+
+export interface LazySelectProps extends Omit<SelectProps<any>, 'mode' | 'options' | 'value' | 'onChange'> {
+  fieldNames: AssociationFieldNames;
+  value?: AssociationOption | AssociationOption[] | string | string[] | number | number[];
+  multiple?: boolean;
+  allowMultiple?: boolean;
+  // 在特定场景（如默认值弹窗）下，多选点击选项后保持下拉展开
+  keepDropdownOpenOnSelect?: boolean;
+  options?: AssociationOption[];
+  valueMode?: 'record' | 'value';
+  onChange: (option: AssociationOption | AssociationOption[] | string | string[] | number | number[]) => void;
+  onDropdownVisibleChange?: (open: boolean) => void;
+  onPopupScroll?: SelectProps<any>['onPopupScroll'];
+  onSearch?: SelectProps<any>['onSearch'];
+  loading?: boolean;
+  onCompositionStart?: (e: any) => void;
+  onCompositionEnd?: (e: any, flag?: boolean) => void;
+  quickCreate?: 'none' | 'modalAdd' | 'quickAdd';
+  onModalAddClick?: (e: any) => void;
+  onDropdownAddClick?: (e: any) => void;
+  searchText?: string;
+  allowCreate?: boolean;
+  allowEdit?: boolean;
+}
+
+export interface LabelByFieldProps {
+  option: AssociationOption;
+  fieldNames: AssociationFieldNames;
+}
+
+function toSafeDisplayLabel(value: unknown): string | number | boolean | undefined {
+  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+    return value;
+  }
+
+  if (Array.isArray(value)) {
+    const parts = value
+      .map((item) => {
+        if (typeof item === 'string' || typeof item === 'number' || typeof item === 'boolean') {
+          return item;
+        }
+        if (item && typeof item === 'object') {
+          const nested = (item as Record<string, unknown>).label ?? (item as Record<string, unknown>).name;
+          if (typeof nested === 'string' || typeof nested === 'number' || typeof nested === 'boolean') {
+            return nested;
+          }
+        }
+        return undefined;
+      })
+      .filter((item): item is string | number | boolean => item !== undefined);
+
+    return parts.length ? parts.map(String).join(', ') : undefined;
+  }
+
+  if (value && typeof value === 'object') {
+    const nested = (value as Record<string, unknown>).label ?? (value as Record<string, unknown>).name;
+    if (typeof nested === 'string' || typeof nested === 'number' || typeof nested === 'boolean') {
+      return nested;
+    }
+  }
+
+  return undefined;
+}
+
+export function LabelByField(props: Readonly<LabelByFieldProps>) {
+  const { option, fieldNames } = props;
+  const currentModel = useFlowModel();
+  const record = unwrapAssociationOptionRecord(option);
+  const normalizedFieldNames = normalizeAssociationFieldNames(
+    fieldNames,
+    currentModel.context.collectionField?.targetCollection,
+  );
+  const field: any = currentModel.subModels.field as FlowModel;
+  const labelValue =
+    toSafeDisplayLabel(record?.[normalizedFieldNames.label]) ??
+    toSafeDisplayLabel(record?.label) ??
+    toSafeDisplayLabel(record?.[normalizedFieldNames.value]);
+  if (!field) {
+    return <span>{labelValue ?? 'N/A'}</span>;
+  }
+
+  const optionKey = String(record?.[normalizedFieldNames.value] ?? labelValue ?? 'association-option');
+  const fieldModel = field.createFork({}, optionKey);
+  fieldModel.context.defineProperty('record', {
+    get: () => record,
+    cache: false,
+    meta: createCurrentRecordMetaFactory(fieldModel.context, () => fieldModel.context.collection),
+  });
+
+  const titleCollectionField = currentModel.context.collectionField.targetCollection?.getField?.(
+    normalizedFieldNames.label,
+  );
+  const titleFieldComponentProps =
+    titleCollectionField && typeof titleCollectionField.getComponentProps === 'function'
+      ? titleCollectionField.getComponentProps()
+      : {};
+  fieldModel.setProps({ value: labelValue, clickToOpen: false, ...titleFieldComponentProps });
+
+  const renderedLabel =
+    labelValue !== null && typeof labelValue !== 'undefined' && labelValue !== ''
+      ? (fieldModel.render() as React.ReactNode)
+      : 'N/A';
+
+  return <span style={{ pointerEvents: 'none' }}>{renderedLabel}</span>;
+}
+
+export function toSelectValue(
+  record: AssociationOption | AssociationOption[] | string | string[] | number | number[] | undefined,
+  fieldNames: AssociationFieldNames,
+  multiple = false,
+  valueMode: 'record' | 'value' = 'record',
+  options: AssociationOption[] = [],
+) {
+  if (!record) return multiple ? [] : undefined;
+
+  const { value: valueKey } = fieldNames || {};
+
+  const isAssociationOption = (item: unknown): item is AssociationOption => typeof item === 'object' && item !== null;
+
+  const convert = (item: AssociationOption): any => {
+    if (!isAssociationOption(item)) return undefined;
+    return {
+      label: <LabelByField option={item} fieldNames={fieldNames} />,
+      value: item[valueKey],
+    };
+  };
+
+  if (valueMode === 'value') {
+    const toValue = (item: AssociationOption | string | number): any => {
+      if (typeof item === 'object' && item !== null) {
+        return convert(item);
+      }
+      const matchedOption = options.find((option) => option?.[valueKey] === item);
+      if (matchedOption) {
+        return convert(matchedOption);
+      }
+      // Handle string or number values
+      return {
+        label: String(item),
+        value: item,
+      };
+    };
+    if (multiple) {
+      if (!Array.isArray(record)) return [];
+      return record.map((item) => toValue(item)).filter(Boolean);
+    }
+    if (Array.isArray(record)) {
+      return toValue(record[0]);
+    }
+    return toValue(record as AssociationOption);
+  }
+
+  if (multiple) {
+    if (!Array.isArray(record)) return [];
+    return record.filter(isAssociationOption).map(convert).filter(Boolean);
+  }
+  if (Array.isArray(record)) {
+    const first = record[0];
+    return isAssociationOption(first) ? convert(first) : undefined;
+  }
+  return isAssociationOption(record) ? convert(record) : undefined;
+}
+
+export function resolveOptions(
+  options: AssociationOption[] | undefined,
+  value: AssociationOption | AssociationOption[] | string | string[] | number | number[] | undefined,
+  isMultiple: boolean,
+) {
+  if (options?.length) {
+    return options.map((v) => {
+      return omit(v, 'disabled', 'options', 'style');
+    });
+  }
+
+  if (isMultiple) {
+    if (Array.isArray(value)) {
+      return value.filter((item) => typeof item === 'object' && item !== null) as AssociationOption[];
+    }
+    return [];
+  }
+
+  if (value && typeof value === 'object') {
+    return [value as AssociationOption];
+  }
+
+  return [];
+}

package/src/flow/models/fields/CheckboxFieldModel.tsx

@@ -0,0 +1,31 @@
+/**
+ * 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 { Checkbox } from 'antd';
+import React from 'react';
+import { EditableItemModel } from '@nocobase/flow-engine';
+import { FieldModel } from '../base/FieldModel';
+
+export class CheckboxFieldModel extends FieldModel {
+  render() {
+    return (
+      <Checkbox
+        {...this.props}
+        checked={this.props.value}
+        onChange={(val) => {
+          this.props.onChange(val.target.checked);
+        }}
+      />
+    );
+  }
+}
+
+EditableItemModel.bindModelToInterface('CheckboxFieldModel', ['checkbox'], {
+  isDefault: true,
+});

package/src/flow/models/fields/CheckboxGroupFieldModel.tsx

@@ -0,0 +1,25 @@
+/**
+ * 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 { Checkbox } from 'antd';
+import React from 'react';
+import { EditableItemModel, tExpr } from '@nocobase/flow-engine';
+import { FieldModel } from '../base/FieldModel';
+
+export class CheckboxGroupFieldModel extends FieldModel {
+  render() {
+    return <Checkbox.Group {...this.props} />;
+  }
+}
+CheckboxGroupFieldModel.define({
+  label: tExpr('CheckboxGroup'),
+});
+EditableItemModel.bindModelToInterface('CheckboxGroupFieldModel', ['checkboxGroup'], {
+  isDefault: true,
+});