zds-pickers 4.0.3 → 4.0.6

package/dist/types/hooks/useComponentSize.d.ts

@@ -0,0 +1,5 @@
+declare const useComponentSize: (ref: React.RefObject<HTMLDivElement>) => {
+    width: number;
+    height: number;
+};
+export default useComponentSize;

package/dist/types/hooks/useStateWithDynamicDefault.d.ts

@@ -0,0 +1,2 @@
+declare const useStateWithDynamicDefault: <T>(defaultVal: T) => readonly [T, import("react").Dispatch<import("react").SetStateAction<T>>];
+export default useStateWithDynamicDefault;

package/dist/types/index.d.ts

@@ -1,2 +1,266 @@
-export * from '../main'
-export {}
+import { default as default_2 } from 'soundfont-player';
+import { ForwardRefExoticComponent } from 'react';
+import { GroupBase } from 'react-select';
+import { JSX as JSX_2 } from 'react/jsx-runtime';
+import { JSX as JSX_3 } from 'react';
+import { JSXElementConstructor } from 'react';
+import { Mapping } from 'zds-mappings';
+import { ReactElement } from 'react';
+import { ReactNode } from 'react';
+import { RefAttributes } from 'react';
+import { SelectInstance } from 'react-select';
+
+export declare const CCPicker: ForwardRefExoticComponent<CCPickerProps & RefAttributes<SelectInstance<Option_2<number>, false, GroupBase<Option_2<number>>>>>;
+
+declare type CCPickerProps = SelectProps<number>;
+
+export declare const ccValues: Option_2<number>[];
+
+declare type Channel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15;
+
+export declare const ChannelMappingPicker: ForwardRefExoticComponent<ChannelMappingPickerProps & RefAttributes<SelectInstance<Option_2<InternalValue>, false, GroupBase<Option_2<InternalValue>>>>>;
+
+declare interface ChannelMappingPickerProps extends SelectProps<InternalValue> {
+    channels: Option_2<number>[];
+    className?: string;
+    filterOptions?: (candidate: Option_2<InternalValue>, inputValue: string) => boolean;
+    value: number;
+    onChange: (value: InternalValue) => void;
+}
+
+export declare const ChannelPicker: ForwardRefExoticComponent<ChannelPickerProps & RefAttributes<SelectInstance<Option_2<Channel>, false, GroupBase<Option_2<Channel>>>>>;
+
+declare type ChannelPickerProps = SelectProps<Channel>;
+
+export declare const combineStatusWithChannel: (channel: number, status: Status_2) => number;
+
+declare type Curve = typeof RESPONSE_CURVE_0 | typeof RESPONSE_CURVE_1 | typeof RESPONSE_CURVE_2 | typeof RESPONSE_CURVE_3 | typeof RESPONSE_CURVE_4 | typeof RESPONSE_CURVE_5 | typeof RESPONSE_CURVE_6 | typeof RESPONSE_CURVE_7;
+
+export declare const extractStatusAndChannel: (status: number) => {
+    status: Status_2;
+    channel: number;
+};
+
+export declare const getStatusLabel: (val: Status_2) => string | number | true | ReactElement<any, string | JSXElementConstructor<any>> | Iterable<ReactNode>;
+
+declare type InternalValue = number | 'separator';
+
+export declare const Knob: (props: KnobProps) => JSX_2.Element;
+
+export declare const KnobPicker: ForwardRefExoticComponent<SelectProps<number> & {
+highToLow?: boolean;
+includeLabel?: boolean;
+includePicker?: boolean;
+knobProps?: Partial<KnobPickerProps>;
+max?: number;
+min?: number;
+wheelEnabled?: boolean;
+wheelSensitivity?: number;
+value: number;
+} & RefAttributes<SelectInstance<Option_2<number>, false, GroupBase<Option_2<number>>>>>;
+
+declare type KnobPickerProps = SelectProps<number> & {
+    highToLow?: boolean;
+    includeLabel?: boolean;
+    includePicker?: boolean;
+    knobProps?: Partial<KnobPickerProps>;
+    max?: number;
+    min?: number;
+    wheelEnabled?: boolean;
+    wheelSensitivity?: number;
+    value: number;
+};
+
+declare type KnobProps = {
+    disabled?: boolean;
+    max?: number;
+    min?: number;
+    onChange?: (value: number) => void;
+    value?: number;
+    wheelEnabled?: boolean;
+    wheelSensitivity?: number;
+};
+
+export declare const LatchPicker: ForwardRefExoticComponent<LatchPickerProps & RefAttributes<SelectInstance<Option_2<Polarity>, false, GroupBase<Option_2<Polarity>>>>>;
+
+declare type LatchPickerProps = SelectProps<Polarity>;
+
+export declare const MappingPicker: ForwardRefExoticComponent<SelectProps<string> & {
+allowClearing: boolean;
+} & RefAttributes<SelectInstance<Option_2<string>, false, GroupBase<Option_2<string>>>>>;
+
+export declare const MASK_CHANNEL = 15;
+
+export declare const MASK_STATUS = 240;
+
+export declare const NotePicker: ForwardRefExoticComponent<SelectProps<number> & {
+channel: number;
+disabled?: boolean;
+isMelodicMode?: boolean;
+mapping?: Mapping;
+onChange: (value: number) => void;
+} & RefAttributes<SelectInstance<Option_2<number>, false, GroupBase<Option_2<number>>>>>;
+
+export declare const OctavePlayer: ({ format, height, hostname, instrumentName, octave, onChange, onClick, onDoubleClick, onKeyMouseEnter, onKeyMouseLeave, soundfont, Tooltip, width, }: WithProviderProps) => JSX_2.Element;
+
+declare type Option_2<T> = {
+    label: React.ReactNode;
+    value: T;
+};
+
+export declare const PianoPicker: ({ format, height, hostname, instrumentName, onChange, onClick, onDoubleClick, onKeyMouseEnter, onKeyMouseLeave, soundfont, width, }: WithProviderProps) => JSX_2.Element;
+
+declare type Polarity = 0 | 1;
+
+export declare const PolarityPicker: ForwardRefExoticComponent<SelectProps<Polarity> & {
+labelOff?: string;
+labelOn?: string;
+} & RefAttributes<SelectInstance<Option_2<Polarity>, false, GroupBase<Option_2<Polarity>>>>>;
+
+declare const RESPONSE_CURVE_0 = 0;
+
+declare const RESPONSE_CURVE_1 = 1;
+
+declare const RESPONSE_CURVE_2 = 2;
+
+declare const RESPONSE_CURVE_3 = 3;
+
+declare const RESPONSE_CURVE_4 = 4;
+
+declare const RESPONSE_CURVE_5 = 5;
+
+declare const RESPONSE_CURVE_6 = 6;
+
+declare const RESPONSE_CURVE_7 = 7;
+
+export declare const RESPONSE_CURVES: Option_2<Curve>[];
+
+export declare type ResponseCurve = {
+    value: Curve;
+    label: React.ReactNode;
+    c1: number;
+    c2: number;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    labelX: number;
+    labelY: number;
+};
+
+export declare const ResponseCurve: (props: ResponseCurveProps) => JSX_2.Element;
+
+export declare const ResponseCurvePicker: ForwardRefExoticComponent<SelectProps<Curve> & {
+inverted?: boolean;
+Tooltip?: React.FC<TooltipProps>;
+} & RefAttributes<SelectInstance<Option_2<Curve>, false, GroupBase<Option_2<Curve>>>>>;
+
+declare type ResponseCurveProps = {
+    autosize: boolean;
+    disabled?: boolean;
+    inverted: boolean;
+    onChange: (event: {
+        target: {
+            value: Curve;
+        };
+    }) => void;
+    Tooltip: React.FC<TooltipProps>;
+    value: Curve;
+};
+
+export declare const Select: <T>(props: SelectProps<T> & {
+    ref?: React.ForwardedRef<SelectInstance<Option_2<T>, false, GroupBase<Option_2<T>>>>;
+}) => JSX_3.Element;
+
+declare type SelectProps<T> = {
+    className?: string;
+    components?: object;
+    disabled?: boolean;
+    filterOptions?: (candidate: Option_2<T>, inputValue: string) => boolean;
+    formatOptionLabel?: (option: Option_2<unknown>, { context }: {
+        context: 'menu' | 'value';
+    }) => React.ReactNode;
+    isSearchable?: boolean;
+    label?: string;
+    onChange: (value: Option_2<T>['value']) => void;
+    options: Option_2<T>[] | {
+        entries: Option_2<T>[];
+    }[];
+    preserveMenuWidth?: boolean;
+    shrinkLabel?: boolean;
+    value: Option_2<T>['value'];
+};
+
+declare type Status = (typeof Statuses_2)[keyof typeof Statuses_2]
+
+declare type Status_2 = (typeof Statuses)[keyof typeof Statuses];
+
+export declare const Statuses: {
+    noteOff: number;
+    noteOn: number;
+    aftertouch: number;
+    controlChange: number;
+    programChange: number;
+    channelPressure: number;
+    pitchWheel: number;
+};
+
+declare const Statuses_2 = {
+    noteOff: 8, // 1000
+    noteOn: 9, // 1001
+    aftertouch: 10, // 1010
+    controlChange: 11, // 1011
+    programChange: 12, // 1100
+    channelPressure: 13, // 1101
+    pitchWheel: 14, // 1110
+};
+
+export declare const StatusPicker: ForwardRefExoticComponent<SelectProps<number> & {
+statuses: Option_2<Status>[];
+} & RefAttributes<SelectInstance<Option_2<number>, false, GroupBase<Option_2<number>>>>>;
+
+export declare const SVGText: (props: TextProps) => JSX_2.Element;
+
+declare type TextProps = Partial<HTMLOrSVGElement> & {
+    className?: string;
+    dx?: number;
+    dy?: number;
+    maxHeight?: number;
+    maxWidth?: number;
+    transform?: string;
+    text: string;
+    textAnchor?: React.CSSProperties['textAnchor'];
+    verticalAnchor?: 'start' | 'middle' | 'end';
+    x?: number;
+    y?: number;
+};
+
+declare type TooltipProps = {
+    children?: React.ReactNode;
+    placement?: 'left' | 'right' | 'top' | 'bottom';
+    title: React.ReactNode;
+};
+
+export declare const ValuePicker: ForwardRefExoticComponent<SelectProps<number> & {
+highToLow?: boolean;
+max?: number;
+min?: number;
+} & RefAttributes<SelectInstance<Option_2<number>, false, GroupBase<Option_2<number>>>>>;
+
+declare type WithProviderProps = {
+    format?: 'mp3' | 'ogg';
+    height: number;
+    hostname?: string;
+    instrumentName: default_2.InstrumentName;
+    octave?: number;
+    onChange?: (note: number) => void;
+    onClick?: (note: number) => void;
+    onDoubleClick?: (note: number) => void;
+    onKeyMouseEnter?: (note: number) => void;
+    onKeyMouseLeave?: (note: number) => void;
+    soundfont?: 'MusyngKite' | 'FluidR3_GM';
+    Tooltip?: TooltipProps;
+    width: number;
+};
+
+export { }

