@cutoff/audio-ui-core 1.0.0-preview.20260123.1125

package/dist/constants/cssVars.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Shared constants for CSS custom property names used throughout the library.
+ * Using string constants makes it easier to update prefixes in the future and
+ * keeps TypeScript aware of the possible values.
+ */
+export declare const CSS_VARS: {
+    readonly roundnessBase: "--audioui-roundness-base";
+    readonly primaryColor: "--audioui-primary-color";
+    readonly adaptiveDefaultColor: "--audioui-adaptive-default-color";
+    readonly adaptive50: "--audioui-adaptive-50";
+    readonly adaptive20: "--audioui-adaptive-20";
+    readonly adaptiveLight: "--audioui-adaptive-light";
+    readonly adaptiveDark: "--audioui-adaptive-dark";
+    readonly primary50: "--audioui-primary-50";
+    readonly primary20: "--audioui-primary-20";
+    readonly primaryLight: "--audioui-primary-light";
+    readonly primaryDark: "--audioui-primary-dark";
+    readonly textColor: "--audioui-text-color";
+    readonly defaultFontSize: "--audioui-default-font-size";
+    readonly highlightEffect: "--audioui-highlight-effect";
+    readonly highlightTransitionDuration: "--audioui-highlight-transition-duration";
+    readonly cursorClickable: "--audioui-cursor-clickable";
+    readonly cursorBidirectional: "--audioui-cursor-bidirectional";
+    readonly cursorHorizontal: "--audioui-cursor-horizontal";
+    readonly cursorVertical: "--audioui-cursor-vertical";
+    readonly cursorCircular: "--audioui-cursor-circular";
+    readonly cursorNoneditable: "--audioui-cursor-noneditable";
+    readonly cursorDisabled: "--audioui-cursor-disabled";
+    readonly keysIvory: "--audioui-keys-ivory";
+    readonly keysIvoryStroke: "--audioui-keys-ivory-stroke";
+    readonly keysEbony: "--audioui-keys-ebony";
+    readonly keysEbonyStroke: "--audioui-keys-ebony-stroke";
+    readonly knobCapFill: "--audioui-knob-cap-fill";
+    readonly buttonStrokeWidth: "--audioui-button-stroke-width";
+    readonly sliderTrackColor: "--audioui-slider-track-color";
+    readonly sliderStripColor: "--audioui-slider-strip-color";
+    readonly sliderCursorColor: "--audioui-slider-cursor-color";
+    readonly sliderCursorBorderColor: "--audioui-slider-cursor-border-color";
+    readonly sliderCursorBorderWidth: "--audioui-slider-cursor-border-width";
+};
+export type AudioUiCssVar = (typeof CSS_VARS)[keyof typeof CSS_VARS];
+//# sourceMappingURL=cssVars.d.ts.map

package/dist/constants/cssVars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cssVars.d.ts","sourceRoot":"","sources":["../../src/constants/cssVars.ts"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CX,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,QAAQ,CAAC,CAAC,MAAM,OAAO,QAAQ,CAAC,CAAC"}

package/dist/constants/cursors.d.ts

@@ -0,0 +1,2 @@
+export declare const CIRCULAR_CURSOR = "url('data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzIiIGhlaWdodD0iMzIiIHZpZXdCb3g9IjAgMCAzMiAzMiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48Y2lyY2xlIGN4PSIxNiIgY3k9IjE2IiByPSIxMCIgc3Ryb2tlPSJ3aGl0ZSIgc3Ryb2tlLXdpZHRoPSI0Ii8+PGNpcmNsZSBjeD0iMTYiIGN5PSIxNiIgcj0iMTAiIHN0cm9rZT0iYmxhY2siIHN0cm9rZS13aWR0aD0iMiIvPjwvc3ZnPg==') 16 16, move";
+//# sourceMappingURL=cursors.d.ts.map

package/dist/constants/cursors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursors.d.ts","sourceRoot":"","sources":["../../src/constants/cursors.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,eAAe,sWAC2U,CAAC"}

