@nocobase/client-v2 2.1.0-beta.38 → 2.1.0-beta.40

package/src/flow/models/actions/__tests__/AssignFormRefill.test.ts

@@ -9,7 +9,7 @@
 
 import { describe, it, expect } from 'vitest';
 import { FlowEngine, FlowModel } from '@nocobase/flow-engine';
-import { UpdateRecordActionModel } from '../../..'; // 这样可以解决循环依赖问题
+import { FormSubmitActionModel, UpdateRecordActionModel } from '../../..'; // 这样可以解决循环依赖问题
 
 /**
  * 精简版 AssignFormModel（仅用于单测）：
@@ -52,4 +52,29 @@ describe('AssignForm value refill and save (beforeParamsSave)', () => {
     const saved = action.getStepParams('assignSettings', 'assignFieldValues');
     expect(saved?.assignedValues).toEqual({ nickname: 'Alice', score: 99 });
   });
+
+  it('FormSubmitActionModel: reuses assignFieldValues step and saves assignedValues from AssignForm', async () => {
+    const root = new FlowEngine();
+
+    root.registerModels({ FormSubmitActionModel, AssignFormModel: TestAssignFormModel });
+
+    const action = root.createModel<FormSubmitActionModel>({ use: 'FormSubmitActionModel', uid: 'submit-u' });
+    const form = root.createModel<TestAssignFormModel>({
+      use: 'AssignFormModel',
+      uid: 'submit-form-u',
+      parentId: action.uid,
+      subKey: 'assignForm',
+    });
+    form.setAssignedValues({ status: 'published' });
+    action.assignFormUid = form.uid;
+
+    const flow = action.getFlow('submitSettings') as any;
+    const step = flow?.steps?.assignFieldValues;
+    expect(step?.beforeParamsSave).toBeTypeOf('function');
+
+    await step.beforeParamsSave({ engine: root, model: action });
+
+    const saved = action.getStepParams('submitSettings', 'assignFieldValues');
+    expect(saved?.assignedValues).toEqual({ status: 'published' });
+  });
 });

package/src/flow/models/blocks/assign-form/AssignFormItemModel.tsx

@@ -28,6 +28,64 @@ import { customAlphabet as Alphabet } from 'nanoid';
 import { ensureOptionsFromUiSchemaEnumIfAbsent } from '../../../internal/utils/enumOptionsUtils';
 import { RunJSValueEditor } from '../../../components/RunJSValueEditor';
 
+type AssignFormTempOriginField = {
+  uid?: string;
+  props?: {
+    fieldNames?: unknown;
+    titleField?: unknown;
+  };
+  getStepParams?: (flowKey: string, stepKey: string) => unknown;
+};
+
+function getAssignFormTempFieldOptions(
+  originField: AssignFormTempOriginField | undefined,
+  init: Record<string, unknown>,
+) {
+  const inheritedFieldNames = originField?.props?.fieldNames;
+  const inheritedTitleField = originField?.props?.titleField;
+  const inheritedSelectFieldNamesStep = originField?.getStepParams?.('selectSettings', 'fieldNames');
+
+  return {
+    stepParams: {
+      fieldSettings: {
+        init,
+      },
+      ...(inheritedSelectFieldNamesStep
+        ? {
+            selectSettings: {
+              fieldNames: inheritedSelectFieldNamesStep,
+            },
+          }
+        : {}),
+    },
+    props: {
+      ...(typeof inheritedFieldNames !== 'undefined' ? { fieldNames: inheritedFieldNames } : {}),
+      ...(typeof inheritedTitleField !== 'undefined' ? { titleField: inheritedTitleField } : {}),
+    },
+  };
+}
+
+function stringifyAssignFormTempFieldOption(value: unknown) {
+  try {
+    return JSON.stringify(value) ?? '';
+  } catch {
+    return String(value);
+  }
+}
+
+function getAssignFormTempFieldRefreshKey(originField: AssignFormTempOriginField | undefined) {
+  const inheritedFieldNames = originField?.props?.fieldNames;
+  const inheritedTitleField = originField?.props?.titleField;
+  const inheritedSelectFieldNamesStep = originField?.getStepParams?.('selectSettings', 'fieldNames');
+
+  return [
+    originField?.uid || '',
+    stringifyAssignFormTempFieldOption(inheritedFieldNames),
+    stringifyAssignFormTempFieldOption(inheritedTitleField),
+    stringifyAssignFormTempFieldOption(inheritedSelectFieldNamesStep),
+  ].join('|');
+}
+
 /**
  * 使用 FormItemModel 的“表单项”包装，内部渲染 VariableInput，并将“常量”映射到临时字段模型。
  */