package/dist/types/main.d.ts

@@ -0,0 +1,19 @@
+export { default as CCPicker } from './pickers/CCPicker';
+export { default as ChannelMappingPicker } from './pickers/ChannelMappingPicker';
+export { default as ChannelPicker } from './pickers/ChannelPicker';
+export { default as Knob } from './pickers/Knob';
+export { default as KnobPicker } from './pickers/KnobPicker';
+export { default as LatchPicker } from './pickers/LatchPicker';
+export { default as MappingPicker } from './pickers/MappingPicker';
+export { default as NotePicker } from './pickers/NotePicker';
+export { default as OctavePlayer } from './other/OctavePlayer';
+export { default as PianoPicker } from './pickers/PianoPicker';
+export { default as PolarityPicker } from './pickers/PolarityPicker';
+export { default as ResponseCurvePicker } from './pickers/ResponseCurvePicker';
+export { default as Select } from './pickers/Select';
+export { default as StatusPicker } from './pickers/StatusPicker';
+export { default as SVGText } from './other/SVGText';
+export { default as ValuePicker } from './pickers/ValuePicker';
+export { combineStatusWithChannel, extractStatusAndChannel, getStatusLabel, MASK_CHANNEL, MASK_STATUS, Statuses, } from './midi/export';
+export { default as ResponseCurve, RESPONSE_CURVES, } from './pickers/ResponseCurve';
+export { default as ccValues } from './midi/ccValues';