package/dist/constants/interaction.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Standard sensitivity for continuous controls.
+ * Represents normalized value change per pixel of drag.
+ * 0.005 means 200 pixels for a full 0-1 sweep.
+ * This aligns with standard "virtual throw" in audio software.
+ */
+export declare const DEFAULT_CONTINUOUS_SENSITIVITY = 0.005;
+/**
+ * Standard sensitivity for wheel interactions.
+ * Represents normalized value change per unit of wheel delta.
+ */
+export declare const DEFAULT_WHEEL_SENSITIVITY = 0.005;
+/**
+ * Target pixels per discrete step.
+ * Used for adaptive sensitivity: if a step exists, we ensure
+ * it doesn't take more than this many pixels to traverse it.
+ * This prevents "dead zones" in low-resolution parameters.
+ */
+export declare const TARGET_PIXELS_PER_STEP = 30;
+/**
+ * Default step size for keyboard interaction (normalized 0..1).
+ */
+export declare const DEFAULT_KEYBOARD_STEP = 0.05;
+//# sourceMappingURL=interaction.d.ts.map

package/dist/constants/interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interaction.d.ts","sourceRoot":"","sources":["../../src/constants/interaction.ts"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,QAAQ,CAAC;AAEpD;;;GAGG;AACH,eAAO,MAAM,yBAAyB,QAAQ,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC;;GAEG;AACH,eAAO,MAAM,qBAAqB,OAAO,CAAC"}

package/dist/constants/styles.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Centralized collection of CSS class names used across AudioUI components.
+ * Keeping them in one place makes it easier to enforce prefixing conventions
+ * and minimizes the risk of typos in string literals.
+ */
+export declare const CLASSNAMES: {
+    /** Root class applied to all AudioUI components */
+    readonly root: "audioui";
+    /** Container helper class for components that manage their own SVG sizing */
+    readonly container: "audioui-component-container";
+    /** Highlight class used for interactive states */
+    readonly highlight: "audioui-highlight";
+    /** Icon wrapper class for HTML overlay - ensures SVG icons fill their container */
+    readonly iconWrapper: "audioui-icon-wrapper";
+};
+export type AudioUiClassName = (typeof CLASSNAMES)[keyof typeof CLASSNAMES];
+//# sourceMappingURL=styles.d.ts.map

package/dist/constants/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../src/constants/styles.ts"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,eAAO,MAAM,UAAU;IACnB,mDAAmD;;IAEnD,6EAA6E;;IAE7E,kDAAkD;;IAElD,mFAAmF;;CAE7E,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,OAAO,UAAU,CAAC,CAAC"}

package/dist/constants/theme.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Predefined theme colors as CSS color values
+ * These are just the primary color - variants (primary50, primary20) are computed automatically by components
+ *
+ * @example
+ * ```tsx
+ * import { themeColors, setThemeColor } from '@cutoff/audio-ui-react';
+ *
+ * // Set global theme color
+ * setThemeColor(themeColors.blue);
+ *
+ * // Or use in component props
+ * <Knob value={50} color={themeColors.blue} />
+ * ```
+ */
+export declare const themeColors: {
+    /** Default adaptive color (white in dark mode, black in light mode) */
+    readonly default: "var(--audioui-theme-default)";
+    /** Blue theme color */
+    readonly blue: "var(--audioui-theme-blue)";
+    /** Orange theme color */
+    readonly orange: "var(--audioui-theme-orange)";
+    /** Pink theme color */
+    readonly pink: "var(--audioui-theme-pink)";
+    /** Green theme color */
+    readonly green: "var(--audioui-theme-green)";
+    /** Purple theme color */
+    readonly purple: "var(--audioui-theme-purple)";
+    /** Yellow theme color */
+    readonly yellow: "var(--audioui-theme-yellow)";
+};
+/**
+ * Predefined theme colors as direct HSL values
+ * Use these when CSS variables aren't available or you need direct color values
+ */
+export declare const themeColorsDirect: {
+    readonly default: {
+        readonly light: "hsl(0, 0%, 10%)";
+        readonly dark: "hsl(0, 0%, 96%)";
+    };
+    readonly blue: {
+        readonly light: "hsl(204, 88%, 52%)";
+        readonly dark: "hsl(204, 88%, 53%)";
+    };
+    readonly orange: {
+        readonly light: "hsl(29, 100%, 48%)";
+        readonly dark: "hsl(29, 100%, 50%)";
+    };
+    readonly pink: {
+        readonly light: "hsl(332, 92%, 52%)";
+        readonly dark: "hsl(332, 95%, 54%)";
+    };
+    readonly green: {
+        readonly light: "hsl(160, 95%, 44%)";
+        readonly dark: "hsl(160, 98%, 37%)";
+    };
+    readonly purple: {
+        readonly light: "hsl(252, 96%, 54%)";
+        readonly dark: "hsl(252, 100%, 67%)";
+    };
+    readonly yellow: {
+        readonly light: "hsl(50, 100%, 50%)";
+        readonly dark: "hsl(50, 100%, 50%)";
+    };
+};
+//# sourceMappingURL=theme.d.ts.map

