@simpleform/render 3.0.15 → 3.0.17

package/lib/store.d.ts

@@ -1,25 +1,25 @@
 /// <reference types="react" />
-import { CustomUnionType, GenerateParams, WidgetItem, WidgetList } from "./types";
-export type FormRenderListener = (newValue?: any, oldValue?: any) => void;
+import { CustomUnionType, FormRenderProps, WidgetList } from "./typings";
+export type FormRenderListener<V> = (newValue?: V, oldValue?: V) => void;
 export declare class SimpleFormRender {
-    plugins: any;
-    components: any;
+    plugins: FormRenderProps['plugins'];
+    components: FormRenderProps['components'];
     private widgetList;
     private lastWidgetList;
     private widgetListListeners;
     constructor();
-    addPlugin(data: any): void;
-    registry(data: any): void;
-    getFormComponent(target?: CustomUnionType): import("react").ComponentType<{}> | null | undefined;
-    createFormElement(target?: CustomUnionType, commonProps?: GenerateParams): any;
+    addPlugin(data: FormRenderProps['plugins']): void;
+    registry(data: FormRenderProps['components']): void;
+    getFormComponent(target?: CustomUnionType): import("react").ComponentClass<unknown, any> | import("react").FunctionComponent<unknown> | import("react").ForwardRefExoticComponent<unknown> | null | undefined;
+    createFormElement(target?: CustomUnionType, commonProps?: unknown): import("react").ReactNode;
     getWidgetList(): WidgetList;
-    setWidgetList(data?: WidgetList): void;
-    setItemByPath: (data?: any, path?: string) => void;
-    setItemByIndex: (data?: any, index?: number, parent?: string) => void;
-    insertItemByIndex: (data?: WidgetItem | Array<WidgetItem>, index?: number, parent?: string) => void;
+    setWidgetList(data?: SimpleFormRender['widgetList']): void;
+    setItemByPath: (data?: unknown, path?: string) => void;
+    setItemByIndex: <V>(data?: unknown, index?: number, parent?: string) => void;
+    insertItemByIndex: <V>(data?: V | V[] | undefined, index?: number, parent?: string) => void;
     delItemByPath: (path?: string) => void;
-    getItemByPath: (path?: string) => any;
-    getItemByIndex: (index: number, parent?: string) => any;
+    getItemByPath: <V>(path?: string) => V | undefined;
+    getItemByIndex: <V>(index: number, parent?: string) => V | undefined;
     moveItemByPath: (from: {
         parent?: string;
         index: number;
@@ -27,7 +27,7 @@ export declare class SimpleFormRender {
         parent?: string;
         index?: number;
     }) => void;
-    subscribeWidgetList(listener: FormRenderListener): () => void;
+    subscribeWidgetList(listener: SimpleFormRender['widgetListListeners'][number]): () => void;
     unsubscribeWidgetList(): void;
     private notifyWidgetList;
 }

package/lib/typings.d.ts

@@ -0,0 +1,47 @@
+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 interface CustomWidget<P = {}> {
+    type?: string;
+    props?: Record<string, unknown> & {
+        children?: CustomUnionType;
+    };
+    widgetList?: WidgetList<P>;
+}
+export interface RegisteredComponents<P = any> {
+    [key: string]: ReactComponent<P>;
+}
+export type CustomUnionType = CustomWidget | Array<CustomWidget> | ReactComponent<unknown> | Function | ReactNode;
+export type WidgetList<P = {}> = Array<WidgetItem<P>>;
+export type GenerateWidgetItem<P = {}> = CustomWidget<P> & FormItemProps & {
+    inside?: CustomUnionType;
+    outside?: CustomUnionType;
+    readOnly?: boolean;
+    readOnlyRender?: CustomUnionType;
+    typeRender?: CustomUnionType;
+    hidden?: boolean;
+} & P;
+export type WidgetItem<P = {}> = {
+    [key in keyof GenerateWidgetItem<P>]: (string | GenerateWidgetItem<P>[key]);
+};
+export type WidgetOptions<P = {}> = GenerateWidgetItem<P> & Pick<FormChildrenProps, 'form' | 'formrender'> & {
+    index?: number;
+    path?: string;
+};
+export type WidgetContextProps<P = {}> = {
+    _options?: WidgetOptions<P>;
+};
+export type CustomRenderType = <C, P = {}>(children?: C, params?: WidgetContextProps<P>) => C;
+export type FormChildrenProps<P = {}> = Pick<FormProps, 'form'> & Pick<GenerateWidgetItem<P>, 'inside'> & {
+    formrender?: SimpleFormRender;
+    options?: GenerateWidgetItem<P> | ((item: GenerateWidgetItem<P>) => GenerateWidgetItem<P>);
+    uneval?: boolean;
+    components?: RegisteredComponents;
+    plugins?: Record<string, unknown>;
+    widgetList?: WidgetList<P>;
+    renderList?: CustomRenderType;
+    renderItem?: CustomRenderType;
+    onRenderChange?: (newData?: WidgetList<P>, oldData?: WidgetList<P>) => void;
+};
+export type FormRenderProps<P = {}> = FormProps & FormChildrenProps<P>;

package/lib/utils/ReactIs.d.ts

@@ -1 +1 @@
-export declare function isValidComponent(component?: any): boolean | undefined;
+export declare function isValidComponent(component?: unknown): boolean;

package/lib/utils/array.d.ts

@@ -1 +1 @@
-export declare const arrayMove: <T = any>(arr: T[], preIndex: number, nextIndex: number) => T[];
+export declare const arrayMove: <T>(arr: T[], preIndex: number, nextIndex: number) => T[];

package/lib/utils/object.d.ts

@@ -1,2 +1,2 @@
-export declare function deepClone<T = any>(value: T): T;
-export declare function isEqual(a: any, b: any): boolean;
+export declare function deepClone<T>(value: T): T;
+export declare function isEqual(a: unknown, b: unknown): boolean;

package/lib/utils/transform.d.ts

@@ -1,7 +1,8 @@
 import React from 'react';
-import { GenerateParams } from "../types";
-export interface ComponentsMap {
-    [key: string]: React.ComponentType;
-}
-export declare const getFormComponent: (target: any, typeMap?: ComponentsMap) => React.ComponentType | undefined | null;
-export declare const createFormElement: (target?: any, typeMap?: ComponentsMap, commonProps?: GenerateParams) => any;
+import { SimpleFormRender } from '../store';
+import { CustomRenderType, CustomUnionType, RegisteredComponents, WidgetContextProps } from "../typings";
+export declare const getFormComponent: (target?: unknown, typeMap?: RegisteredComponents) => React.ComponentClass<unknown, any> | React.FunctionComponent<unknown> | React.ForwardRefExoticComponent<unknown> | null | undefined;
+export declare const createFormElement: (target?: unknown, typeMap?: RegisteredComponents, commonProps?: unknown) => React.ReactNode;
+export declare const compileExpression: <V, P extends object = {}>(value: V, plugins?: P | undefined, uneval?: boolean) => any;
+export declare const evalAttr: <V, P extends object = {}>(val: V, plugins?: P | undefined, uneval?: boolean) => any;
+export declare const withSide: (formrender: SimpleFormRender, target?: React.ReactNode, render?: CustomRenderType, side?: CustomUnionType, params?: WidgetContextProps) => string | number | boolean | React.ReactElement<any, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined;

package/lib/utils/type.d.ts

@@ -1,25 +1,34 @@
 /**
  * 精确类型判断
  */
-export declare function getType(obj: any): string;
-export declare function isBoolean(data: any): boolean;
-export declare function isNumber(data: any): boolean;
-export declare function isString(data: any): boolean;
-export declare function isFunction(data: any): boolean;
-export declare function isArray(data: any): boolean;
-export declare function isDate(data: any): boolean;
-export declare function isRegExp(data: any): boolean;
-export declare function isUndefined(data: any): boolean;
-export declare function isNull(data: any): boolean;
-export declare function isObject(data: any): boolean;
-export declare function isElement(data: any): boolean;
-export declare function isDom(ele: any): any;
-export declare function isNodeList(data: any): boolean;
-export declare function isEmpty(value: unknown): boolean;
-export declare function isArrayBuffer(data: any): boolean;
-export declare function isFormData(data: any): boolean;
-export declare function isArrayBufferView(val: any): any;
-export declare function isFile(data: any): boolean;
-export declare function isBlob(data: any): boolean;
-export declare function isStream(val: any): boolean;
-export declare const isNumberStr: (str?: string | Number) => true | undefined;
+export declare function getType<T>(obj: T): string;
+export declare function isBoolean<T>(data: T): boolean;
+export declare function isNumber<T>(data: T): boolean;
+export declare function isString<T>(data: T): boolean;
+export declare function isFunction<T>(data: T): boolean;
+export declare function isArray<T>(data: T): boolean;
+export declare function isDate<T>(data: T): boolean;
+export declare function isRegExp<T>(data: T): boolean;
+export declare function isUndefined<T>(data: T): boolean;
+export declare function isNull<T>(data: T): boolean;
+export declare function isObject<T>(data: T): boolean;
+export declare function isElement<T>(data: T): boolean;
+export declare function isDom<T>(data: T & {
+    nodeType?: number;
+    nodeName?: string;
+}): boolean;
+export declare function isNodeList<T>(data: T): boolean;
+export declare function isEmpty<T>(value: T): boolean | undefined;
+export declare function isArrayBuffer<T>(data: T): boolean;
+export declare function isFormData<T>(data: T): boolean;
+export declare function isArrayBufferView<T>(data: T & {
+    buffer?: ArrayBuffer;
+}): any;
+export declare function isFile<T>(data: T): boolean;
+export declare function isBlob<T>(data: T): boolean;
+export declare function isStream<T>(data: T & {
+    pipe?: Function;
+}): boolean;
+export declare function isBase<T>(data: T): boolean;
+export declare const isNumberStr: <T>(str?: T | undefined) => true | undefined;
+export declare const isBase64: <T>(str?: T | undefined) => boolean | undefined;

package/lib/utils/utils.d.ts

@@ -1,28 +1,37 @@
-import { WidgetItem, WidgetList } from "../types";
-export declare const matchExpression: (value?: any) => string | undefined;
+import { WidgetList } from "../typings";
+export declare const matchExpression: (value?: unknown) => string | undefined;
 export declare const getPathEnd: (path?: string) => string | number | undefined;
 export declare const getParent: (path?: string) => string;
 export declare const getPathLen: (path?: string) => number;
-export declare const setItemByPath: (widgetList: WidgetList, data?: any, path?: string) => any;
-export declare const getItemByPath: (widgetList?: WidgetList, path?: string) => any;
-export declare const getKeyValueByIndex: (widgetList: WidgetList, index?: number, parent?: string) => [string | number, any] | undefined;
-export declare const toEntries: (data: any) => {
+export declare const setItemByPath: (widgetList?: WidgetList, data?: unknown, path?: string) => WidgetList | undefined;
+export type GetItemByPath = {
+    (widgetList?: WidgetList): WidgetList | undefined;
+    <V>(widgetList?: WidgetList, path?: string): V | undefined;
+};
+export declare const getItemByPath: GetItemByPath;
+export declare const getKeyValueByIndex: <V>(widgetList?: WidgetList, index?: number, parent?: string) => [string, V] | undefined;
+export declare const toEntries: <T>(data: T) => {
     isList: boolean;
-    entries: [string, any][];
+    entries: (T extends (infer I)[] | Record<string, infer I> ? [string, I] : unknown)[];
+};
+export type ParseEntries = {
+    <T>(entries: Array<[string, T]>): Record<string, T>;
+    <T>(entries: Array<[string, T]>, isList: boolean): Array<T> | Record<string, T>;
 };
-export declare const insertItemByIndex: (widgetList: WidgetList, data?: WidgetItem | Array<WidgetItem>, index?: number, parent?: string) => any;
-export declare const moveSameLevel: (widgetList: WidgetList, from: {
+export declare const parseEntries: ParseEntries;
+export declare const insertItemByIndex: <V>(widgetList?: WidgetList, data?: V | V[] | undefined, index?: number, parent?: string) => WidgetList | undefined;
+export declare const moveSameLevel: (widgetList: WidgetList | undefined, from: {
     parent?: string;
     index: number;
 }, to: {
     parent?: string;
     index?: number;
-}) => any;
-export declare const moveDiffLevel: (widgetList: WidgetList, from: {
+}) => WidgetList | undefined;
+export declare const moveDiffLevel: (widgetList: WidgetList | undefined, from: {
     parent?: string;
     index: number;
 }, to: {
     parent?: string;
     index?: number;
-}) => any;
-export declare const getInitialValues: (widgetList?: WidgetList) => {} | undefined;
+}) => WidgetList | undefined;
+export declare const getInitialValues: <V>(widgetList?: WidgetList) => V | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simpleform/render",
-  "version": "3.0.15",
+  "version": "3.0.17",
   "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.0.18",
+    "@simpleform/form": "^2.0.20",
     "classnames": "^2.3.2",
     "copy-anything": "^3.0.5",
     "react-fast-compare": "^3.2.2"

package/lib/types.d.ts

@@ -1,50 +0,0 @@
-import React, { ReactNode } from "react";
-import { FormItemProps, FormProps, FormRule, SimpleForm } from "@simpleform/form";
-import { SimpleFormRender } from "./store";
-export interface CustomWidget {
-    type?: string;
-    props?: Record<string, any> & {
-        children?: any | Array<CustomWidget>;
-    };
-    widgetList?: WidgetList;
-}
-export type UnionComponent<P> = React.ComponentType<P> | React.ForwardRefExoticComponent<P> | keyof React.ReactHTML;
-export type CustomUnionType = CustomWidget | Array<CustomWidget> | UnionComponent<any> | Function | ReactNode;
-export type WidgetList = Array<WidgetItem>;
-export type GenerateWidgetItem<T extends Record<string, any> = {}> = CustomWidget & FormItemProps & T & {
-    inside?: CustomUnionType;
-    outside?: CustomUnionType;
-    readOnly?: boolean;
-    readOnlyRender?: CustomUnionType;
-    typeRender?: CustomUnionType;
-    hidden?: boolean;
-};
-export type CustomRenderType = (params: GenerateParams<any> & {
-    children?: any;
-}) => any;
-export type WidgetItem = {
-    [key in keyof GenerateWidgetItem]: key extends 'rules' ? (string | Array<{
-        [key in keyof FormRule]: FormRule[key] | string;
-    }> | GenerateWidgetItem[key]) : (string | GenerateWidgetItem[key]);
-};
-export interface FormChildrenProps<T extends Record<string, any> = {}> {
-    form?: SimpleForm;
-    formrender?: SimpleFormRender;
-    options?: GenerateWidgetItem<T> | ((params: GenerateWidgetItem<T>) => GenerateWidgetItem<T>);
-    uneval?: boolean;
-    components?: Record<string, any>;
-    plugins?: Record<string, any>;
-    inside?: CustomUnionType;
-    widgetList?: WidgetList;
-    renderList?: CustomRenderType;
-    renderItem?: CustomRenderType;
-    onRenderChange?: (newValue: WidgetList, oldValue?: WidgetList) => void;
-}
-export type FormRenderProps<T extends Record<string, any> = {}> = Omit<FormProps, 'form'> & FormChildrenProps<T>;
-export interface GenerateParams<T extends Record<string, any> = {}> {
-    index?: number;
-    path?: string;
-    widgetItem?: GenerateWidgetItem<T>;
-    formrender?: SimpleFormRender;
-    form?: SimpleForm;
-}