zds-pickers 4.0.2 → 4.0.5

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

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

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

@@ -0,0 +1,13 @@
+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;
+}
+declare const ChannelMappingPicker: import("react").ForwardRefExoticComponent<ChannelMappingPickerProps & import("react").RefAttributes<SelectInstance<Option<InternalValue>, false, GroupBase<Option<InternalValue>>>>>;
+export default ChannelMappingPicker;
+export type { ChannelMappingPickerProps };

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

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

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,6 @@
+import type { GroupBase, SelectInstance } from 'react-select';
+import type { Option, SelectProps } from './Select';
+type LatchPickerProps = SelectProps<number>;
+declare const LatchPicker: import("react").ForwardRefExoticComponent<LatchPickerProps & import("react").RefAttributes<SelectInstance<Option<number>, false, GroupBase<Option<number>>>>>;
+export default LatchPicker;
+export type { LatchPickerProps };

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

@@ -0,0 +1,10 @@
+import type { GroupBase, SelectInstance } from 'react-select';
+import type { Option, SelectProps } from './Select';
+type MappingPickerProps = SelectProps<string> & {
+    allowClearing: boolean;
+};
+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 };

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

@@ -0,0 +1,19 @@
+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;
+};
+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 };

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,12 @@
+import type { GroupBase, SelectInstance } from 'react-select';
+import type { Option, SelectProps } from './Select';
+type PolarityPickerProps = SelectProps<number> & {
+    labelOff?: string;
+    labelOn?: string;
+};
+declare const PolarityPicker: import("react").ForwardRefExoticComponent<SelectProps<number> & {
+    labelOff?: string;
+    labelOn?: string;
+} & import("react").RefAttributes<SelectInstance<Option<number>, false, GroupBase<Option<number>>>>>;
+export default PolarityPicker;
+export type { PolarityPickerProps };

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

@@ -0,0 +1,31 @@
+import { type TooltipProps } from '../other/DefaultTooltip';
+import type { Option } from './Select';
+type ResponseCurve = {
+    value: string | number;
+    label: React.ReactNode;
+    c1: number;
+    c2: number;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    labelX: number;
+    labelY: number;
+};
+declare const RESPONSE_CURVES: Option<number>[];
+type ResponseCurveProps = {
+    autosize: boolean;
+    disabled?: boolean;
+    inverted: boolean;
+    onChange: (event: {
+        target: {
+            value: number;
+        };
+    }) => void;
+    Tooltip: React.FC<TooltipProps>;
+    value: number;
+};
+declare const ResponseCurve: (props: ResponseCurveProps) => import("react/jsx-runtime").JSX.Element;
+export default ResponseCurve;
+export { RESPONSE_CURVES };
+export type { ResponseCurveProps };

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

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

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,11 @@
+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>[];
+};
+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 };

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

@@ -0,0 +1,14 @@
+import type { GroupBase, SelectInstance } from 'react-select';
+import type { Option, SelectProps } from './Select';
+type ValuePickerProps = SelectProps<number> & {
+    highToLow?: boolean;
+    max?: number;
+    min?: 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 };

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

@@ -0,0 +1,14 @@
+declare const knobSkin10: {
+    knobX: number;
+    knobY: number;
+    svg: string;
+    updateAttributes: {
+        element: string;
+        content: (_props: React.CSSProperties, value: number) => string;
+        attrs: {
+            name: string;
+            value: () => string;
+        }[];
+    }[];
+};
+export default knobSkin10;