package/dist/constants/theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../src/constants/theme.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW;IACpB,uEAAuE;;IAEvE,uBAAuB;;IAEvB,yBAAyB;;IAEzB,uBAAuB;;IAEvB,wBAAwB;;IAExB,yBAAyB;;IAEzB,yBAAyB;;CAEnB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BpB,CAAC"}

package/dist/constants/themeDefaults.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Default theme values for themable components.
+ * These constants provide a single source of truth for default values
+ * and can be easily adjusted to change the global appearance.
+ */
+/**
+ * Default roundness value (normalized 0.0-1.0)
+ * @default 0.3
+ */
+export declare const DEFAULT_ROUNDNESS = 0.3;
+/**
+ * Default thickness value (normalized 0.0-1.0)
+ * @default 0.4
+ */
+export declare const DEFAULT_THICKNESS = 0.4;
+//# sourceMappingURL=themeDefaults.d.ts.map

package/dist/constants/themeDefaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"themeDefaults.d.ts","sourceRoot":"","sources":["../../src/constants/themeDefaults.ts"],"names":[],"mappings":"AAMA;;;;GAIG;AAEH;;;GAGG;AACH,eAAO,MAAM,iBAAiB,MAAM,CAAC;AAErC;;;GAGG;AACH,eAAO,MAAM,iBAAiB,MAAM,CAAC"}

package/dist/controller/BooleanInteractionController.d.ts

