@v-c/slider 1.0.2 → 1.0.4

package/dist/hooks/useDrag.js

@@ -1,88 +1,157 @@
-import N from "@v-c/util/dist/hooks/useEvent";
-import { ref as r, inject as Q, onUnmounted as W, computed as Z } from "vue";
-import { UnstableContextKey as $, defaultUnstableContextValue as w } from "../context.js";
-const I = 130;
-function _(h) {
-  const C = "targetTouches" in h ? h.targetTouches[0] : h;
-  return { pageX: C.pageX, pageY: C.pageY };
+import { UnstableContextKey, defaultUnstableContextValue } from "../context.js";
+import { computed, inject, onUnmounted, ref, watch } from "vue";
+import useEvent from "@v-c/util/dist/hooks/useEvent";
+var REMOVE_DIST = 130;
+function getPosition(e) {
+	const obj = "targetTouches" in e ? e.targetTouches[0] : e;
+	return {
+		pageX: obj.pageX,
+		pageY: obj.pageY
+	};
 }
-function ne(h, C, f, T, X, y, B, K, q, R, x) {
-  const Y = r(null), c = r(-1), D = r(!1), i = r(f.value), g = r(f.value), p = r(null), E = r(null), v = r(null), z = Q($, w), { onDragStart: U, onDragChange: O } = z;
-  c.value === -1 && (i.value = f.value), W(() => {
-    document.removeEventListener("mousemove", p.value), document.removeEventListener("mouseup", E.value), v.value && (v.value.removeEventListener("touchmove", p.value), v.value.removeEventListener("touchend", E.value));
-  });
-  const j = (t, n, o) => {
-    n !== void 0 && (Y.value = n), i.value = t;
-    let a = t;
-    o && (a = t.filter((l, e) => e !== c.value)), B(a), O && O({
-      rawValues: t,
-      deleteIndex: o ? c.value : -1,
-      draggingIndex: c.value,
-      draggingValue: n
-    });
-  }, A = N(
-    (t, n, o) => {
-      if (t === -1) {
-        const a = g.value[0], l = g.value[g.value.length - 1], e = T.value - a, s = X.value - l;
-        let u = n * (X.value - T.value);
-        u = Math.max(u, e), u = Math.min(u, s), u = y(a + u) - a;
-        const m = g.value.map((d) => d + u);
-        j(m);
-      } else {
-        const a = (X.value - T.value) * n, l = [...i.value];
-        l[t] = g.value[t];
-        const e = q(l, a, t, "dist");
-        j(e.values, e.value, o);
-      }
-    }
-  ), F = (t, n, o) => {
-    t.stopPropagation();
-    const a = o || f.value, l = a[n];
-    c.value = n, Y.value = l, g.value = a, i.value = a, D.value = !1;
-    const { pageX: e, pageY: s } = _(t);
-    let u = !1;
-    U && U({
-      rawValues: a,
-      draggingIndex: n,
-      draggingValue: l
-    });
-    const V = (d) => {
-      d.preventDefault();
-      const { pageX: H, pageY: J } = _(d), M = H - e, S = J - s, { width: k, height: P } = h.value.getBoundingClientRect();
-      let L, b;
-      switch (C.value) {
-        case "btt":
-          L = -S / P, b = M;
-          break;
-        case "ttb":
-          L = S / P, b = M;
-          break;
-        case "rtl":
-          L = -M / k, b = S;
-          break;
-        default:
-          L = M / k, b = S;
-      }
-      u = R ? Math.abs(b) > I && x < i.value.length : !1, D.value = u, A(n, L, u);
-    }, m = (d) => {
-      d.preventDefault(), document.removeEventListener("mouseup", m), document.removeEventListener("mousemove", V), v.value && (v.value.removeEventListener("touchmove", p.value), v.value.removeEventListener("touchend", E.value)), p.value = null, E.value = null, v.value = null, K(u), c.value = -1, D.value = !1;
-    };
-    document.addEventListener("mouseup", m), document.addEventListener("mousemove", V), t.currentTarget.addEventListener("touchend", m), t.currentTarget.addEventListener("touchmove", V), p.value = V, E.value = m, v.value = t.currentTarget;
-  }, G = Z(() => {
-    const t = [...f.value].sort((e, s) => e - s), n = [...i.value].sort((e, s) => e - s), o = {};
-    n.forEach((e) => {
-      o[e] = (o[e] || 0) + 1;
-    }), t.forEach((e) => {
-      o[e] = (o[e] || 0) - 1;
-    });
-    const a = R ? 1 : 0;
-    return Object.values(o).reduce(
-      (e, s) => e + Math.abs(s),
-      0
-    ) <= a ? i.value : f.value;
-  });
-  return [c, Y, D, G, F];
+function useDrag(containerRef, direction, rawValues, min, max, formatValue, triggerChange, finishChange, offsetValues, editable, minCount) {
+	const draggingValue = ref(null);
+	const draggingIndex = ref(-1);
+	const draggingDelete = ref(false);
+	const cacheValues = ref(rawValues.value);
+	const originValues = ref(rawValues.value);
+	const mouseMoveEventRef = ref(null);
+	const mouseUpEventRef = ref(null);
+	const touchEventTargetRef = ref(null);
+	const { onDragStart, onDragChange } = inject(UnstableContextKey, defaultUnstableContextValue);
+	watch(rawValues, (val) => {
+		if (draggingIndex.value === -1) {
+			cacheValues.value = [...val];
+			originValues.value = [...val];
+		}
+	}, { immediate: true });
+	onUnmounted(() => {
+		document.removeEventListener("mousemove", mouseMoveEventRef.value);
+		document.removeEventListener("mouseup", mouseUpEventRef.value);
+		if (touchEventTargetRef.value) {
+			touchEventTargetRef.value.removeEventListener("touchmove", mouseMoveEventRef.value);
+			touchEventTargetRef.value.removeEventListener("touchend", mouseUpEventRef.value);
+		}
+	});
+	const flushValues = (nextValues, nextValue, deleteMark) => {
+		if (nextValue !== void 0) draggingValue.value = nextValue;
+		cacheValues.value = nextValues;
+		let changeValues = nextValues;
+		if (deleteMark) changeValues = nextValues.filter((_, i) => i !== draggingIndex.value);
+		triggerChange(changeValues);
+		if (onDragChange) onDragChange({
+			rawValues: nextValues,
+			deleteIndex: deleteMark ? draggingIndex.value : -1,
+			draggingIndex: draggingIndex.value,
+			draggingValue: nextValue
+		});
+	};
+	const updateCacheValue = useEvent((valueIndex, offsetPercent, deleteMark) => {
+		if (valueIndex === -1) {
+			const startValue = originValues.value[0];
+			const endValue = originValues.value[originValues.value.length - 1];
+			const maxStartOffset = min.value - startValue;
+			const maxEndOffset = max.value - endValue;
+			let offset = offsetPercent * (max.value - min.value);
+			offset = Math.max(offset, maxStartOffset);
+			offset = Math.min(offset, maxEndOffset);
+			offset = formatValue.value(startValue + offset) - startValue;
+			flushValues(originValues.value.map((val) => val + offset));
+		} else {
+			const offsetDist = (max.value - min.value) * offsetPercent;
+			const cloneValues = [...cacheValues.value];
+			cloneValues[valueIndex] = originValues.value[valueIndex];
+			const next = offsetValues.value(cloneValues, offsetDist, valueIndex, "dist");
+			flushValues(next.values, next.value, deleteMark);
+		}
+	});
+	const onStartMove = (e, valueIndex, startValues) => {
+		e.stopPropagation();
+		const initialValues = startValues || rawValues.value;
+		const originValue = initialValues[valueIndex];
+		draggingIndex.value = valueIndex;
+		draggingValue.value = originValue;
+		originValues.value = initialValues;
+		cacheValues.value = initialValues;
+		draggingDelete.value = false;
+		const { pageX: startX, pageY: startY } = getPosition(e);
+		let deleteMark = false;
+		if (onDragStart) onDragStart({
+			rawValues: initialValues,
+			draggingIndex: valueIndex,
+			draggingValue: originValue
+		});
+		const onMouseMove = (event) => {
+			event.preventDefault();
+			const { pageX: moveX, pageY: moveY } = getPosition(event);
+			const offsetX = moveX - startX;
+			const offsetY = moveY - startY;
+			const { width, height } = containerRef.value.getBoundingClientRect();
+			let offSetPercent;
+			let removeDist;
+			switch (direction.value) {
+				case "btt":
+					offSetPercent = -offsetY / height;
+					removeDist = offsetX;
+					break;
+				case "ttb":
+					offSetPercent = offsetY / height;
+					removeDist = offsetX;
+					break;
+				case "rtl":
+					offSetPercent = -offsetX / width;
+					removeDist = offsetY;
+					break;
+				default:
+					offSetPercent = offsetX / width;
+					removeDist = offsetY;
+			}
+			deleteMark = editable.value ? Math.abs(removeDist) > REMOVE_DIST && minCount.value < cacheValues.value.length : false;
+			draggingDelete.value = deleteMark;
+			updateCacheValue(valueIndex, offSetPercent, deleteMark);
+		};
+		const onMouseUp = (event) => {
+			event.preventDefault();
+			document.removeEventListener("mouseup", onMouseUp);
+			document.removeEventListener("mousemove", onMouseMove);
+			if (touchEventTargetRef.value) {
+				touchEventTargetRef.value.removeEventListener("touchmove", mouseMoveEventRef.value);
+				touchEventTargetRef.value.removeEventListener("touchend", mouseUpEventRef.value);
+			}
+			mouseMoveEventRef.value = null;
+			mouseUpEventRef.value = null;
+			touchEventTargetRef.value = null;
+			finishChange(deleteMark);
+			draggingIndex.value = -1;
+			draggingDelete.value = false;
+		};
+		document.addEventListener("mouseup", onMouseUp);
+		document.addEventListener("mousemove", onMouseMove);
+		e.currentTarget.addEventListener("touchend", onMouseUp);
+		e.currentTarget.addEventListener("touchmove", onMouseMove);
+		mouseMoveEventRef.value = onMouseMove;
+		mouseUpEventRef.value = onMouseUp;
+		touchEventTargetRef.value = e.currentTarget;
+	};
+	return [
+		draggingIndex,
+		draggingValue,
+		draggingDelete,
+		computed(() => {
+			const sourceValues = [...rawValues.value].sort((a, b) => a - b);
+			const targetValues = [...cacheValues.value].sort((a, b) => a - b);
+			const counts = {};
+			targetValues.forEach((val) => {
+				counts[val] = (counts[val] || 0) + 1;
+			});
+			sourceValues.forEach((val) => {
+				counts[val] = (counts[val] || 0) - 1;
+			});
+			const maxDiffCount = editable.value ? 1 : 0;
+			return Object.values(counts).reduce((prev, next) => prev + Math.abs(next), 0) <= maxDiffCount ? cacheValues.value : rawValues.value;
+		}),
+		onStartMove
+	];
 }
-export {
-  ne as default
-};
+var useDrag_default = useDrag;
+export { useDrag_default as default };

package/dist/hooks/useOffset.cjs

@@ -1 +1,124 @@
-"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const m=require("vue");function P(c,a,f,D,O,g){const w=m.computed(()=>n=>Math.max(c,Math.min(a,n))).value,V=m.computed(()=>n=>{if(f!==null){const l=c+Math.round((w(n)-c)/f)*f,u=r=>(String(r).split(".")[1]||"").length,o=Math.max(u(f),u(a),u(c)),t=Number(l.toFixed(o));return c<=t&&t<=a?t:null}return null}).value,y=m.computed(()=>n=>{const l=w(n),u=D.map(r=>r.value);f!==null&&u.push(V(n)),u.push(c,a);let o=u[0],t=a-c;return u.forEach(r=>{const h=Math.abs(l-r);h<=t&&(o=r,t=h)}),o}).value,b=(n,l,u,o="unit")=>{if(typeof l=="number"){let t;const r=n[u],h=r+l;let e=[];D.forEach(s=>{e.push(s.value)}),e.push(c,a),e.push(V(r));const i=l>0?1:-1;o==="unit"?e.push(V(r+i*f)):e.push(V(h)),e=e.filter(s=>s!==null).filter(s=>l<0?s<=r:s>=r),o==="unit"&&(e=e.filter(s=>s!==r));const S=o==="unit"?r:h;t=e[0];let E=Math.abs(t-S);if(e.forEach(s=>{const N=Math.abs(s-S);N<E&&(t=s,E=N)}),t===void 0)return l<0?c:a;if(o==="dist")return t;if(Math.abs(l)>1){const s=[...n];return s[u]=t,b(s,l-i,u,o)}return t}else{if(l==="min")return c;if(l==="max")return a}},M=(n,l,u,o="unit")=>{const t=n[u],r=b(n,l,u,o);return{value:r,changed:r!==t}},p=n=>g===null&&n===0||typeof g=="number"&&n<g;return[y,(n,l,u,o="unit")=>{const t=n.map(y),r=t[u],h=b(t,l,u,o);if(t[u]=h,O){if(typeof g=="number"||g===null){for(let e=u+1;e<t.length;e+=1){let i=!0;for(;p(t[e]-t[e-1])&&i;)({value:t[e],changed:i}=M(t,1,e))}for(let e=u;e>0;e-=1){let i=!0;for(;p(t[e]-t[e-1])&&i;)({value:t[e-1],changed:i}=M(t,-1,e-1))}for(let e=t.length-1;e>0;e-=1){let i=!0;for(;p(t[e]-t[e-1])&&i;)({value:t[e-1],changed:i}=M(t,-1,e-1))}for(let e=0;e<t.length-1;e+=1){let i=!0;for(;p(t[e+1]-t[e])&&i;)({value:t[e+1],changed:i}=M(t,1,e+1))}}}else{const e=g||0;u>0&&t[u-1]!==r&&(t[u]=Math.max(t[u],t[u-1]+e)),u<t.length-1&&t[u+1]!==r&&(t[u]=Math.min(t[u],t[u+1]-e))}return{value:t[u],values:t}}]}exports.default=P;
+Object.defineProperty(exports, "__esModule", { value: true });
+function useOffset(min, max, step, markList, allowCross, pushable) {
+	const formatRangeValue = (val) => Math.max(min.value, Math.min(max.value, val));
+	const formatStepValue = (val) => {
+		if (step.value !== null) {
+			const stepValue = min.value + Math.round((formatRangeValue(val) - min.value) / step.value) * step.value;
+			const getDecimal = (num) => (String(num).split(".")[1] || "").length;
+			const maxDecimal = Math.max(getDecimal(step.value), getDecimal(max.value), getDecimal(min.value));
+			const fixedValue = Number(stepValue.toFixed(maxDecimal));
+			return min.value <= fixedValue && fixedValue <= max.value ? fixedValue : null;
+		}
+		return null;
+	};
+	const formatValue = (val) => {
+		const formatNextValue = formatRangeValue(val);
+		const alignValues = markList.value.map((mark) => mark && mark.value);
+		if (step.value !== null) {
+			const stepValue = formatStepValue(val);
+			if (stepValue !== null) alignValues.push(stepValue);
+		}
+		alignValues.push(min.value, max.value);
+		let closeValue = alignValues[0];
+		let closeDist = max.value - min.value;
+		alignValues.forEach((alignValue) => {
+			const dist = Math.abs(formatNextValue - alignValue);
+			if (dist <= closeDist) {
+				closeValue = alignValue;
+				closeDist = dist;
+			}
+		});
+		return closeValue;
+	};
+	const offsetValue = (values, offset, valueIndex, mode = "unit") => {
+		if (typeof offset === "number") {
+			let nextValue;
+			const originValue = values[valueIndex];
+			const targetDistValue = originValue + offset;
+			let potentialValues = [];
+			markList.value.forEach((mark) => {
+				potentialValues.push(mark.value);
+			});
+			potentialValues.push(min.value, max.value);
+			const originStepValue = formatStepValue(originValue);
+			if (originStepValue !== null) potentialValues.push(originStepValue);
+			const sign = offset > 0 ? 1 : -1;
+			if (mode === "unit") {
+				if (step.value !== null) {
+					const allStepValues = formatStepValue(originValue + sign * step.value);
+					if (allStepValues !== null) potentialValues.push(allStepValues);
+				}
+			} else if (step.value !== null) {
+				const targetStepValue = formatStepValue(targetDistValue);
+				if (targetStepValue !== null) potentialValues.push(targetStepValue);
+			}
+			potentialValues = potentialValues.filter((val) => val !== null).filter((val) => offset < 0 ? val <= originValue : val >= originValue);
+			if (mode === "unit") potentialValues = potentialValues.filter((val) => val !== originValue);
+			const compareValue = mode === "unit" ? originValue : targetDistValue;
+			nextValue = potentialValues[0];
+			let valueDist = Math.abs(nextValue - compareValue);
+			potentialValues.forEach((potentialValue) => {
+				const dist = Math.abs(potentialValue - compareValue);
+				if (dist < valueDist) {
+					nextValue = potentialValue;
+					valueDist = dist;
+				}
+			});
+			if (nextValue === void 0) return offset < 0 ? min.value : max.value;
+			if (mode === "dist") return nextValue;
+			if (Math.abs(offset) > 1) {
+				const cloneValues = [...values];
+				cloneValues[valueIndex] = nextValue;
+				return offsetValue(cloneValues, offset - sign, valueIndex, mode);
+			}
+			return nextValue;
+		}
+		if (offset === "min") return min.value;
+		if (offset === "max") return max.value;
+		return values[valueIndex];
+	};
+	const offsetChangedValue = (values, offset, valueIndex, mode = "unit") => {
+		const originValue = values[valueIndex];
+		const nextValue = offsetValue(values, offset, valueIndex, mode);
+		return {
+			value: nextValue,
+			changed: nextValue !== originValue
+		};
+	};
+	const needPush = (dist) => {
+		return pushable.value === null && dist === 0 || typeof pushable.value === "number" && dist < pushable.value;
+	};
+	const offsetValues = (values, offset, valueIndex, mode = "unit") => {
+		const nextValues = values.map(formatValue);
+		const originValue = nextValues[valueIndex];
+		nextValues[valueIndex] = offsetValue(nextValues, offset, valueIndex, mode);
+		if (!allowCross.value) {
+			const pushNum = pushable.value || 0;
+			if (valueIndex > 0 && nextValues[valueIndex - 1] !== originValue) nextValues[valueIndex] = Math.max(nextValues[valueIndex], nextValues[valueIndex - 1] + pushNum);
+			if (valueIndex < nextValues.length - 1 && nextValues[valueIndex + 1] !== originValue) nextValues[valueIndex] = Math.min(nextValues[valueIndex], nextValues[valueIndex + 1] - pushNum);
+		} else if (typeof pushable.value === "number" || pushable.value === null) {
+			for (let i = valueIndex + 1; i < nextValues.length; i += 1) {
+				let changed = true;
+				while (needPush(nextValues[i] - nextValues[i - 1]) && changed) ({value: nextValues[i], changed} = offsetChangedValue(nextValues, 1, i));
+			}
+			for (let i = valueIndex; i > 0; i -= 1) {
+				let changed = true;
+				while (needPush(nextValues[i] - nextValues[i - 1]) && changed) ({value: nextValues[i - 1], changed} = offsetChangedValue(nextValues, -1, i - 1));
+			}
+			for (let i = nextValues.length - 1; i > 0; i -= 1) {
+				let changed = true;
+				while (needPush(nextValues[i] - nextValues[i - 1]) && changed) ({value: nextValues[i - 1], changed} = offsetChangedValue(nextValues, -1, i - 1));
+			}
+			for (let i = 0; i < nextValues.length - 1; i += 1) {
+				let changed = true;
+				while (needPush(nextValues[i + 1] - nextValues[i]) && changed) ({value: nextValues[i + 1], changed} = offsetChangedValue(nextValues, 1, i + 1));
+			}
+		}
+		return {
+			value: nextValues[valueIndex],
+			values: nextValues
+		};
+	};
+	return [formatValue, offsetValues];
+}
+exports.default = useOffset;

package/dist/hooks/useOffset.d.ts

@@ -1,3 +1,4 @@
+import { Ref } from 'vue';
 import { InternalMarkObj } from '../Marks';
 /** Format value align with step & marks */
 type FormatValue = (value: number) => number;
@@ -6,5 +7,5 @@ export type OffsetValues = (values: number[], offset: number | 'min' | 'max', va
     value: number;
     values: number[];
 };
-export default function useOffset(min: number, max: number, step: number, markList: InternalMarkObj[], allowCross: boolean, pushable: false | number): [FormatValue, OffsetValues];
+export default function useOffset(min: Ref<number>, max: Ref<number>, step: Ref<number | null>, markList: Ref<InternalMarkObj[]>, allowCross: Ref<boolean>, pushable: Ref<false | number | null>): [FormatValue, OffsetValues];
 export {};

package/dist/hooks/useOffset.js

@@ -1,98 +1,123 @@
-import { computed as m } from "vue";
-function P(c, a, f, w, C, V) {
-  const b = m(() => (n) => Math.max(c, Math.min(a, n))).value, g = m(() => (n) => {
-    if (f !== null) {
-      const l = c + Math.round((b(n) - c) / f) * f, r = (u) => (String(u).split(".")[1] || "").length, i = Math.max(r(f), r(a), r(c)), t = Number(l.toFixed(i));
-      return c <= t && t <= a ? t : null;
-    }
-    return null;
-  }).value, y = m(() => (n) => {
-    const l = b(n), r = w.map((u) => u.value);
-    f !== null && r.push(g(n)), r.push(c, a);
-    let i = r[0], t = a - c;
-    return r.forEach((u) => {
-      const h = Math.abs(l - u);
-      h <= t && (i = u, t = h);
-    }), i;
-  }).value, D = (n, l, r, i = "unit") => {
-    if (typeof l == "number") {
-      let t;
-      const u = n[r], h = u + l;
-      let e = [];
-      w.forEach((s) => {
-        e.push(s.value);
-      }), e.push(c, a), e.push(g(u));
-      const o = l > 0 ? 1 : -1;
-      i === "unit" ? e.push(g(u + o * f)) : e.push(g(h)), e = e.filter((s) => s !== null).filter((s) => l < 0 ? s <= u : s >= u), i === "unit" && (e = e.filter((s) => s !== u));
-      const E = i === "unit" ? u : h;
-      t = e[0];
-      let N = Math.abs(t - E);
-      if (e.forEach((s) => {
-        const S = Math.abs(s - E);
-        S < N && (t = s, N = S);
-      }), t === void 0)
-        return l < 0 ? c : a;
-      if (i === "dist")
-        return t;
-      if (Math.abs(l) > 1) {
-        const s = [...n];
-        return s[r] = t, D(s, l - o, r, i);
-      }
-      return t;
-    } else {
-      if (l === "min")
-        return c;
-      if (l === "max")
-        return a;
-    }
-  }, p = (n, l, r, i = "unit") => {
-    const t = n[r], u = D(n, l, r, i);
-    return {
-      value: u,
-      changed: u !== t
-    };
-  }, M = (n) => V === null && n === 0 || typeof V == "number" && n < V;
-  return [y, (n, l, r, i = "unit") => {
-    const t = n.map(y), u = t[r], h = D(t, l, r, i);
-    if (t[r] = h, C) {
-      if (typeof V == "number" || V === null) {
-        for (let e = r + 1; e < t.length; e += 1) {
-          let o = !0;
-          for (; M(t[e] - t[e - 1]) && o; )
-            ({ value: t[e], changed: o } = p(t, 1, e));
-        }
-        for (let e = r; e > 0; e -= 1) {
-          let o = !0;
-          for (; M(t[e] - t[e - 1]) && o; )
-            ({ value: t[e - 1], changed: o } = p(t, -1, e - 1));
-        }
-        for (let e = t.length - 1; e > 0; e -= 1) {
-          let o = !0;
-          for (; M(t[e] - t[e - 1]) && o; )
-            ({ value: t[e - 1], changed: o } = p(t, -1, e - 1));
-        }
-        for (let e = 0; e < t.length - 1; e += 1) {
-          let o = !0;
-          for (; M(t[e + 1] - t[e]) && o; )
-            ({ value: t[e + 1], changed: o } = p(t, 1, e + 1));
-        }
-      }
-    } else {
-      const e = V || 0;
-      r > 0 && t[r - 1] !== u && (t[r] = Math.max(
-        t[r],
-        t[r - 1] + e
-      )), r < t.length - 1 && t[r + 1] !== u && (t[r] = Math.min(
-        t[r],
-        t[r + 1] - e
-      ));
-    }
-    return {
-      value: t[r],
-      values: t
-    };
-  }];
+function useOffset(min, max, step, markList, allowCross, pushable) {
+	const formatRangeValue = (val) => Math.max(min.value, Math.min(max.value, val));
+	const formatStepValue = (val) => {
+		if (step.value !== null) {
+			const stepValue = min.value + Math.round((formatRangeValue(val) - min.value) / step.value) * step.value;
+			const getDecimal = (num) => (String(num).split(".")[1] || "").length;
+			const maxDecimal = Math.max(getDecimal(step.value), getDecimal(max.value), getDecimal(min.value));
+			const fixedValue = Number(stepValue.toFixed(maxDecimal));
+			return min.value <= fixedValue && fixedValue <= max.value ? fixedValue : null;
+		}
+		return null;
+	};
+	const formatValue = (val) => {
+		const formatNextValue = formatRangeValue(val);
+		const alignValues = markList.value.map((mark) => mark && mark.value);
+		if (step.value !== null) {
+			const stepValue = formatStepValue(val);
+			if (stepValue !== null) alignValues.push(stepValue);
+		}
+		alignValues.push(min.value, max.value);
+		let closeValue = alignValues[0];
+		let closeDist = max.value - min.value;
+		alignValues.forEach((alignValue) => {
+			const dist = Math.abs(formatNextValue - alignValue);
+			if (dist <= closeDist) {
+				closeValue = alignValue;
+				closeDist = dist;
+			}
+		});
+		return closeValue;
+	};
+	const offsetValue = (values, offset, valueIndex, mode = "unit") => {
+		if (typeof offset === "number") {
+			let nextValue;
+			const originValue = values[valueIndex];
+			const targetDistValue = originValue + offset;
+			let potentialValues = [];
+			markList.value.forEach((mark) => {
+				potentialValues.push(mark.value);
+			});
+			potentialValues.push(min.value, max.value);
+			const originStepValue = formatStepValue(originValue);
+			if (originStepValue !== null) potentialValues.push(originStepValue);
+			const sign = offset > 0 ? 1 : -1;
+			if (mode === "unit") {
+				if (step.value !== null) {
+					const allStepValues = formatStepValue(originValue + sign * step.value);
+					if (allStepValues !== null) potentialValues.push(allStepValues);
+				}
+			} else if (step.value !== null) {
+				const targetStepValue = formatStepValue(targetDistValue);
+				if (targetStepValue !== null) potentialValues.push(targetStepValue);
+			}
+			potentialValues = potentialValues.filter((val) => val !== null).filter((val) => offset < 0 ? val <= originValue : val >= originValue);
+			if (mode === "unit") potentialValues = potentialValues.filter((val) => val !== originValue);
+			const compareValue = mode === "unit" ? originValue : targetDistValue;
+			nextValue = potentialValues[0];
+			let valueDist = Math.abs(nextValue - compareValue);
+			potentialValues.forEach((potentialValue) => {
+				const dist = Math.abs(potentialValue - compareValue);
+				if (dist < valueDist) {
+					nextValue = potentialValue;
+					valueDist = dist;
+				}
+			});
+			if (nextValue === void 0) return offset < 0 ? min.value : max.value;
+			if (mode === "dist") return nextValue;
+			if (Math.abs(offset) > 1) {
+				const cloneValues = [...values];
+				cloneValues[valueIndex] = nextValue;
+				return offsetValue(cloneValues, offset - sign, valueIndex, mode);
+			}
+			return nextValue;
+		}
+		if (offset === "min") return min.value;
+		if (offset === "max") return max.value;
+		return values[valueIndex];
+	};
+	const offsetChangedValue = (values, offset, valueIndex, mode = "unit") => {
+		const originValue = values[valueIndex];
+		const nextValue = offsetValue(values, offset, valueIndex, mode);
+		return {
+			value: nextValue,
+			changed: nextValue !== originValue
+		};
+	};
+	const needPush = (dist) => {
+		return pushable.value === null && dist === 0 || typeof pushable.value === "number" && dist < pushable.value;
+	};
+	const offsetValues = (values, offset, valueIndex, mode = "unit") => {
+		const nextValues = values.map(formatValue);
+		const originValue = nextValues[valueIndex];
+		nextValues[valueIndex] = offsetValue(nextValues, offset, valueIndex, mode);
+		if (!allowCross.value) {
+			const pushNum = pushable.value || 0;
+			if (valueIndex > 0 && nextValues[valueIndex - 1] !== originValue) nextValues[valueIndex] = Math.max(nextValues[valueIndex], nextValues[valueIndex - 1] + pushNum);
+			if (valueIndex < nextValues.length - 1 && nextValues[valueIndex + 1] !== originValue) nextValues[valueIndex] = Math.min(nextValues[valueIndex], nextValues[valueIndex + 1] - pushNum);
+		} else if (typeof pushable.value === "number" || pushable.value === null) {
+			for (let i = valueIndex + 1; i < nextValues.length; i += 1) {
+				let changed = true;
+				while (needPush(nextValues[i] - nextValues[i - 1]) && changed) ({value: nextValues[i], changed} = offsetChangedValue(nextValues, 1, i));
+			}
+			for (let i = valueIndex; i > 0; i -= 1) {
+				let changed = true;
+				while (needPush(nextValues[i] - nextValues[i - 1]) && changed) ({value: nextValues[i - 1], changed} = offsetChangedValue(nextValues, -1, i - 1));
+			}
+			for (let i = nextValues.length - 1; i > 0; i -= 1) {
+				let changed = true;
+				while (needPush(nextValues[i] - nextValues[i - 1]) && changed) ({value: nextValues[i - 1], changed} = offsetChangedValue(nextValues, -1, i - 1));
+			}
+			for (let i = 0; i < nextValues.length - 1; i += 1) {
+				let changed = true;
+				while (needPush(nextValues[i + 1] - nextValues[i]) && changed) ({value: nextValues[i + 1], changed} = offsetChangedValue(nextValues, 1, i + 1));
+			}
+		}
+		return {
+			value: nextValues[valueIndex],
+			values: nextValues
+		};
+	};
+	return [formatValue, offsetValues];
 }
-export {
-  P as default
-};
+export { useOffset as default };

package/dist/hooks/useRange.cjs

@@ -1 +1,21 @@
-"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const u=require("@v-c/util/dist/warning");function i(e){if(e===!0||!e)return[!!e,!1,!1,0];const{editable:t=!1,draggableTrack:r=!1,minCount:a,maxCount:n}=e;return process.env.NODE_ENV!=="production"&&u.warning(!t||!r,"`editable` can not work with `draggableTrack`."),[!0,t,!t&&r,a||0,n]}exports.default=i;
+Object.defineProperty(exports, "__esModule", { value: true });
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+let __v_c_util_dist_warning = require("@v-c/util/dist/warning");
+function useRange(range) {
+	if (range === true || !range) return [
+		!!range,
+		false,
+		false,
+		0
+	];
+	const { editable = false, draggableTrack = false, minCount, maxCount } = range;
+	if (process.env.NODE_ENV !== "production") (0, __v_c_util_dist_warning.warning)(!editable || !draggableTrack, "`editable` can not work with `draggableTrack`.");
+	return [
+		true,
+		editable,
+		!editable && draggableTrack,
+		minCount || 0,
+		maxCount
+	];
+}
+exports.default = useRange;