duoyun-ui 2.2.3 → 2.2.9

package/react/DyCountdown.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunCountdownElement } from '../elements/countdown';
+export * from '../elements/countdown';
+export type DyCountdownProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunCountdownElement> & {};
+export type DyCountdownExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-countdown': DyCountdownProps;
+        }
+    }
+}
+export declare const DyCountdown: ForwardRefExoticComponent<Omit<DyCountdownProps, "ref"> & RefAttributes<DyCountdownExpose>>;
+export default DyCountdown;

package/react/DyCountdown.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/countdown';
+export const DyCountdown = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {};
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        [].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-countdown", { ref: elementRef, ...props });
+});
+export default DyCountdown;

package/react/DyDatePanel.d.ts

@@ -0,0 +1,22 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunDatePanelElement } from '../elements/date-panel';
+export * from '../elements/date-panel';
+export type DyDatePanelProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunDatePanelElement> & {
+    time?: DuoyunDatePanelElement['time'];
+    'onchange'?: (event: CustomEvent<Parameters<DuoyunDatePanelElement['change']>[0]>) => void;
+    'ondatehover'?: (event: CustomEvent<Parameters<DuoyunDatePanelElement['datehover']>[0]>) => void;
+    value?: DuoyunDatePanelElement['value'];
+    highlights?: DuoyunDatePanelElement['highlights'];
+    initValue?: DuoyunDatePanelElement['initValue'];
+};
+export type DyDatePanelExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-date-panel': DyDatePanelProps;
+        }
+    }
+}
+export declare const DyDatePanel: ForwardRefExoticComponent<Omit<DyDatePanelProps, "ref"> & RefAttributes<DyDatePanelExpose>>;
+export default DyDatePanel;

package/react/DyDatePanel.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/date-panel';
+export const DyDatePanel = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {};
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        ["time", "value", "highlights", "initValue"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-date-panel", { ref: elementRef, ...props });
+});
+export default DyDatePanel;

package/react/DyDatePicker.d.ts

@@ -0,0 +1,26 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunDatePickerElement } from '../elements/date-picker';
+export * from '../elements/date-picker';
+export type DyDatePickerProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunDatePickerElement> & {
+    placeholder?: DuoyunDatePickerElement['placeholder'];
+    time?: DuoyunDatePickerElement['time'];
+    clearable?: DuoyunDatePickerElement['clearable'];
+    disabled?: DuoyunDatePickerElement['disabled'];
+    active?: DuoyunDatePickerElement['active'];
+    value?: DuoyunDatePickerElement['value'];
+    'onchange'?: (event: CustomEvent<Parameters<DuoyunDatePickerElement['change']>[0]>) => void;
+    'onclear'?: (event: CustomEvent<Parameters<DuoyunDatePickerElement['clear']>[0]>) => void;
+};
+export type DyDatePickerExpose = {
+    showPicker: DuoyunDatePickerElement['showPicker'];
+};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-date-picker': DyDatePickerProps;
+        }
+    }
+}
+export declare const DyDatePicker: ForwardRefExoticComponent<Omit<DyDatePickerProps, "ref"> & RefAttributes<DyDatePickerExpose>>;
+export default DyDatePicker;

package/react/DyDatePicker.js

@@ -0,0 +1,22 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/date-picker';
+export const DyDatePicker = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {
+            showPicker(...args) {
+                return elementRef.current.showPicker(...args);
+            },
+        };
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        ["placeholder", "time", "clearable", "disabled", "active", "value"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-date-picker", { ref: elementRef, ...props });
+});
+export default DyDatePicker;

package/react/DyDateRangePanel.d.ts

@@ -0,0 +1,18 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunDateRangePanelElement } from '../elements/date-range-panel';
+export * from '../elements/date-range-panel';
+export type DyDateRangePanelProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunDateRangePanelElement> & {
+    value?: DuoyunDateRangePanelElement['value'];
+    'onchange'?: (event: CustomEvent<Parameters<DuoyunDateRangePanelElement['change']>[0]>) => void;
+};
+export type DyDateRangePanelExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-date-range-panel': DyDateRangePanelProps;
+        }
+    }
+}
+export declare const DyDateRangePanel: ForwardRefExoticComponent<Omit<DyDateRangePanelProps, "ref"> & RefAttributes<DyDateRangePanelExpose>>;
+export default DyDateRangePanel;