@@ -0,0 +1,141 @@
+export type BooleanInteractionMode = "toggle" | "momentary";
+export interface BooleanInteractionConfig {
+    /** Current value of the control */
+    value: boolean;
+    /** Interaction mode: toggle (latch) or momentary */
+    mode: BooleanInteractionMode;
+    /** Callback to update the value */
+    onValueChange: (value: boolean) => void;
+    /** Whether the control is disabled */
+    disabled?: boolean;
+}
+/**
+ * Framework-agnostic controller for boolean interaction logic.
+ *
+ * Handles the logic for toggle and momentary button interactions, including:
+ * - Mouse down/up events for activation and release
+ * - Global pointer tracking (works even when press starts outside button)
+ * - Mouse enter/leave events for drag-in/drag-out behavior
+ * - Keyboard events (Enter/Space) for activation and release
+ * - Press state tracking for momentary mode
+ *
+ * **Drag-In/Drag-Out Behavior:**
+ * The controller tracks global pointer state to enable hardware-like button interactions:
+ * - **Momentary Mode**: Press inside → turns on; drag out while pressed → turns off; drag back in while pressed → turns on again. Works even when press starts outside the button.
+ * - **Toggle Mode**: Press inside → toggles state; drag out while pressed → no change; drag back in while pressed → toggles again. Works even when press starts outside the button.
+ *
+ * This enables step sequencer-like interactions where multiple buttons can be activated with a single drag gesture.
+ *
+ * This controller is designed to be framework-agnostic and can be used with any UI framework
+ * by wrapping it in framework-specific hooks (e.g., `useBooleanInteraction` for React).
+ */
+export declare class BooleanInteractionController {
+    private config;
+    private isPressed;
+    private isGlobalPointerDown;
+    constructor(config: BooleanInteractionConfig);
+    /**
+     * Updates the controller configuration.
+     *
+     * This method should be called whenever the configuration changes (e.g., value, mode, disabled state).
+     * The controller will use the new configuration for all subsequent interactions.
+     *
+     * @param {BooleanInteractionConfig} config - New configuration object
+     */
+    updateConfig(config: BooleanInteractionConfig): void;
+    /**
+     * Handles global pointer down events (mouse or touch).
+     *
+     * This tracks when a pointer is pressed anywhere on the page, not just on this button.
+     * This allows the button to respond to drag-in behavior even when the press starts outside.
+     *
+     * @param {boolean} defaultPrevented - Whether the event's default action has been prevented. If true, the handler does nothing.
+     */
+    handleGlobalPointerDown: (defaultPrevented: boolean) => void;
+    /**
+     * Handles mouse down events on the button element.
+     *
+     * Behavior depends on interaction mode:
+     * - **Toggle mode**: Flips the current value (true ↔ false)
+     * - **Momentary mode**: Sets value to true and tracks press state for later release
+     *
+     * @param {boolean} defaultPrevented - Whether the event's default action has been prevented. If true, the handler does nothing.
+     */
+    handleMouseDown: (defaultPrevented: boolean) => void;
+    /**
+     * Handles mouse up events on the button element.
+     *
+     * For momentary mode: Sets value to false if the button is currently pressed.
+     * This prevents false releases if the button wasn't actually pressed.
+     * Toggle mode: No action (toggle happens on mousedown only).
+     *
+     * Note: This is called when mouse is released on the button. The global pointer up
+     * handler will also be called to reset global state.
+     *
+     * @param {boolean} defaultPrevented - Whether the event's default action has been prevented. If true, the handler does nothing.
+     */
+    handleMouseUp: (defaultPrevented: boolean) => void;
+    /**
+     * Handles global pointer up events (mouse or touch).
+     *
+     * This method is called when a pointer up event occurs anywhere on the page.
+     * It resets the global pointer state and handles release for momentary buttons.
+     *
+     * Only affects momentary mode buttons that are currently pressed.
+     */
+    handleGlobalPointerUp: () => void;
+    /**
+     * Handles mouse enter events (pointer enters the button element).
+     *
+     * When a pointer enters the button while globally pressed:
+     * - **Momentary mode**: Sets value to true
+     * - **Toggle mode**: Toggles the value
+     *
+     * This enables drag-in behavior: pressing outside and dragging into the button activates it.
+     */
+    handleMouseEnter: () => void;
+    /**
+     * Handles mouse leave events (pointer leaves the button element).
+     *
+     * When a pointer leaves the button while globally pressed:
+     * - **Momentary mode**: Sets value to false
+     * - **Toggle mode**: No action (state remains as-is)
+     *
+     * This enables drag-out behavior: pressing inside and dragging out deactivates momentary buttons.
+     */
+    handleMouseLeave: () => void;
+    /**
+     * Handles keyboard key down events.
+     *
+     * Supported keys:
+     * - `Enter` or `Space`: Activates the button
+     *   - Toggle mode: Flips the value
+     *   - Momentary mode: Sets value to true
+     *
+     * @param {string} key - The keyboard key that was pressed
+     * @returns {boolean} `true` if the event was handled (and should be prevented), `false` otherwise
+     */
+    handleKeyDown: (key: string) => boolean;
+    /**
+     * Handles keyboard key up events.
+     *
+     * Supported keys (momentary mode only):
+     * - `Enter` or `Space`: Releases the button (sets value to false)
+     *
+     * Toggle mode: No action (toggle happens on keydown only).
+     *
+     * @param {string} key - The keyboard key that was released
+     * @returns {boolean} `true` if the event was handled (and should be prevented), `false` otherwise
+     */
+    handleKeyUp: (key: string) => boolean;
+    /**
+     * Gets the current press state (for momentary buttons).
+     *
+     * This is primarily used for internal state tracking. External code typically
+     * doesn't need to check this, as the value reflects the button state.
+     *
+     * @returns {boolean} `true` if the button is currently pressed, `false` otherwise
+     */
+    getIsPressed(): boolean;
+}
+//# sourceMappingURL=BooleanInteractionController.d.ts.map