package/dist/types/midi/ccValues.d.ts

@@ -0,0 +1,3 @@
+import type { Option } from '../pickers/Select';
+declare const CC_NAMES: Option<number>[];
+export default CC_NAMES;

package/dist/types/midi/export.d.ts

@@ -0,0 +1,22 @@
+import type { Option } from 'lib/pickers/Select';
+declare const Statuses: {
+    noteOff: number;
+    noteOn: number;
+    aftertouch: number;
+    controlChange: number;
+    programChange: number;
+    channelPressure: number;
+    pitchWheel: number;
+};
+type Status = (typeof Statuses)[keyof typeof Statuses];
+declare const MASK_CHANNEL = 15;
+declare const MASK_STATUS = 240;
+declare const statusOptions: Option<Status>[];
+declare const getStatusLabel: (val: Status) => string | number | true | import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode>;
+declare const combineStatusWithChannel: (channel: number, status: Status) => number;
+declare const extractStatusAndChannel: (status: number) => {
+    status: Status;
+    channel: number;
+};
+export { combineStatusWithChannel, extractStatusAndChannel, getStatusLabel, MASK_CHANNEL, MASK_STATUS, statusOptions, Statuses, };
+export type { Status };

package/dist/types/other/DefaultTooltip.d.ts

@@ -0,0 +1,10 @@
+type TooltipProps = {
+    children?: React.ReactNode;
+    placement?: 'left' | 'right' | 'top' | 'bottom';
+    title: React.ReactNode;
+};
+declare const DefaultTooltip: ({ children }: React.PropsWithoutRef<TooltipProps>) => import("react").FunctionComponentElement<{
+    children?: import("react").ReactNode | undefined;
+}>;
+export default DefaultTooltip;
+export type { TooltipProps };

