duoyun-ui 2.2.3 → 2.2.9

package/react/DyPopover.d.ts

@@ -0,0 +1,27 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunPopoverElement } from '../elements/popover';
+export * from '../elements/popover';
+export type DyPopoverProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunPopoverElement> & {
+    debug?: DuoyunPopoverElement['debug'];
+    unreachable?: DuoyunPopoverElement['unreachable'];
+    disabled?: DuoyunPopoverElement['disabled'];
+    trigger?: DuoyunPopoverElement['trigger'];
+    position?: DuoyunPopoverElement['position'];
+    content?: DuoyunPopoverElement['content'];
+    'onopen'?: (event: CustomEvent<Parameters<DuoyunPopoverElement['open']>[0]>) => void;
+    'onclose'?: (event: CustomEvent<Parameters<DuoyunPopoverElement['close']>[0]>) => void;
+    ghostStyle?: DuoyunPopoverElement['ghostStyle'];
+};
+export type DyPopoverExpose = {
+    popoverElement: DuoyunPopoverElement['popoverElement'];
+};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-popover': DyPopoverProps;
+        }
+    }
+}
+export declare const DyPopover: ForwardRefExoticComponent<Omit<DyPopoverProps, "ref"> & RefAttributes<DyPopoverExpose>>;
+export default DyPopover;

package/react/DyPopover.js

@@ -0,0 +1,22 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/popover';
+export const DyPopover = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {
+            get popoverElement() {
+                return elementRef.current.popoverElement;
+            },
+        };
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        ["debug", "unreachable", "disabled", "trigger", "position", "content", "ghostStyle"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-popover", { ref: elementRef, ...props });
+});
+export default DyPopover;

package/react/DyPopoverGhost.d.ts

@@ -0,0 +1,17 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunPopoverGhostElement } from '../elements/popover';
+export * from '../elements/popover';
+export type DyPopoverGhostProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunPopoverGhostElement> & {
+    'onclose'?: (event: CustomEvent<Parameters<DuoyunPopoverGhostElement['close']>[0]>) => void;
+};
+export type DyPopoverGhostExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-popover-ghost': DyPopoverGhostProps;
+        }
+    }
+}
+export declare const DyPopoverGhost: ForwardRefExoticComponent<Omit<DyPopoverGhostProps, "ref"> & RefAttributes<DyPopoverGhostExpose>>;
+export default DyPopoverGhost;

package/react/DyPopoverGhost.js

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

package/react/DyProgress.d.ts

@@ -0,0 +1,18 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunProgressElement } from '../elements/progress';
+export * from '../elements/progress';
+export type DyProgressProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunProgressElement> & {
+    estimate?: DuoyunProgressElement['estimate'];
+    calculateColor?: DuoyunProgressElement['calculateColor'];
+};
+export type DyProgressExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-progress': DyProgressProps;
+        }
+    }
+}
+export declare const DyProgress: ForwardRefExoticComponent<Omit<DyProgressProps, "ref"> & RefAttributes<DyProgressExpose>>;
+export default DyProgress;

package/react/DyProgress.js

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

package/react/DyRadarChart.d.ts

@@ -0,0 +1,22 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunRadarChartElement } from '../elements/radar-chart';
+export * from '../elements/radar-chart';
+export type DyRadarChartProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunRadarChartElement> & {
+    dimensions?: DuoyunRadarChartElement['dimensions'];
+    sequences?: DuoyunRadarChartElement['sequences'];
+    showPoint?: DuoyunRadarChartElement['showPoint'];
+    showArea?: DuoyunRadarChartElement['showArea'];
+    xAxi?: DuoyunRadarChartElement['xAxi'];
+    yAxi?: DuoyunRadarChartElement['yAxi'];
+};
+export type DyRadarChartExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-radar-chart': DyRadarChartProps;
+        }
+    }
+}
+export declare const DyRadarChart: ForwardRefExoticComponent<Omit<DyRadarChartProps, "ref"> & RefAttributes<DyRadarChartExpose>>;
+export default DyRadarChart;

package/react/DyRadarChart.js

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

package/react/DyRadio.d.ts

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

package/react/DyRadio.js

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

package/react/DyRadioGroup.d.ts

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

package/react/DyRadioGroup.js

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

package/react/DyRate.d.ts

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

package/react/DyRate.js

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

package/react/DyReflect.d.ts

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

package/react/DyReflect.js

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

package/react/DyResult.d.ts

@@ -0,0 +1,21 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunResultElement } from '../elements/result';
+export * from '../elements/result';
+export type DyResultProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunResultElement> & {
+    status?: DuoyunResultElement['status'];
+    header?: DuoyunResultElement['header'];
+    description?: DuoyunResultElement['description'];
+    icon?: DuoyunResultElement['icon'];
+    illustrator?: DuoyunResultElement['illustrator'];
+};
+export type DyResultExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-result': DyResultProps;
+        }
+    }
+}
+export declare const DyResult: ForwardRefExoticComponent<Omit<DyResultProps, "ref"> & RefAttributes<DyResultExpose>>;
+export default DyResult;

package/react/DyResult.js

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