package/dist/controller/BooleanInteractionController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BooleanInteractionController.d.ts","sourceRoot":"","sources":["../../src/controller/BooleanInteractionController.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,sBAAsB,GAAG,QAAQ,GAAG,WAAW,CAAC;AAE5D,MAAM,WAAW,wBAAwB;IACrC,mCAAmC;IACnC,KAAK,EAAE,OAAO,CAAC;IACf,oDAAoD;IACpD,IAAI,EAAE,sBAAsB,CAAC;IAC7B,mCAAmC;IACnC,aAAa,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACxC,sCAAsC;IACtC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,4BAA4B;IAIzB,OAAO,CAAC,MAAM;IAH1B,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,mBAAmB,CAAkB;gBAEzB,MAAM,EAAE,wBAAwB;IAEpD;;;;;;;OAOG;IACI,YAAY,CAAC,MAAM,EAAE,wBAAwB;IAIpD;;;;;;;OAOG;IACI,uBAAuB,GAAI,kBAAkB,OAAO,UAIzD;IAEF;;;;;;;;OAQG;IACI,eAAe,GAAI,kBAAkB,OAAO,UAcjD;IAEF;;;;;;;;;;;OAWG;IACI,aAAa,GAAI,kBAAkB,OAAO,UAW/C;IAEF;;;;;;;OAOG;IACI,qBAAqB,aAS1B;IAEF;;;;;;;;OAQG;IACI,gBAAgB,aAcrB;IAEF;;;;;;;;OAQG;IACI,gBAAgB,aAYrB;IAEF;;;;;;;;;;OAUG;IACI,aAAa,GAAI,KAAK,MAAM,KAAG,OAAO,CAc3C;IAEF;;;;;;;;;;OAUG;IACI,WAAW,GAAI,KAAK,MAAM,KAAG,OAAO,CAQzC;IAEF;;;;;;;OAOG;IACI,YAAY,IAAI,OAAO;CAGjC"}

package/dist/controller/ContinuousInteractionController.d.ts

