duoyun-ui 2.2.3 → 2.2.8

package/react/DyMeter.d.ts

@@ -0,0 +1,24 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunMeterElement } from '../elements/meter';
+export * from '../elements/meter';
+export type DyMeterProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunMeterElement> & {
+    value?: DuoyunMeterElement['value'];
+    max?: DuoyunMeterElement['max'];
+    min?: DuoyunMeterElement['min'];
+    color?: DuoyunMeterElement['color'];
+    layout?: DuoyunMeterElement['layout'];
+    label?: DuoyunMeterElement['label'];
+    valueLabel?: DuoyunMeterElement['valueLabel'];
+    calculateColor?: DuoyunMeterElement['calculateColor'];
+};
+export type DyMeterExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-meter': DyMeterProps;
+        }
+    }
+}
+export declare const DyMeter: ForwardRefExoticComponent<Omit<DyMeterProps, "ref"> & RefAttributes<DyMeterExpose>>;
+export default DyMeter;

package/react/DyMeter.js

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

package/react/DyMore.d.ts

@@ -0,0 +1,20 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunMoreElement } from '../elements/more';
+export * from '../elements/more';
+export type DyMoreProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunMoreElement> & {
+    maxheight?: DuoyunMoreElement['maxheight'];
+    more?: DuoyunMoreElement['more'];
+    less?: DuoyunMoreElement['less'];
+    expandless?: DuoyunMoreElement['expandless'];
+};
+export type DyMoreExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-more': DyMoreProps;
+        }
+    }
+}
+export declare const DyMore: ForwardRefExoticComponent<Omit<DyMoreProps, "ref"> & RefAttributes<DyMoreExpose>>;
+export default DyMore;

package/react/DyMore.js

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

package/react/DyMoreSlot.d.ts

@@ -0,0 +1,17 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunMoreSlotElement } from '../elements/more';
+export * from '../elements/more';
+export type DyMoreSlotProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunMoreSlotElement> & {
+    'onchange'?: (event: CustomEvent<Parameters<DuoyunMoreSlotElement['change']>[0]>) => void;
+};
+export type DyMoreSlotExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-more-slot': DyMoreSlotProps;
+        }
+    }
+}
+export declare const DyMoreSlot: ForwardRefExoticComponent<Omit<DyMoreSlotProps, "ref"> & RefAttributes<DyMoreSlotExpose>>;
+export default DyMoreSlot;

package/react/DyMoreSlot.js

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

package/react/DyOptions.d.ts

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

package/react/DyOptions.js

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

package/react/DyPageLoadbar.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunPageLoadbarElement } from '../elements/page-loadbar';
+export * from '../elements/page-loadbar';
+export type DyPageLoadbarProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunPageLoadbarElement> & {};
+export type DyPageLoadbarExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-page-loadbar': DyPageLoadbarProps;
+        }
+    }
+}
+export declare const DyPageLoadbar: ForwardRefExoticComponent<Omit<DyPageLoadbarProps, "ref"> & RefAttributes<DyPageLoadbarExpose>>;
+export default DyPageLoadbar;

package/react/DyPageLoadbar.js

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

package/react/DyPagination.d.ts

@@ -0,0 +1,23 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunPaginationElement } from '../elements/pagination';
+export * from '../elements/pagination';
+export type DyPaginationProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunPaginationElement> & {
+    align?: DuoyunPaginationElement['align'];
+    page?: DuoyunPaginationElement['page'];
+    total?: DuoyunPaginationElement['total'];
+    size?: DuoyunPaginationElement['size'];
+    'onpagechange'?: (event: CustomEvent<Parameters<DuoyunPaginationElement['pagechange']>[0]>) => void;
+    'onsizechange'?: (event: CustomEvent<Parameters<DuoyunPaginationElement['sizechange']>[0]>) => void;
+    sizes?: DuoyunPaginationElement['sizes'];
+};
+export type DyPaginationExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-pagination': DyPaginationProps;
+        }
+    }
+}
+export declare const DyPagination: ForwardRefExoticComponent<Omit<DyPaginationProps, "ref"> & RefAttributes<DyPaginationExpose>>;
+export default DyPagination;