package/dist/types/other/OctavePlayer.d.ts

@@ -0,0 +1,20 @@
+import type Soundfont from 'soundfont-player';
+import type { TooltipProps } from './DefaultTooltip';
+type WithProviderProps = {
+    format?: 'mp3' | 'ogg';
+    height: number;
+    hostname?: string;
+    instrumentName: Soundfont.InstrumentName;
+    octave?: number;
+    onChange?: (note: number) => void;
+    onClick?: (note: number) => void;
+    onDoubleClick?: (note: number) => void;
+    onKeyMouseEnter?: (note: number) => void;
+    onKeyMouseLeave?: (note: number) => void;
+    soundfont?: 'MusyngKite' | 'FluidR3_GM';
+    Tooltip?: TooltipProps;
+    width: number;
+};
+declare const WithProvider: ({ format, height, hostname, instrumentName, octave, onChange, onClick, onDoubleClick, onKeyMouseEnter, onKeyMouseLeave, soundfont, Tooltip, width, }: WithProviderProps) => import("react/jsx-runtime").JSX.Element;
+export default WithProvider;
+export type { WithProviderProps };

package/dist/types/other/SVGText.d.ts

@@ -0,0 +1,17 @@
+declare const MEASUREMENT_ELEMENT_ID = "__react_svg_text_measurement_id";
+type TextProps = Partial<HTMLOrSVGElement> & {
+    className?: string;
+    dx?: number;
+    dy?: number;
+    maxHeight?: number;
+    maxWidth?: number;
+    transform?: string;
+    text: string;
+    textAnchor?: React.CSSProperties['textAnchor'];
+    verticalAnchor?: 'start' | 'middle' | 'end';
+    x?: number;
+    y?: number;
+};
+declare const Text: (props: TextProps) => import("react/jsx-runtime").JSX.Element;
+export default Text;
+export { MEASUREMENT_ELEMENT_ID };