package/react/DyRollingNumber.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunRollingNumberElement } from '../elements/rolling-number';
+export * from '../elements/rolling-number';
+export type DyRollingNumberProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunRollingNumberElement> & {};
+export type DyRollingNumberExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-rolling-number': DyRollingNumberProps;
+        }
+    }
+}
+export declare const DyRollingNumber: ForwardRefExoticComponent<Omit<DyRollingNumberProps, "ref"> & RefAttributes<DyRollingNumberExpose>>;
+export default DyRollingNumber;

package/react/DyRollingNumber.js

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

package/react/DyRoute.d.ts

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

package/react/DyRoute.js

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

package/react/DySankeyChart.d.ts

@@ -0,0 +1,21 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunSankeyChartElement } from '../elements/sankey-chart';
+export * from '../elements/sankey-chart';
+export type DySankeyChartProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunSankeyChartElement> & {
+    data?: DuoyunSankeyChartElement['data'];
+    nodeWidth?: DuoyunSankeyChartElement['nodeWidth'];
+    nodePadding?: DuoyunSankeyChartElement['nodePadding'];
+    xAxi?: DuoyunSankeyChartElement['xAxi'];
+    yAxi?: DuoyunSankeyChartElement['yAxi'];
+};
+export type DySankeyChartExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-sankey-chart': DySankeyChartProps;
+        }
+    }
+}
+export declare const DySankeyChart: ForwardRefExoticComponent<Omit<DySankeyChartProps, "ref"> & RefAttributes<DySankeyChartExpose>>;
+export default DySankeyChart;

package/react/DySankeyChart.js

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

package/react/DyScatterChart.d.ts

@@ -0,0 +1,17 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunScatterChartElement } from '../elements/scatter-chart';
+export * from '../elements/scatter-chart';
+export type DyScatterChartProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunScatterChartElement> & {
+    sequences?: DuoyunScatterChartElement['sequences'];
+};
+export type DyScatterChartExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-scatter-chart': DyScatterChartProps;
+        }
+    }
+}
+export declare const DyScatterChart: ForwardRefExoticComponent<Omit<DyScatterChartProps, "ref"> & RefAttributes<DyScatterChartExpose>>;
+export default DyScatterChart;

package/react/DyScatterChart.js

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

package/react/DyScrollBox.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunScrollBoxElement } from '../elements/scroll-box';
+export * from '../elements/scroll-box';
+export type DyScrollBoxProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunScrollBoxElement> & {};
+export type DyScrollBoxExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-scroll-box': DyScrollBoxProps;
+        }
+    }
+}
+export declare const DyScrollBox: ForwardRefExoticComponent<Omit<DyScrollBoxProps, "ref"> & RefAttributes<DyScrollBoxExpose>>;
+export default DyScrollBox;

package/react/DyScrollBox.js

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

package/react/DySegmented.d.ts

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

package/react/DySegmented.js

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

package/react/DySelect.d.ts

@@ -0,0 +1,37 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunSelectElement } from '../elements/select';
+export * from '../elements/select';
+export type DySelectProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunSelectElement> & {
+    multiple?: DuoyunSelectElement['multiple'];
+    disabled?: DuoyunSelectElement['disabled'];
+    searchable?: DuoyunSelectElement['searchable'];
+    keepsearch?: DuoyunSelectElement['keepsearch'];
+    inline?: DuoyunSelectElement['inline'];
+    placeholder?: DuoyunSelectElement['placeholder'];
+    borderless?: DuoyunSelectElement['borderless'];
+    pinselected?: DuoyunSelectElement['pinselected'];
+    loading?: DuoyunSelectElement['loading'];
+    dropdownStyle?: DuoyunSelectElement['dropdownStyle'];
+    options?: DuoyunSelectElement['options'];
+    adder?: DuoyunSelectElement['adder'];
+    value?: DuoyunSelectElement['value'];
+    renderLabel?: DuoyunSelectElement['renderLabel'];
+    renderTag?: DuoyunSelectElement['renderTag'];
+    active?: DuoyunSelectElement['active'];
+    'onchange'?: (event: CustomEvent<Parameters<DuoyunSelectElement['change']>[0]>) => void;
+    'onsearch'?: (event: CustomEvent<Parameters<DuoyunSelectElement['search']>[0]>) => void;
+};
+export type DySelectExpose = {
+    showPicker: DuoyunSelectElement['showPicker'];
+    setSearch: DuoyunSelectElement['setSearch'];
+};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-select': DySelectProps;
+        }
+    }
+}
+export declare const DySelect: ForwardRefExoticComponent<Omit<DySelectProps, "ref"> & RefAttributes<DySelectExpose>>;
+export default DySelect;

package/react/DySelect.js

@@ -0,0 +1,25 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/select';
+export const DySelect = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {
+            showPicker(...args) {
+                return elementRef.current.showPicker(...args);
+            },
+            setSearch(...args) {
+                return elementRef.current.setSearch(...args);
+            },
+        };
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        ["multiple", "disabled", "searchable", "keepsearch", "inline", "placeholder", "borderless", "pinselected", "loading", "dropdownStyle", "options", "adder", "value", "renderLabel", "renderTag", "active"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-select", { ref: elementRef, ...props });
+});
+export default DySelect;