package/react/DyDateRangePanel.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/date-range-panel';
+export const DyDateRangePanel = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {};
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        ["value"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-date-range-panel", { ref: elementRef, ...props });
+});
+export default DyDateRangePanel;

package/react/DyDateRangePicker.d.ts

@@ -0,0 +1,26 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunDateRangePickerElement } from '../elements/date-range-picker';
+export * from '../elements/date-range-picker';
+export type DyDateRangePickerProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunDateRangePickerElement> & {
+    placeholder?: DuoyunDateRangePickerElement['placeholder'];
+    clearable?: DuoyunDateRangePickerElement['clearable'];
+    disabled?: DuoyunDateRangePickerElement['disabled'];
+    active?: DuoyunDateRangePickerElement['active'];
+    value?: DuoyunDateRangePickerElement['value'];
+    quickRanges?: DuoyunDateRangePickerElement['quickRanges'];
+    'onchange'?: (event: CustomEvent<Parameters<DuoyunDateRangePickerElement['change']>[0]>) => void;
+    'onclear'?: (event: CustomEvent<Parameters<DuoyunDateRangePickerElement['clear']>[0]>) => void;
+};
+export type DyDateRangePickerExpose = {
+    showPicker: DuoyunDateRangePickerElement['showPicker'];
+};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-date-range-picker': DyDateRangePickerProps;
+        }
+    }
+}
+export declare const DyDateRangePicker: ForwardRefExoticComponent<Omit<DyDateRangePickerProps, "ref"> & RefAttributes<DyDateRangePickerExpose>>;
+export default DyDateRangePicker;

package/react/DyDateRangePicker.js

@@ -0,0 +1,22 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/date-range-picker';
+export const DyDateRangePicker = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {
+            showPicker(...args) {
+                return elementRef.current.showPicker(...args);
+            },
+        };
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        ["placeholder", "clearable", "disabled", "active", "value", "quickRanges"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-date-range-picker", { ref: elementRef, ...props });
+});
+export default DyDateRangePicker;

package/react/DyDivider.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunDividerElement } from '../elements/divider';
+export * from '../elements/divider';
+export type DyDividerProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunDividerElement> & {};
+export type DyDividerExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-divider': DyDividerProps;
+        }
+    }
+}
+export declare const DyDivider: ForwardRefExoticComponent<Omit<DyDividerProps, "ref"> & RefAttributes<DyDividerExpose>>;
+export default DyDivider;

package/react/DyDivider.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/divider';
+export const DyDivider = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {};
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        [].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-divider", { ref: elementRef, ...props });
+});
+export default DyDivider;

package/react/DyDonutChart.d.ts

@@ -0,0 +1,20 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunDonutChartElement } from '../elements/donut-chart';
+export * from '../elements/donut-chart';
+export type DyDonutChartProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunDonutChartElement> & {
+    label?: DuoyunDonutChartElement['label'];
+    total?: DuoyunDonutChartElement['total'];
+    aspectRatio?: DuoyunDonutChartElement['aspectRatio'];
+    sequences?: DuoyunDonutChartElement['sequences'];
+};
+export type DyDonutChartExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-donut-chart': DyDonutChartProps;
+        }
+    }
+}
+export declare const DyDonutChart: ForwardRefExoticComponent<Omit<DyDonutChartProps, "ref"> & RefAttributes<DyDonutChartExpose>>;
+export default DyDonutChart;

package/react/DyDonutChart.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/donut-chart';
+export const DyDonutChart = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {};
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        ["label", "total", "aspectRatio", "sequences"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-donut-chart", { ref: elementRef, ...props });
+});
+export default DyDonutChart;

package/react/DyDrawer.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunDrawerElement } from '../elements/drawer';
+export * from '../elements/drawer';
+export type DyDrawerProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunDrawerElement> & {};
+export type DyDrawerExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-drawer': DyDrawerProps;
+        }
+    }
+}
+export declare const DyDrawer: ForwardRefExoticComponent<Omit<DyDrawerProps, "ref"> & RefAttributes<DyDrawerExpose>>;
+export default DyDrawer;

package/react/DyDrawer.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/drawer';
+export const DyDrawer = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {};
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        [].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-drawer", { ref: elementRef, ...props });
+});
+export default DyDrawer;

package/react/DyDropArea.d.ts