package/dist/types/other/SoundFontProvider.d.ts

@@ -0,0 +1,17 @@
+import Soundfont from 'soundfont-player';
+type SoundfontProviderProps = {
+    audioContext: AudioContext;
+    format?: 'mp3' | 'ogg';
+    hostname?: string;
+    instrumentName: Soundfont.InstrumentName;
+    onChange?: (midiNumber: number) => void;
+    render: (props: {
+        isLoading: boolean;
+        playNote: (midiNumber: number) => void;
+        stopNote: (midiNumber: number) => void;
+        stopAllNotes: () => void;
+    }) => React.ReactNode;
+    soundfont?: 'MusyngKite' | 'FluidR3_GM';
+};
+declare const SoundfontProvider: (props: SoundfontProviderProps) => import("react").ReactNode;
+export default SoundfontProvider;

package/dist/types/pickers/CCPicker.d.ts

@@ -0,0 +1,7 @@
+import type { GroupBase, SelectInstance } from 'react-select';
+import type { Option, SelectProps } from './Select';
+type CCPickerProps = SelectProps<number>;
+type CCPickerRef = SelectInstance<Option<number>, false, GroupBase<Option<number>>>;
+declare const CCPicker: import("react").ForwardRefExoticComponent<CCPickerProps & import("react").RefAttributes<SelectInstance<Option<number>, false, GroupBase<Option<number>>>>>;
+export default CCPicker;
+export type { CCPickerProps, CCPickerRef };

package/dist/types/pickers/ChannelMappingPicker.d.ts

@@ -0,0 +1,14 @@
+import type { GroupBase, SelectInstance } from 'react-select';
+import type { Option, SelectProps } from './Select';
+type InternalValue = number | 'separator';
+interface ChannelMappingPickerProps extends SelectProps<InternalValue> {
+    channels: Option<number>[];
+    className?: string;
+    filterOptions?: (candidate: Option<InternalValue>, inputValue: string) => boolean;
+    value: number;
+    onChange: (value: InternalValue) => void;
+}
+type ChannelMappingPickerRef = SelectInstance<Option<number>, false, GroupBase<Option<number>>>;
+declare const ChannelMappingPicker: import("react").ForwardRefExoticComponent<ChannelMappingPickerProps & import("react").RefAttributes<SelectInstance<Option<InternalValue>, false, GroupBase<Option<InternalValue>>>>>;
+export default ChannelMappingPicker;
+export type { ChannelMappingPickerProps, ChannelMappingPickerRef };

package/dist/types/pickers/ChannelPicker.d.ts

@@ -0,0 +1,8 @@
+import type { GroupBase, SelectInstance } from 'react-select';
+import type { Option, SelectProps } from './Select';
+type Channel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15;
+type ChannelPickerProps = SelectProps<Channel>;
+type ChannelPickerRef = SelectInstance<Option<Channel>, false, GroupBase<Option<Channel>>>;
+declare const ChannelPicker: import("react").ForwardRefExoticComponent<ChannelPickerProps & import("react").RefAttributes<SelectInstance<Option<Channel>, false, GroupBase<Option<Channel>>>>>;
+export default ChannelPicker;
+export type { Channel, ChannelPickerProps, ChannelPickerRef };

