@tremolo-ui/react 0.0.1 → 0.0.2

package/dist/cjs/index.js

@@ -1,65 +1,63 @@
 'use strict';
 
+var math = require('common/math');
 var jsxRuntime = require('@emotion/react/jsx-runtime');
-var react$1 = require('@emotion/react');
-var react = require('react');
+var react = require('@emotion/react');
+var React = require('react');
+var type = require('common/components/Slider/type');
+var util = require('common/util');
 
-function clamp(value, min, max) {
-    return Math.max(min, Math.min(value, max));
-}
-function normalizeValue(rawValue, min, max, skew = 1) {
-    if (min >= max)
-        throw new RangeError('requirements: min < max');
-    const v = clamp((rawValue - min) / (max - min), 0, 1);
-    return Math.pow(v, skew);
-}
-function rawValue(normalizedValue, min, max, skew = 1) {
-    if (min >= max)
-        throw new RangeError('requirements: min < max');
-    const v = skew == 1
-        ? clamp(normalizedValue, 0, 1)
-        : Math.exp(Math.log(clamp(normalizedValue, 0, 1)) / skew);
-    return min + v * (max - min);
-}
-function skewWithCenterValue(centerValue, min, max) {
-    if (!(min <= centerValue && centerValue <= max))
-        throw new RangeError('requirements: min <= centerValue <= max');
-    return Math.log(0.5) / Math.log((centerValue - min) / (max - min));
-}
-function stepValue(value, step) {
-    var _a;
-    if (step <= 0)
-        throw new RangeError('requirements: step > 0');
-    const quotient = Math.floor(value / step);
-    const decimalDigits = (_a = decimalPart(step)) === null || _a === void 0 ? void 0 : _a.length;
-    const v = toFixed(quotient * step, decimalDigits);
-    const next = toFixed((quotient + 1) * step, decimalDigits);
-    return Math.abs(value - v) < Math.abs(value - next) ? v : next;
-}
-function toFixed(x, fractionDigits) {
-    return Number(x.toFixed(fractionDigits));
-}
-function decimalPart(x) {
-    return String(x).split('.')[1];
-}
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
 
 /**
  * This hook is user-land implementation of the experimental `useEffectEvent` hook.
  * React docs: https://react.dev/learn/separating-events-from-effects#declaring-an-effect-event
  */
 function useCallbackRef(callback, deps = []) {
-    const callbackRef = react.useRef(() => {
+    const callbackRef = React.useRef(() => {
         throw new Error('Cannot call an event handler while rendering.');
     });
-    react.useInsertionEffect(() => {
+    React.useInsertionEffect(() => {
         callbackRef.current = callback;
     });
-    return react.useCallback((...args) => { var _a; return (_a = callbackRef.current) === null || _a === void 0 ? void 0 : _a.call(callbackRef, ...args); }, deps);
+    return React.useCallback((...args) => { var _a; return (_a = callbackRef.current) === null || _a === void 0 ? void 0 : _a.call(callbackRef, ...args); }, deps);
 }
 
 function useEventListener(target, event, handler, options) {
     const listener = useCallbackRef(handler);
-    react.useEffect(() => {
+    React.useEffect(() => {
         const node = typeof target === 'function' ? target() : (target !== null && target !== void 0 ? target : document);
         if (!handler || !node)
             return;
@@ -74,238 +72,351 @@ function useEventListener(target, event, handler, options) {
     };
 }
 
-function styleHelper(property) {
-    if (typeof property == 'number') {
-        return `${property}px`;
-    }
-    else {
-        return property;
-    }
+function useRefCallbackEvent(event, handler, options, deps = []) {
+    return React.useMemo(() => {
+        let cleanup;
+        return (node) => {
+            if (!node) {
+                cleanup === null || cleanup === void 0 ? void 0 : cleanup();
+                return;
+            }
+            node.addEventListener(event, handler, options);
+            cleanup = () => {
+                node.removeEventListener(event, handler, options);
+            };
+        };
+    }, deps);
 }
 
-function Knob({ value, min, max, step = 1, skew = 1, size = 50, active = '#7998ec', inactive = '#eee', bg = '#ccc', thumb = '#4e76e6', lineWeight = 12, thumbWeight = 4, cursor = 'pointer', style, bodyNoSelect = true, enableWheel, onChange, }) {
+// https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/save
+const drawingState = [
+    'strokeStyle',
+    'fillStyle',
+    'globalAlpha',
+    'lineWidth',
+    'lineCap',
+    'lineJoin',
+    'miterLimit',
+    'lineDashOffset',
+    'shadowOffsetX',
+    'shadowOffsetY',
+    'shadowBlur',
+    'shadowColor',
+    'globalCompositeOperation',
+    'font',
+    'textAlign',
+    'textBaseline',
+    'direction',
+    'imageSmoothingEnabled',
+];
+
+function setDprConfig(canvas, context, width, height, dpr) {
+    canvas.width = width * dpr;
+    canvas.height = height * dpr;
+    context.scale(dpr, dpr);
+    canvas.style.width = `${width}px`;
+    canvas.style.height = `${height}px`;
+}
+/**
+ * A simple animatable canvas with requestAnimationFrame()
+ */
+function AnimationCanvas(_a) {
+    var { width = 100, height = 100, style, relativeSize = false, reduceFlickering = true, options, init, draw } = _a, props = __rest(_a, ["width", "height", "style", "relativeSize", "reduceFlickering", "options", "init", "draw"]);
+    const canvasRef = React.useRef(null);
+    const memoCanvasRef = React.useRef(null);
+    const reqIdRef = React.useRef();
+    const widthRef = React.useRef(0);
+    const heightRef = React.useRef(0);
+    const loop = (context, width, height, count) => {
+        reqIdRef.current = requestAnimationFrame(() => loop(context, width, height, count + 1));
+        draw(context, width, height, count + 1);
+    };
+    React.useEffect(() => {
+        if (!canvasRef.current)
+            return;
+        const canvas = canvasRef.current;
+        const context = canvas.getContext('2d', options);
+        if (!context)
+            throw new Error('Cannot get canvas context.');
+        const dpr = window.devicePixelRatio;
+        if (relativeSize) {
+            const parent = canvas.parentElement;
+            if (!parent)
+                throw new Error("Canvas doesn't have a parent element.");
+            const memoCanvas = memoCanvasRef.current;
+            const memoContext = memoCanvas === null || memoCanvas === void 0 ? void 0 : memoCanvas.getContext('2d', options);
+            const resizeObserver = new ResizeObserver(() => {
+                console.log('resize');
+                // Prevents loss of some context when the canvas is resized
+                const contextMemo = {};
+                for (const prop of drawingState) {
+                    contextMemo[prop] = context[prop];
+                }
+                const w = Math.floor(parent.clientWidth);
+                const h = Math.floor(parent.clientHeight);
+                if (reduceFlickering && memoCanvas && memoContext) {
+                    memoCanvas.width = w * dpr;
+                    memoCanvas.height = h * dpr;
+                    memoContext.scale(1 / dpr, 1 / dpr);
+                    memoContext.drawImage(context.canvas, 0, 0);
+                }
+                setDprConfig(canvas, context, w, h, dpr);
+                widthRef.current = w;
+                heightRef.current = h;
+                for (const prop of drawingState) {
+                    context[prop] = contextMemo[prop];
+                }
+                if (reduceFlickering && memoContext) {
+                    context.drawImage(memoContext.canvas, 0, 0);
+                }
+            });
+            resizeObserver.observe(parent);
+            const w = Math.floor(parent.clientWidth);
+            const h = Math.floor(parent.clientHeight);
+            setDprConfig(canvas, context, w, h, dpr);
+            if (init)
+                init(context, widthRef, heightRef, 0);
+            loop(context, widthRef, heightRef, 0);
+            return () => {
+                if (reqIdRef.current)
+                    cancelAnimationFrame(reqIdRef.current);
+                resizeObserver.unobserve(parent);
+            };
+        }
+        else {
+            const rect = canvas.getBoundingClientRect();
+            setDprConfig(canvas, context, rect.width, rect.height, dpr);
+            widthRef.current = rect.width;
+            heightRef.current = rect.height;
+            if (init)
+                init(context, widthRef, heightRef, 0);
+            loop(context, widthRef, heightRef, 0);
+            return () => {
+                if (reqIdRef.current)
+                    cancelAnimationFrame(reqIdRef.current);
+            };
+        }
+    }, [loop]);
+    return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [jsxRuntime.jsx("canvas", Object.assign({ width: relativeSize ? 0 : width, height: relativeSize ? 0 : height, css: react.css(style), ref: canvasRef }, props)), relativeSize && reduceFlickering && (jsxRuntime.jsx("canvas", { style: { display: 'none' }, width: relativeSize ? 0 : width, height: relativeSize ? 0 : height, ref: memoCanvasRef }))] }));
+}
+
+const defaultOptions = {
+    active: '#7998ec',
+    inactive: '#eee',
+    bg: '#ccc',
+    thumb: '#4e76e6',
+    lineWeight: 6,
+    thumbWeight: 4,
+};
+/**
+ * simple rotary Knob.
+ */
+function Knob(_a) {
+    var { value, min, max, defaultValue = min, startValue = min, step = 1, skew = 1, size, width = 50, height = 50, options = defaultOptions, 
+    // draw,
+    cursor = 'pointer', style, bodyNoSelect = true, enableWheel, enableDoubleClickDefault = true, onChange, _active, _focus, _hover } = _a, props = __rest(_a, ["value", "min", "max", "defaultValue", "startValue", "step", "skew", "size", "width", "height", "options", "cursor", "style", "bodyNoSelect", "enableWheel", "enableDoubleClickDefault", "onChange", "_active", "_focus", "_hover"]);
     // -- state and ref ---
     // const [privateValue, setPrivateValue] = useState(value);
-    const dragOffsetY = react.useRef(undefined);
+    const dragOffsetY = React.useRef(undefined);
     // --- interpret props ---
-    const percent = normalizeValue(value, min, max, skew);
-    const handleValue = (event) => {
+    const opts = Object.assign(Object.assign({}, defaultOptions), options);
+    // const percent = normalizeValue(value, min, max, skew)
+    const isRelativeSize = typeof (size !== null && size !== void 0 ? size : width) == 'string';
+    const adaptSize = (size) => {
+        if (typeof size == 'string') {
+            return Number(size.slice(0, -1));
+        }
+        else {
+            return size;
+        }
+    };
+    const handleEvent = (event) => {
+        const isTouch = event instanceof TouchEvent;
+        if (isTouch && event.cancelable)
+            event.preventDefault();
         if (dragOffsetY.current) {
             if (bodyNoSelect)
                 document.body.classList.add('no-select');
-            const delta = dragOffsetY.current - event.screenY;
-            dragOffsetY.current = event.screenY;
-            const n = normalizeValue(value, min, max, skew);
-            const v = rawValue(n + delta / 100, min, max, skew);
-            const v2 = clamp(stepValue(v, step), min, max);
+            const screenY = isTouch ? event.touches[0].screenY : event.screenY;
+            const delta = dragOffsetY.current - screenY;
+            dragOffsetY.current = screenY;
+            const n = math.normalizeValue(value, min, max, skew);
+            const v = math.rawValue(n + delta / 100, min, max, skew);
+            const v2 = math.clamp(math.stepValue(v, step), min, max);
             if (onChange)
                 onChange(v2);
         }
     };
     // --- hooks ---
-    const wrapperRef = react.useMemo(() => {
-        let cleanup;
-        return (div) => {
-            if (!div) {
-                cleanup === null || cleanup === void 0 ? void 0 : cleanup();
-                return;
-            }
-            const controller = new AbortController();
-            div.addEventListener('wheel', (event) => {
-                if (!enableWheel)
-                    return;
-                event.preventDefault();
-                const x = event.deltaY > 0 ? -enableWheel[1] : enableWheel[1];
-                let v;
-                if (enableWheel[0] == 'normalized') {
-                    const n = normalizeValue(value, min, max, skew);
-                    v = rawValue(n + x, min, max, skew);
-                }
-                else {
-                    v = value + x;
-                }
-                if (onChange)
-                    onChange(clamp(stepValue(v, step), min, max));
-            }, {
-                signal: controller.signal,
-                passive: false,
-            });
-            cleanup = () => {
-                // console.log("cleanup")
-                controller.abort();
-            };
-        };
-    }, [value]);
-    useEventListener(window, 'mousemove', (event) => {
-        handleValue(event);
-    });
-    useEventListener(window, 'mouseup', () => {
+    const wheelRefCallback = useRefCallbackEvent('wheel', (event) => {
+        if (!enableWheel)
+            return;
+        event.preventDefault();
+        const x = event.deltaY > 0 ? -enableWheel[1] : enableWheel[1];
+        let v;
+        if (enableWheel[0] == 'normalized') {
+            const n = math.normalizeValue(value, min, max, skew);
+            v = math.rawValue(n + x, min, max, skew);
+        }
+        else {
+            v = value + x;
+        }
+        if (onChange)
+            onChange(math.clamp(math.stepValue(v, step), min, max));
+    }, { passive: false }, [enableWheel, value, min, max, skew, step, onChange]);
+    const touchMoveRefCallback = useRefCallbackEvent('touchmove', handleEvent, { passive: false }, [value, min, max, skew, step, onChange, bodyNoSelect]);
+    useEventListener(window, 'mousemove', handleEvent);
+    useEventListener(window, 'pointerup', () => {
         dragOffsetY.current = undefined;
         if (bodyNoSelect)
             document.body.classList.remove('no-select');
     });
-    return (jsxRuntime.jsx("div", { className: "tremolo-knob", ref: wrapperRef, onMouseDown: (event) => {
+    return (jsxRuntime.jsxs("div", Object.assign({ className: "tremolo-knob", ref: (div) => {
+            wheelRefCallback(div);
+            touchMoveRefCallback(div);
+        }, role: "slider", tabIndex: 0, "aria-valuenow": value, "aria-valuemax": max, "aria-valuemin": min, css: react.css(Object.assign(Object.assign({ display: 'inline-block', width: size !== null && size !== void 0 ? size : width, height: size !== null && size !== void 0 ? size : height, cursor: cursor }, style), { ':active': Object.assign({}, _active), ':focus': Object.assign({}, _focus), ':hover': Object.assign({}, _hover) })), onPointerDown: (event) => {
             dragOffsetY.current = event.screenY;
-            handleValue(event);
-        }, style: Object.assign({ display: 'inline-block', width: size, height: size }, style), children: jsxRuntime.jsx("div", { css: react$1.css({
-                display: 'inline-block',
-                width: size,
-                height: size,
-                background: `conic-gradient(${active} ${percent * 270}deg, ${inactive} ${percent * 270}deg, ${inactive} ${270}deg, ${bg} 90deg)`,
-                borderRadius: '50%',
-                position: 'relative',
-                cursor: cursor,
-                rotate: '-135deg',
-                '&::before': {
-                    display: 'block',
-                    position: 'absolute',
-                    right: 0,
-                    left: 0,
-                    top: 0,
-                    bottom: 0,
-                    margin: 'auto',
-                    content: '""',
-                    width: `calc(${styleHelper(size)} - ${styleHelper(lineWeight)})`,
-                    height: `calc(${styleHelper(size)} - ${styleHelper(lineWeight)})`,
-                    backgroundColor: bg,
-                    borderRadius: '50%',
-                },
-                '&::after': {
-                    display: 'block',
-                    position: 'absolute',
-                    top: 0,
-                    bottom: 0,
-                    // left: lineWeight,
-                    margin: 'auto 0',
-                    content: '""',
-                    width: `calc(0.5 * ${styleHelper(size)})`,
-                    height: thumbWeight,
-                    borderRadius: thumbWeight,
-                    backgroundColor: thumb,
-                    rotate: `${90 + percent * 270}deg`,
-                    transformOrigin: '100% 50%',
-                },
-            }), children: jsxRuntime.jsx(react$1.Global, { styles: {
+            handleEvent(event);
+        }, onDoubleClick: () => {
+            if (enableDoubleClickDefault && onChange) {
+                onChange(defaultValue);
+            }
+        } }, props, { children: [jsxRuntime.jsx(react.Global, { styles: {
                     '.no-select': {
                         userSelect: 'none',
                     },
-                } }) }) }));
+                } }), jsxRuntime.jsx(AnimationCanvas, { width: adaptSize(size !== null && size !== void 0 ? size : width), height: adaptSize(size !== null && size !== void 0 ? size : height), relativeSize: isRelativeSize, 
+                // TODO
+                // reduceFlickering={false}
+                draw: (ctx, _w, _h) => {
+                    const p = math.normalizeValue(value, min, max, skew);
+                    const startP = math.normalizeValue(startValue, min, max, skew);
+                    const w = _w.current, cx = w / 2;
+                    const h = _h.current, cy = h / 2;
+                    const r = Math.min(cx, cy);
+                    // reset
+                    ctx.clearRect(0, 0, w, h);
+                    ctx.lineCap = 'butt';
+                    // bg
+                    ctx.beginPath();
+                    ctx.fillStyle = opts.bg;
+                    ctx.arc(cx, cy, r - 0.5, 0, 2 * Math.PI);
+                    ctx.fill();
+                    ctx.lineCap = 'round';
+                    ctx.lineWidth = opts.lineWeight;
+                    // inactive rotary
+                    ctx.beginPath();
+                    ctx.strokeStyle = opts.inactive;
+                    ctx.arc(cx, cy, r - 0.5 - opts.lineWeight / 2, math.radian(135), math.radian(45));
+                    ctx.stroke();
+                    // active rotary
+                    ctx.beginPath();
+                    ctx.strokeStyle = opts.active;
+                    ctx.arc(cx, cy, r - 0.5 - opts.lineWeight / 2, math.radian(135 + 270 * startP), math.radian(135 + 270 * p), p < startP);
+                    ctx.stroke();
+                    // thumb
+                    ctx.beginPath();
+                    ctx.moveTo(cx, cy);
+                    ctx.lineTo(cx +
+                        Math.cos(math.radian(135 + 270 * p)) *
+                            (r - 0.5 - opts.thumbWeight / 2), cy +
+                        Math.sin(math.radian(135 + 270 * p)) *
+                            (r - 0.5 - opts.thumbWeight / 2));
+                    ctx.strokeStyle = opts.thumb;
+                    ctx.lineWidth = opts.thumbWeight;
+                    ctx.stroke();
+                } })] })));
 }
 
-function isHorizontal(d) {
-    return d == 'right' || d == 'left';
-}
-function isVertical(d) {
-    return d == 'up' || d == 'down';
-}
-function isReversed(d) {
-    return d == 'left' || d == 'up';
-}
-function gradientDirection(d) {
-    if (d == 'left' || d == 'right')
-        return d;
-    if (d == 'up')
-        return 'top';
-    if (d == 'down')
-        return 'bottom';
-}
-function parseScaleOrderList(scale, min, max, step) {
-    var _a;
-    let scalesList = [];
-    if (!scale) ;
-    else if (typeof scale[0] == 'object') {
-        scalesList = scale;
-    }
-    else {
-        const per = scale[0] == 'step' ? step : scale[0];
-        const count = Math.floor(max / per) - Math.ceil(min / per) + 1;
-        for (let i = 0; i < count; i++) {
-            const at = toFixed(per * (Math.ceil(min / per) + i), (_a = decimalPart(per)) === null || _a === void 0 ? void 0 : _a.length);
-            scalesList.push({ at: at, type: scale[1] });
-        }
-    }
-    return scalesList;
+function SliderThumb({ color, children, style, __css, }) {
+    return (jsxRuntime.jsx("div", { className: "tremolo-slider-thumb-wrapper", css: react.css(Object.assign({ width: 'fit-content', height: 'fit-content', position: 'absolute', translate: '-50% -50%', zIndex: 100 }, __css)), children: children ? (children) : (
+        // default slider thumb
+        jsxRuntime.jsx("div", { className: "tremolo-slider-thumb", 
+            // eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex
+            tabIndex: 0, css: react.css(Object.assign({ background: color, width: '1.4rem', height: '1.4rem', borderRadius: '50%' }, style)) })) }));
 }
 
-// interface SliderThumbProps {}
-function SliderThumb( /* {}: SliderThumbProps */) {
-    return jsxRuntime.jsx("div", {});
+function SliderTrack({ children, style, __css, }) {
+    return (jsxRuntime.jsx("div", { className: "tremolo-slider-track", css: react.css(Object.assign(Object.assign({}, __css), style)), children: children }));
 }
-function Slider({ value, min, max, step = 1, length = 140, thickness = 10, direction = 'right', skew = 1, scale, scaleOption, color = '#4e76e6', bg = '#eee', cursor = 'pointer', style, bodyNoSelect = true, enableWheel, onChange, children, }) {
-    var _a, _b;
+
+/**
+ * Customizable slider
+ */
+function Slider(_a) {
+    var _b, _c;
+    var { value, min, max, step = 1, skew = 1, length = 140, thickness = 10, direction = 'right', scale, scaleOption, color = '#4e76e6', bg = '#eee', className, style, bodyNoSelect = true, enableWheel, onChange, children } = _a; __rest(_a, ["value", "min", "max", "step", "skew", "length", "thickness", "direction", "scale", "scaleOption", "color", "bg", "className", "style", "bodyNoSelect", "enableWheel", "onChange", "children"]);
     // -- state and ref ---
-    const baseWrapperElement = react.useRef(null);
-    // --- interpret props ---
-    const percent = normalizeValue(value, min, max, skew) * 100;
-    const percentRev = isReversed(direction) ? 100 - percent : percent;
-    const scalesList = parseScaleOrderList(scale, min, max, step);
-    if (isReversed(direction))
+    const trackElementRef = React.useRef(null);
+    const percent = math.normalizeValue(value, min, max, skew) * 100;
+    const percentRev = type.isReversed(direction) ? 100 - percent : percent;
+    const scalesList = type.parseScaleOrderList(scale, min, max, step);
+    if (type.isReversed(direction))
         scalesList.reverse();
-    // let defaultThumb = true
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let trackProps;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let thumbProps;
     if (children != undefined) {
-        const childElements = react.Children.toArray(children);
-        const lastElement = childElements[childElements.length - 1];
-        if (react.isValidElement(lastElement)) {
-            // defaultThumb = false
-            if (lastElement.type == SliderThumb) ;
-        }
-        else {
-            throw new Error('children is an invalid element.');
-        }
+        React.Children.forEach(children, (child) => {
+            if (React.isValidElement(child)) {
+                if (child.type == SliderThumb) {
+                    thumbProps = child.props;
+                }
+                else if (child.type == SliderTrack) {
+                    trackProps = child.props;
+                }
+                else {
+                    throw new Error('only <SliderThumb> or <SliderTrack>');
+                }
+            }
+            else {
+                throw new Error('children is an invalid element.');
+            }
+        });
     }
-    const thumbDragged = react.useRef(false);
+    const thumbDragged = React.useRef(false);
     const handleValue = (event) => {
-        if (baseWrapperElement.current && thumbDragged.current) {
-            if (bodyNoSelect)
-                document.body.classList.add('no-select');
-            const { left: x1, top: y1, right: x2, bottom: y2, } = baseWrapperElement.current.getBoundingClientRect();
-            const mouseX = event.clientX;
-            const mouseY = event.clientY;
-            const n = isHorizontal(direction)
-                ? normalizeValue(mouseX, x1, x2)
-                : normalizeValue(mouseY, y1, y2);
-            const v = rawValue(isReversed(direction) ? 1 - n : n, min, max, skew);
-            const v2 = clamp(stepValue(v, step), min, max);
-            if (onChange)
-                onChange(v2);
-        }
+        if (!trackElementRef.current || !thumbDragged.current)
+            return;
+        const isTouch = event instanceof TouchEvent;
+        if (isTouch && event.cancelable)
+            event.preventDefault();
+        if (bodyNoSelect)
+            document.body.classList.add('no-select');
+        const { left: x1, top: y1, right: x2, bottom: y2, } = trackElementRef.current.getBoundingClientRect();
+        const mouseX = isTouch ? event.touches[0].clientX : event.clientX;
+        const mouseY = isTouch ? event.touches[0].clientY : event.clientY;
+        const n = type.isHorizontal(direction)
+            ? math.normalizeValue(mouseX, x1, x2)
+            : math.normalizeValue(mouseY, y1, y2);
+        const v = math.rawValue(type.isReversed(direction) ? 1 - n : n, min, max, skew);
+        const v2 = math.clamp(math.stepValue(v, step), min, max);
+        if (onChange)
+            onChange(v2);
     };
     // --- hooks ---
-    const wrapperRef = react.useMemo(() => {
-        let cleanup;
-        return (div) => {
-            if (!div) {
-                cleanup === null || cleanup === void 0 ? void 0 : cleanup();
-                return;
-            }
-            const controller = new AbortController();
-            div.addEventListener('wheel', (event) => {
-                if (!enableWheel)
-                    return;
-                event.preventDefault();
-                let x = event.deltaY > 0 ? enableWheel[1] : -enableWheel[1];
-                if (isReversed(direction))
-                    x *= -1;
-                let v;
-                if (enableWheel[0] == 'normalized') {
-                    const n = normalizeValue(value, min, max, skew);
-                    v = rawValue(n + x, min, max, skew);
-                }
-                else {
-                    v = value + x;
-                }
-                if (onChange)
-                    onChange(clamp(stepValue(v, step), min, max));
-            }, {
-                signal: controller.signal,
-                passive: false,
-            });
-            cleanup = () => {
-                // console.log("cleanup")
-                controller.abort();
-            };
-        };
-    }, [value]);
+    const touchMoveRefCallback = useRefCallbackEvent('touchmove', handleValue, { passive: false }, [min, max, skew, step, direction, onChange]);
+    const wheelRefCallback = useRefCallbackEvent('wheel', (event) => {
+        if (!enableWheel)
+            return;
+        event.preventDefault();
+        let x = event.deltaY > 0 ? enableWheel[1] : -enableWheel[1];
+        if (type.isReversed(direction) || type.isHorizontal(direction))
+            x *= -1;
+        let v;
+        if (enableWheel[0] == 'normalized') {
+            const n = math.normalizeValue(value, min, max, skew);
+            v = math.rawValue(n + x, min, max, skew);
+        }
+        else {
+            v = value + x;
+        }
+        if (onChange)
+            onChange(math.clamp(math.stepValue(v, step), min, max));
+    }, {
+        passive: false,
+    }, [enableWheel, value, min, max, skew, step]);
     useEventListener(window, 'mousemove', (event) => {
         handleValue(event);
     });
@@ -314,84 +425,81 @@ function Slider({ value, min, max, step = 1, length = 140, thickness = 10, direc
         if (bodyNoSelect)
             document.body.classList.remove('no-select');
     });
-    return (jsxRuntime.jsxs("div", { ref: wrapperRef, className: "tremolo-slider", style: {
-            display: 'inline-block',
-            boxSizing: 'border-box',
-            margin: '0.7rem',
-            padding: 0,
-            cursor: cursor,
-        }, onMouseDown: (event) => {
+    return (jsxRuntime.jsxs("div", { className: 'tremolo-slider' + (className ? ` ${className}` : ''), ref: (div) => {
+            wheelRefCallback(div);
+            touchMoveRefCallback(div);
+        }, tabIndex: -1, role: "slider", "aria-valuenow": value, "aria-valuemax": max, "aria-valuemin": min, "aria-orientation": type.isHorizontal(direction) ? 'horizontal' : 'vertical', css: react.css(Object.assign({ display: 'inline-block', boxSizing: 'border-box', margin: '0.7rem', padding: 0, cursor: 'pointer' }, style)), onPointerDown: (event) => {
             thumbDragged.current = true;
             handleValue(event);
-        }, children: [jsxRuntime.jsx(react$1.Global, { styles: {
+        }, children: [jsxRuntime.jsx(react.Global, { styles: {
                     '.no-select': {
                         userSelect: 'none',
                     },
-                } }), jsxRuntime.jsxs("div", { style: {
+                } }), jsxRuntime.jsxs("div", { css: react.css({
                     display: 'flex',
-                    flexDirection: isHorizontal(direction) ? 'column' : 'row',
-                }, children: [jsxRuntime.jsx("div", { ref: baseWrapperElement, css: react$1.css(Object.assign({ background: `linear-gradient(to ${gradientDirection(direction)}, ${color} ${percent}%, ${bg} ${percent}%)`, borderRadius: typeof thickness == 'number'
-                                ? thickness / 2
-                                : `calc(${thickness} / 2)`, borderStyle: 'solid', borderColor: '#ccc', borderWidth: 2, width: isHorizontal(direction) ? length : thickness, height: isHorizontal(direction) ? thickness : length, position: 'relative', zIndex: 1 }, style)), children: jsxRuntime.jsx("div", { className: "tremolo-slider-thumb-wrapper", style: {
-                                width: 'fix-content',
-                                height: 'fix-content',
-                                position: 'absolute',
-                                top: isHorizontal(direction) ? '50%' : `${percentRev}%`,
-                                left: isHorizontal(direction) ? `${percentRev}%` : '50%',
-                                translate: '-50% -50%',
-                                zIndex: 100,
-                            }, children: children ? (children) : (jsxRuntime.jsx("div", { className: "tremolo-slider-thumb", style: {
-                                    background: color,
-                                    width: '1.4rem',
-                                    height: '1.4rem',
-                                    borderRadius: '50%',
-                                } })) }) }), scale && (jsxRuntime.jsx("div", { className: "tremolo-slider-scale-wrapper", style: Object.assign({ position: 'relative', width: isHorizontal(direction) ? length : undefined, height: isVertical(direction) ? length : undefined, marginLeft: isHorizontal(direction)
+                    flexDirection: type.isHorizontal(direction) ? 'column' : 'row',
+                }), children: [jsxRuntime.jsxs("div", { className: "tremolo-slider-track-wrapper", ref: trackElementRef, css: react.css({ position: 'relative' }), children: [jsxRuntime.jsx(SliderTrack, Object.assign({ __css: {
+                                    background: `linear-gradient(to ${type.gradientDirection(direction)}, ${color} ${percent}%, ${bg} ${percent}%)`,
+                                    borderRadius: util.styleHelper(thickness, '/', 2),
+                                    borderStyle: 'solid',
+                                    borderColor: '#ccc',
+                                    borderWidth: 2,
+                                    width: type.isHorizontal(direction) ? length : thickness,
+                                    height: type.isHorizontal(direction) ? thickness : length,
+                                    zIndex: 1,
+                                } }, trackProps)), jsxRuntime.jsx(SliderThumb, Object.assign({ color: color, __css: {
+                                    top: type.isHorizontal(direction) ? '50%' : `${percentRev}%`,
+                                    left: type.isHorizontal(direction) ? `${percentRev}%` : '50%',
+                                } }, thumbProps))] }), scale && (jsxRuntime.jsx("div", { className: "tremolo-slider-scale-wrapper", css: react.css(Object.assign({ position: 'relative', width: type.isHorizontal(direction) ? length : undefined, height: type.isVertical(direction) ? length : undefined, marginLeft: type.isHorizontal(direction)
                                 ? 2
-                                : ((_a = scaleOption === null || scaleOption === void 0 ? void 0 : scaleOption.gap) !== null && _a !== void 0 ? _a : `calc((1.4rem - ${styleHelper(thickness)}) / 2)`), marginTop: isVertical(direction)
+                                : ((_b = scaleOption === null || scaleOption === void 0 ? void 0 : scaleOption.gap) !== null && _b !== void 0 ? _b : `calc((1.4rem - ${util.styleHelper(thickness)}) / 2)`), marginTop: type.isVertical(direction)
                                 ? 2
-                                : ((_b = scaleOption === null || scaleOption === void 0 ? void 0 : scaleOption.gap) !== null && _b !== void 0 ? _b : `calc((1.4rem - ${styleHelper(thickness)}) / 2)`) }, scaleOption === null || scaleOption === void 0 ? void 0 : scaleOption.style), children: scalesList.map((item, index) => {
-                            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
-                            return (jsxRuntime.jsxs("div", { style: {
+                                : ((_c = scaleOption === null || scaleOption === void 0 ? void 0 : scaleOption.gap) !== null && _c !== void 0 ? _c : `calc((1.4rem - ${util.styleHelper(thickness)}) / 2)`) }, scaleOption === null || scaleOption === void 0 ? void 0 : scaleOption.style)), children: scalesList.map((item, index) => {
+                            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+                            return (jsxRuntime.jsxs("div", { css: react.css({
                                     display: 'flex',
-                                    flexDirection: isHorizontal(direction) ? 'column' : 'row',
+                                    flexDirection: type.isHorizontal(direction) ? 'column' : 'row',
                                     justifyContent: 'center',
                                     alignItems: 'center',
                                     position: 'absolute',
-                                    left: isHorizontal(direction)
-                                        ? `${isReversed(direction)
-                                            ? 100 - normalizeValue(item.at, min, max, skew) * 100
-                                            : normalizeValue(item.at, min, max, skew) * 100}%`
+                                    left: type.isHorizontal(direction)
+                                        ? `${type.isReversed(direction)
+                                            ? 100 - math.normalizeValue(item.at, min, max, skew) * 100
+                                            : math.normalizeValue(item.at, min, max, skew) * 100}%`
                                         : undefined,
-                                    top: isVertical(direction)
-                                        ? `${isReversed(direction)
-                                            ? 100 - normalizeValue(item.at, min, max, skew) * 100
-                                            : normalizeValue(item.at, min, max, skew) * 100}%`
+                                    top: type.isVertical(direction)
+                                        ? `${type.isReversed(direction)
+                                            ? 100 - math.normalizeValue(item.at, min, max, skew) * 100
+                                            : math.normalizeValue(item.at, min, max, skew) * 100}%`
                                         : undefined,
-                                    translate: isHorizontal(direction) ? '-50% 0' : '0 -50%',
+                                    translate: type.isHorizontal(direction) ? '-50% 0' : '0 -50%',
                                     zIndex: 10,
-                                }, children: [item.type != 'number' && (jsxRuntime.jsx("div", { className: "tremolo-slider-scale-mark", style: {
-                                            width: isHorizontal(direction)
-                                                ? ((_b = (_a = item.style) === null || _a === void 0 ? void 0 : _a.thickness) !== null && _b !== void 0 ? _b : 1)
-                                                : ((_d = (_c = item.style) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : '0.5rem'),
-                                            height: isVertical(direction)
-                                                ? ((_f = (_e = item.style) === null || _e === void 0 ? void 0 : _e.thickness) !== null && _f !== void 0 ? _f : 1)
-                                                : ((_h = (_g = item.style) === null || _g === void 0 ? void 0 : _g.length) !== null && _h !== void 0 ? _h : '0.5rem'),
-                                            backgroundColor: (_l = (_k = (_j = item.style) === null || _j === void 0 ? void 0 : _j.markColor) !== null && _k !== void 0 ? _k : scaleOption === null || scaleOption === void 0 ? void 0 : scaleOption.markColor) !== null && _l !== void 0 ? _l : '#222',
-                                            marginBottom: isHorizontal(direction) ? 2 : undefined,
-                                            marginRight: isVertical(direction) ? 2 : undefined,
-                                        } })), item.type != 'mark' && (jsxRuntime.jsx("div", { className: "tremolo-slider-scale-number", style: {
-                                            color: (_o = (_m = item.style) === null || _m === void 0 ? void 0 : _m.labelColor) !== null && _o !== void 0 ? _o : scaleOption === null || scaleOption === void 0 ? void 0 : scaleOption.labelColor,
-                                        }, children: item.at }))] }, index));
+                                }), children: [((_b = (_a = item.type) !== null && _a !== void 0 ? _a : scaleOption === null || scaleOption === void 0 ? void 0 : scaleOption.defaultType) !== null && _b !== void 0 ? _b : 'mark-number') !=
+                                        'number' && (jsxRuntime.jsx("div", { className: "tremolo-slider-scale-mark", css: react.css({
+                                            width: type.isHorizontal(direction)
+                                                ? ((_d = (_c = item.style) === null || _c === void 0 ? void 0 : _c.thickness) !== null && _d !== void 0 ? _d : 1)
+                                                : ((_f = (_e = item.style) === null || _e === void 0 ? void 0 : _e.length) !== null && _f !== void 0 ? _f : '0.5rem'),
+                                            height: type.isVertical(direction)
+                                                ? ((_h = (_g = item.style) === null || _g === void 0 ? void 0 : _g.thickness) !== null && _h !== void 0 ? _h : 1)
+                                                : ((_k = (_j = item.style) === null || _j === void 0 ? void 0 : _j.length) !== null && _k !== void 0 ? _k : '0.5rem'),
+                                            backgroundColor: (_o = (_m = (_l = item.style) === null || _l === void 0 ? void 0 : _l.markColor) !== null && _m !== void 0 ? _m : scaleOption === null || scaleOption === void 0 ? void 0 : scaleOption.markColor) !== null && _o !== void 0 ? _o : '#222',
+                                            marginBottom: type.isHorizontal(direction) ? 2 : undefined,
+                                            marginRight: type.isVertical(direction) ? 2 : undefined,
+                                        }) })), ((_q = (_p = item.type) !== null && _p !== void 0 ? _p : scaleOption === null || scaleOption === void 0 ? void 0 : scaleOption.defaultType) !== null && _q !== void 0 ? _q : 'mark-number') !=
+                                        'mark' && (jsxRuntime.jsx("div", { className: "tremolo-slider-scale-number", css: react.css({
+                                            color: (_s = (_r = item.style) === null || _r === void 0 ? void 0 : _r.labelColor) !== null && _s !== void 0 ? _s : scaleOption === null || scaleOption === void 0 ? void 0 : scaleOption.labelColor,
+                                            width: scaleOption === null || scaleOption === void 0 ? void 0 : scaleOption.labelWidth,
+                                            textAlign: 'right',
+                                        }), children: (_t = item.text) !== null && _t !== void 0 ? _t : item.at }))] }, index));
                         }) }))] })] }));
 }
 
 exports.Knob = Knob;
 exports.Slider = Slider;
-exports.clamp = clamp;
-exports.decimalPart = decimalPart;
-exports.normalizeValue = normalizeValue;
-exports.rawValue = rawValue;
-exports.skewWithCenterValue = skewWithCenterValue;
-exports.stepValue = stepValue;
-exports.toFixed = toFixed;
+Object.keys(math).forEach(function (k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () { return math[k]; }
+    });
+});
 //# sourceMappingURL=index.js.map