@@ -0,0 +1,23 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunDropAreaElement } from '../elements/drop-area';
+export * from '../elements/drop-area';
+export type DyDropAreaProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunDropAreaElement> & {
+    tip?: DuoyunDropAreaElement['tip'];
+    accept?: DuoyunDropAreaElement['accept'];
+    dropeffect?: DuoyunDropAreaElement['dropeffect'];
+    allowDrop?: DuoyunDropAreaElement['allowDrop'];
+    'onchange'?: (event: CustomEvent<Parameters<DuoyunDropAreaElement['change']>[0]>) => void;
+    'onignore'?: (event: CustomEvent<Parameters<DuoyunDropAreaElement['ignore']>[0]>) => void;
+    'onnodata'?: (event: CustomEvent<Parameters<DuoyunDropAreaElement['nodata']>[0]>) => void;
+};
+export type DyDropAreaExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-drop-area': DyDropAreaProps;
+        }
+    }
+}
+export declare const DyDropArea: ForwardRefExoticComponent<Omit<DyDropAreaProps, "ref"> & RefAttributes<DyDropAreaExpose>>;
+export default DyDropArea;

package/react/DyDropArea.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/drop-area';
+export const DyDropArea = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {};
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        ["tip", "accept", "dropeffect", "allowDrop"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-drop-area", { ref: elementRef, ...props });
+});
+export default DyDropArea;

package/react/DyEmpty.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunEmptyElement } from '../elements/empty';
+export * from '../elements/empty';
+export type DyEmptyProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunEmptyElement> & {};
+export type DyEmptyExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-empty': DyEmptyProps;
+        }
+    }
+}
+export declare const DyEmpty: ForwardRefExoticComponent<Omit<DyEmptyProps, "ref"> & RefAttributes<DyEmptyExpose>>;
+export default DyEmpty;

package/react/DyEmpty.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/empty';
+export const DyEmpty = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {};
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        [].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-empty", { ref: elementRef, ...props });
+});
+export default DyEmpty;

package/react/DyFilePicker.d.ts

@@ -0,0 +1,27 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunFilePickerElement } from '../elements/file-picker';
+export * from '../elements/file-picker';
+export type DyFilePickerProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunFilePickerElement> & {
+    type?: DuoyunFilePickerElement['type'];
+    accept?: DuoyunFilePickerElement['accept'];
+    /**@deprecated */
+    placeholder?: DuoyunFilePickerElement['placeholder'];
+    directory?: DuoyunFilePickerElement['directory'];
+    disabled?: DuoyunFilePickerElement['disabled'];
+    multiple?: DuoyunFilePickerElement['multiple'];
+    'onchange'?: (event: CustomEvent<Parameters<DuoyunFilePickerElement['change']>[0]>) => void;
+    value?: DuoyunFilePickerElement['value'];
+};
+export type DyFilePickerExpose = {
+    showPicker: DuoyunFilePickerElement['showPicker'];
+};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-file-picker': DyFilePickerProps;
+        }
+    }
+}
+export declare const DyFilePicker: ForwardRefExoticComponent<Omit<DyFilePickerProps, "ref"> & RefAttributes<DyFilePickerExpose>>;
+export default DyFilePicker;

package/react/DyFilePicker.js

@@ -0,0 +1,22 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/file-picker';
+export const DyFilePicker = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {
+            showPicker(...args) {
+                return elementRef.current.showPicker(...args);
+            },
+        };
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        ["type", "accept", "placeholder", "directory", "disabled", "multiple", "value"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-file-picker", { ref: elementRef, ...props });
+});
+export default DyFilePicker;

package/react/DyForm.d.ts

@@ -0,0 +1,24 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunFormElement } from '../elements/form';
+export * from '../elements/form';
+export type DyFormProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunFormElement> & {
+    inline?: DuoyunFormElement['inline'];
+    'onchange'?: (event: CustomEvent<Parameters<DuoyunFormElement['change']>[0]>) => void;
+};
+export type DyFormExpose = {
+    valid: DuoyunFormElement['valid'];
+    clearInvalidMessage: DuoyunFormElement['clearInvalidMessage'];
+    items: DuoyunFormElement['items'];
+    elements: DuoyunFormElement['elements'];
+    data: DuoyunFormElement['data'];
+};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-form': DyFormProps;
+        }
+    }
+}
+export declare const DyForm: ForwardRefExoticComponent<Omit<DyFormProps, "ref"> & RefAttributes<DyFormExpose>>;
+export default DyForm;

package/react/DyForm.js