@@ -108,6 +166,8 @@ export class AssignFormItemModel extends FormItemModel {
     const init = this.fieldInit;
     const namePath = this.props?.name || (this.fieldPath ? [this.fieldPath] : undefined);
     const fieldPath = this.fieldPath;
+    const originField = this.subModels?.field as AssignFormTempOriginField | undefined;
+    const tempFieldRefreshKey = getAssignFormTempFieldRefreshKey(originField);
 
     const FieldRow: React.FC = () => {
       const [tempRoot, setTempRoot] = React.useState<any>(null);
@@ -121,13 +181,14 @@ export class AssignFormItemModel extends FormItemModel {
           return;
         }
         const fieldModel = binding.modelName;
+        const tempFieldOptions = getAssignFormTempFieldOptions(originField, init);
         const created = ctx?.engine?.createModel?.({
           use: 'VariableFieldFormModel',
           subModels: {
             fields: [
               {
                 use: fieldModel,
-                stepParams: { fieldSettings: { init } },
+                ...tempFieldOptions,
               },
             ],
           },
@@ -302,7 +363,7 @@ export class AssignFormItemModel extends FormItemModel {
       );
     };
 
-    return <FieldRow />;
+    return <FieldRow key={tempFieldRefreshKey} />;
   }
 }
 

package/src/flow/models/blocks/assign-form/assignFieldValuesFlow.tsx

@@ -0,0 +1,206 @@
+/**
+ * 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 {
+  FlowModelRenderer,
+  resolveRunJSObjectValues,
+  tExpr,
+  type FlowModelContext,
+  useFlowEngine,
+  useFlowSettingsContext,
+} from '@nocobase/flow-engine';
+import React, { useEffect, useRef } from 'react';
+import { CollectionActionModel } from '../../base/CollectionActionModel';
+import { RecordActionModel } from '../../base/RecordActionModel';
+import { AssignFormModel } from './AssignFormModel';
+
+export const ASSIGN_FIELD_VALUES_STEP_KEY = 'assignFieldValues';
+
+type AssignedValues = Record<string, unknown>;
+
+type AssignFieldValuesCollection = {
+  dataSourceKey?: string;
+  name?: string;
+};
+
+type AssignFieldValuesContext = FlowModelContext & {
+  collection?: AssignFieldValuesCollection;
+  flowSettingsEnabled?: boolean;
+};
+
+type AssignFieldValuesModel = {
+  uid: string;
+  assignFormUid?: string;
+  context?: AssignFieldValuesContext;
+  getStepParams?: (flowKey: string, stepKey: string) => { assignedValues?: AssignedValues } | undefined;
+  setStepParams?: (flowKey: string, stepKey: string, params: { assignedValues: AssignedValues }) => void;
+};
+
+type AssignFieldValuesStepOptions = {
+  settingsFlowKey: string;
+  title?: string;
+  tipComponent?: React.ComponentType;
+  validateBeforeSave?: boolean;
+  clearRecordContext?: boolean;
+};
+
+function getContextCollection(ctx: AssignFieldValuesContext | undefined): AssignFieldValuesCollection | undefined {
+  const collection = ctx?.collection;
+  return collection && typeof collection === 'object' ? collection : undefined;
+}
+
+function getResourceInit(ctx: AssignFieldValuesContext): { dataSourceKey: string; collectionName: string } | undefined {
+  const collection = getContextCollection(ctx);
+  const dsKey = collection?.dataSourceKey;
+  const collName = collection?.name;
+  return dsKey && collName ? { dataSourceKey: dsKey, collectionName: collName } : undefined;
+}
+
+export function createAssignFormSubModelOptions(ctx: AssignFieldValuesContext) {
+  return {
+    async: true,
+    use: 'AssignFormModel',
+    stepParams: { resourceSettings: { init: getResourceInit(ctx) } },
+  };
+}
+
+export function getAssignFieldValuesDefaultParams(
+  ctx: {
+    model: Pick<AssignFieldValuesModel, 'getStepParams'>;
+  },
+  settingsFlowKey: string,
+): { assignedValues: AssignedValues } {
+  const step = ctx.model.getStepParams?.(settingsFlowKey, ASSIGN_FIELD_VALUES_STEP_KEY) || {};
+  return { assignedValues: step?.assignedValues || {} };
+}
+
+export async function resolveAssignFieldValues(
+  ctx: {
+    message?: { error?: (message: string) => void };
+    t?: (message: string) => string;
+  },
+  rawAssignedValues: unknown,
+  logName = 'AssignFieldValues',
+): Promise<AssignedValues | null> {
+  try {
+    return await resolveRunJSObjectValues(ctx, rawAssignedValues);
+  } catch (error) {
+    console.error(`[${logName}] RunJS execution failed`, error);
+    ctx.message?.error?.(ctx.t?.('RunJS execution failed') || 'RunJS execution failed');
+    return null;
+  }
+}
+
+export function mergeAssignFieldValues<T extends Record<string, unknown>>(
+  values: T,
+  assignedValues?: AssignedValues | null,
+): T {
+  if (!assignedValues || typeof assignedValues !== 'object' || !Object.keys(assignedValues).length) {
+    return values;
+  }
+  return {
+    ...values,
+    ...assignedValues,
+  } as T;
+}
+
+function AssignFieldsEditor(props: { settingsFlowKey: string; clearRecordContext?: boolean }) {
+  const { model, blockModel } = useFlowSettingsContext();
+  const action = model as AssignFieldValuesModel;
+  const engine = useFlowEngine();
+  const initializedRef = useRef(false);
+  const [formModel, setFormModel] = React.useState<AssignFormModel | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+    const loadAssignForm = async () => {
+      const loaded = (await engine.loadOrCreateModel(
+        {
+          parentId: action.uid,
+          subKey: 'assignForm',
+          use: 'AssignFormModel',
+        },
+        { skipSave: !model.context.flowSettingsEnabled },
+      )) as AssignFormModel;
+      if (cancelled) return;
+      setFormModel(loaded);
+      action.assignFormUid = loaded?.uid || action.assignFormUid;
+    };
+    loadAssignForm();
+    return () => {
+      cancelled = true;
+    };
+  }, [action, engine, model.context.flowSettingsEnabled]);
+
+  useEffect(() => {
+    if (initializedRef.current) return;
+    if (!formModel) return;
+
+    const prev = action.getStepParams?.(props.settingsFlowKey, ASSIGN_FIELD_VALUES_STEP_KEY) || {};
+    const coll = blockModel?.collection || getContextCollection(action?.context);
+    const dsKey = coll?.dataSourceKey;
+    const collName = coll?.name;
+    if (dsKey && collName) {
+      formModel.setStepParams('resourceSettings', 'init', {
+        dataSourceKey: dsKey,
+        collectionName: collName,
+      });
+    }
+    formModel.setInitialAssignedValues(prev?.assignedValues || {});
+
+    const isBulk =
+      props.clearRecordContext || (action instanceof CollectionActionModel && !(action instanceof RecordActionModel));
+    if (isBulk && formModel.context?.defineProperty) {
+      formModel.context.defineProperty('record', { get: () => undefined, cache: false });
+    }
+    initializedRef.current = true;
+  }, [action, blockModel?.collection, formModel, props.clearRecordContext, props.settingsFlowKey]);
+
+  return formModel ? <FlowModelRenderer model={formModel} showFlowSettings={false} /> : null;
+}
+
+export function createAssignFieldValuesStep(options: AssignFieldValuesStepOptions) {
+  return {
+    title: options.title || tExpr('Assign field values'),
+    uiSchema() {
+      return {
+        tip: options.tipComponent
+          ? {
+              'x-decorator': 'FormItem',
+              'x-component': options.tipComponent,
+            }
+          : undefined,
+        editor: {
+          'x-decorator': 'FormItem',
+          'x-component': () => (
+            <AssignFieldsEditor
+              settingsFlowKey={options.settingsFlowKey}
+              clearRecordContext={options.clearRecordContext}
+            />
+          ),
+        },
+      };
+    },
+    async beforeParamsSave(ctx: {
+      model: AssignFieldValuesModel;
+      engine: {
+        getModel?: (uid: string, fromRoot?: boolean) => AssignFormModel | undefined;
+      };
+    }) {
+      const form = ctx.model.assignFormUid ? ctx.engine.getModel?.(ctx.model.assignFormUid, true) : undefined;
+      if (!form) return;
+      if (options.validateBeforeSave) {
+        await form.form?.validateFields?.();
+      }
+      const assignedValues = form.getAssignedValues?.() || {};
+      ctx.model.setStepParams?.(options.settingsFlowKey, ASSIGN_FIELD_VALUES_STEP_KEY, { assignedValues });
+    },
+    handler() {},
+  };
+}

package/src/flow/models/blocks/assign-form/index.ts

@@ -10,3 +10,4 @@
 export * from './AssignFormModel';
 export * from './AssignFormGridModel';
 export * from './AssignFormItemModel';
+export * from './assignFieldValuesFlow';

package/src/flow/models/blocks/form/FormActionModel.tsx

@@ -7,15 +7,27 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { tExpr } from '@nocobase/flow-engine';
+import { DefaultStructure, FlowExitAllException, tExpr } from '@nocobase/flow-engine';
 import { ButtonProps } from 'antd';
 import { AxiosRequestConfig } from 'axios';
 import { ActionModel } from '../../base/ActionModelCore';
+import { AssignFormModel } from '../assign-form/AssignFormModel';
+import {
+  createAssignFieldValuesStep,
+  createAssignFormSubModelOptions,
+  getAssignFieldValuesDefaultParams,
+} from '../assign-form/assignFieldValuesFlow';
 import { shouldSkipSubmitValidation, validateSubmitForm } from './submitValues';
 
-export class FormActionModel extends ActionModel {}
+export class FormActionModel<T extends DefaultStructure = DefaultStructure> extends ActionModel<T> {}
+
+export class FormSubmitActionModel extends FormActionModel<{
+  subModels: {
+    assignForm: AssignFormModel;
+  };
+}> {
+  assignFormUid?: string;
 
-export class FormSubmitActionModel extends FormActionModel {
   defaultProps: ButtonProps = {
     title: tExpr('Submit'),
     type: 'primary',
@@ -35,6 +47,11 @@ export class FormSubmitActionModel extends FormActionModel {
 
 FormSubmitActionModel.define({
   label: tExpr('Submit'),
+  createModelOptions: (ctx) => ({
+    subModels: {
+      assignForm: createAssignFormSubModelOptions(ctx),
+    },
+  }),
 });
 
 FormSubmitActionModel.registerFlow({
@@ -82,7 +99,14 @@ FormSubmitActionModel.registerFlow({
       },
       handler() {},
     },
+    assignFieldValues: createAssignFieldValuesStep({
+      settingsFlowKey: 'submitSettings',
+      title: tExpr('Assign field values'),
+    }),
     saveResource: {
+      async defaultParams(ctx) {
+        return getAssignFieldValuesDefaultParams(ctx, 'submitSettings');
+      },
       async handler(ctx, params) {
         if (!ctx?.resource) {
           throw new Error('Resource is not initialized');
@@ -96,6 +120,9 @@ FormSubmitActionModel.registerFlow({
           await submitHandler(ctx, params);
         } catch (error) {
           ctx.model.setProps('loading', false);
+          if (error instanceof FlowExitAllException) {
+            throw error;
+          }
           // 显示保存失败提示
           ctx.message.error(ctx.t('Save failed'));
           console.error('Form submission error:', error);

package/src/flow/models/blocks/form/__tests__/submitHandler.test.ts

@@ -0,0 +1,71 @@
+/**
+ * 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 { SingleRecordResource } from '@nocobase/flow-engine';
+import { describe, expect, it, vi } from 'vitest';
+import { submitHandler } from '../submitHandler';
+
+describe('submitHandler', () => {
+  it('merges assigned values into submitted values and lets assigned values override form values', async () => {
+    const resource = Object.create(SingleRecordResource.prototype);
+    resource.save = vi.fn(async () => ({ data: { id: 1 } }));
+
+    const blockModel = {
+      form: {
+        validateFields: vi.fn(async () => undefined),
+        getFieldsValue: vi.fn(() => ({
+          title: 'Draft title',
+          status: 'draft',
+        })),
+        resetFields: vi.fn(),
+      },
+      emitter: {
+        emit: vi.fn(),
+      },
+      resetUserModifiedFields: vi.fn(),
+      formValueRuntime: {
+        resetAfterFormReset: vi.fn(),
+      },
+      collection: {
+        name: 'posts',
+      },
+    };
+
+    const ctx = {
+      resource,
+      blockModel,
+      model: {
+        getStepParams: vi.fn(),
+      },
+      view: {
+        inputArgs: {},
+      },
+      message: {
+        error: vi.fn(),
+      },
+      t: (value: string) => value,
+    };
+
+    await submitHandler(ctx, {
+      assignedValues: {
+        status: 'published',
+        reviewer: 'Alice',
+      },
+    });
+
+    expect(resource.save).toHaveBeenCalledWith(
+      {
+        title: 'Draft title',
+        status: 'published',
+        reviewer: 'Alice',
+      },
+      undefined,
+    );
+  });
+});

package/src/flow/models/blocks/form/submitHandler.ts

@@ -8,6 +8,7 @@
  */
 
 import { MultiRecordResource, SingleRecordResource } from '@nocobase/flow-engine';
+import { mergeAssignFieldValues, resolveAssignFieldValues } from '../assign-form/assignFieldValuesFlow';
 import type { FormBlockModel } from './FormBlockModel';
 import { omitHiddenModelValuesFromSubmit, shouldSkipSubmitValidation, validateSubmitForm } from './submitValues';
 
@@ -24,7 +25,13 @@ export async function submitHandler(ctx, params, cb?: (values?: any, filterByTk?
     skipValidator: shouldSkipSubmitValidation(ctx?.model),
   });
   const rawValues = blockModel.form.getFieldsValue(true);
-  const values = omitHiddenModelValuesFromSubmit(rawValues, blockModel);
+  const formValues = omitHiddenModelValuesFromSubmit(rawValues, blockModel);
+  const assignedValues = await resolveAssignFieldValues(ctx, params?.assignedValues, 'FormSubmitAction');
+  if (!assignedValues) {
+    ctx.exit?.();
+    return;
+  }
+  const values = mergeAssignFieldValues(formValues, assignedValues);
   if (resource instanceof SingleRecordResource) {
     if (isEditFormModel) {
       const currentFilterByTk = resource.getMeta('currentFilterByTk');

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

@@ -38,6 +38,12 @@ const CollectionSelector = (props) => {
   );
 };
 
+function getConfiguredCollectionNames(collectionField) {
+  return (collectionField?.uiSchema?.enum || collectionField?.enum || [])
+    .map((item) => (item && typeof item === 'object' ? item.value : item))
+    .filter((value) => value !== null && typeof value !== 'undefined');
+}
+
 export class CollectionSelectorFieldModel extends FieldModel {
   render() {
     return <CollectionSelector {...this.props} />;
@@ -66,12 +72,12 @@ CollectionSelectorFieldModel.registerFlow({
           });
         } else {
           const collections = ctx.dataSourceManager.getDataSource('main').getCollections();
-          const defaultOptions = ctx.model.context.collectionField.enum || [];
+          const defaultOptions = getConfiguredCollectionNames(ctx.model.context.collectionField);
           const options = collections
             .filter((item: any) => !item.options.hidden)
             .filter((v) => {
               if (defaultOptions.length) {
-                return defaultOptions.find((c) => c.value === v.name);
+                return defaultOptions.includes(v.name);
               }
               return true;
             })

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

@@ -43,6 +43,12 @@ const fieldNames = {
   color: 'color',
 };
 
+function getConfiguredCollectionNames(collectionField) {
+  return (collectionField?.uiSchema?.enum || collectionField?.enum || [])
+    .map((item) => (item && typeof item === 'object' ? item.value : item))
+    .filter((value) => value !== null && typeof value !== 'undefined');
+}
+
 export class DisplayEnumFieldModel extends ClickableFieldModel {
   isEmpty(value: any) {
     return value === null || value === undefined || value === '';
@@ -134,12 +140,12 @@ DisplayEnumFieldModel.registerFlow({
             });
           } else {
             const collections = ctx.dataSourceManager.getDataSource('main').getCollections();
-            const defaultOptions = ctx.model.context.collectionField.enum || [];
+            const defaultOptions = getConfiguredCollectionNames(ctx.model.context.collectionField);
             const options = collections
               .filter((item: any) => !item.options.hidden)
               .filter((v) => {
                 if (defaultOptions.length) {
-                  return defaultOptions.find((c) => c.value === v.name);
+                  return defaultOptions.includes(v.name);
                 }
                 return true;
               })

package/src/index.ts

@@ -32,7 +32,11 @@ export { default as languageCodes } from './locale/languageCodes';
 export * from './nocobase-buildin-plugin';
 export * from './collection-field-interface/CollectionFieldInterface';
 export * from './collection-field-interface/CollectionFieldInterfaceManager';
+export * from './collection-manager/field-configure';
+export * from './collection-manager/field-validation';
+export * from './collection-manager/filter-operators';
 export * from './collection-manager/interfaces';
+export * from './collection-manager/template-fields';
 export * from './data-source';
 export * from './flow';
 export { DEFAULT_DATA_SOURCE_KEY, isTitleField, isTitleFieldInterface } from './flow-compat';

package/es/collection-manager/interfaces/linkTo.d.ts

@@ -1,90 +0,0 @@
-/**
- * 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 { ISchema } from '@formily/react';
-import { CollectionFieldInterface } from '../../collection-field-interface/CollectionFieldInterface';
-export declare class LinkToFieldInterface extends CollectionFieldInterface {
-    name: string;
-    type: string;
-    group: string;
-    order: number;
-    title: string;
-    description: string;
-    isAssociation: boolean;
-    default: {
-        type: string;
-        uiSchema: {
-            'x-component': string;
-            'x-component-props': {
-                multiple: boolean;
-                fieldNames: {
-                    label: string;
-                    value: string;
-                };
-            };
-        };
-        reverseField: {
-            interface: string;
-            type: string;
-            uiSchema: {
-                'x-component': string;
-                'x-component-props': {
-                    multiple: boolean;
-                    fieldNames: {
-                        label: string;
-                        value: string;
-                    };
-                };
-            };
-        };
-    };
-    schemaInitialize(schema: ISchema, { readPretty, block, targetCollection }: {
-        readPretty: any;
-        block: any;
-        targetCollection: any;
-    }): void;
-    initialize: (values: any) => void;
-    properties: {
-        target: {
-            type: string;
-            title: string;
-            required: boolean;
-            'x-reactions': string[];
-            'x-decorator': string;
-            'x-component': string;
-            'x-disabled': string;
-        };
-        'uiSchema.x-component-props.multiple': {
-            type: string;
-            'x-content': string;
-            'x-decorator': string;
-            'x-component': string;
-        };
-        'uiSchema.title': {
-            type: string;
-            title: string;
-            required: boolean;
-            'x-decorator': string;
-            'x-component': string;
-        };
-        name: {
-            type: string;
-            title: string;
-            required: boolean;
-            'x-disabled': string;
-            'x-decorator': string;
-            'x-component': string;
-            'x-validator': string;
-            description: string;
-        };
-    };
-    filterable: {
-        nested: boolean;
-        children: any[];
-    };
-}