@1money/component-ui 0.0.75 → 0.0.77

package/lib/components/ProForm/core/interface.d.ts

@@ -1,174 +1,228 @@
 import type React from 'react';
 import type { FC, ReactNode } from 'react';
+import type { ProFormFieldName, ProFormFieldValueMap, ProFormPathValue, ProFormRecursivePartial, ProFormValuesPatch } from './namePathType';
 import type { FormSize, FormLayout, LabelAlign, ValidateStatus, ValidateTrigger } from './constants';
+import { RULE_CONTEXT_READ_MEMBERS, RULE_CONTEXT_MUTATOR_MEMBERS } from './constants';
 export type { FormSize, FormLayout, LabelAlign, ValidateStatus, ValidateTrigger, };
+export type { ProFormFieldName, ProFormFieldValueMap, ProFormPathValue, ProFormRecursivePartial, ProFormValuesPatch, } from './namePathType';
+/** Built-in `type` check names. */
+export type RuleType = 'string' | 'number' | 'boolean' | 'method' | 'regexp' | 'integer' | 'float' | 'object' | 'array' | 'date' | 'url' | 'hex' | 'email' | 'enum';
 export interface Rule {
     /** Fails on undefined / null / '' / empty array */
     required?: boolean;
-    message?: string;
+    /** Error content shown on failure — any ReactNode (falls back to a generated string) */
+    message?: ReactNode;
     /** For strings: min length; arrays: min item count; numbers: min value */
     min?: number;
     /** For strings: max length; arrays: max item count; numbers: max value */
     max?: number;
+    /** Exact string length / array item count / numeric value. Takes precedence over min/max */
+    len?: number;
     pattern?: RegExp;
-    type?: 'number' | 'email' | 'url';
-    enum?: unknown[];
+    type?: RuleType;
+    enum?: any[];
+    /** Fails a non-empty string consisting only of whitespace */
+    whitespace?: boolean;
+    /** Transform the value before every check (builtin and validator) of THIS rule */
+    transform?: (value: any) => any;
+    /** Deep rule(s) applied to every member of an array/object value */
+    defaultField?: Rule | Rule[];
+    /** Deep rules applied per key of an object/array value */
+    fields?: Record<string, Rule | Rule[]>;
     /** A failing rule produces a non-blocking warning instead of an error */
     warningOnly?: boolean;
     /**
-     * Run this rule only on the given interactive trigger(s); rules without it
-     * follow the form-level validateTrigger. Submit always runs every rule.
+     * Run this rule only on the given interactive event(s). It
+     * must be a subset of the item's effective triggers to fire interactively.
+     * Rules without it run on every effective trigger. Submit always runs
+     * every rule.
      */
     validateTrigger?: ValidateTrigger | ValidateTrigger[];
-    validator?: (value: unknown, values: Record<string, unknown>) => boolean | string | Promise<boolean | string>;
+    /**
+     * Custom validator: resolve (or return undefined) to pass,
+     * reject/throw to fail. The failure message is taken from the rejection
+     * (Error.message or a plain string), then `rule.message`, then a generic
+     * fallback. Return values are ignored — returning `false` or a string does
+     * NOT fail the rule.
+     */
+    validator?: (rule: Rule, value: any) => Promise<void> | void;
 }