@@ -0,0 +1,114 @@
+import { InteractionDirection, InteractionMode } from '../types';
+
+export interface ContinuousInteractionConfig {
+    /**
+     * Function to adjust the value based on a delta.
+     * ...
+     */
+    adjustValue: (delta: number, sensitivity?: number) => void;
+    /**
+     * Interaction mode: drag, wheel, or both.
+     * @default "both"
+     */
+    interactionMode?: InteractionMode;
+    /**
+     * Direction of the drag interaction.
+     * @default "both"
+     */
+    direction?: InteractionDirection;
+    /**
+     * Sensitivity of the control.
+     * ...
+     * @default 0.005
+     */
+    sensitivity?: number;
+    /**
+     * Separate sensitivity for wheel events.
+     * If not provided, defaults to DEFAULT_WHEEL_SENSITIVITY (0.005).
+     */
+    wheelSensitivity?: number;
+    /**
+     * Step size for keyboard interaction (normalized 0..1)
+     * @default 0.05
+     */
+    keyboardStep?: number;
+    /**
+     * Normalized step size of the parameter (0..1).
+     * Used for adaptive wheel interaction (accumulating deltas until a step is reached).
+     * If not provided, wheel interaction is continuous.
+     */
+    step?: number;
+    /**
+     * Callback when a drag interaction starts
+     */
+    onDragStart?: () => void;
+    /**
+     * Callback when a drag interaction ends
+     */
+    onDragEnd?: () => void;
+    /**
+     * Whether the control is disabled
+     */
+    disabled?: boolean;
+}
+/**
+ * Framework-agnostic controller for handling user interactions (Drag, Wheel, Keyboard)
+ * for continuous controls.
+ */
+export declare class ContinuousInteractionController {
+    private config;
+    private startX;
+    private startY;
+    private centerX;
+    private centerY;
+    private isDragging;
+    private wheelAccumulator;
+    private dragAccumulator;
+    constructor(config: ContinuousInteractionConfig);
+    /**
+     * Updates the configuration of the controller.
+     * @param config Partial configuration to update.
+     */
+    updateConfig(config: Partial<ContinuousInteractionConfig>): void;
+    /**
+     * Handles the start of a mouse drag interaction.
+     * Should be called from the component's onMouseDown handler.
+     * @param clientX The X coordinate of the mouse event.
+     * @param clientY The Y coordinate of the mouse event.
+     * @param target The event target (used for circular center calculation).
+     */
+    handleMouseDown: (clientX: number, clientY: number, target?: EventTarget) => void;
+    /**
+     * Handles the start of a touch interaction.
+     * Should be called from the component's onTouchStart handler.
+     * @param clientX The X coordinate of the touch event.
+     * @param clientY The Y coordinate of the touch event.
+     * @param target The event target.
+     */
+    handleTouchStart: (clientX: number, clientY: number, target?: EventTarget) => void;
+    private startDrag;
+    private handleGlobalMouseMove;
+    private handleGlobalTouchMove;
+    private processDrag;
+    /**
+     * Handles global mouse up event to end drag.
+     */
+    private handleGlobalMouseUp;
+    /**
+     * Handles wheel events.
+     * Should be called from the component's onWheel handler.
+     * @param e The wheel event.
+     */
+    handleWheel: (e: WheelEvent) => void;
+    /**
+     * Handles keyboard events (Arrow keys, Home, End).
+     * Should be called from the component's onKeyDown handler.
+     * @param e The keyboard event.
+     */
+    handleKeyDown: (e: KeyboardEvent) => void;
+    /**
+     * Cleans up event listeners.
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=ContinuousInteractionController.d.ts.map

package/dist/controller/ContinuousInteractionController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContinuousInteractionController.d.ts","sourceRoot":"","sources":["../../src/controller/ContinuousInteractionController.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAOjE,MAAM,WAAW,2BAA2B;IACxC;;;OAGG;IACH,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAE3D;;;OAGG;IACH,eAAe,CAAC,EAAE,eAAe,CAAC;IAElC;;;OAGG;IACH,SAAS,CAAC,EAAE,oBAAoB,CAAC;IAEjC;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;IAEzB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IAEvB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;GAGG;AACH,qBAAa,+BAA+B;IACxC,OAAO,CAAC,MAAM,CAOZ;IACF,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,eAAe,CAAK;gBAEhB,MAAM,EAAE,2BAA2B;IAgB/C;;;OAGG;IACI,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,2BAA2B,CAAC;IAIhE;;;;;;OAMG;IACI,eAAe,GAAI,SAAS,MAAM,EAAE,SAAS,MAAM,EAAE,SAAS,WAAW,UAG9E;IAEF;;;;;;OAMG;IACI,gBAAgB,GAAI,SAAS,MAAM,EAAE,SAAS,MAAM,EAAE,SAAS,WAAW,UAG/E;IAEF,OAAO,CAAC,SAAS;IAgCjB,OAAO,CAAC,qBAAqB;IAM7B,OAAO,CAAC,qBAAqB;IAO7B,OAAO,CAAC,WAAW;IAuDnB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAe3B;;;;OAIG;IACI,WAAW,GAAI,GAAG,UAAU,UA2BjC;IAEF;;;;OAIG;IACI,aAAa,GAAI,GAAG,aAAa,UA+BtC;IAEF;;OAEG;IACI,OAAO;CAGjB"}

package/dist/controller/DiscreteInteractionController.d.ts

@@ -0,0 +1,51 @@
+export interface DiscreteInteractionConfig {
+    /** Current value of the control */
+    value: string | number;
+    /** List of available options */
+    options: Array<{
+        value: string | number;
+    }>;
+    /** Callback to update the value */
+    onValueChange: (value: string | number) => void;
+    /** Whether the control is disabled */
+    disabled?: boolean;
+}
+/**
+ * Framework-agnostic controller for discrete interaction logic.
+ * Handles the logic for cycling and stepping through discrete options.
+ */
+export declare class DiscreteInteractionController {
+    private config;
+    constructor(config: DiscreteInteractionConfig);
+    /**
+     * Updates the configuration.
+     * @param config New configuration object.
+     */
+    updateConfig(config: DiscreteInteractionConfig): void;
+    private getCurrentIndex;
+    private setValueAtIndex;
+    /**
+     * Cycles to the next value, wrapping around to the start if needed.
+     */
+    cycleNext(): void;
+    /**
+     * Steps to the next value, clamping at the end.
+     */
+    stepNext(): void;
+    /**
+     * Steps to the previous value, clamping at the start.
+     */
+    stepPrev(): void;
+    /**
+     * Handles click events.
+     * Cycles to the next value if the event was not already prevented (e.g. by a drag).
+     * @param defaultPrevented Whether the event's default action has been prevented.
+     */
+    handleClick: (defaultPrevented: boolean) => void;
+    /**
+     * Handles keyboard events for discrete controls.
+     * Returns true if the event was handled (and thus should be prevented), false otherwise.
+     */
+    handleKeyDown: (key: string) => boolean;
+}
+//# sourceMappingURL=DiscreteInteractionController.d.ts.map