package/react/DyPagination.js

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

package/react/DyParagraph.d.ts

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

package/react/DyParagraph.js

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

package/react/DyPatConsole.d.ts

@@ -0,0 +1,25 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DyPatConsoleElement } from '../patterns/console';
+export * from '../patterns/console';
+export type DyPatConsoleProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DyPatConsoleElement> & {
+    keyboardAccess?: DyPatConsoleElement['keyboardAccess'];
+    screencastMode?: DyPatConsoleElement['screencastMode'];
+    responsive?: DyPatConsoleElement['responsive'];
+    name?: DyPatConsoleElement['name'];
+    logo?: DyPatConsoleElement['logo'];
+    routes?: DyPatConsoleElement['routes'];
+    navItems?: DyPatConsoleElement['navItems'];
+    contextMenus?: DyPatConsoleElement['contextMenus'];
+    userInfo?: DyPatConsoleElement['userInfo'];
+};
+export type DyPatConsoleExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-pat-console': DyPatConsoleProps;
+        }
+    }
+}
+export declare const DyPatConsole: ForwardRefExoticComponent<Omit<DyPatConsoleProps, "ref"> & RefAttributes<DyPatConsoleExpose>>;
+export default DyPatConsole;

package/react/DyPatConsole.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../patterns/console';
+export const DyPatConsole = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {};
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        ["keyboardAccess", "screencastMode", "responsive", "name", "logo", "routes", "navItems", "contextMenus", "userInfo"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-pat-console", { ref: elementRef, ...props });
+});
+export default DyPatConsole;

package/react/DyPatFilterForm.d.ts

@@ -0,0 +1,20 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DyPatFilterFormElement } from '../patterns/filter-form';
+export * from '../patterns/filter-form';
+export type DyPatFilterFormProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DyPatFilterFormElement> & {
+    options?: DyPatFilterFormElement['options'];
+    getText?: DyPatFilterFormElement['getText'];
+    'onsubmit'?: (event: CustomEvent<Parameters<DyPatFilterFormElement['submit']>[0]>) => void;
+    initValue?: DyPatFilterFormElement['initValue'];
+};
+export type DyPatFilterFormExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-pat-filter-form': DyPatFilterFormProps;
+        }
+    }
+}
+export declare const DyPatFilterForm: ForwardRefExoticComponent<Omit<DyPatFilterFormProps, "ref"> & RefAttributes<DyPatFilterFormExpose>>;
+export default DyPatFilterForm;

package/react/DyPatFilterForm.js

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

package/react/DyPatFooter.d.ts

@@ -0,0 +1,23 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DyPatFooterElement } from '../patterns/footer';
+export * from '../patterns/footer';
+export type DyPatFooterProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DyPatFooterElement> & {
+    social?: DyPatFooterElement['social'];
+    links?: DyPatFooterElement['links'];
+    logo?: DyPatFooterElement['logo'];
+    terms?: DyPatFooterElement['terms'];
+    help?: DyPatFooterElement['help'];
+    languages?: DyPatFooterElement['languages'];
+    'onlanguagechange'?: (event: CustomEvent<Parameters<DyPatFooterElement['languagechange']>[0]>) => void;
+};
+export type DyPatFooterExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-pat-footer': DyPatFooterProps;
+        }
+    }
+}
+export declare const DyPatFooter: ForwardRefExoticComponent<Omit<DyPatFooterProps, "ref"> & RefAttributes<DyPatFooterExpose>>;
+export default DyPatFooter;