@@ -0,0 +1,34 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/form';
+export const DyForm = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {
+            valid(...args) {
+                return elementRef.current.valid(...args);
+            },
+            clearInvalidMessage(...args) {
+                return elementRef.current.clearInvalidMessage(...args);
+            },
+            get items() {
+                return elementRef.current.items;
+            },
+            get elements() {
+                return elementRef.current.elements;
+            },
+            get data() {
+                return elementRef.current.data;
+            },
+        };
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        ["inline"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-form", { ref: elementRef, ...props });
+});
+export default DyForm;

package/react/DyFormItem.d.ts

@@ -0,0 +1,47 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunFormItemElement } from '../elements/form';
+export * from '../elements/form';
+export type DyFormItemProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunFormItemElement> & {
+    type?: DuoyunFormItemElement['type'];
+    multiple?: DuoyunFormItemElement['multiple'];
+    name?: DuoyunFormItemElement['name'];
+    label?: DuoyunFormItemElement['label'];
+    placeholder?: DuoyunFormItemElement['placeholder'];
+    required?: DuoyunFormItemElement['required'];
+    checked?: DuoyunFormItemElement['checked'];
+    autofocus?: DuoyunFormItemElement['autofocus'];
+    disabled?: DuoyunFormItemElement['disabled'];
+    searchable?: DuoyunFormItemElement['searchable'];
+    clearable?: DuoyunFormItemElement['clearable'];
+    loading?: DuoyunFormItemElement['loading'];
+    invalid?: DuoyunFormItemElement['invalid'];
+    value?: DuoyunFormItemElement['value'];
+    renderLabel?: DuoyunFormItemElement['renderLabel'];
+    rows?: DuoyunFormItemElement['rows'];
+    step?: DuoyunFormItemElement['step'];
+    min?: DuoyunFormItemElement['min'];
+    max?: DuoyunFormItemElement['max'];
+    /**@deprecated */
+    dataList?: DuoyunFormItemElement['dataList'];
+    options?: DuoyunFormItemElement['options'];
+    adder?: DuoyunFormItemElement['adder'];
+    'onitemchange'?: (event: CustomEvent<Parameters<DuoyunFormItemElement['itemchange']>[0]>) => void;
+    'onsearch'?: (event: CustomEvent<Parameters<DuoyunFormItemElement['search']>[0]>) => void;
+    rules?: DuoyunFormItemElement['rules'];
+};
+export type DyFormItemExpose = {
+    focus: DuoyunFormItemElement['focus'];
+    clearInvalidMessage: DuoyunFormItemElement['clearInvalidMessage'];
+    valid: DuoyunFormItemElement['valid'];
+    data: DuoyunFormItemElement['data'];
+};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-form-item': DyFormItemProps;
+        }
+    }
+}
+export declare const DyFormItem: ForwardRefExoticComponent<Omit<DyFormItemProps, "ref"> & RefAttributes<DyFormItemExpose>>;
+export default DyFormItem;

package/react/DyFormItem.js

@@ -0,0 +1,31 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/form';
+export const DyFormItem = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {
+            focus(...args) {
+                return elementRef.current.focus(...args);
+            },
+            clearInvalidMessage(...args) {
+                return elementRef.current.clearInvalidMessage(...args);
+            },
+            valid(...args) {
+                return elementRef.current.valid(...args);
+            },
+            get data() {
+                return elementRef.current.data;
+            },
+        };
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        ["type", "multiple", "name", "label", "placeholder", "required", "checked", "autofocus", "disabled", "searchable", "clearable", "loading", "invalid", "value", "renderLabel", "rows", "step", "min", "max", "dataList", "options", "adder", "rules"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-form-item", { ref: elementRef, ...props });
+});
+export default DyFormItem;

package/react/DyFormItemInlineGroup.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunFormItemInlineGroupElement } from '../elements/form';
+export * from '../elements/form';
+export type DyFormItemInlineGroupProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunFormItemInlineGroupElement> & {};
+export type DyFormItemInlineGroupExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-form-item-inline-group': DyFormItemInlineGroupProps;
+        }
+    }
+}
+export declare const DyFormItemInlineGroup: ForwardRefExoticComponent<Omit<DyFormItemInlineGroupProps, "ref"> & RefAttributes<DyFormItemInlineGroupExpose>>;
+export default DyFormItemInlineGroup;

package/react/DyFormItemInlineGroup.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/form';
+export const DyFormItemInlineGroup = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {};
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        [].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-form-item-inline-group", { ref: elementRef, ...props });
+});
+export default DyFormItemInlineGroup;