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

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

@@ -69,15 +69,6 @@ export declare class UUIDFieldInterface extends CollectionFieldInterface {
                     'x-decorator': string;
                     'x-component': string;
                     'x-disabled': string;
-                    'x-reactions': {
-                        dependencies: string[];
-                        when: string;
-                        fulfill: {
-                            state: {
-                                value: boolean;
-                            };
-                        };
-                    }[];
                 };
                 unique: {
                     type: string;
@@ -85,36 +76,12 @@ export declare class UUIDFieldInterface extends CollectionFieldInterface {
                     'x-decorator': string;
                     'x-component': string;
                     'x-disabled': string;
-                    'x-reactions': {
-                        dependencies: string[];
-                        when: string;
-                        fulfill: {
-                            state: {
-                                value: boolean;
-                            };
-                        };
-                    }[];
                 };
             };
         };
     };
     filterable: {
-        operators: ({
-            label: string;
-            value: string;
-            selected: boolean;
-            noValue?: undefined;
-        } | {
-            label: string;
-            value: string;
-            selected?: undefined;
-            noValue?: undefined;
-        } | {
-            label: string;
-            value: string;
-            noValue: boolean;
-            selected?: undefined;
-        })[];
+        operators: string;
     };
     titleUsable: boolean;
 }

package/es/collection-manager/template-fields.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 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 type { ReactNode } from 'react';
+export interface CollectionTemplateFieldOption {
+    label: ReactNode;
+    value: string | number | boolean;
+    [key: string]: unknown;
+}
+export interface CollectionTemplateField {
+    name: string;
+    interface?: string;
+    type?: string;
+    title?: ReactNode;
+    options?: CollectionTemplateFieldOption[];
+    component?: string;
+    componentProps?: Record<string, unknown>;
+    uiSchema?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+interface FieldInterfaceConfigureLike {
+    default?: {
+        uiSchema?: Record<string, unknown>;
+        [key: string]: unknown;
+    };
+}
+interface FieldInterfaceLike {
+    default?: {
+        uiSchema?: Record<string, unknown>;
+        [key: string]: unknown;
+    };
+}
+export interface CollectionTemplateFieldNormalizeManager {
+    getFieldInterfaceConfigure?: (name: string, collectionInfo?: Record<string, unknown>) => FieldInterfaceConfigureLike | undefined;
+    getFieldInterface?: (name: string) => FieldInterfaceLike | undefined;
+}
+export interface NormalizeCollectionTemplateFieldOptions {
+    collectionInfo?: Record<string, unknown>;
+}
+export declare function normalizeCollectionTemplateField(field: CollectionTemplateField, manager?: CollectionTemplateFieldNormalizeManager, options?: NormalizeCollectionTemplateFieldOptions): {
+    [key: string]: unknown;
+    uiSchema?: Record<string, unknown>;
+} & CollectionTemplateField;
+export declare function normalizeCollectionTemplateFields(fields?: CollectionTemplateField[], manager?: CollectionTemplateFieldNormalizeManager, options?: NormalizeCollectionTemplateFieldOptions): ({
+    [key: string]: unknown;
+    uiSchema?: Record<string, unknown>;
+} & CollectionTemplateField)[];
+export {};

package/es/components/form/VariableInput.d.ts

@@ -8,8 +8,45 @@
  */
 import { type MetaTreeNode, type VariableHybridInputConverters } from '@nocobase/flow-engine';
 import React from 'react';
-export declare function parseVariablePath(value?: string): string[] | undefined;
-export declare function formatVariablePath(meta?: MetaTreeNode): string | undefined;
+/**
+ * The flow-engine defaults emit `{{ ctx.$X.Y }}` and only parse the same
+ * shape back into a path — but NocoBase server templates (and v1 stored
+ * values) use the bare `{{$X.Y}}` form without the `ctx.` prefix. These
+ * converters keep the picker's output stable against v1 and let already-
+ * stored values round-trip to a labelled pill instead of falling back to a
+ * raw `{{…}}` literal.
+ */
+/**
+ * Variable delimiters: opening + closing tokens. Default `['{{', '}}']`
+ * matches NocoBase server template convention (Handlebars HTML-escaped
+ * output). Pass `['{{{', '}}}']` to switch to Handlebars' raw/unescaped
+ * form — required for fields whose content is rendered as HTML (e.g.
+ * in-app message body) so the variable expansion bypasses HTML escaping.
+ *
+ * Restrict to literal-token pairs, since the regex builder escapes them
+ * verbatim.
+ */
+export type VariableDelimiters = readonly [string, string];
+/**
+ * Factory: returns a `parseValueToPath` bound to the given delimiters.
+ * Anchored (`^…$`) — only treats the whole input as a single variable
+ * reference, matching the v1 single-line picker behaviour.
+ */
+export declare function makeParseVariablePath(delimiters?: VariableDelimiters): (value?: string) => string[] | undefined;
+/**
+ * Factory: returns a `formatPathToValue` bound to the given delimiters.
+ * No inner spaces — matches the v1 storage shape exactly so round-trips
+ * through the API stay byte-stable.
+ */
+export declare function makeFormatVariablePath(delimiters?: VariableDelimiters): (meta?: MetaTreeNode) => string | undefined;
+/**
+ * Factory: returns a global regex matching every occurrence of the
+ * variable token within a longer string. Used by `VariableHybridInput`
+ * to render embedded variables as pills.
+ */
+export declare function makeVariableRegExp(delimiters?: VariableDelimiters): RegExp;
+export declare const parseVariablePath: (value?: string) => string[] | undefined;
+export declare const formatVariablePath: (meta?: MetaTreeNode) => string | undefined;
 /**
  * Resolve the meta tree the variable picker should expose. Filters the global
  * meta tree by `namespaces` (top-level property names like `'$env'`,
@@ -48,8 +85,22 @@ export interface VariableInputProps {
      * Override the converters used by the underlying `VariableHybridInput`.
      * Mostly useful when the caller wants to constrain `formatPathToValue` to a
      * specific namespace (see `EnvVariableInput` for that pattern).
+     *
+     * Takes precedence over `delimiters` when both are set on the same field
+     * (an explicit converter wins over the delimiter-derived one).
      */
     converters?: VariableHybridInputConverters;
+    /**
+     * Token pair wrapping variable references in the stored string. Defaults
+     * to `['{{', '}}']` — the standard NocoBase server-template form,
+     * HTML-escaped by Handlebars. Pass `['{{{', '}}}']` for fields rendered
+     * as HTML where escaping would corrupt the variable value (e.g. the
+     * in-app message body).
+     *
+     * Ignored when `converters` is also supplied — caller-provided converters
+     * win.
+     */
+    delimiters?: VariableDelimiters;
     className?: string;
     style?: React.CSSProperties;
 }