package/dist/types/pickers/Knob.d.ts

@@ -0,0 +1,12 @@
+type KnobProps = {
+    disabled?: boolean;
+    max?: number;
+    min?: number;
+    onChange?: (value: number) => void;
+    value?: number;
+    wheelEnabled?: boolean;
+    wheelSensitivity?: number;
+};
+declare const Knob: (props: KnobProps) => import("react/jsx-runtime").JSX.Element;
+export default Knob;
+export type { KnobProps };

package/dist/types/pickers/KnobPicker.d.ts

@@ -0,0 +1,27 @@
+import type { GroupBase, SelectInstance } from 'react-select';
+import type { Option, SelectProps } from './Select';
+type KnobPickerProps = SelectProps<number> & {
+    highToLow?: boolean;
+    includeLabel?: boolean;
+    includePicker?: boolean;
+    knobProps?: Partial<KnobPickerProps>;
+    max?: number;
+    min?: number;
+    wheelEnabled?: boolean;
+    wheelSensitivity?: number;
+    value: number;
+};
+type KnobPickerRef = SelectInstance<Option<number>, false, GroupBase<Option<number>>>;
+declare const KnobPicker: import("react").ForwardRefExoticComponent<SelectProps<number> & {
+    highToLow?: boolean;
+    includeLabel?: boolean;
+    includePicker?: boolean;
+    knobProps?: Partial<KnobPickerProps>;
+    max?: number;
+    min?: number;
+    wheelEnabled?: boolean;
+    wheelSensitivity?: number;
+    value: number;
+} & import("react").RefAttributes<SelectInstance<Option<number>, false, GroupBase<Option<number>>>>>;
+export default KnobPicker;
+export type { KnobPickerProps, KnobPickerRef };

package/dist/types/pickers/LatchPicker.d.ts

@@ -0,0 +1,8 @@
+import type { GroupBase, SelectInstance } from 'react-select';
+import type { Polarity } from './PolarityPicker';
+import type { Option, SelectProps } from './Select';
+type LatchPickerProps = SelectProps<Polarity>;
+type LatchPickerRef = SelectInstance<Option<Polarity>, false, GroupBase<Option<Polarity>>>;
+declare const LatchPicker: import("react").ForwardRefExoticComponent<LatchPickerProps & import("react").RefAttributes<SelectInstance<Option<Polarity>, false, GroupBase<Option<Polarity>>>>>;
+export default LatchPicker;
+export type { LatchPickerProps, LatchPickerRef };

package/dist/types/pickers/MappingPicker.d.ts

@@ -0,0 +1,11 @@
+import type { GroupBase, SelectInstance } from 'react-select';
+import type { Option, SelectProps } from './Select';
+type MappingPickerProps = SelectProps<string> & {
+    allowClearing: boolean;
+};
+type MappingPickerRef = SelectInstance<Option<string>, false, GroupBase<Option<string>>>;
+declare const MappingPicker: import("react").ForwardRefExoticComponent<SelectProps<string> & {
+    allowClearing: boolean;
+} & import("react").RefAttributes<SelectInstance<Option<string>, false, GroupBase<Option<string>>>>>;
+export default MappingPicker;
+export type { MappingPickerProps, MappingPickerRef };

package/dist/types/pickers/NotePicker.d.ts