package/dist/types/rotaryKnob/InternalInput.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+type InternalInputProps = {
+    disabled?: boolean;
+    min: number;
+    max: number;
+    value: number;
+    step?: number;
+    inputRef: React.RefObject<HTMLInputElement>;
+    onChange: (val: number) => void;
+    style?: React.CSSProperties;
+};
+declare class InternalInput extends React.Component<InternalInputProps> {
+    static defaultProps: {
+        step: number;
+    };
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export default InternalInput;

package/dist/types/rotaryKnob/Types.d.ts

@@ -0,0 +1,5 @@
+type Point = {
+    x: number;
+    y: number;
+};
+export type { Point };

package/dist/types/rotaryKnob/helpers/DrawCircle.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+/**
+ * Draws a circle with radius = r
+ * position must be handled by parent
+ */
+type DrawCircleProps = React.SVGProps<SVGCircleElement> & {
+    r: number;
+    borderColor?: string;
+    fillColor?: string;
+    borderWidth?: number;
+    fillOpacity: number;
+    cx: number;
+    cy: number;
+};
+declare class DrawCircle extends React.Component<DrawCircleProps> {
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export default DrawCircle;

package/dist/types/rotaryKnob/helpers/DrawLine.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { Point } from '../Types';
+/**
+ * Draws a line from p1 to p2
+ */
+type DrawLineProps = React.SVGProps<SVGLineElement> & {
+    width?: number;
+    color?: string;
+    p1: Point;
+    p2: Point;
+};
+declare class DrawLine extends React.Component<DrawLineProps> {
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export default DrawLine;

package/dist/types/rotaryKnob/helpers/HelpersOverlay.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+type HelpersOverlayProps = React.PropsWithChildren & {
+    overlayStyle?: React.CSSProperties;
+};
+/**
+ * Draws the overlay and the children
+ */
+declare class HelpersOverlay extends React.Component<HelpersOverlayProps> {
+    render(): React.ReactPortal;
+}
+export default HelpersOverlay;

package/dist/types/rotaryKnob/helpers/KnobVisualHelpers.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+import type { Point } from '../Types';
+/** Precision visual helpers */
+/**
+ * Precision mode visual helpers
+ */
+type KnobVisualHelpersProps = {
+    svgRef?: SVGSVGElement;
+    radius: number;
+    minimumDragDistance: number;
+    valueAngle: number;
+    mousePos: Point;
+};
+type KnobVisualHelpersState = {
+    centerX: number;
+    centerY: number;
+    valueMarkerX: number;
+    valueMarkerY: number;
+};
+declare class KnobVisualHelpers extends React.Component<KnobVisualHelpersProps, KnobVisualHelpersState> {
+    state: {
+        centerX: number;
+        centerY: number;
+        valueMarkerX: number;
+        valueMarkerY: number;
+    };
+    static getDerivedStateFromProps(props: KnobVisualHelpersProps, state: KnobVisualHelpersState): KnobVisualHelpersState;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export { KnobVisualHelpers };

package/dist/types/rotaryKnob/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Show the rotation circle and marker
+ * dispatches drag events
+ */
+/**
+ * type definition for the skin system attribute modification element
+ */
+type AttributeSetValue = {
+    name: string;
+    value: (props: unknown, value: unknown) => string;
+};
+/**
+ * Type definition for the skin element manipulation block
+ */
+interface UpdateElement {
+    element: string;
+    content: (_props: React.CSSProperties, value: number) => string;
+    attrs: AttributeSetValue[];
+}
+interface Skin {
+    svg: string;
+    knobX: number;
+    knobY: number;
+    updateAttributes: UpdateElement[];
+}
+type KnobProps = Omit<React.ComponentProps<'div'>, 'onChange'> & {
+    clampMax?: number;
+    clampMin?: number;
+    defaultValue?: number;
+    disabled?: boolean;
+    format?: (val: number) => string;
+    max?: number;
+    min?: number;
+    onChange?: (val: number) => void;
+    onEnd?: () => void;
+    onStart?: () => void;
+    preciseMode?: boolean;
+    rotateDegrees?: number;
+    skin?: Skin;
+    step?: number;
+    style: React.CSSProperties;
+    unlockDistance?: number;
+    value?: number;
+};
+/**
+ * Generic knob component
+ */
+declare const RotaryKnob: (props: KnobProps) => import("react/jsx-runtime").JSX.Element;
+export default RotaryKnob;

package/dist/types/rotaryKnob/knobdefaultskin.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    knobX: number;
+    knobY: number;
+    svg: string;
+};
+export default _default;

package/dist/types/rotaryKnob/utils.d.ts

@@ -0,0 +1,49 @@
+/** Note on viewbox/width
+ * This methods only work when the pixels match the svg units.
+ * when the viewbox is changed, or width is set they won't return
+ * the correct results
+ */
+/**
+ * Returns the global coordinates of a position given
+ * for a specific coordinate system
+ * @param {*} svgdoc
+ * @param {*} elem
+ * @param {*} x
+ * @param {*} y
+ */
+/**
+ * Converts a global position to a local one
+ * @param {*} svgdoc
+ * @param {*} elem
+ * @param {*} x
+ * @param {*} y
+ */
+declare function toRadians(angle: number): number;
+declare function getQuadrant(x: number, y: number): 1 | 2 | 3 | 4;
+/**
+ * Returns the angle (degrees) given a point.
+ * Assumes 0,0 as the center of the circle
+ * @param {number} x
+ * @param {number} y
+ */
+declare function getAngleForPoint(x: number, y: number): number;
+/**
+ * Transforms the top/left variables of the rectangle
+ * returned by getBoundingClientRect to document based coordinates
+ * without the scroll.
+ * UPDATE
+ * @param {Rect} box
+ */
+declare function transformBoundingClientRectToDocument(box: DOMRect): {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+};
+declare const _default: {
+    toRadians: typeof toRadians;
+    getQuadrant: typeof getQuadrant;
+    getAngleForPoint: typeof getAngleForPoint;
+    transformBoundingClientRectToDocument: typeof transformBoundingClientRectToDocument;
+};
+export default _default;

package/dist/types/utils.d.ts

@@ -0,0 +1,9 @@
+declare const arraySequence: (numberOfElements: number) => number[];
+declare const assertRange: (value: number | string, max?: number, min?: number) => number;
+declare const findObj: <T>(key: keyof T, value: T[keyof T]) => (arr: T[]) => T | undefined;
+declare const omit: <T extends Record<string, unknown>>(...keys: string[]) => (obj: T) => {};
+declare const pick: <T extends object>(...keys: (keyof T)[]) => (obj: T) => {};
+declare const set: <T>(key: keyof T, value: T[keyof T]) => (obj: T) => T & {
+    [x: string]: T[keyof T];
+};
+export { arraySequence, assertRange, findObj, omit, pick, set };

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "zds-pickers",
-  "version": "4.0.2",
+  "version": "4.0.5",
   "main": "./dist/index.cjs.js",
   "module": "./dist/index.es.js",
-  "types": "./dist/main.d.ts",
+  "types": "dist/types/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "dist/types"
   ],
   "exports": {
     ".": {
-      "types": "./dist/main.d.ts",
+      "types": "./dist/types/index.d.ts",
       "import": "./dist/index.es.js",
       "require": "./dist/index.cjs.js"
     }
@@ -33,7 +34,7 @@
   },
   "scripts": {
     "dev": "vite",
-    "build": "tsc --p ./tsconfig.json && vite build",
+    "build": "vite build && tsc --emitDeclarationOnly",
     "build-storybook": "storybook build",
     "lint": "biome check --write",
     "preview": "vite preview",