duoyun-ui 2.2.3 → 2.2.8

package/react/DyGesture.d.ts

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

package/react/DyGesture.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/gesture';
+export const DyGesture = 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-gesture", { ref: elementRef, ...props });
+});
+export default DyGesture;

package/react/DyGroupedPicker.d.ts

@@ -0,0 +1,27 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunGroupedPickerElement } from '../elements/grouped-picker';
+export * from '../elements/grouped-picker';
+export type DyGroupedPickerProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunGroupedPickerElement> & {
+    placeholder?: DuoyunGroupedPickerElement['placeholder'];
+    disabled?: DuoyunGroupedPickerElement['disabled'];
+    borderless?: DuoyunGroupedPickerElement['borderless'];
+    fit?: DuoyunGroupedPickerElement['fit'];
+    active?: DuoyunGroupedPickerElement['active'];
+    options?: DuoyunGroupedPickerElement['options'];
+    value?: DuoyunGroupedPickerElement['value'];
+    renderValue?: DuoyunGroupedPickerElement['renderValue'];
+    'onchange'?: (event: CustomEvent<Parameters<DuoyunGroupedPickerElement['change']>[0]>) => void;
+};
+export type DyGroupedPickerExpose = {
+    showPicker: DuoyunGroupedPickerElement['showPicker'];
+};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-grouped-picker': DyGroupedPickerProps;
+        }
+    }
+}
+export declare const DyGroupedPicker: ForwardRefExoticComponent<Omit<DyGroupedPickerProps, "ref"> & RefAttributes<DyGroupedPickerExpose>>;
+export default DyGroupedPicker;

package/react/DyGroupedPicker.js

@@ -0,0 +1,22 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/grouped-picker';
+export const DyGroupedPicker = 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", "disabled", "borderless", "fit", "active", "options", "value", "renderValue"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-grouped-picker", { ref: elementRef, ...props });
+});
+export default DyGroupedPicker;

package/react/DyHeading.d.ts

@@ -0,0 +1,17 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunHeadingElement } from '../elements/heading';
+export * from '../elements/heading';
+export type DyHeadingProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunHeadingElement> & {
+    lv?: DuoyunHeadingElement['lv'];
+};
+export type DyHeadingExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-heading': DyHeadingProps;
+        }
+    }
+}
+export declare const DyHeading: ForwardRefExoticComponent<Omit<DyHeadingProps, "ref"> & RefAttributes<DyHeadingExpose>>;
+export default DyHeading;

package/react/DyHeading.js

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

package/react/DyHelpText.d.ts

@@ -0,0 +1,17 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunHelpTextElement } from '../elements/help-text';
+export * from '../elements/help-text';
+export type DyHelpTextProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunHelpTextElement> & {
+    status?: DuoyunHelpTextElement['status'];
+};
+export type DyHelpTextExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-help-text': DyHelpTextProps;
+        }
+    }
+}
+export declare const DyHelpText: ForwardRefExoticComponent<Omit<DyHelpTextProps, "ref"> & RefAttributes<DyHelpTextExpose>>;
+export default DyHelpText;

package/react/DyHelpText.js

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

package/react/DyIcons.d.ts

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

package/react/DyIcons.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/icons';
+export const DyIcons = 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-icons", { ref: elementRef, ...props });
+});
+export default DyIcons;

package/react/DyImagePreview.d.ts

@@ -0,0 +1,20 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunImagePreviewElement } from '../elements/image-preview';
+export * from '../elements/image-preview';
+export type DyImagePreviewProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunImagePreviewElement> & {
+    status?: DuoyunImagePreviewElement['status'];
+    progress?: DuoyunImagePreviewElement['progress'];
+    file?: DuoyunImagePreviewElement['file'];
+    actions?: DuoyunImagePreviewElement['actions'];
+};
+export type DyImagePreviewExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-image-preview': DyImagePreviewProps;
+        }
+    }
+}
+export declare const DyImagePreview: ForwardRefExoticComponent<Omit<DyImagePreviewProps, "ref"> & RefAttributes<DyImagePreviewExpose>>;
+export default DyImagePreview;

package/react/DyImagePreview.js

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

package/react/DyInput.d.ts

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

package/react/DyInput.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/input';
+export const DyInput = 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-input", { ref: elementRef, ...props });
+});
+export default DyInput;

package/react/DyInputCapture.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunInputCaptureElement } from '../elements/input-capture';
+export * from '../elements/input-capture';
+export type DyInputCaptureProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunInputCaptureElement> & {};
+export type DyInputCaptureExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-input-capture': DyInputCaptureProps;
+        }
+    }
+}
+export declare const DyInputCapture: ForwardRefExoticComponent<Omit<DyInputCaptureProps, "ref"> & RefAttributes<DyInputCaptureExpose>>;
+export default DyInputCapture;