package/dist/controller/DiscreteInteractionController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DiscreteInteractionController.d.ts","sourceRoot":"","sources":["../../src/controller/DiscreteInteractionController.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,yBAAyB;IACtC,mCAAmC;IACnC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,gCAAgC;IAChC,OAAO,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3C,mCAAmC;IACnC,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,KAAK,IAAI,CAAC;IAChD,sCAAsC;IACtC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;GAGG;AACH,qBAAa,6BAA6B;IAC1B,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,yBAAyB;IAErD;;;OAGG;IACI,YAAY,CAAC,MAAM,EAAE,yBAAyB;IAIrD,OAAO,CAAC,eAAe;IAKvB,OAAO,CAAC,eAAe;IAQvB;;OAEG;IACI,SAAS;IAOhB;;OAEG;IACI,QAAQ;IAQf;;OAEG;IACI,QAAQ;IAQf;;;;OAIG;IACI,WAAW,GAAI,kBAAkB,OAAO,UAK7C;IAEF;;;OAGG;IACI,aAAa,GAAI,KAAK,MAAM,KAAG,OAAO,CAkB3C;CACL"}

package/dist/controller/NoteInteractionController.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Configuration for the NoteInteractionController.
+ */
+export interface NoteInteractionConfig {
+    /** Callback triggered when a note is pressed (on) */
+    onNoteOn: (note: number, pointerId: number | string) => void;
+    /** Callback triggered when a note is released (off) */
+    onNoteOff: (note: number, pointerId: number | string) => void;
+    /** Whether the interaction is disabled */
+    disabled?: boolean;
+}
+/**
+ * Framework-agnostic controller for keyboard/note interaction logic.
+ *
+ * Handles polyphonic glissando-style interactions:
+ * - Tracks multiple concurrent pointers (mouse, multi-touch)
+ * - Detects note changes when sliding across keys
+ * - Triggers onNoteOn/onNoteOff events
+ *
+ * This controller is designed to be used by any UI framework by providing
+ * coordinates-to-note mapping and pointer events.
+ *
+ * @example
+ * ```ts
+ * const controller = new NoteInteractionController({
+ *   onNoteOn: (note) => console.log('Note On:', note),
+ *   onNoteOff: (note) => console.log('Note Off:', note)
+ * });
+ *
+ * // On mouse/touch down
+ * controller.handlePointerDown(1, 60); // C4
+ *
+ * // On movement
+ * controller.handlePointerMove(1, 62); // D4 (triggers Note Off 60, Note On 62)
+ *
+ * // On mouse/touch up
+ * controller.handlePointerUp(1); // triggers Note Off 62
+ * ```
+ */
+export declare class NoteInteractionController {
+    private config;
+    private pointerNotes;
+    /**
+     * Creates a new NoteInteractionController.
+     * @param config Initial configuration
+     */
+    constructor(config: NoteInteractionConfig);
+    /**
+     * Updates the controller configuration.
+     * @param config New configuration object
+     */
+    updateConfig(config: NoteInteractionConfig): void;
+    /**
+     * Handles the start of a pointer interaction (down).
+     *
+     * Tracks the pointer state globally and triggers onNoteOn if the pointer
+     * is over a specific note.
+     *
+     * @param pointerId Unique identifier for the pointer
+     * @param note The MIDI note number at the pointer location, or null if none
+     */
+    handlePointerDown(pointerId: number | string, note: number | null): void;
+    /**
+     * Handles pointer movement (move).
+     *
+     * Enables glissando behavior by detecting when a tracked pointer moves
+     * from one note to another.
+     *
+     * @param pointerId Unique identifier for the pointer
+     * @param note The MIDI note number at the current pointer location, or null if none
+     */
+    handlePointerMove(pointerId: number | string, note: number | null): void;
+    /**
+     * Handles the end of a pointer interaction (up).
+     *
+     * Releases any active note associated with the pointer and removes it
+     * from the tracking map.
+     *
+     * @param pointerId Unique identifier for the pointer
+     */
+    handlePointerUp(pointerId: number | string): void;
+    /**
+     * Cancels all active pointer interactions.
+     * Useful when the component is unmounted or focus is lost.
+     */
+    cancelAll(): void;
+}
+//# sourceMappingURL=NoteInteractionController.d.ts.map