+/**
+ * Form/Item-level validateTrigger config: a single event, a
+ * list of events, or `false` to disable interactive validation entirely
+ * (submit / validateFields still run every rule). Item-level overrides
+ * form-level.
+ */
+export type ValidateTriggerProp = ValidateTrigger | ValidateTrigger[] | false;
+/**
+ * The form context handed to function-form rules. The read helpers are
+ * always available (derived from the validation-time value snapshot). The
+ * remaining members are backed by the live form instance and are present
+ * whenever rules run inside a mounted form — they are only absent when the
+ * pure rule engine is invoked directly without an instance.
+ */
+export interface RuleContext<Values = Record<string, any>> {
+    getFieldValue: <Name extends ProFormFieldName<Values>>(name: Name) => ProFormPathValue<Values, Name>;
+    getFieldsValue: () => Values;
+    setFieldValue?: <Name extends ProFormFieldName<Values>>(name: Name, value: ProFormPathValue<Values, Name>) => void;
+    setFieldsValue?: (values: ProFormValuesPatch<Values>) => void;
+    resetFields?: () => void;
+    getFieldError?: (name: ProFormFieldName<Values>) => ReactNode | undefined;
+    getFieldWarning?: (name: ProFormFieldName<Values>) => ReactNode | undefined;
+    isFieldTouched?: (name: ProFormFieldName<Values>) => boolean;
+    isFieldValidating?: (name: ProFormFieldName<Values>) => boolean;
+}
+/**
+ * A rule entry as consumers write it: a static Rule, or — for cross-field
+ * validation — a function of the form context returning a Rule (the
+ * `({ getFieldValue }) => ({ validator })` idiom).
+ */
+export type FormRule<Values = Record<string, any>> = Rule | ((ctx: RuleContext<Values>) => Rule);
+export type RuleContextReadMember = (typeof RULE_CONTEXT_READ_MEMBERS)[number];
+export type RuleContextMutatorMember = (typeof RULE_CONTEXT_MUTATOR_MEMBERS)[number];
+type AssertRuleContextMembers<T extends keyof RuleContext> = T;
+/**
+ * Compile-time guard: the member lists in constants.ts must stay subsets of
+ * RuleContext — renaming or removing a member there breaks this line.
+ */
+export type RuleContextInstanceMember = AssertRuleContextMembers<RuleContextReadMember | RuleContextMutatorMember>;
 export interface FieldProps {
     name: string;
-    value: unknown;
-    error?: string;
+    value: any;
+    error?: ReactNode;
     touched?: boolean;
     validating?: boolean;
-    onChange: (value: unknown) => void;
+    onChange: (value: any) => void;
     onBlur: () => void;
 }
 export interface FieldOptions {
-    rules?: Rule[];
-    validateTrigger?: ValidateTrigger;
+    rules?: FormRule[];
+    validateTrigger?: ValidateTriggerProp;
 }
 export interface FieldComponentProps {
     children: ReactNode | ((props: FieldProps) => ReactNode);
     render?: (props: FieldProps) => ReactNode;
 }
 /** Lightweight form instance returned by useFormCore */