package/react/DyInputCapture.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/input-capture';
+export const DyInputCapture = 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-input-capture", { ref: elementRef, ...props });
+});
+export default DyInputCapture;

package/react/DyInputGroup.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunInputGroupElement } from '../elements/input';
+export * from '../elements/input';
+export type DyInputGroupProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunInputGroupElement> & {};
+export type DyInputGroupExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-input-group': DyInputGroupProps;
+        }
+    }
+}
+export declare const DyInputGroup: ForwardRefExoticComponent<Omit<DyInputGroupProps, "ref"> & RefAttributes<DyInputGroupExpose>>;
+export default DyInputGroup;

package/react/DyInputGroup.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/input';
+export const DyInputGroup = 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-input-group", { ref: elementRef, ...props });
+});
+export default DyInputGroup;

package/react/DyKeyboardAccess.d.ts

@@ -0,0 +1,19 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunKeyboardAccessElement } from '../elements/keyboard-access';
+export * from '../elements/keyboard-access';
+export type DyKeyboardAccessProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunKeyboardAccessElement> & {
+    activekey?: DuoyunKeyboardAccessElement['activekey'];
+    scrollContainer?: DuoyunKeyboardAccessElement['scrollContainer'];
+    'onnavigation'?: (event: CustomEvent<Parameters<DuoyunKeyboardAccessElement['navigation']>[0]>) => void;
+};
+export type DyKeyboardAccessExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-keyboard-access': DyKeyboardAccessProps;
+        }
+    }
+}
+export declare const DyKeyboardAccess: ForwardRefExoticComponent<Omit<DyKeyboardAccessProps, "ref"> & RefAttributes<DyKeyboardAccessExpose>>;
+export default DyKeyboardAccess;

package/react/DyKeyboardAccess.js

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

package/react/DyLegend.d.ts

@@ -0,0 +1,20 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunLegendElement } from '../elements/legend';
+export * from '../elements/legend';
+export type DyLegendProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunLegendElement> & {
+    colors?: DuoyunLegendElement['colors'];
+    legends?: DuoyunLegendElement['legends'];
+    value?: DuoyunLegendElement['value'];
+    'onchange'?: (event: CustomEvent<Parameters<DuoyunLegendElement['change']>[0]>) => void;
+};
+export type DyLegendExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-legend': DyLegendProps;
+        }
+    }
+}
+export declare const DyLegend: ForwardRefExoticComponent<Omit<DyLegendProps, "ref"> & RefAttributes<DyLegendExpose>>;
+export default DyLegend;

package/react/DyLegend.js

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

package/react/DyLetters.d.ts

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

package/react/DyLetters.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/letters';
+export const DyLetters = 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-letters", { ref: elementRef, ...props });
+});
+export default DyLetters;

package/react/DyLightRoute.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunLightRouteElement } from '../elements/route';
+export * from '../elements/route';
+export type DyLightRouteProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunLightRouteElement> & {};
+export type DyLightRouteExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-light-route': DyLightRouteProps;
+        }
+    }
+}
+export declare const DyLightRoute: ForwardRefExoticComponent<Omit<DyLightRouteProps, "ref"> & RefAttributes<DyLightRouteExpose>>;
+export default DyLightRoute;

package/react/DyLightRoute.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/route';
+export const DyLightRoute = 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-light-route", { ref: elementRef, ...props });
+});
+export default DyLightRoute;

package/react/DyLineChart.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunLineChartElement } from '../elements/line-chart';
+export * from '../elements/line-chart';
+export type DyLineChartProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunLineChartElement> & {};
+export type DyLineChartExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-line-chart': DyLineChartProps;
+        }
+    }
+}
+export declare const DyLineChart: ForwardRefExoticComponent<Omit<DyLineChartProps, "ref"> & RefAttributes<DyLineChartExpose>>;
+export default DyLineChart;

package/react/DyLineChart.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/line-chart';
+export const DyLineChart = 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-line-chart", { ref: elementRef, ...props });
+});
+export default DyLineChart;

package/react/DyLink.d.ts

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

package/react/DyLink.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/link';
+export const DyLink = 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-link", { ref: elementRef, ...props });
+});
+export default DyLink;

package/react/DyList.d.ts

@@ -0,0 +1,17 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunListElement } from '../elements/list';
+export * from '../elements/list';
+export type DyListProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunListElement> & {
+    renderItem?: DuoyunListElement['renderItem'];
+};
+export type DyListExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-list': DyListProps;
+        }
+    }
+}
+export declare const DyList: ForwardRefExoticComponent<Omit<DyListProps, "ref"> & RefAttributes<DyListExpose>>;
+export default DyList;

package/react/DyList.js

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

package/react/DyLoading.d.ts

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

package/react/DyLoading.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/loading';
+export const DyLoading = 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-loading", { ref: elementRef, ...props });
+});
+export default DyLoading;