@simpleform/render 4.2.1 → 4.2.3

package/lib/store/index.d.ts

@@ -1,20 +1,41 @@
 import { FormRenderNodeProps, FormRenderProps } from '../typings';
+import { Form } from '@simpleform/form';
 export type FormRenderListener<V> = (newValue?: V, oldValue?: V) => void;
 export declare class SimpleFormRender {
-    config?: FormRenderProps;
+    config: Omit<FormRenderProps, 'formConfig' | 'components'> & {
+        formConfig: NonNullable<FormRenderProps['formConfig']>;
+        components: NonNullable<FormRenderProps['components']>;
+    };
     private widgetList;
     private lastWidgetList;
     private widgetListListeners;
+    static defaultConfig: {
+        formConfig: {
+            Form: typeof Form;
+            Item: import("react").ForwardRefExoticComponent<Omit<import("@simpleform/form").ItemProps, "children"> & import("@simpleform/form").ItemCoreProps & {
+                component?: import("react").ComponentType<any> | import("react").ForwardRefExoticComponent<any> | null;
+            } & {
+                className?: string;
+                style?: import("react").CSSProperties;
+            } & import("react").RefAttributes<HTMLDivElement>>;
+        };
+        components: {
+            row: import("react").ForwardRefExoticComponent<import("../components").CustomRowProps & import("react").RefAttributes<HTMLDivElement>>;
+            col: import("react").ForwardRefExoticComponent<import("../components").CustomColProps & import("react").RefAttributes<HTMLDivElement>>;
+        };
+    };
     constructor(config?: SimpleFormRender['config']);
-    defineConfig(payload?: SimpleFormRender['config'] | ((config?: FormRenderProps) => Partial<FormRenderProps>)): void;
-    getWidgetList(): import("../typings").WithExpression<Omit<import("../typings").FRGenerateNode, "rules"> & {
-        rules?: import("../typings").ArrWithExpression<import("@simpleform/form").FormItemProps["rules"]>;
+    defineConfig(payload?: Partial<SimpleFormRender['config']> | ((config?: SimpleFormRender['config']) => SimpleFormRender['config'])): void;
+    getWidgetList(): import("../typings").WithExpression<Omit<import("../typings").FRGenerateNode, "inside" | "outside"> & {
+        inside?: import("../typings").ReactComponent<any> | import("react").ReactNode | import("../typings").FRNode;
+        outside?: import("../typings").ReactComponent<any> | import("react").ReactNode | import("../typings").FRNode;
     }>[];
     setWidgetList(data?: SimpleFormRender['widgetList'], option?: {
         ignore?: boolean;
     }): void;
-    getItemByPath: (path?: FormRenderNodeProps["path"]) => import("../typings").WithExpression<Omit<import("../typings").FRGenerateNode, "rules"> & {
-        rules?: import("../typings").ArrWithExpression<import("@simpleform/form").FormItemProps["rules"]>;
+    getItemByPath: (path?: FormRenderNodeProps["path"]) => import("../typings").WithExpression<Omit<import("../typings").FRGenerateNode, "inside" | "outside"> & {
+        inside?: import("../typings").ReactComponent<any> | import("react").ReactNode | import("../typings").FRNode;
+        outside?: import("../typings").ReactComponent<any> | import("react").ReactNode | import("../typings").FRNode;
     }>[] | undefined;
     getActions(): {
         [k: string]: (...args: any[]) => void;

package/lib/typings.d.ts

@@ -1,8 +1,19 @@
 import React, { ReactNode } from 'react';
-import { FormItemProps, FormProps } from '@simpleform/form';
 import { SimpleFormRender } from './store';
 export type ReactComponent<P> = React.ComponentType<P> | React.ForwardRefExoticComponent<P>;
-export type FRGenerateNode = FormItemProps & {
+export type FormConfig = {
+    Form: React.FunctionComponent<{
+        [key in string]: any;
+    }>;
+    Item: ReactComponent<{
+        [key in string]: any;
+    }>;
+    context?: {
+        [key in string]: any;
+    };
+    form?: any;
+};
+export type FRGenerateNode = {
     type?: string | ReactComponent<any>;
     props?: Record<string, unknown>;
     children?: any;
@@ -12,44 +23,45 @@ export type FRGenerateNode = FormItemProps & {
     readOnlyRender?: ReactNode | ((context?: FRContext) => ReactNode);
     typeRender?: ReactNode | ((context?: FRContext) => ReactNode);
     hidden?: boolean;
-};
+} & React.ComponentProps<FormConfig['Item']>;
 export type WithExpression<T> = {
-    [P in keyof T]: T[P] | string;
+    [P in keyof T]: T[P] extends any[] ? ArrWithExpression<T[P]> : T[P] | string;
 };
 export type ArrWithExpression<T extends Array<any> | undefined> = Array<WithExpression<NonNullable<T>[number]>>;
-export type FRNode = WithExpression<Omit<FRGenerateNode, 'rules'> & {
-    rules?: ArrWithExpression<FormItemProps['rules']>;
+export type FRNode = WithExpression<Omit<FRGenerateNode, 'inside' | 'outside'> & {
+    inside?: ReactComponent<any> | ReactNode | FRNode;
+    outside?: ReactComponent<any> | ReactNode | FRNode;
 }>;
 export type FROptions = Partial<FRGenerateNode> & {
     [key in string]: any;
 };
 export type FRContext = {
-    _options: FROptions & Pick<FormChildrenProps, 'formrender'> & Pick<FormProps, 'form'> & {
+    _options: FROptions & Pick<FormChildrenProps, 'formrender'> & Pick<FormConfig, 'form'> & {
         index?: number;
         path?: Array<string | number>;
     };
 };
 export type CustomRenderType = <C>(children?: C, context?: FRContext) => C;
-export type FormRenderNodeProps = Pick<FormProps, 'onValuesChange'> & {
+export type FormRenderNodeProps = {
     formrender: SimpleFormRender;
     widget: FRNode;
     index?: FRContext['_options']['index'];
     path?: FRContext['_options']['path'];
     renderList?: CustomRenderType;
     renderItem?: CustomRenderType;
+    onValuesChange?: (...args: any[]) => void;
 };
 export type FormChildrenProps = Pick<FormRenderNodeProps, 'renderList' | 'renderItem'> & {
-    /**@deprecated no longer recommended */
-    form?: FormProps['form'];
+    /**@deprecated no longer recommended, please use 'variables' instead */
+    plugins?: Record<string, unknown>;
     formrender?: SimpleFormRender;
     wrapper?: FRNode['inside'];
     options?: FROptions | ((frGenerateNode: any) => FROptions);
     widgetList?: Array<FRNode>;
-    /**@deprecated no longer recommended, please use 'variables' instead */
-    plugins?: Record<string, unknown>;
     variables?: Record<string, unknown>;
     parser?: <V>(value?: V, variables?: object) => V;
     components?: Record<string, ReactComponent<any>>;
+    formConfig?: FormConfig;
     onRenderChange?: (newData?: FormChildrenProps['widgetList'], oldData?: FormChildrenProps['widgetList']) => void;
 };
-export type FormRenderProps = FormProps & Omit<FormChildrenProps, 'form'>;
+export type FormRenderProps = FormChildrenProps & React.ComponentProps<FormConfig['Form']>;

package/lib/utils/transform.d.ts

@@ -1,12 +1,12 @@
 import React from 'react';
-import { CustomRenderType, FormRenderNodeProps, FormRenderProps, FRContext } from '../typings';
+import { CustomRenderType, FormChildrenProps, FormRenderNodeProps, FormRenderProps, FRContext, FRGenerateNode } from '../typings';
 export declare const mergeFROptions: (oldConfig: any, newConfig: any, mergeFunNames?: string[]) => any;
 export declare const traverseMapObject: (val: any, callback: any) => any;
 export declare const traverseList: <V>(list?: Array<V>, callback?: (item: V, index: number, parent?: Array<string | number>) => any | void, parent?: Array<string | number>) => void[] | undefined;
 export declare const traverseParse: <V>(obj: V, variables?: object, parser?: FormRenderProps["parser"]) => any;
-export declare const getInitialValues: <V>(widgetList?: FormRenderProps["widgetList"]) => V | undefined;
+export declare const getInitialValues: (widgetList?: FRGenerateNode[]) => {} | undefined;
 export declare const createFRElement: (target?: any, props?: any, widgets?: FormRenderProps["components"]) => React.ReactNode;
 export declare const parseFRData: (data: any, formrender: FormRenderProps["formrender"], form?: FormRenderProps["form"]) => any;
 export declare const withSide: (target?: React.ReactNode, customRender?: CustomRenderType, side?: React.ReactNode, context?: FRContext) => React.ReactElement<any, any>;
-export declare const renderFRNode: (node?: FormRenderNodeProps, formContext?: any) => React.ReactElement<any, any> | null | undefined;
-export declare const renderFRNodeList: (formrender: FormRenderNodeProps["formrender"], widgetList?: any, formContext?: any, parentNode?: Partial<FormRenderNodeProps>) => (React.ReactElement<any, any> | null | undefined)[] | undefined;
+export declare const renderFRNode: (node?: FormRenderNodeProps, formConfig?: FormChildrenProps["formConfig"]) => React.ReactElement<any, any> | null | undefined;
+export declare const renderFRNodeList: (formrender: FormRenderNodeProps["formrender"], widgetList?: any, formConfig?: FormChildrenProps["formConfig"], parentNode?: Partial<FormRenderNodeProps>) => (React.ReactElement<any, any> | null | undefined)[] | undefined;

package/lib/utils/utils.d.ts

@@ -6,9 +6,11 @@ export declare function toEntries<T>(data: T[]): [number, T][];
 export declare function toEntries<T>(data: Record<string, T>): [string, T][];
 export declare function parseEntries<T>(entries: Array<[number, T]>): T[];
 export declare function parseEntries<T>(entries: Array<[string, T]>): Record<string, T>;
-export declare const insertItemByIndex: (widgetList: FormRenderProps["widgetList"] | undefined, data: unknown, index?: number, parent?: FormRenderNodeProps["path"]) => import("src/typings").WithExpression<Omit<import("src/typings").FRGenerateNode, "rules"> & {
-    rules?: import("src/typings").ArrWithExpression<import("@simpleform/form").FormItemProps["rules"]>;
+export declare const insertItemByIndex: (widgetList: FormRenderProps["widgetList"] | undefined, data: unknown, index?: number, parent?: FormRenderNodeProps["path"]) => import("src/typings").WithExpression<Omit<import("src/typings").FRGenerateNode, "inside" | "outside"> & {
+    inside?: import("src/typings").ReactComponent<any> | import("react").ReactNode | import("src/typings").FRNode;
+    outside?: import("src/typings").ReactComponent<any> | import("react").ReactNode | import("src/typings").FRNode;
 }>[] | undefined;
-export declare const moveItemByPath: (widgetList: FormRenderProps["widgetList"] | undefined, fromPath: FormRenderNodeProps["path"], toPath: FormRenderNodeProps["path"]) => import("src/typings").WithExpression<Omit<import("src/typings").FRGenerateNode, "rules"> & {
-    rules?: import("src/typings").ArrWithExpression<import("@simpleform/form").FormItemProps["rules"]>;
+export declare const moveItemByPath: (widgetList: FormRenderProps["widgetList"] | undefined, fromPath: FormRenderNodeProps["path"], toPath: FormRenderNodeProps["path"]) => import("src/typings").WithExpression<Omit<import("src/typings").FRGenerateNode, "inside" | "outside"> & {
+    inside?: import("src/typings").ReactComponent<any> | import("react").ReactNode | import("src/typings").FRNode;
+    outside?: import("src/typings").ReactComponent<any> | import("react").ReactNode | import("src/typings").FRNode;
 }>[] | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simpleform/render",
-  "version": "4.2.1",
+  "version": "4.2.3",
   "description": "dynamic rendering core of simple form",
   "author": "mezhanglei <496623925@qq.com>",
   "homepage": "https://github.com/mezhanglei/simpleform#readme",
@@ -45,7 +45,7 @@
     "react-router-dom": "^6.19.0"
   },
   "dependencies": {
-    "@simpleform/form": "^2.2.7",
+    "@simpleform/form": "^2.2.8",
     "@simpleform/evaluator": "^0.0.2",
     "classnames": "^2.3.2",
     "copy-anything": "^3.0.5",