@uinstinct/svelte-wheel-picker 0.1.0 → 0.1.4

package/dist/use-controllable-state.svelte.js

@@ -1,42 +1,61 @@
-class ControllableState {
-    #internal = $state(undefined);
-    #onChange;
-    #isControlled;
-    // $state so that reactive consumers (selectedIndex $derived) re-evaluate when prop changes
-    #controlledValue = $state(undefined);
-    constructor(opts) {
-        this.#isControlled = typeof opts.onChange === 'function';
-        this.#onChange = opts.onChange;
-        this.#controlledValue = opts.value;
-        if (this.#isControlled) {
-            this.#internal = opts.value;
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ControllableState_internal, _ControllableState_onChange, _ControllableState_isControlled, _ControllableState_controlledValue;
+var ControllableState = /** @class */ (function () {
+    function ControllableState(opts) {
+        _ControllableState_internal.set(this, $state(undefined));
+        _ControllableState_onChange.set(this, void 0);
+        _ControllableState_isControlled.set(this, void 0);
+        // $state so that reactive consumers (selectedIndex $derived) re-evaluate when prop changes
+        _ControllableState_controlledValue.set(this, $state(undefined));
+        __classPrivateFieldSet(this, _ControllableState_isControlled, typeof opts.onChange === 'function', "f");
+        __classPrivateFieldSet(this, _ControllableState_onChange, opts.onChange, "f");
+        __classPrivateFieldSet(this, _ControllableState_controlledValue, opts.value, "f");
+        if (__classPrivateFieldGet(this, _ControllableState_isControlled, "f")) {
+            __classPrivateFieldSet(this, _ControllableState_internal, opts.value, "f");
         }
         else {
-            this.#internal = opts.defaultValue;
+            __classPrivateFieldSet(this, _ControllableState_internal, opts.defaultValue, "f");
         }
     }
     /**
      * Update the tracked controlled value when the external `value` prop changes.
      * Must be called from a $effect in the consuming component whenever `value` changes.
      */
-    updateControlledValue(value) {
-        this.#controlledValue = value;
-    }
-    get current() {
-        if (this.#isControlled) {
-            return this.#controlledValue;
-        }
-        return this.#internal;
-    }
-    set current(next) {
-        if (this.#isControlled) {
-            this.#onChange?.(next);
-        }
-        else {
-            this.#internal = next;
-        }
-    }
-}
+    ControllableState.prototype.updateControlledValue = function (value) {
+        __classPrivateFieldSet(this, _ControllableState_controlledValue, value, "f");
+    };
+    Object.defineProperty(ControllableState.prototype, "current", {
+        get: function () {
+            if (__classPrivateFieldGet(this, _ControllableState_isControlled, "f")) {
+                return __classPrivateFieldGet(this, _ControllableState_controlledValue, "f");
+            }
+            return __classPrivateFieldGet(this, _ControllableState_internal, "f");
+        },
+        set: function (next) {
+            var _a;
+            if (__classPrivateFieldGet(this, _ControllableState_isControlled, "f")) {
+                (_a = __classPrivateFieldGet(this, _ControllableState_onChange, "f")) === null || _a === void 0 ? void 0 : _a.call(this, next);
+            }
+            else {
+                __classPrivateFieldSet(this, _ControllableState_internal, next, "f");
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return ControllableState;
+}());
+_ControllableState_internal = new WeakMap(), _ControllableState_onChange = new WeakMap(), _ControllableState_isControlled = new WeakMap(), _ControllableState_controlledValue = new WeakMap();
 export function useControllableState(opts) {
     return new ControllableState(opts);
 }

package/dist/use-typeahead-search.svelte.js

@@ -1,59 +1,77 @@
-class TypeaheadSearch {
-    #buffer = $state('');
-    #lastKey = $state('');
-    #lastTime = 0;
-    #timer = null;
-    search(key, options, currentIndex) {
-        const now = Date.now();
-        const withinWindow = now - this.#lastTime < 500;
-        const singleChar = key.length === 1;
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _TypeaheadSearch_instances, _TypeaheadSearch_buffer, _TypeaheadSearch_lastKey, _TypeaheadSearch_lastTime, _TypeaheadSearch_timer, _TypeaheadSearch_getSearchText, _TypeaheadSearch_findFirst, _TypeaheadSearch_cycleMatch;
+var TypeaheadSearch = /** @class */ (function () {
+    function TypeaheadSearch() {
+        _TypeaheadSearch_instances.add(this);
+        _TypeaheadSearch_buffer.set(this, $state(''));
+        _TypeaheadSearch_lastKey.set(this, $state(''));
+        _TypeaheadSearch_lastTime.set(this, 0);
+        _TypeaheadSearch_timer.set(this, null);
+    }
+    TypeaheadSearch.prototype.search = function (key, options, currentIndex) {
+        var _this = this;
+        var now = Date.now();
+        var withinWindow = now - __classPrivateFieldGet(this, _TypeaheadSearch_lastTime, "f") < 500;
+        var singleChar = key.length === 1;
         if (!singleChar)
             return -1;
-        const lowerKey = key.toLowerCase();
-        const isSameKey = withinWindow && lowerKey === this.#lastKey;
-        this.#lastKey = lowerKey;
-        this.#lastTime = now;
+        var lowerKey = key.toLowerCase();
+        var isSameKey = withinWindow && lowerKey === __classPrivateFieldGet(this, _TypeaheadSearch_lastKey, "f");
+        __classPrivateFieldSet(this, _TypeaheadSearch_lastKey, lowerKey, "f");
+        __classPrivateFieldSet(this, _TypeaheadSearch_lastTime, now, "f");
         // Reset timer
-        if (this.#timer)
-            clearTimeout(this.#timer);
-        this.#timer = setTimeout(() => {
-            this.#buffer = '';
-            this.#lastKey = '';
-        }, 500);
+        if (__classPrivateFieldGet(this, _TypeaheadSearch_timer, "f"))
+            clearTimeout(__classPrivateFieldGet(this, _TypeaheadSearch_timer, "f"));
+        __classPrivateFieldSet(this, _TypeaheadSearch_timer, setTimeout(function () {
+            __classPrivateFieldSet(_this, _TypeaheadSearch_buffer, '', "f");
+            __classPrivateFieldSet(_this, _TypeaheadSearch_lastKey, '', "f");
+        }, 500), "f");
         if (isSameKey) {
             // Same key cycling (D-02): find next match after currentIndex
-            return this.#cycleMatch(lowerKey, options, currentIndex);
+            return __classPrivateFieldGet(this, _TypeaheadSearch_instances, "m", _TypeaheadSearch_cycleMatch).call(this, lowerKey, options, currentIndex);
         }
         else {
             // Accumulate or start fresh
-            this.#buffer = withinWindow ? this.#buffer + lowerKey : lowerKey;
-            return this.#findFirst(this.#buffer, options);
+            __classPrivateFieldSet(this, _TypeaheadSearch_buffer, withinWindow ? __classPrivateFieldGet(this, _TypeaheadSearch_buffer, "f") + lowerKey : lowerKey, "f");
+            return __classPrivateFieldGet(this, _TypeaheadSearch_instances, "m", _TypeaheadSearch_findFirst).call(this, __classPrivateFieldGet(this, _TypeaheadSearch_buffer, "f"), options);
         }
-    }
-    #getSearchText(option) {
-        return (option.textValue ?? option.label).toLowerCase();
-    }
-    #findFirst(prefix, options) {
-        return options.findIndex((o) => !o.disabled && this.#getSearchText(o).startsWith(prefix));
-    }
-    #cycleMatch(key, options, fromIndex) {
-        const prefix = key.toLowerCase();
-        const matches = options
-            .map((o, i) => ({ i, matches: !o.disabled && this.#getSearchText(o).startsWith(prefix) }))
-            .filter((x) => x.matches)
-            .map((x) => x.i);
-        if (matches.length === 0)
-            return -1;
-        const afterCurrent = matches.find((i) => i > fromIndex);
-        return afterCurrent ?? matches[0]; // wrap around
-    }
-    destroy() {
-        if (this.#timer) {
-            clearTimeout(this.#timer);
-            this.#timer = null;
+    };
+    TypeaheadSearch.prototype.destroy = function () {
+        if (__classPrivateFieldGet(this, _TypeaheadSearch_timer, "f")) {
+            clearTimeout(__classPrivateFieldGet(this, _TypeaheadSearch_timer, "f"));
+            __classPrivateFieldSet(this, _TypeaheadSearch_timer, null, "f");
         }
-    }
-}
+    };
+    return TypeaheadSearch;
+}());
+_TypeaheadSearch_buffer = new WeakMap(), _TypeaheadSearch_lastKey = new WeakMap(), _TypeaheadSearch_lastTime = new WeakMap(), _TypeaheadSearch_timer = new WeakMap(), _TypeaheadSearch_instances = new WeakSet(), _TypeaheadSearch_getSearchText = function _TypeaheadSearch_getSearchText(option) {
+    var _a;
+    return ((_a = option.textValue) !== null && _a !== void 0 ? _a : option.label).toLowerCase();
+}, _TypeaheadSearch_findFirst = function _TypeaheadSearch_findFirst(prefix, options) {
+    var _this = this;
+    return options.findIndex(function (o) { return !o.disabled && __classPrivateFieldGet(_this, _TypeaheadSearch_instances, "m", _TypeaheadSearch_getSearchText).call(_this, o).startsWith(prefix); });
+}, _TypeaheadSearch_cycleMatch = function _TypeaheadSearch_cycleMatch(key, options, fromIndex) {
+    var _this = this;
+    var prefix = key.toLowerCase();
+    var matches = options
+        .map(function (o, i) { return ({ i: i, matches: !o.disabled && __classPrivateFieldGet(_this, _TypeaheadSearch_instances, "m", _TypeaheadSearch_getSearchText).call(_this, o).startsWith(prefix) }); })
+        .filter(function (x) { return x.matches; })
+        .map(function (x) { return x.i; });
+    if (matches.length === 0)
+        return -1;
+    var afterCurrent = matches.find(function (i) { return i > fromIndex; });
+    return afterCurrent !== null && afterCurrent !== void 0 ? afterCurrent : matches[0]; // wrap around
+};
 export function useTypeaheadSearch() {
     return new TypeaheadSearch();
 }

package/dist/use-wheel-physics.svelte.js

@@ -10,53 +10,67 @@
  * - Boundary resistance uses RESISTANCE constant from React v1.2.2 source.
  * - Disabled options are always skipped when computing snap targets.
  */
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _WheelPhysics_instances, _WheelPhysics_itemHeight, _WheelPhysics_visibleCount, _WheelPhysics_dragSensitivity, _WheelPhysics_scrollSensitivity, _WheelPhysics_options, _WheelPhysics_onSnap, _WheelPhysics_infinite, _WheelPhysics_rafId, _WheelPhysics_isDragging, _WheelPhysics_dragStartOffset, _WheelPhysics_dragStartY, _WheelPhysics_yList, _WheelPhysics_lastWheelTime, _WheelPhysics_animating, _WheelPhysics_cancelRaf, _WheelPhysics_indexToOffset, _WheelPhysics_offsetToIndex;
 import { easeOutCubic, indexToOffset, offsetToIndex, clampIndex, wrapIndex, snapToNearestEnabled, calculateVelocity, computeSnapTarget, computeAnimationDuration, RESISTANCE, DEFAULT_DRAG_SENSITIVITY, DEFAULT_SCROLL_SENSITIVITY, DEFAULT_ITEM_HEIGHT, DEFAULT_VISIBLE_COUNT, SNAP_BACK_DECELERATION, } from './wheel-physics-utils.js';
 // Re-export for convenience so consumers only need one import
 export { DEFAULT_DRAG_SENSITIVITY, DEFAULT_SCROLL_SENSITIVITY, DEFAULT_ITEM_HEIGHT, DEFAULT_VISIBLE_COUNT, };
-export class WheelPhysics {
-    // ---------------------------------------------------------------------------
-    // Public reactive state ($state) — the ONLY field bound to the DOM transform
-    // ---------------------------------------------------------------------------
-    offset = $state(0);
-    // ---------------------------------------------------------------------------
-    // Private configuration (set in constructor, may be updated by update())
-    // ---------------------------------------------------------------------------
-    #itemHeight;
-    #visibleCount;
-    #dragSensitivity;
-    #scrollSensitivity;
-    #options;
-    #onSnap;
-    #infinite;
-    // ---------------------------------------------------------------------------
-    // Private non-reactive animation/drag state (NOT $state — Pitfall 2)
-    // ---------------------------------------------------------------------------
-    /** Current RAF handle — null when no animation running */
-    #rafId = null;
-    /** True between pointerdown and pointerup */
-    #isDragging = false;
-    /** The offset value when the current drag began */
-    #dragStartOffset = 0;
-    /** clientY at the start of the current drag (used for direct delta) */
-    #dragStartY = 0;
-    /** Recent pointer positions for velocity calculation: [clientY, timestamp][] */
-    #yList = [];
-    /** Timestamp of the last wheel event (100ms debounce guard) */
-    #lastWheelTime = -Infinity;
-    /** True while a snap or inertia animation is running */
-    #animating = false;
+var WheelPhysics = /** @class */ (function () {
     // ---------------------------------------------------------------------------
     // Constructor
     // ---------------------------------------------------------------------------
-    constructor(opts) {
-        this.#itemHeight = opts.itemHeight ?? DEFAULT_ITEM_HEIGHT;
-        this.#visibleCount = opts.visibleCount ?? DEFAULT_VISIBLE_COUNT;
-        this.#dragSensitivity = opts.dragSensitivity ?? DEFAULT_DRAG_SENSITIVITY;
-        this.#scrollSensitivity = opts.scrollSensitivity ?? DEFAULT_SCROLL_SENSITIVITY;
-        this.#infinite = opts.infinite ?? false;
-        this.#options = opts.options;
-        this.#onSnap = opts.onSnap;
-        this.offset = this.#indexToOffset(opts.initialIndex);
+    function WheelPhysics(opts) {
+        var _a, _b, _c, _d, _e;
+        _WheelPhysics_instances.add(this);
+        // ---------------------------------------------------------------------------
+        // Public reactive state ($state) — the ONLY field bound to the DOM transform
+        // ---------------------------------------------------------------------------
+        this.offset = $state(0);
+        // ---------------------------------------------------------------------------
+        // Private configuration (set in constructor, may be updated by update())
+        // ---------------------------------------------------------------------------
+        _WheelPhysics_itemHeight.set(this, void 0);
+        _WheelPhysics_visibleCount.set(this, void 0);
+        _WheelPhysics_dragSensitivity.set(this, void 0);
+        _WheelPhysics_scrollSensitivity.set(this, void 0);
+        _WheelPhysics_options.set(this, void 0);
+        _WheelPhysics_onSnap.set(this, void 0);
+        _WheelPhysics_infinite.set(this, void 0);
+        // ---------------------------------------------------------------------------
+        // Private non-reactive animation/drag state (NOT $state — Pitfall 2)
+        // ---------------------------------------------------------------------------
+        /** Current RAF handle — null when no animation running */
+        _WheelPhysics_rafId.set(this, null);
+        /** True between pointerdown and pointerup */
+        _WheelPhysics_isDragging.set(this, false);
+        /** The offset value when the current drag began */
+        _WheelPhysics_dragStartOffset.set(this, 0);
+        /** clientY at the start of the current drag (used for direct delta) */
+        _WheelPhysics_dragStartY.set(this, 0);
+        /** Recent pointer positions for velocity calculation: [clientY, timestamp][] */
+        _WheelPhysics_yList.set(this, []);
+        /** Timestamp of the last wheel event (100ms debounce guard) */
+        _WheelPhysics_lastWheelTime.set(this, -Infinity);
+        /** True while a snap or inertia animation is running */
+        _WheelPhysics_animating.set(this, false);
+        __classPrivateFieldSet(this, _WheelPhysics_itemHeight, (_a = opts.itemHeight) !== null && _a !== void 0 ? _a : DEFAULT_ITEM_HEIGHT, "f");
+        __classPrivateFieldSet(this, _WheelPhysics_visibleCount, (_b = opts.visibleCount) !== null && _b !== void 0 ? _b : DEFAULT_VISIBLE_COUNT, "f");
+        __classPrivateFieldSet(this, _WheelPhysics_dragSensitivity, (_c = opts.dragSensitivity) !== null && _c !== void 0 ? _c : DEFAULT_DRAG_SENSITIVITY, "f");
+        __classPrivateFieldSet(this, _WheelPhysics_scrollSensitivity, (_d = opts.scrollSensitivity) !== null && _d !== void 0 ? _d : DEFAULT_SCROLL_SENSITIVITY, "f");
+        __classPrivateFieldSet(this, _WheelPhysics_infinite, (_e = opts.infinite) !== null && _e !== void 0 ? _e : false, "f");
+        __classPrivateFieldSet(this, _WheelPhysics_options, opts.options, "f");
+        __classPrivateFieldSet(this, _WheelPhysics_onSnap, opts.onSnap, "f");
+        this.offset = __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_indexToOffset).call(this, opts.initialIndex);
     }
     // ---------------------------------------------------------------------------
     // Configuration update (called when props change in parent component)
@@ -65,47 +79,47 @@ export class WheelPhysics {
      * Update configuration when parent props change.
      * This does NOT re-trigger animation — it takes effect on the next interaction.
      */
-    update(opts) {
+    WheelPhysics.prototype.update = function (opts) {
         if (opts.itemHeight !== undefined)
-            this.#itemHeight = opts.itemHeight;
+            __classPrivateFieldSet(this, _WheelPhysics_itemHeight, opts.itemHeight, "f");
         if (opts.visibleCount !== undefined)
-            this.#visibleCount = opts.visibleCount;
+            __classPrivateFieldSet(this, _WheelPhysics_visibleCount, opts.visibleCount, "f");
         if (opts.dragSensitivity !== undefined)
-            this.#dragSensitivity = opts.dragSensitivity;
+            __classPrivateFieldSet(this, _WheelPhysics_dragSensitivity, opts.dragSensitivity, "f");
         if (opts.scrollSensitivity !== undefined)
-            this.#scrollSensitivity = opts.scrollSensitivity;
+            __classPrivateFieldSet(this, _WheelPhysics_scrollSensitivity, opts.scrollSensitivity, "f");
         if (opts.infinite !== undefined)
-            this.#infinite = opts.infinite;
+            __classPrivateFieldSet(this, _WheelPhysics_infinite, opts.infinite, "f");
         if (opts.options !== undefined)
-            this.#options = opts.options;
+            __classPrivateFieldSet(this, _WheelPhysics_options, opts.options, "f");
         if (opts.onSnap !== undefined)
-            this.#onSnap = opts.onSnap;
-    }
+            __classPrivateFieldSet(this, _WheelPhysics_onSnap, opts.onSnap, "f");
+    };
     // ---------------------------------------------------------------------------
     // Drag handlers (pointer events)
     // ---------------------------------------------------------------------------
     /**
      * Called on pointerdown. Cancels any running animation and begins tracking.
      */
-    startDrag(clientY) {
-        this.#cancelRaf();
-        this.#isDragging = true;
-        this.#animating = false;
-        this.#dragStartOffset = this.offset;
-        this.#dragStartY = clientY;
-        this.#yList = [[clientY, performance.now()]];
-    }
+    WheelPhysics.prototype.startDrag = function (clientY) {
+        __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_cancelRaf).call(this);
+        __classPrivateFieldSet(this, _WheelPhysics_isDragging, true, "f");
+        __classPrivateFieldSet(this, _WheelPhysics_animating, false, "f");
+        __classPrivateFieldSet(this, _WheelPhysics_dragStartOffset, this.offset, "f");
+        __classPrivateFieldSet(this, _WheelPhysics_dragStartY, clientY, "f");
+        __classPrivateFieldSet(this, _WheelPhysics_yList, [[clientY, performance.now()]], "f");
+    };
     /**
      * Called on pointermove. Updates offset applying boundary resistance at ends.
      */
-    moveDrag(clientY) {
-        if (!this.#isDragging)
+    WheelPhysics.prototype.moveDrag = function (clientY) {
+        if (!__classPrivateFieldGet(this, _WheelPhysics_isDragging, "f"))
             return;
-        const delta = clientY - this.#dragStartY;
-        const maxOffset = this.#indexToOffset(0);
-        const minOffset = this.#indexToOffset(this.#options.length - 1);
-        let newOffset = this.#dragStartOffset + delta;
-        if (this.#infinite) {
+        var delta = clientY - __classPrivateFieldGet(this, _WheelPhysics_dragStartY, "f");
+        var maxOffset = __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_indexToOffset).call(this, 0);
+        var minOffset = __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_indexToOffset).call(this, __classPrivateFieldGet(this, _WheelPhysics_options, "f").length - 1);
+        var newOffset = __classPrivateFieldGet(this, _WheelPhysics_dragStartOffset, "f") + delta;
+        if (__classPrivateFieldGet(this, _WheelPhysics_infinite, "f")) {
             // Infinite mode: normalize offset when the drag exceeds the ghost item bounds.
             // The DOM has 3×N items (before-ghosts + real + after-ghosts), covering rawIndex
             // -N..2N-1. When the pointer is captured outside the container, the user can drag
@@ -114,18 +128,18 @@ export class WheelPhysics {
             //
             // Applying the same shift to #dragStartOffset keeps future delta computations
             // consistent so the drag feels continuous across the normalization boundary.
-            const loopDistance = this.#options.length * this.#itemHeight;
+            var loopDistance = __classPrivateFieldGet(this, _WheelPhysics_options, "f").length * __classPrivateFieldGet(this, _WheelPhysics_itemHeight, "f");
             // After-ghost overflow: newOffset went past the last after-ghost (rawIndex >= 2N)
-            const afterGhostEnd = this.#indexToOffset(2 * this.#options.length);
+            var afterGhostEnd = __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_indexToOffset).call(this, 2 * __classPrivateFieldGet(this, _WheelPhysics_options, "f").length);
             // Before-ghost overflow: newOffset went past the first before-ghost (rawIndex < -N)
-            const beforeGhostEnd = this.#indexToOffset(-this.#options.length - 1);
+            var beforeGhostEnd = __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_indexToOffset).call(this, -__classPrivateFieldGet(this, _WheelPhysics_options, "f").length - 1);
             while (newOffset < afterGhostEnd) {
                 newOffset += loopDistance;
-                this.#dragStartOffset += loopDistance;
+                __classPrivateFieldSet(this, _WheelPhysics_dragStartOffset, __classPrivateFieldGet(this, _WheelPhysics_dragStartOffset, "f") + loopDistance, "f");
             }
             while (newOffset > beforeGhostEnd) {
                 newOffset -= loopDistance;
-                this.#dragStartOffset -= loopDistance;
+                __classPrivateFieldSet(this, _WheelPhysics_dragStartOffset, __classPrivateFieldGet(this, _WheelPhysics_dragStartOffset, "f") - loopDistance, "f");
             }
         }
         else {
@@ -139,31 +153,31 @@ export class WheelPhysics {
         }
         this.offset = newOffset;
         // Track last 5 pointer positions for velocity calculation
-        this.#yList.push([clientY, performance.now()]);
-        if (this.#yList.length > 5) {
-            this.#yList.shift();
+        __classPrivateFieldGet(this, _WheelPhysics_yList, "f").push([clientY, performance.now()]);
+        if (__classPrivateFieldGet(this, _WheelPhysics_yList, "f").length > 5) {
+            __classPrivateFieldGet(this, _WheelPhysics_yList, "f").shift();
         }
-    }
+    };
     /**
      * Called on pointerup. Computes velocity and kicks off inertia or direct snap.
      */
-    endDrag() {
-        console.log('[endDrag] called, isDragging=', this.#isDragging, 'offset=', this.offset);
-        if (!this.#isDragging)
+    WheelPhysics.prototype.endDrag = function () {
+        console.log('[endDrag] called, isDragging=', __classPrivateFieldGet(this, _WheelPhysics_isDragging, "f"), 'offset=', this.offset);
+        if (!__classPrivateFieldGet(this, _WheelPhysics_isDragging, "f"))
             return;
-        this.#isDragging = false;
-        const velocity = calculateVelocity(this.#yList, this.#itemHeight);
-        const rawIndex = this.#offsetToIndex(this.offset);
-        const N = this.#options.length;
-        const currentIndex = this.#infinite
+        __classPrivateFieldSet(this, _WheelPhysics_isDragging, false, "f");
+        var velocity = calculateVelocity(__classPrivateFieldGet(this, _WheelPhysics_yList, "f"), __classPrivateFieldGet(this, _WheelPhysics_itemHeight, "f"));
+        var rawIndex = __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_offsetToIndex).call(this, this.offset);
+        var N = __classPrivateFieldGet(this, _WheelPhysics_options, "f").length;
+        var currentIndex = __classPrivateFieldGet(this, _WheelPhysics_infinite, "f")
             ? wrapIndex(rawIndex, N)
             : clampIndex(rawIndex, N);
-        console.log('[endDrag] velocity=', velocity, 'rawIndex=', rawIndex, 'currentIndex=', currentIndex, 'infinite=', this.#infinite);
+        console.log('[endDrag] velocity=', velocity, 'rawIndex=', rawIndex, 'currentIndex=', currentIndex, 'infinite=', __classPrivateFieldGet(this, _WheelPhysics_infinite, "f"));
         if (Math.abs(velocity) < 0.5) {
             // Slow release — snap directly to nearest enabled option
-            const snapIndex = snapToNearestEnabled(currentIndex, this.#options);
+            var snapIndex = snapToNearestEnabled(currentIndex, __classPrivateFieldGet(this, _WheelPhysics_options, "f"));
             console.log('[endDrag] slow path, snapIndex=', snapIndex);
-            if (this.#infinite) {
+            if (__classPrivateFieldGet(this, _WheelPhysics_infinite, "f")) {
                 // Preserve ghost-section context so the snap animation continues in the
                 // same direction as the drag rather than jumping backward to real-section.
                 // rawIndex is in [-N, 2N-1] (guaranteed by moveDrag normalization).
@@ -171,7 +185,7 @@ export class WheelPhysics {
                 //   before-ghost (rawIndex < 0): animate to snapIndex - N
                 //   after-ghost  (rawIndex >= N): animate to snapIndex + N
                 //   real section (rawIndex in [0, N-1]): animate to snapIndex directly
-                const loopOffset = rawIndex < 0 ? -N : rawIndex >= N ? N : 0;
+                var loopOffset = rawIndex < 0 ? -N : rawIndex >= N ? N : 0;
                 this.animateTo(snapIndex + loopOffset);
             }
             else {
@@ -182,25 +196,25 @@ export class WheelPhysics {
             // Inertia — compute overshoot target
             // Use rawIndex (not currentIndex) so the overshoot accounts for the current
             // ghost-loop position, giving the correct item index after inertia deceleration.
-            const rawTarget = computeSnapTarget(rawIndex, velocity, this.#dragSensitivity);
-            if (this.#infinite) {
+            var rawTarget = computeSnapTarget(rawIndex, velocity, __classPrivateFieldGet(this, _WheelPhysics_dragSensitivity, "f"));
+            if (__classPrivateFieldGet(this, _WheelPhysics_infinite, "f")) {
                 // snapIndex is the nearest enabled item to the overshoot target (in [0, N-1])
-                const wrapped = wrapIndex(rawTarget, N);
-                const snapIndex = snapToNearestEnabled(wrapped, this.#options);
+                var wrapped = wrapIndex(rawTarget, N);
+                var snapIndex = snapToNearestEnabled(wrapped, __classPrivateFieldGet(this, _WheelPhysics_options, "f"));
                 // Animate to the ghost-section position of snapIndex matching the current
                 // loop, so the animation moves in the same direction as the drag.
                 // snapIndex is in [0,N-1]; loopOffset is -N, 0, or +N based on current section.
-                const loopOffset = rawIndex < 0 ? -N : rawIndex >= N ? N : 0;
+                var loopOffset = rawIndex < 0 ? -N : rawIndex >= N ? N : 0;
                 console.log('[endDrag] inertia path, rawTarget=', rawTarget, 'wrapped=', wrapped, 'snapIndex=', snapIndex, 'loopOffset=', loopOffset);
                 this.animateTo(snapIndex + loopOffset);
             }
             else {
-                const clamped = clampIndex(rawTarget, N);
-                const snapIndex = snapToNearestEnabled(clamped, this.#options);
+                var clamped = clampIndex(rawTarget, N);
+                var snapIndex = snapToNearestEnabled(clamped, __classPrivateFieldGet(this, _WheelPhysics_options, "f"));
                 this.animateTo(snapIndex);
             }
         }
-    }
+    };
     // ---------------------------------------------------------------------------
     // Wheel event handler
     // ---------------------------------------------------------------------------
@@ -210,29 +224,29 @@ export class WheelPhysics {
      * deltaY > 0: scroll down → move to next item (higher index)
      * deltaY < 0: scroll up → move to previous item (lower index)
      */
-    handleWheel(deltaY) {
-        const now = performance.now();
-        if (now - this.#lastWheelTime < 100)
+    WheelPhysics.prototype.handleWheel = function (deltaY) {
+        var now = performance.now();
+        if (now - __classPrivateFieldGet(this, _WheelPhysics_lastWheelTime, "f") < 100)
             return;
-        this.#lastWheelTime = now;
-        const rawIndex = this.#offsetToIndex(this.offset);
-        const currentIndex = this.#infinite
-            ? wrapIndex(rawIndex, this.#options.length)
-            : clampIndex(rawIndex, this.#options.length);
+        __classPrivateFieldSet(this, _WheelPhysics_lastWheelTime, now, "f");
+        var rawIndex = __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_offsetToIndex).call(this, this.offset);
+        var currentIndex = __classPrivateFieldGet(this, _WheelPhysics_infinite, "f")
+            ? wrapIndex(rawIndex, __classPrivateFieldGet(this, _WheelPhysics_options, "f").length)
+            : clampIndex(rawIndex, __classPrivateFieldGet(this, _WheelPhysics_options, "f").length);
         // deltaY > 0 = scroll down = move to next item (increment index)
-        const direction = deltaY > 0 ? 1 : -1;
-        if (this.#infinite) {
-            const next = currentIndex + direction;
-            const wrapped = wrapIndex(next, this.#options.length);
-            const snapIndex = snapToNearestEnabled(wrapped, this.#options);
+        var direction = deltaY > 0 ? 1 : -1;
+        if (__classPrivateFieldGet(this, _WheelPhysics_infinite, "f")) {
+            var next = currentIndex + direction;
+            var wrapped = wrapIndex(next, __classPrivateFieldGet(this, _WheelPhysics_options, "f").length);
+            var snapIndex = snapToNearestEnabled(wrapped, __classPrivateFieldGet(this, _WheelPhysics_options, "f"));
             this.animateTo(snapIndex);
         }
         else {
-            const targetIndex = clampIndex(currentIndex + direction, this.#options.length);
-            const snapIndex = snapToNearestEnabled(targetIndex, this.#options);
+            var targetIndex = clampIndex(currentIndex + direction, __classPrivateFieldGet(this, _WheelPhysics_options, "f").length);
+            var snapIndex = snapToNearestEnabled(targetIndex, __classPrivateFieldGet(this, _WheelPhysics_options, "f"));
             this.animateTo(snapIndex);
         }
-    }
+    };
     // ---------------------------------------------------------------------------
     // Animation
     // ---------------------------------------------------------------------------
@@ -242,96 +256,86 @@ export class WheelPhysics {
      *
      * Cancels any currently running animation before starting.
      */
-    animateTo(targetIndex) {
+    WheelPhysics.prototype.animateTo = function (targetIndex) {
+        var _this = this;
         console.log('[animateTo] targetIndex=', targetIndex, 'from offset=', this.offset);
-        this.#cancelRaf();
-        this.#animating = true;
-        const startOffset = this.offset;
-        const targetOffset = this.#indexToOffset(targetIndex);
-        const distance = Math.abs(targetIndex - this.#offsetToIndex(startOffset));
-        const durationSec = computeAnimationDuration(distance, this.#scrollSensitivity);
-        const durationMs = durationSec * 1000;
-        const startTime = performance.now();
-        const tick = (now) => {
-            if (!this.#animating)
+        __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_cancelRaf).call(this);
+        __classPrivateFieldSet(this, _WheelPhysics_animating, true, "f");
+        var startOffset = this.offset;
+        var targetOffset = __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_indexToOffset).call(this, targetIndex);
+        var distance = Math.abs(targetIndex - __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_offsetToIndex).call(this, startOffset));
+        var durationSec = computeAnimationDuration(distance, __classPrivateFieldGet(this, _WheelPhysics_scrollSensitivity, "f"));
+        var durationMs = durationSec * 1000;
+        var startTime = performance.now();
+        var tick = function (now) {
+            if (!__classPrivateFieldGet(_this, _WheelPhysics_animating, "f"))
                 return;
-            const elapsed = now - startTime;
-            const progress = Math.min(elapsed / durationMs, 1);
-            const eased = easeOutCubic(progress);
-            this.offset = startOffset + (targetOffset - startOffset) * eased;
+            var elapsed = now - startTime;
+            var progress = Math.min(elapsed / durationMs, 1);
+            var eased = easeOutCubic(progress);
+            _this.offset = startOffset + (targetOffset - startOffset) * eased;
             if (progress < 1) {
-                this.#rafId = requestAnimationFrame(tick);
+                __classPrivateFieldSet(_this, _WheelPhysics_rafId, requestAnimationFrame(tick), "f");
             }
             else {
                 // Snap to exact target to avoid float accumulation
-                this.offset = targetOffset;
-                this.#rafId = null;
-                this.#animating = false;
-                this.#onSnap(targetIndex);
+                _this.offset = targetOffset;
+                __classPrivateFieldSet(_this, _WheelPhysics_rafId, null, "f");
+                __classPrivateFieldSet(_this, _WheelPhysics_animating, false, "f");
+                __classPrivateFieldGet(_this, _WheelPhysics_onSnap, "f").call(_this, targetIndex);
             }
         };
-        this.#rafId = requestAnimationFrame(tick);
-    }
-    /**
-     * Returns the option index that the current offset visually corresponds to.
-     * Used to guard against redundant animations when the wheel is already positioned correctly.
-     */
-    get currentIndex() {
-        const raw = this.#offsetToIndex(this.offset);
-        return this.#infinite
-            ? wrapIndex(raw, this.#options.length)
-            : clampIndex(raw, this.#options.length);
-    }
+        __classPrivateFieldSet(this, _WheelPhysics_rafId, requestAnimationFrame(tick), "f");
+    };
+    Object.defineProperty(WheelPhysics.prototype, "currentIndex", {
+        /**
+         * Returns the option index that the current offset visually corresponds to.
+         * Used to guard against redundant animations when the wheel is already positioned correctly.
+         */
+        get: function () {
+            var raw = __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_offsetToIndex).call(this, this.offset);
+            return __classPrivateFieldGet(this, _WheelPhysics_infinite, "f")
+                ? wrapIndex(raw, __classPrivateFieldGet(this, _WheelPhysics_options, "f").length)
+                : clampIndex(raw, __classPrivateFieldGet(this, _WheelPhysics_options, "f").length);
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
      * Immediately sets the offset to the position for the given index, no animation.
      * Used for initial render and controlled value updates.
      */
-    jumpTo(index) {
-        this.#cancelRaf();
-        this.offset = this.#indexToOffset(index);
-    }
+    WheelPhysics.prototype.jumpTo = function (index) {
+        __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_cancelRaf).call(this);
+        this.offset = __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_indexToOffset).call(this, index);
+    };
     /**
      * Cancels any in-progress animation.
      */
-    cancelAnimation() {
-        this.#cancelRaf();
-    }
+    WheelPhysics.prototype.cancelAnimation = function () {
+        __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_cancelRaf).call(this);
+    };
     /**
      * Cleans up RAF on component destroy.
      */
-    destroy() {
+    WheelPhysics.prototype.destroy = function () {
         this.cancelAnimation();
+    };
+    return WheelPhysics;
+}());
+export { WheelPhysics };
+_WheelPhysics_itemHeight = new WeakMap(), _WheelPhysics_visibleCount = new WeakMap(), _WheelPhysics_dragSensitivity = new WeakMap(), _WheelPhysics_scrollSensitivity = new WeakMap(), _WheelPhysics_options = new WeakMap(), _WheelPhysics_onSnap = new WeakMap(), _WheelPhysics_infinite = new WeakMap(), _WheelPhysics_rafId = new WeakMap(), _WheelPhysics_isDragging = new WeakMap(), _WheelPhysics_dragStartOffset = new WeakMap(), _WheelPhysics_dragStartY = new WeakMap(), _WheelPhysics_yList = new WeakMap(), _WheelPhysics_lastWheelTime = new WeakMap(), _WheelPhysics_animating = new WeakMap(), _WheelPhysics_instances = new WeakSet(), _WheelPhysics_cancelRaf = function _WheelPhysics_cancelRaf() {
+    if (__classPrivateFieldGet(this, _WheelPhysics_rafId, "f") !== null) {
+        cancelAnimationFrame(__classPrivateFieldGet(this, _WheelPhysics_rafId, "f"));
+        __classPrivateFieldSet(this, _WheelPhysics_rafId, null, "f");
     }
-    // ---------------------------------------------------------------------------
-    // Private helpers
-    // ---------------------------------------------------------------------------
-    #cancelRaf() {
-        if (this.#rafId !== null) {
-            cancelAnimationFrame(this.#rafId);
-            this.#rafId = null;
-        }
-        this.#animating = false;
-    }
-    /**
-     * Converts an option index to a translateY offset, accounting for before-ghost
-     * rows prepended to the DOM container in infinite mode.
-     *
-     * In infinite mode the container begins with N = options.length ghost rows, so
-     * real item[i] sits at DOM position (N + i) * itemHeight. The offset must be
-     * shifted by -N * itemHeight relative to the non-infinite formula.
-     */
-    #indexToOffset(index) {
-        const ghostCount = this.#infinite ? this.#options.length : 0;
-        return indexToOffset(index + ghostCount, this.#itemHeight, this.#visibleCount);
-    }
-    /**
-     * Converts a translateY offset back to an option index, accounting for the
-     * before-ghost prefix in infinite mode (inverse of #indexToOffset).
-     */
-    #offsetToIndex(offset) {
-        const ghostCount = this.#infinite ? this.#options.length : 0;
-        return offsetToIndex(offset, this.#itemHeight, this.#visibleCount) - ghostCount;
-    }
-}
+    __classPrivateFieldSet(this, _WheelPhysics_animating, false, "f");
+}, _WheelPhysics_indexToOffset = function _WheelPhysics_indexToOffset(index) {
+    var ghostCount = __classPrivateFieldGet(this, _WheelPhysics_infinite, "f") ? __classPrivateFieldGet(this, _WheelPhysics_options, "f").length : 0;
+    return indexToOffset(index + ghostCount, __classPrivateFieldGet(this, _WheelPhysics_itemHeight, "f"), __classPrivateFieldGet(this, _WheelPhysics_visibleCount, "f"));
+}, _WheelPhysics_offsetToIndex = function _WheelPhysics_offsetToIndex(offset) {
+    var ghostCount = __classPrivateFieldGet(this, _WheelPhysics_infinite, "f") ? __classPrivateFieldGet(this, _WheelPhysics_options, "f").length : 0;
+    return offsetToIndex(offset, __classPrivateFieldGet(this, _WheelPhysics_itemHeight, "f"), __classPrivateFieldGet(this, _WheelPhysics_visibleCount, "f")) - ghostCount;
+};
 // Unused export to prevent unused import warnings
 void SNAP_BACK_DECELERATION;

package/dist/wheel-physics-utils.js

@@ -11,21 +11,21 @@
 // Physics constants (from React source v1.2.2)
 // ---------------------------------------------------------------------------
 /** Boundary resistance factor — how much drag is applied when pulling past the ends. */
-export const RESISTANCE = 0.3;
+export var RESISTANCE = 0.3;
 /** Maximum scroll velocity in items/second. */
-export const MAX_VELOCITY = 30;
+export var MAX_VELOCITY = 30;
 /** Default drag sensitivity (pointer drag delta multiplier for inertia). */
-export const DEFAULT_DRAG_SENSITIVITY = 3;
+export var DEFAULT_DRAG_SENSITIVITY = 3;
 /** Default scroll sensitivity (wheel event multiplier for snap animation duration). */
-export const DEFAULT_SCROLL_SENSITIVITY = 5;
+export var DEFAULT_SCROLL_SENSITIVITY = 5;
 /** Default height in pixels of each option row. */
-export const DEFAULT_ITEM_HEIGHT = 30;
+export var DEFAULT_ITEM_HEIGHT = 30;
 /** Default number of visible option rows. */
-export const DEFAULT_VISIBLE_COUNT = 5;
+export var DEFAULT_VISIBLE_COUNT = 5;
 /** Deceleration constant used in snap-back calculations. */
-export const SNAP_BACK_DECELERATION = 10;
+export var SNAP_BACK_DECELERATION = 10;
 /** Minimum scaleY for cylindrical mode to prevent items collapsing to zero height. */
-export const MIN_CYLINDRICAL_SCALE = 0.1;
+export var MIN_CYLINDRICAL_SCALE = 0.1;
 // ---------------------------------------------------------------------------
 // Pure physics functions
 // ---------------------------------------------------------------------------
@@ -99,17 +99,18 @@ export function wrapIndex(index, optionsLength) {
  * @returns The nearest enabled index
  */
 export function snapToNearestEnabled(targetIndex, options) {
-    if (!options[targetIndex]?.disabled) {
+    var _a, _b, _c;
+    if (!((_a = options[targetIndex]) === null || _a === void 0 ? void 0 : _a.disabled)) {
         return targetIndex;
     }
     // Walk outward from targetIndex to find the nearest enabled option
-    for (let delta = 1; delta < options.length; delta++) {
-        const lower = targetIndex - delta;
-        const upper = targetIndex + delta;
-        if (lower >= 0 && !options[lower]?.disabled) {
+    for (var delta = 1; delta < options.length; delta++) {
+        var lower = targetIndex - delta;
+        var upper = targetIndex + delta;
+        if (lower >= 0 && !((_b = options[lower]) === null || _b === void 0 ? void 0 : _b.disabled)) {
             return lower;
         }
-        if (upper < options.length && !options[upper]?.disabled) {
+        if (upper < options.length && !((_c = options[upper]) === null || _c === void 0 ? void 0 : _c.disabled)) {
             return upper;
         }
     }
@@ -130,13 +131,13 @@ export function calculateVelocity(yList, itemHeight) {
     if (yList.length < 2) {
         return 0;
     }
-    const [y1, t1] = yList[yList.length - 2];
-    const [y2, t2] = yList[yList.length - 1];
+    var _a = yList[yList.length - 2], y1 = _a[0], t1 = _a[1];
+    var _b = yList[yList.length - 1], y2 = _b[0], t2 = _b[1];
     if (t2 === t1) {
         return 0;
     }
-    const velocity = ((y2 - y1) / itemHeight) * (1000 / (t2 - t1));
-    const clamped = Math.max(-MAX_VELOCITY, Math.min(MAX_VELOCITY, velocity));
+    var velocity = ((y2 - y1) / itemHeight) * (1000 / (t2 - t1));
+    var clamped = Math.max(-MAX_VELOCITY, Math.min(MAX_VELOCITY, velocity));
     return clamped;
 }
 /**
@@ -152,11 +153,11 @@ export function calculateVelocity(yList, itemHeight) {
  * @returns The rounded target index after inertia overshoot
  */
 export function computeSnapTarget(currentIndexFromOffset, velocity, dragSensitivity) {
-    const baseDeceleration = dragSensitivity * 10;
-    const overshoot = (0.5 * velocity * velocity) / baseDeceleration;
+    var baseDeceleration = dragSensitivity * 10;
+    var overshoot = (0.5 * velocity * velocity) / baseDeceleration;
     // Velocity sign is inverted relative to index direction:
     // drag down (positive velocity) increases offset → decreases index → overshoot toward lower index.
-    const rawTarget = currentIndexFromOffset - Math.sign(velocity) * overshoot;
+    var rawTarget = currentIndexFromOffset - Math.sign(velocity) * overshoot;
     return Math.round(rawTarget);
 }
 /**
@@ -170,7 +171,7 @@ export function computeSnapTarget(currentIndexFromOffset, velocity, dragSensitiv
  * @returns Animation duration in seconds
  */
 export function computeAnimationDuration(distance, scrollSensitivity) {
-    const raw = Math.sqrt(Math.abs(distance) / scrollSensitivity);
+    var raw = Math.sqrt(Math.abs(distance) / scrollSensitivity);
     return Math.max(0.1, Math.min(0.6, raw));
 }
 /**
@@ -192,7 +193,7 @@ export function computeAnimationDuration(distance, scrollSensitivity) {
  * @returns scaleY in range [MIN_CYLINDRICAL_SCALE, 1.0]
  */
 export function cylindricalScaleY(slotIndex, offset, itemHeight, visibleCount) {
-    const dist = slotIndex + offset / itemHeight - Math.floor(visibleCount / 2);
-    const angle = (dist * Math.PI) / visibleCount;
+    var dist = slotIndex + offset / itemHeight - Math.floor(visibleCount / 2);
+    var angle = (dist * Math.PI) / visibleCount;
     return Math.max(MIN_CYLINDRICAL_SCALE, Math.cos(angle));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uinstinct/svelte-wheel-picker",
-  "version": "0.1.0",
+  "version": "0.1.4",
   "type": "module",
   "description": "iOS-style wheel picker for Svelte 5 with inertia scrolling, infinite loop, and keyboard navigation",
   "license": "MIT",
@@ -25,17 +25,6 @@
   "peerDependencies": {
     "svelte": "^5.0.0"
   },
-  "scripts": {
-    "dev": "vite dev",
-    "build": "vite build",
-    "package": "svelte-package && rm -rf dist/__tests__ && rm -f dist/*.test.js dist/*.test.d.ts && publint",
-    "prepack": "npm run package",
-    "test": "PLAYWRIGHT_BROWSERS_PATH=.playwright vitest run",
-    "test:watch": "PLAYWRIGHT_BROWSERS_PATH=.playwright vitest",
-    "lint": "eslint .",
-    "format": "prettier --write .",
-    "registry:build": "shadcn-svelte registry build"
-  },
   "devDependencies": {
     "@eslint/js": "10.0.1",
     "@sveltejs/adapter-vercel": "^6.3.3",
@@ -57,5 +46,15 @@
     "vite": "8.0.1",
     "vitest": "4.1.0",
     "vitest-browser-svelte": "2.1.0"
+  },
+  "scripts": {
+    "dev": "vite dev",
+    "build": "vite build",
+    "package": "svelte-package && rm -rf dist/__tests__ && rm -f dist/*.test.js dist/*.test.d.ts && publint",
+    "test": "PLAYWRIGHT_BROWSERS_PATH=.playwright vitest run",
+    "test:watch": "PLAYWRIGHT_BROWSERS_PATH=.playwright vitest",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "registry:build": "shadcn-svelte registry build"
   }
-}
+}