@@ -0,0 +1,20 @@
+import type { GroupBase, SelectInstance } from 'react-select';
+import { type Mapping } from 'zds-mappings';
+import type { Option, SelectProps } from './Select';
+type NotePickerProps = SelectProps<number> & {
+    channel: number;
+    disabled?: boolean;
+    isMelodicMode?: boolean;
+    mapping?: Mapping;
+    onChange: (value: number) => void;
+};
+type NotePickerRef = SelectInstance<Option<number>, false, GroupBase<Option<number>>>;
+declare const NotePicker: import("react").ForwardRefExoticComponent<SelectProps<number> & {
+    channel: number;
+    disabled?: boolean;
+    isMelodicMode?: boolean;
+    mapping?: Mapping;
+    onChange: (value: number) => void;
+} & import("react").RefAttributes<SelectInstance<Option<number>, false, GroupBase<Option<number>>>>>;
+export default NotePicker;
+export type { NotePickerProps, NotePickerRef };

package/dist/types/pickers/PianoPicker.d.ts

@@ -0,0 +1,9 @@
+import type { WithProviderProps } from '../other/OctavePlayer';
+type PianoProps = {
+    disabled: boolean;
+    height: number;
+    width: number;
+};
+declare const WithProvider: ({ format, height, hostname, instrumentName, onChange, onClick, onDoubleClick, onKeyMouseEnter, onKeyMouseLeave, soundfont, width, }: WithProviderProps) => import("react/jsx-runtime").JSX.Element;
+export default WithProvider;
+export type { PianoProps };

package/dist/types/pickers/PolarityPicker.d.ts

@@ -0,0 +1,14 @@
+import type { GroupBase, SelectInstance } from 'react-select';
+import type { Option, SelectProps } from './Select';
+type Polarity = 0 | 1;
+type PolarityPickerProps = SelectProps<Polarity> & {
+    labelOff?: string;
+    labelOn?: string;
+};
+type PolarityPickerRef = SelectInstance<Option<Polarity>, false, GroupBase<Option<Polarity>>>;
+declare const PolarityPicker: import("react").ForwardRefExoticComponent<SelectProps<Polarity> & {
+    labelOff?: string;
+    labelOn?: string;
+} & import("react").RefAttributes<SelectInstance<Option<Polarity>, false, GroupBase<Option<Polarity>>>>>;
+export default PolarityPicker;
+export type { Polarity, PolarityPickerProps, PolarityPickerRef };

package/dist/types/pickers/ResponseCurve.d.ts

@@ -0,0 +1,40 @@
+import { type TooltipProps } from '../other/DefaultTooltip';
+import type { Option } from './Select';
+declare const RESPONSE_CURVE_0 = 0;
+declare const RESPONSE_CURVE_1 = 1;
+declare const RESPONSE_CURVE_2 = 2;
+declare const RESPONSE_CURVE_3 = 3;
+declare const RESPONSE_CURVE_4 = 4;
+declare const RESPONSE_CURVE_5 = 5;
+declare const RESPONSE_CURVE_6 = 6;
+declare const RESPONSE_CURVE_7 = 7;
+type Curve = typeof RESPONSE_CURVE_0 | typeof RESPONSE_CURVE_1 | typeof RESPONSE_CURVE_2 | typeof RESPONSE_CURVE_3 | typeof RESPONSE_CURVE_4 | typeof RESPONSE_CURVE_5 | typeof RESPONSE_CURVE_6 | typeof RESPONSE_CURVE_7;
+type ResponseCurve = {
+    value: Curve;
+    label: React.ReactNode;
+    c1: number;
+    c2: number;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    labelX: number;
+    labelY: number;
+};
+declare const RESPONSE_CURVES: Option<Curve>[];
+type ResponseCurveProps = {
+    autosize: boolean;
+    disabled?: boolean;
+    inverted: boolean;
+    onChange: (event: {
+        target: {
+            value: Curve;
+        };
+    }) => void;
+    Tooltip: React.FC<TooltipProps>;
+    value: Curve;
+};
+declare const ResponseCurve: (props: ResponseCurveProps) => import("react/jsx-runtime").JSX.Element;
+export default ResponseCurve;
+export { RESPONSE_CURVES };
+export type { Curve, ResponseCurve, ResponseCurveProps };