package/es/components/form/filter/CollectionFilter.d.ts

@@ -19,7 +19,15 @@ export interface CollectionFilterProps {
     t?: (key: string, options?: Record<string, any>) => string;
     /** Whitelist of root-level field names to expose. */
     filterableFieldNames?: string[];
-    /** Bypass the `filterableFieldNames` whitelist. */
+    /**
+     * Blacklist of root-level field names to drop. Mirrors v1's `nonfilterable: [...]` on `Filter.Action`. When both `filterableFieldNames` and this prop are supplied, both apply (final = whitelist ∩ ¬blacklist).
+     */
+    nonfilterableFieldNames?: string[];
+    /**
+     * Bypass the `filterableFieldNames` whitelist.
+     *
+     * Legacy escape hatch — prefer adjusting `filterableFieldNames` / `nonfilterableFieldNames` instead.
+     */
     noIgnore?: boolean;
     /** Override the trigger button's label. Defaults to `t('Filter')`, or the v1-style `t('{{count}} filter items', { count })` when conditions are present. */
     buttonText?: React.ReactNode;

package/es/components/form/filter/CollectionFilterItem.d.ts

@@ -21,7 +21,15 @@ export interface CollectionFilterItemProps {
     collection: Collection;
     /** Whitelist of field names to expose; empty/undefined means all filterable fields. */
     filterableFieldNames?: string[];
-    /** Bypass the `filterableFieldNames` whitelist (matches the legacy FilterItem `noIgnore`). */
+    /**
+     * Blacklist of field names to drop. Mirrors v1's `nonfilterable: [...]` on `Filter.Action`. When both whitelist and blacklist are supplied, both apply (final = whitelist ∩ ¬blacklist).
+     */
+    nonfilterableFieldNames?: string[];
+    /**
+     * Bypass the `filterableFieldNames` whitelist (matches the legacy FilterItem `noIgnore`).
+     *
+     * Legacy escape hatch — prefer adjusting `filterableFieldNames` / `nonfilterableFieldNames` instead.
+     */
     noIgnore?: boolean;
     /** Translator; defaults to identity so callers can omit it. */
     t?: (key: string) => string;
@@ -35,7 +43,7 @@ export declare const CollectionFilterItem: FC<CollectionFilterItemProps>;
 /**
  * Convenience factory returning a `FilterContainer`-compatible `FilterItem` component bound to a specific collection. Avoids creating an inline closure on every parent render, which would otherwise reset any focused inner antd control.
  */
-export declare function createCollectionFilterItem(collection: Collection, bound?: Pick<CollectionFilterItemProps, 'filterableFieldNames' | 'noIgnore' | 't'>): React.FC<{
+export declare function createCollectionFilterItem(collection: Collection, bound?: Pick<CollectionFilterItemProps, 'filterableFieldNames' | 'nonfilterableFieldNames' | 'noIgnore' | 't'>): React.FC<{
     value: CollectionFilterItemValue;
 }>;
 export default CollectionFilterItem;

package/es/flow/components/filter/useFilterOptions.d.ts

@@ -36,10 +36,22 @@ export type FilterOption = {
 };
 export interface UseFilterOptionsArgs {
     /**
+     * **Preferred way to restrict fields**, alongside `nonfilterableFieldNames`.
+     *
      * Whitelist of root-level field names to expose. Empty/undefined means "all filterable fields". The whitelist applies only at depth 1 — nested fields under an allowed association field are always included, matching the legacy v1 `Filter.Action` behaviour.
      */
     filterableFieldNames?: string[];
-    /** Bypass the `filterableFieldNames` whitelist (mirrors v1 `noIgnore`). */
+    /**
+     * **Preferred way to restrict fields**, alongside `filterableFieldNames`.
+     *
+     * Blacklist of root-level field names to drop. Mirrors v1's `nonfilterable: [...]` schema prop on `Filter.Action`. Applies at depth 1 only, same as the whitelist. When both `filterableFieldNames` and `nonfilterableFieldNames` are provided, both apply: the final field set is `(whitelist or all) minus blacklist`.
+     */
+    nonfilterableFieldNames?: string[];
+    /**
+     * Bypass the `filterableFieldNames` whitelist (mirrors v1 `noIgnore`).
+     *
+     * Legacy escape hatch from v1 schemas — prefer adjusting `filterableFieldNames` / `nonfilterableFieldNames` instead. Kept only for parity with existing v1 schemas that already set `noIgnore`.
+     */
     noIgnore?: boolean;
     /** Translator used for field/operator labels. Defaults to identity. */
     t?: (key: string) => string;

package/es/flow/models/blocks/assign-form/assignFieldValuesFlow.d.ts

@@ -0,0 +1,84 @@
+/**
+ * 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 { type FlowModelContext } from '@nocobase/flow-engine';
+import React from 'react';
+import { AssignFormModel } from './AssignFormModel';
+export declare 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;
+};
+export declare function createAssignFormSubModelOptions(ctx: AssignFieldValuesContext): {
+    async: boolean;
+    use: string;
+    stepParams: {
+        resourceSettings: {
+            init: {
+                dataSourceKey: string;
+                collectionName: string;
+            };
+        };
+    };
+};
+export declare function getAssignFieldValuesDefaultParams(ctx: {
+    model: Pick<AssignFieldValuesModel, 'getStepParams'>;
+}, settingsFlowKey: string): {
+    assignedValues: AssignedValues;
+};
+export declare function resolveAssignFieldValues(ctx: {
+    message?: {
+        error?: (message: string) => void;
+    };
+    t?: (message: string) => string;
+}, rawAssignedValues: unknown, logName?: string): Promise<AssignedValues | null>;
+export declare function mergeAssignFieldValues<T extends Record<string, unknown>>(values: T, assignedValues?: AssignedValues | null): T;
+export declare function createAssignFieldValuesStep(options: AssignFieldValuesStepOptions): {
+    title: string;
+    uiSchema(): {
+        tip: {
+            'x-decorator': string;
+            'x-component': React.ComponentType<{}>;
+        };
+        editor: {
+            'x-decorator': string;
+            'x-component': () => React.JSX.Element;
+        };
+    };
+    beforeParamsSave(ctx: {
+        model: AssignFieldValuesModel;
+        engine: {
+            getModel?: (uid: string, fromRoot?: boolean) => AssignFormModel | undefined;
+        };
+    }): Promise<void>;
+    handler(): void;
+};
+export {};

package/es/flow/models/blocks/assign-form/index.d.ts

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

package/es/flow/models/blocks/form/FormActionModel.d.ts

@@ -6,12 +6,19 @@
  * 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 { DefaultStructure } from '@nocobase/flow-engine';
 import { ButtonProps } from 'antd';
 import { AxiosRequestConfig } from 'axios';
 import { ActionModel } from '../../base/ActionModelCore';
-export declare class FormActionModel extends ActionModel {
+import { AssignFormModel } from '../assign-form/AssignFormModel';
+export declare class FormActionModel<T extends DefaultStructure = DefaultStructure> extends ActionModel<T> {
 }
-export declare class FormSubmitActionModel extends FormActionModel {
+export declare class FormSubmitActionModel extends FormActionModel<{
+    subModels: {
+        assignForm: AssignFormModel;
+    };
+}> {
+    assignFormUid?: string;
     defaultProps: ButtonProps;
     /**
      * 简化设置保存请求配置的方式

package/es/index.d.ts

@@ -30,7 +30,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';