package/dist/controller/NoteInteractionController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NoteInteractionController.d.ts","sourceRoot":"","sources":["../../src/controller/NoteInteractionController.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,MAAM,WAAW,qBAAqB;IAClC,qDAAqD;IACrD,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,KAAK,IAAI,CAAC;IAC7D,uDAAuD;IACvD,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,KAAK,IAAI,CAAC;IAC9D,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,yBAAyB;IAOtB,OAAO,CAAC,MAAM;IAN1B,OAAO,CAAC,YAAY,CAAkD;IAEtE;;;OAGG;gBACiB,MAAM,EAAE,qBAAqB;IAEjD;;;OAGG;IACI,YAAY,CAAC,MAAM,EAAE,qBAAqB;IAIjD;;;;;;;;OAQG;IACI,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAcxE;;;;;;;;OAQG;IACI,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAyBxE;;;;;;;OAOG;IACI,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAUjD;;;OAGG;IACI,SAAS;CAQnB"}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+export * from './types';
+export * from './constants/styles';
+export * from './constants/theme';
+export * from './constants/themeDefaults';
+export * from './constants/cssVars';
+export * from './constants/cursors';
+export * from './constants/interaction';
+export * from './controller/ContinuousInteractionController';
+export * from './controller/DiscreteInteractionController';
+export * from './controller/BooleanInteractionController';
+export * from './controller/NoteInteractionController';
+export * from './model/AudioParameter';
+export * from './utils/math';
+export * from './utils/svg';
+export * from './utils/sizing';
+export * from './utils/colorUtils';
+export * from './utils/normalizedProps';
+export * from './utils/noteUtils';
+export * from './utils/valueFormatters';
+export * from './utils/propCompare';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAMA,cAAc,SAAS,CAAC;AACxB,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,8CAA8C,CAAC;AAC7D,cAAc,4CAA4C,CAAC;AAC3D,cAAc,2CAA2C,CAAC;AAC1D,cAAc,wCAAwC,CAAC;AACvD,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC"}