package/dist/types/pickers/ResponseCurvePicker.d.ts

@@ -0,0 +1,15 @@
+import type { GroupBase, SelectInstance } from 'react-select';
+import { type TooltipProps } from '../other/DefaultTooltip';
+import { type Curve } from './ResponseCurve';
+import type { Option, SelectProps } from './Select';
+type ResponseCurvePickerProps = SelectProps<Curve> & {
+    inverted?: boolean;
+    Tooltip?: React.FC<TooltipProps>;
+};
+type ResponseCurvePickerRef = SelectInstance<Option<Curve>, false, GroupBase<Option<Curve>>>;
+declare const ResponseCurvePicker: import("react").ForwardRefExoticComponent<SelectProps<Curve> & {
+    inverted?: boolean;
+    Tooltip?: React.FC<TooltipProps>;
+} & import("react").RefAttributes<SelectInstance<Option<Curve>, false, GroupBase<Option<Curve>>>>>;
+export default ResponseCurvePicker;
+export type { ResponseCurvePickerProps, ResponseCurvePickerRef };

package/dist/types/pickers/Select.d.ts

@@ -0,0 +1,29 @@
+import { type JSX } from 'react';
+import { type GroupBase, type SelectInstance } from 'react-select';
+type Option<T> = {
+    label: React.ReactNode;
+    value: T;
+};
+type SelectProps<T> = {
+    className?: string;
+    components?: object;
+    disabled?: boolean;
+    filterOptions?: (candidate: Option<T>, inputValue: string) => boolean;
+    formatOptionLabel?: (option: Option<unknown>, { context }: {
+        context: 'menu' | 'value';
+    }) => React.ReactNode;
+    isSearchable?: boolean;
+    label?: string;
+    onChange: (value: Option<T>['value']) => void;
+    options: Option<T>[] | {
+        entries: Option<T>[];
+    }[];
+    preserveMenuWidth?: boolean;
+    shrinkLabel?: boolean;
+    value: Option<T>['value'];
+};
+declare const Select: <T>(props: SelectProps<T> & {
+    ref?: React.ForwardedRef<SelectInstance<Option<T>, false, GroupBase<Option<T>>>>;
+}) => JSX.Element;
+export default Select;
+export type { Option, SelectProps };

package/dist/types/pickers/StatusPicker.d.ts

@@ -0,0 +1,12 @@
+import type { Status } from 'lib/midi/export';
+import type { GroupBase, SelectInstance } from 'react-select';
+import type { Option, SelectProps } from './Select';
+type StatusPickerProps = SelectProps<Status> & {
+    statuses: Option<Status>[];
+};
+type StatusPickerRef = SelectInstance<Option<Status>, false, GroupBase<Option<Status>>>;
+declare const StatusPicker: import("react").ForwardRefExoticComponent<SelectProps<number> & {
+    statuses: Option<Status>[];
+} & import("react").RefAttributes<SelectInstance<Option<number>, false, GroupBase<Option<number>>>>>;
+export default StatusPicker;
+export type { StatusPickerProps, StatusPickerRef };

package/dist/types/pickers/ValuePicker.d.ts

@@ -0,0 +1,15 @@
+import type { GroupBase, SelectInstance } from 'react-select';
+import type { Option, SelectProps } from './Select';
+type ValuePickerProps = SelectProps<number> & {
+    highToLow?: boolean;
+    max?: number;
+    min?: number;
+};
+type ValuePickerRef = SelectInstance<Option<number>, false, GroupBase<Option<number>>>;
+declare const ValuePicker: import("react").ForwardRefExoticComponent<SelectProps<number> & {
+    highToLow?: boolean;
+    max?: number;
+    min?: number;
+} & import("react").RefAttributes<SelectInstance<Option<number>, false, GroupBase<Option<number>>>>>;
+export default ValuePicker;
+export type { ValuePickerProps, ValuePickerRef };