-export interface FormCoreInstance {
-    submit: () => {
-        success: boolean;
-        values?: Record<string, unknown>;
-        errors?: Record<string, string>;
-    };
+export interface FormCoreInstance<Values = Record<string, any>> {
     resetFields: () => void;
-    getFieldValue: (name: string) => unknown;
-    getFieldsValue: () => Record<string, unknown>;
-    setFieldsValue: (values: Record<string, unknown>) => void;
-    setFieldValue: (name: string, value: unknown) => void;
-    validateFields: (fieldsRules?: Record<string, Rule[]>) => boolean;
+    getFieldValue: <Name extends ProFormFieldName<Values>>(name: Name) => ProFormPathValue<Values, Name>;
+    getFieldsValue: () => Values;
+    setFieldsValue: (values: ProFormValuesPatch<Values>) => void;
+    setFieldValue: <Name extends ProFormFieldName<Values>>(name: Name, value: ProFormPathValue<Values, Name>) => void;
 }
 /**
  * Full form instance returned by useForm — extends FormCoreInstance with async
  * validation, field helpers, etc. `Values` types the whole-form value shape
  * (defaults to an open record for backward compatibility).
  */
-export interface FormInstance<Values = Record<string, unknown>> {
-    getFieldValue: (name: string) => unknown;
-    getFieldsValue: (nameList?: string[]) => Values;
-    setFieldValue: (name: string, value: unknown) => void;
-    setFieldsValue: (values: Partial<Values>) => void;
-    setFieldError: (name: string, error: string | null) => void;
-    setFieldsError: (errors: Record<string, string>) => void;
-    resetFields: (fields?: string[]) => void;
-    validateFields: (nameList?: string[]) => Promise<Values>;
+export interface FormInstance<Values = Record<string, any>> {
+    getFieldValue: <Name extends ProFormFieldName<Values>>(name: Name) => ProFormPathValue<Values, Name>;
+    getFieldsValue: {
+        (): Values;
+        <Name extends ProFormFieldName<Values>>(nameList: Name[]): ProFormFieldValueMap<Values, Name>;
+    };
+    setFieldValue: <Name extends ProFormFieldName<Values>>(name: Name, value: ProFormPathValue<Values, Name>) => void;
+    setFieldsValue: (values: ProFormValuesPatch<Values>) => void;
+    setFieldError: (name: ProFormFieldName<Values>, error: ReactNode | null) => void;
+    setFieldsError: (errors: Record<string, ReactNode>) => void;
+    resetFields: (fields?: ProFormFieldName<Values>[]) => void;
+    validateFields: {
+        (): Promise<Values>;
+        <Name extends ProFormFieldName<Values>>(nameList: Name[]): Promise<ProFormFieldValueMap<Values, Name>>;
+    };
     submit: (callback?: (values: Values) => void | Promise<void>) => Promise<Values | undefined>;
-    getFieldError: (name: string) => string | undefined;
-    getFieldsError: (nameList?: string[]) => Record<string, string>;
-    getFieldWarning: (name: string) => string | undefined;
-    isFieldTouched: (name: string) => boolean;
-    isFieldsTouched: (nameList?: string[], allTouched?: boolean) => boolean;
-    isFieldValidating: (name: string) => boolean;
-    setFieldTouched: (name: string, isTouched?: boolean) => void;
+    getFieldError: (name: ProFormFieldName<Values>) => ReactNode | undefined;
+    getFieldsError: (nameList?: ProFormFieldName<Values>[]) => Record<string, ReactNode>;
+    getFieldWarning: (name: ProFormFieldName<Values>) => ReactNode | undefined;
+    isFieldTouched: (name: ProFormFieldName<Values>) => boolean;
+    isFieldsTouched: (nameList?: ProFormFieldName<Values>[], allTouched?: boolean) => boolean;
+    isFieldValidating: (name: ProFormFieldName<Values>) => boolean;
+    setFieldTouched: (name: ProFormFieldName<Values>, isTouched?: boolean) => void;
     setFieldsTouched: (touched: Record<string, boolean>) => void;
     defineField: (name: string, options?: FieldOptions) => FC<FieldComponentProps>;
-    registerField: (name: string, rules: Rule[]) => void;
+    registerField: (name: string, rules: FormRule<Values>[]) => void;
     unregisterField: (name: string) => void;
 }
 export interface UseFormOptions {
-    onValuesChange?: (changedValues: Record<string, unknown>, allValues: Record<string, unknown>) => void;
-    validateTrigger?: ValidateTrigger;
-    rules?: Record<string, Rule[]>;
+    onValuesChange?: (changedValues: Record<string, any>, allValues: Record<string, any>) => void;
+    validateTrigger?: ValidateTriggerProp;
+    rules?: Record<string, FormRule[]>;
 }
-export interface UseFormCoreConfig<Values = Record<string, unknown>> {
-    initialValues?: Partial<Values>;
+export interface UseFormCoreConfig<Values = Record<string, any>> {
+    initialValues?: ProFormRecursivePartial<Values>;
     onFinish?: (values: Values) => void;
     onFinishFailed?: (errorInfo: {
         values: Values;
-        errors: Record<string, string>;
+        errors: Record<string, ReactNode>;
     }) => void;
-    onValuesChange?: (changedValues: Partial<Values>, allValues: Values) => void;
+    onValuesChange?: (changedValues: ProFormValuesPatch<Values>, allValues: Values) => void;
     onReset?: () => void;
     size?: FormSize;
     labelAlign?: LabelAlign;
     disabled?: boolean;
-    colon?: boolean;
-    requiredMark?: boolean;
-    validateTrigger?: ValidateTrigger;
-}
-/** Internal shape of data produced by useFormCore, consumed by ProForm to build ProFormContext */
-export interface FormCoreContextShape {
-    values: Record<string, unknown>;
-    errors: Record<string, string>;
-    warnings: Record<string, string>;
-    touched: Record<string, boolean>;
-    formInstance: FormCoreInstance;
-    setFieldValue: (name: string, value: unknown) => void;
-    setFieldError: (name: string, error: string | null) => void;
-    setFieldWarning: (name: string, warning: string | null) => void;
-    validateField: (name: string, rules: Rule[], providedValue?: unknown) => boolean;
-    registerField: (name: string, rules: Rule[]) => void;
-    unregisterField: (name: string) => void;
-    size: FormSize;
-    labelAlign: LabelAlign;
-    disabled: boolean;
-    colon: boolean;
-    requiredMark: boolean;
-    validateTrigger: ValidateTrigger;
+    validateTrigger?: ValidateTriggerProp;
 }
 /** Config for useForm — accepts all UseFormCoreConfig fields */
-export type UseFormConfig<Values = Record<string, unknown>> = UseFormCoreConfig<Values>;
+export type UseFormConfig<Values = Record<string, any>> = UseFormCoreConfig<Values>;
 /** Internal state exposed by useForm for ProForm integration */
-export interface UseFormInternals {
-    values: Record<string, unknown>;
-    errors: Record<string, string>;
-    warnings: Record<string, string>;
+export interface UseFormInternals<Values = Record<string, any>> {
+    values: Record<string, any>;
+    errors: Record<string, ReactNode>;
+    warnings: Record<string, ReactNode>;
     touched: Record<string, boolean>;
     validating: Record<string, boolean>;
-    fieldRules: Record<string, Rule[]>;
-    setFieldValue: (name: string, value: unknown) => void;
-    setFieldError: (name: string, error: string | null) => void;
-    setFieldWarning: (name: string, warning: string | null) => void;
-    validateField: (name: string, rules: Rule[], providedValue?: unknown) => boolean;
-    validateFieldAsync: (name: string, value: unknown, rules: Rule[]) => Promise<{
+    fieldRules: Record<string, FormRule<Values>[]>;
+    setFieldValue: (name: string, value: any) => void;
+    setFieldError: (name: string, error: ReactNode | null) => void;
+    setFieldWarning: (name: string, warning: ReactNode | null) => void;
+    validateFieldAsync: (name: string, value: any, rules: FormRule<Values>[]) => Promise<{
         isValid: boolean;
-        error: string | null;
+        error: ReactNode | null;
     }>;
-    registerField: (name: string, rules: Rule[]) => void;
+    registerField: (name: string, rules: FormRule<Values>[]) => void;
     unregisterField: (name: string) => void;
+    /** Count a mounted instance for `name` — pair with `releaseField` on unmount. */
+    retainField: (name: string) => void;
+    /** Drop one instance count; the field's rules are removed only at zero. */
+    releaseField: (name: string) => void;
     handleSubmit: (e?: React.FormEvent) => void;
     handleReset: (e?: React.FormEvent) => void;
 }
 /** Return type for useForm */
-export interface UseFormReturn {
-    formInstance: FormInstance;
-    internals: UseFormInternals;
+export interface UseFormReturn<Values = Record<string, any>> {
+    formInstance: FormInstance<Values>;
+    internals: UseFormInternals<Values>;
 }
-export interface UseFormCoreReturn {
-    values: Record<string, unknown>;
-    errors: Record<string, string>;
-    warnings: Record<string, string>;
+export interface UseFormCoreReturn<Values = Record<string, any>> {
+    values: Record<string, any>;
+    errors: Record<string, ReactNode>;
+    warnings: Record<string, ReactNode>;
     touched: Record<string, boolean>;
-    fieldRules: Record<string, Rule[]>;
-    getFieldRules: (name: string) => Rule[] | undefined;
-    setFieldValue: (name: string, value: unknown) => void;
-    setFieldError: (name: string, error: string | null) => void;
-    setFieldWarning: (name: string, warning: string | null) => void;
-    setFieldsValue: (values: Record<string, unknown>) => void;
-    getFieldValue: (name: string) => unknown;
-    getFieldsValue: () => Record<string, unknown>;
-    validateField: (name: string, rules: Rule[], providedValue?: unknown) => boolean;
-    validateFields: (fieldsRules?: Record<string, Rule[]>) => boolean;
-    registerField: (name: string, rules: Rule[]) => void;
+    fieldRules: Record<string, FormRule<Values>[]>;
+    getFieldRules: (name: string) => FormRule<Values>[] | undefined;
+    /** Instance handed to function-form rules; useForm upgrades it to the full form instance. */
+    getRuleContextInstance: () => Partial<RuleContext<Values>>;
+    setRuleContextInstance: (instance: Partial<RuleContext<Values>>) => void;
+    /** Bump and return the field's validation epoch — every run captures one. */
+    beginValidationRun: (name: string) => number;
+    /** True while no newer run has started for the field since `epoch` was issued. */
+    isValidationRunCurrent: (name: string, epoch: number) => boolean;
+    /** Invalidate in-flight runs (all fields, or the given ones) — e.g. on reset. */
+    invalidateValidationRuns: (names?: string[]) => void;
+    setFieldValue: (name: string, value: any) => void;
+    setFieldError: (name: string, error: ReactNode | null) => void;
+    setFieldWarning: (name: string, warning: ReactNode | null) => void;
+    setFieldsValue: (values: ProFormValuesPatch<Values>) => void;
+    getFieldValue: (name: string) => any;
+    getFieldsValue: () => Values;
+    registerField: (name: string, rules: FormRule<Values>[]) => void;
     unregisterField: (name: string) => void;
-    handleSubmit: (e?: React.FormEvent) => void;
+    /** Count a mounted instance for `name` — pair with `releaseField` on unmount. */
+    retainField: (name: string) => void;
+    /** Drop one instance count; the field's rules are removed only at zero. */
+    releaseField: (name: string) => void;
     handleReset: (e?: React.FormEvent) => void;
     resetFields: () => void;
-    formInstance: FormCoreInstance;
-    coreContextShape: FormCoreContextShape;
+    formInstance: FormCoreInstance<Values>;
 }

package/lib/components/ProForm/core/namePathType.d.ts

@@ -0,0 +1,25 @@
+type Primitive = string | number | boolean | bigint | symbol | null | undefined | Date | File | Blob | ((...args: never[]) => any);
+type PreviousDepth = [never, 0, 1, 2, 3, 4, 5, 6];
+type StringKey<T> = Extract<keyof T, string>;
+type DotPathInternal<Value, Depth extends number> = [Depth] extends [never] ? never : Value extends Primitive ? never : Value extends readonly (infer Item)[] ? `${number}` | `${number}.${DotPathInternal<NonNullable<Item>, PreviousDepth[Depth]>}` : {
+    [Key in StringKey<Value>]: NonNullable<Value[Key]> extends Primitive ? Key : NonNullable<Value[Key]> extends readonly (infer Item)[] ? Key | `${Key}.${number}` | `${Key}.${number}.${DotPathInternal<NonNullable<Item>, PreviousDepth[Depth]>}` : Key | `${Key}.${DotPathInternal<NonNullable<Value[Key]>, PreviousDepth[Depth]>}`;
+}[StringKey<Value>];
+type SegmentValue<Value, Segment extends string> = Value extends readonly (infer Item)[] ? Segment extends `${number}` ? Item : any : Segment extends keyof Value ? Value[Segment] : any;
+/**
+ * Runtime ProForm field names are dot-path strings (`user.name`,
+ * `items.0.title`). When no concrete `Values` shape is supplied, names remain
+ * open strings for backward compatibility.
+ */
+export type ProFormFieldName<Values = Record<string, any>> = string extends keyof Values ? string : DotPathInternal<NonNullable<Values>, 6>;
+export type ProFormPathValue<Values, Path> = Path extends string ? Path extends `${infer Head}.${infer Tail}` ? ProFormPathValue<NonNullable<SegmentValue<NonNullable<Values>, Head>>, Tail> : SegmentValue<NonNullable<Values>, Path> : any;
+export type ProFormRecursivePartial<Value> = Value extends Primitive ? Value : Value extends readonly (infer Item)[] ? ProFormRecursivePartial<Item>[] : Value extends object ? {
+    [Key in keyof Value]?: ProFormRecursivePartial<Value[Key]>;
+} : Value;
+export type ProFormFieldValueMap<Values, Name extends ProFormFieldName<Values> = ProFormFieldName<Values>> = Partial<{
+    [FieldName in Name]: ProFormPathValue<Values, FieldName>;
+}>;
+type ProFormFieldPatchValue<Values, FieldName extends ProFormFieldName<Values>> = FieldName extends StringKey<Values> ? ProFormRecursivePartial<ProFormPathValue<Values, FieldName>> : ProFormPathValue<Values, FieldName>;
+export type ProFormValuesPatch<Values> = ProFormRecursivePartial<Values> | Partial<{
+    [FieldName in ProFormFieldName<Values>]: ProFormFieldPatchValue<Values, FieldName>;
+}>;
+export {};

package/lib/components/ProForm/core/namePathType.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50cy9Qcm9Gb3JtL2NvcmUvbmFtZVBhdGhUeXBlLmpzIiwibmFtZXMiOltdLCJzb3VyY2VSb290IjoiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjIiwic291cmNlcyI6WyJjb21wb25lbnRzL1Byb0Zvcm0vY29yZS9uYW1lUGF0aFR5cGUuanMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHt9OyJdLCJtYXBwaW5ncyI6IiIsImlnbm9yZUxpc3QiOltdfQ==

package/lib/components/ProForm/core/pathUtils.d.ts

@@ -1,6 +1,8 @@
 /** Read a dot-path value out of a nested object. Returns undefined if any segment is missing. */
-export declare function getNestedValue(obj: Record<string, unknown>, path: string): unknown;
+export declare function getNestedValue(obj: Record<string, any>, path: string): any;
 /** Immutably set a dot-path value, cloning each object/array along the path. */
-export declare function setNestedValue(obj: Record<string, unknown>, path: string, value: unknown): Record<string, unknown>;
+export declare function setNestedValue(obj: Record<string, any>, path: string, value: any): Record<string, any>;
+/** Immutably deep-merge a form values patch. Arrays and non-plain objects replace. */
+export declare function mergeValuesPatch(values: Record<string, any>, patch: Record<string, any>): Record<string, any>;
 /** Read a field value, taking the fast path for flat (non-dotted) names. */
-export declare function resolveValue(values: Record<string, unknown>, name: string): unknown;
+export declare function resolveValue(values: Record<string, any>, name: string): any;

package/lib/components/ProForm/core/pathUtils.js

@@ -5,8 +5,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getNestedValue = getNestedValue;
+exports.mergeValuesPatch = mergeValuesPatch;
 exports.resolveValue = resolveValue;
 exports.setNestedValue = setNestedValue;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
@@ -61,8 +63,25 @@ function setNestedValue(obj, path, value) {
   current[keys[keys.length - 1]] = value;
   return result;
 }
+function isPlainObject(value) {
+  if (value === null || (0, _typeof2["default"])(value) !== 'object') return false;
+  var prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+/** Immutably deep-merge a form values patch. Arrays and non-plain objects replace. */
+function mergeValuesPatch(values, patch) {
+  var result = Object.assign({}, values);
+  for (var _i = 0, _Object$entries = Object.entries(patch); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = (0, _slicedToArray2["default"])(_Object$entries[_i], 2),
+      key = _Object$entries$_i[0],
+      patchValue = _Object$entries$_i[1];
+    var currentValue = result[key];
+    result[key] = isPlainObject(currentValue) && isPlainObject(patchValue) ? mergeValuesPatch(currentValue, patchValue) : patchValue;
+  }
+  return result;
+}
 /** Read a field value, taking the fast path for flat (non-dotted) names. */
 function resolveValue(values, name) {
   return name.includes('.') ? getNestedValue(values, name) : values[name];
 }
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/components/ProForm/core/runRules.d.ts

@@ -1,25 +1,48 @@
-import type { Rule, ValidateTrigger } from './interface';
+import type { ReactNode } from 'react';
+import type { FormRule, Rule, RuleContext, ValidateTrigger, ValidateTriggerProp } from './interface';
 export interface RuleRunResult {
-    error: string | null;
-    warning: string | null;
+    error: ReactNode | null;
+    warning: ReactNode | null;
 }
 /**
- * Filter rules applicable to an interactive trigger. A rule WITHOUT an
- * explicit `validateTrigger` follows the form-level trigger; a rule WITH one
- * runs on exactly those trigger(s), regardless of the form-level setting.
- * Submit-time validation bypasses this filter and runs every rule.
+ * Coerce a thrown/rejected reason into displayable failure content:
+ * a non-empty Error.message or a non-empty plain string — otherwise null
+ * (caller picks its fallback). Shared with the form-level last-resort nets.
  */
-export declare function filterRulesByTrigger(rules: Rule[], trigger: ValidateTrigger, formTrigger: ValidateTrigger): Rule[];
+export declare function coerceFailureReason(reason: any): ReactNode | null;
 /**
- * Synchronous rule run. A Promise-returning validator CANNOT be evaluated
- * here — it is deferred (treated as passing for this run; its rejection is
- * swallowed) and left to the async runs (blur/submit), which always await it.
- * Failing it instead would mis-report "Validation failed" on every keystroke
- * for perfectly valid input.
+ * Resolve function-form rules into static rules. The
+ * context exposes the value snapshot the run was invoked with; function rules
+ * must be cheap and side-effect free — they may be resolved more than once
+ * per validation pass.
  */
-export declare function runRulesSync(name: string, value: unknown, values: Record<string, unknown>, rules: Rule[]): RuleRunResult;
+export declare function resolveRules<Values = Record<string, any>>(rules: FormRule<Values>[], values: Values, instance?: Partial<RuleContext<Values>>): Rule[];
 /**
- * Asynchronous rule run. Custom validators are awaited (sync or async). A
- * validator returning `undefined` is treated as passing.
+ * Normalize a form/item-level validateTrigger config into the effective
+ * interactive event list: item-level (when present) overrides form-level;
+ * `false` disables interactive validation entirely.
  */
-export declare function runRulesAsync(name: string, value: unknown, values: Record<string, unknown>, rules: Rule[]): Promise<RuleRunResult>;
+export declare function normalizeTriggers(itemTrigger: ValidateTriggerProp | undefined, formTrigger: ValidateTriggerProp): ValidateTrigger[];
+/**
+ * Filter rules applicable to an interactive event: the event
+ * validates only when it is in the item's effective trigger set. Within the
+ * set, a rule WITHOUT `validateTrigger` runs on every event; a rule WITH one
+ * runs only on matching events — so a rule trigger outside the item's set
+ * never fires interactively. Submit-time validation bypasses this filter and
+ * runs every rule.
+ *
+ * Dev guard: a rule whose (non-empty) trigger set is fully OUTSIDE the
+ * active set can never fire interactively — usually a leftover of the
+ * pre-0.0.76 override semantics, so it warns once. `validateTrigger: []`
+ * is the deliberate submit-only idiom and stays silent.
+ */
+export declare function filterRulesByTrigger(rules: Rule[], trigger: ValidateTrigger, activeTriggers: ValidateTrigger[], fieldName?: string): Rule[];
+/**
+ * Rule run. Custom validators are awaited (sync or async): resolving passes,
+ * rejecting/throwing fails. Return values are ignored.
+ *
+ * The per-rule try/catch is the totality choke point: NO input — including
+ * exotic values that break a builtin check — may escape as a throw; every
+ * failure surfaces through the error/warning channels.
+ */
+export declare function runRulesAsync<Values = Record<string, any>>(name: string, value: any, values: Values, rules: FormRule<Values>[], instance?: Partial<RuleContext<Values>>): Promise<RuleRunResult>;