package/react/DyPatFooter.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../patterns/footer';
+export const DyPatFooter = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {};
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        ["social", "links", "logo", "terms", "help", "languages"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-pat-footer", { ref: elementRef, ...props });
+});
+export default DyPatFooter;

package/react/DyPatForm.d.ts

@@ -0,0 +1,20 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DyPatFormElement } from '../patterns/form';
+export * from '../patterns/form';
+export type DyPatFormProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DyPatFormElement> & {
+    data?: DyPatFormElement['data'];
+    formItems?: DyPatFormElement['formItems'];
+    'onchange'?: (event: CustomEvent<Parameters<DyPatFormElement['change']>[0]>) => void;
+    valid?: DyPatFormElement['valid'];
+};
+export type DyPatFormExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-pat-form': DyPatFormProps;
+        }
+    }
+}
+export declare const DyPatForm: ForwardRefExoticComponent<Omit<DyPatFormProps, "ref"> & RefAttributes<DyPatFormExpose>>;
+export default DyPatForm;

package/react/DyPatForm.js

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

package/react/DyPatNav.d.ts

@@ -0,0 +1,21 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DyPatNavElement } from '../patterns/nav';
+export * from '../patterns/nav';
+export type DyPatNavProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DyPatNavElement> & {
+    name?: DyPatNavElement['name'];
+    links?: DyPatNavElement['links'];
+    logo?: DyPatNavElement['logo'];
+    switching?: DyPatNavElement['switching'];
+    navSlot?: DyPatNavElement['navSlot'];
+};
+export type DyPatNavExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-pat-nav': DyPatNavProps;
+        }
+    }
+}
+export declare const DyPatNav: ForwardRefExoticComponent<Omit<DyPatNavProps, "ref"> & RefAttributes<DyPatNavExpose>>;
+export default DyPatNav;

package/react/DyPatNav.js

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

package/react/DyPatTable.d.ts

@@ -0,0 +1,32 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DyPatTableElement } from '../patterns/table';
+export * from '../patterns/table';
+export type DyPatTableProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DyPatTableElement> & {
+    filterable?: DyPatTableElement['filterable'];
+    selectable?: DyPatTableElement['selectable'];
+    pagesize?: DyPatTableElement['pagesize'];
+    sizes?: DyPatTableElement['sizes'];
+    data?: DyPatTableElement['data'];
+    paginationStore?: DyPatTableElement['paginationStore'];
+    locationStore?: DyPatTableElement['locationStore'];
+    rowKey?: DyPatTableElement['rowKey'];
+    getRowStyle?: DyPatTableElement['getRowStyle'];
+    expandedRowRender?: DyPatTableElement['expandedRowRender'];
+    getActions?: DyPatTableElement['getActions'];
+    getSelectedActions?: DyPatTableElement['getSelectedActions'];
+    'onexpand'?: (event: CustomEvent<Parameters<DyPatTableElement['expand']>[0]>) => void;
+    'onfetch'?: (event: CustomEvent<Parameters<DyPatTableElement['fetch']>[0]>) => void;
+    columns?: DyPatTableElement['columns'];
+    getText?: DyPatTableElement['getText'];
+};
+export type DyPatTableExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-pat-table': DyPatTableProps;
+        }
+    }
+}
+export declare const DyPatTable: ForwardRefExoticComponent<Omit<DyPatTableProps, "ref"> & RefAttributes<DyPatTableExpose>>;
+export default DyPatTable;

package/react/DyPatTable.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../patterns/table';
+export const DyPatTable = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {};
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        ["filterable", "selectable", "pagesize", "sizes", "data", "paginationStore", "locationStore", "rowKey", "getRowStyle", "expandedRowRender", "getActions", "getSelectedActions", "columns", "getText"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-pat-table", { ref: elementRef, ...props });
+});
+export default DyPatTable;

package/react/DyPicker.d.ts

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

package/react/DyPicker.js

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

package/react/DyPlaceholder.d.ts

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

package/react/DyPlaceholder.js

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