@octanejs/base-ui 0.1.30 → 0.1.32

package/dist/cjs/utils/resolveClassName.cjs

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resolveClassName_exports = {};
+__export(resolveClassName_exports, {
+  resolveClassName: () => resolveClassName
+});
+module.exports = __toCommonJS(resolveClassName_exports);
+function resolveClassName(className, state) {
+  return typeof className === "function" ? className(state) : className;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveClassName
+});

package/dist/cjs/utils/resolveRef.cjs

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resolveRef_exports = {};
+__export(resolveRef_exports, {
+  resolveRef: () => resolveRef
+});
+module.exports = __toCommonJS(resolveRef_exports);
+function resolveRef(maybeRef) {
+  if (maybeRef == null) {
+    return maybeRef;
+  }
+  return "current" in maybeRef ? maybeRef.current : maybeRef;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveRef
+});

package/dist/cjs/utils/resolveStyle.cjs

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resolveStyle_exports = {};
+__export(resolveStyle_exports, {
+  resolveStyle: () => resolveStyle
+});
+module.exports = __toCommonJS(resolveStyle_exports);
+function resolveStyle(style, state) {
+  return typeof style === "function" ? style(state) : style;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveStyle
+});

package/dist/cjs/utils/serializeValue.cjs

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serializeValue_exports = {};
+__export(serializeValue_exports, {
+  serializeValue: () => serializeValue
+});
+module.exports = __toCommonJS(serializeValue_exports);
+function serializeValue(value) {
+  if (value == null) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  serializeValue
+});

package/dist/cjs/utils/slider/asc.cjs

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var asc_exports = {};
+__export(asc_exports, {
+  asc: () => asc
+});
+module.exports = __toCommonJS(asc_exports);
+function asc(a, b) {
+  return a - b;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  asc
+});

package/dist/cjs/utils/slider/getMidpoint.cjs

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getMidpoint_exports = {};
+__export(getMidpoint_exports, {
+  getMidpoint: () => getMidpoint
+});
+module.exports = __toCommonJS(getMidpoint_exports);
+function getMidpoint(element) {
+  const rect = element.getBoundingClientRect();
+  return {
+    x: (rect.left + rect.right) / 2,
+    y: (rect.top + rect.bottom) / 2
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMidpoint
+});

package/dist/cjs/utils/slider/getPushedThumbValues.cjs

@@ -0,0 +1,73 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getPushedThumbValues_exports = {};
+__export(getPushedThumbValues_exports, {
+  getPushedThumbValues: () => getPushedThumbValues
+});
+module.exports = __toCommonJS(getPushedThumbValues_exports);
+var import_clamp = require("../clamp.cjs");
+function getPushedThumbValues({
+  values,
+  index,
+  nextValue,
+  min,
+  max,
+  step,
+  minStepsBetweenValues,
+  initialValues
+}) {
+  if (values.length === 0) {
+    return [];
+  }
+  const nextValues = values.slice();
+  const minValueDifference = step * minStepsBetweenValues;
+  const lastIndex = nextValues.length - 1;
+  const baseInitialValues = initialValues ?? values;
+  const indexMin = min + index * minValueDifference;
+  const indexMax = max - (lastIndex - index) * minValueDifference;
+  nextValues[index] = (0, import_clamp.clamp)(nextValue, indexMin, indexMax);
+  for (let i = index + 1; i <= lastIndex; i += 1) {
+    const minAllowed = nextValues[i - 1] + minValueDifference;
+    const maxAllowed = max - (lastIndex - i) * minValueDifference;
+    const initialValue = baseInitialValues[i] ?? nextValues[i];
+    let candidate = Math.max(nextValues[i], minAllowed);
+    if (initialValue < candidate) {
+      candidate = Math.max(initialValue, minAllowed);
+    }
+    nextValues[i] = (0, import_clamp.clamp)(candidate, minAllowed, maxAllowed);
+  }
+  for (let i = index - 1; i >= 0; i -= 1) {
+    const maxAllowed = nextValues[i + 1] - minValueDifference;
+    const minAllowed = min + i * minValueDifference;
+    const initialValue = baseInitialValues[i] ?? nextValues[i];
+    let candidate = Math.min(nextValues[i], maxAllowed);
+    if (initialValue > candidate) {
+      candidate = Math.min(initialValue, maxAllowed);
+    }
+    nextValues[i] = (0, import_clamp.clamp)(candidate, minAllowed, maxAllowed);
+  }
+  for (let i = 0; i <= lastIndex; i += 1) {
+    nextValues[i] = Number(nextValues[i].toFixed(12));
+  }
+  return nextValues;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPushedThumbValues
+});

package/dist/cjs/utils/slider/getSliderValue.cjs

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getSliderValue_exports = {};
+__export(getSliderValue_exports, {
+  getSliderValue: () => getSliderValue
+});
+module.exports = __toCommonJS(getSliderValue_exports);
+var import_clamp = require("../clamp.cjs");
+var import_replaceArrayItemAtIndex = require("./replaceArrayItemAtIndex.cjs");
+function getSliderValue(valueInput, index, min, max, range, values) {
+  let newValue = valueInput;
+  newValue = (0, import_clamp.clamp)(newValue, min, max);
+  if (range) {
+    newValue = (0, import_replaceArrayItemAtIndex.replaceArrayItemAtIndex)(
+      values,
+      index,
+      // Bound the new value to the thumb's neighbours.
+      (0, import_clamp.clamp)(newValue, values[index - 1] ?? -Infinity, values[index + 1] ?? Infinity)
+    );
+  }
+  return newValue;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSliderValue
+});

package/dist/cjs/utils/slider/replaceArrayItemAtIndex.cjs

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var replaceArrayItemAtIndex_exports = {};
+__export(replaceArrayItemAtIndex_exports, {
+  replaceArrayItemAtIndex: () => replaceArrayItemAtIndex
+});
+module.exports = __toCommonJS(replaceArrayItemAtIndex_exports);
+var import_asc = require("./asc.cjs");
+function replaceArrayItemAtIndex(array, index, newValue) {
+  const output = array.slice();
+  output[index] = newValue;
+  return output.sort(import_asc.asc);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  replaceArrayItemAtIndex
+});

package/dist/cjs/utils/slider/resolveThumbCollision.cjs

@@ -0,0 +1,155 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resolveThumbCollision_exports = {};
+__export(resolveThumbCollision_exports, {
+  resolveThumbCollision: () => resolveThumbCollision
+});
+module.exports = __toCommonJS(resolveThumbCollision_exports);
+var import_clamp = require("../clamp.cjs");
+var import_getPushedThumbValues = require("./getPushedThumbValues.cjs");
+function resolveThumbCollision({
+  behavior,
+  values,
+  currentValues,
+  initialValues,
+  pressedIndex,
+  nextValue,
+  min,
+  max,
+  step,
+  minStepsBetweenValues
+}) {
+  const activeValues = currentValues ?? values;
+  const baselineValues = initialValues ?? values;
+  const range = activeValues.length > 1;
+  if (!range) {
+    return {
+      value: nextValue,
+      thumbIndex: 0,
+      didSwap: false
+    };
+  }
+  const minValueDifference = step * minStepsBetweenValues;
+  switch (behavior) {
+    case "swap": {
+      const pressedInitialValue = activeValues[pressedIndex];
+      const epsilon = 1e-7;
+      const candidateValues = activeValues.slice();
+      const previousNeighbor = candidateValues[pressedIndex - 1];
+      const nextNeighbor = candidateValues[pressedIndex + 1];
+      const lowerBound = previousNeighbor != null ? previousNeighbor + minValueDifference : min;
+      const upperBound = nextNeighbor != null ? nextNeighbor - minValueDifference : max;
+      const constrainedValue = (0, import_clamp.clamp)(nextValue, lowerBound, upperBound);
+      const pressedValueAfterClamp = Number(constrainedValue.toFixed(12));
+      candidateValues[pressedIndex] = pressedValueAfterClamp;
+      const movingForward = nextValue > pressedInitialValue;
+      const movingBackward = nextValue < pressedInitialValue;
+      const shouldSwapForward = movingForward && nextNeighbor != null && nextValue >= nextNeighbor - epsilon;
+      const shouldSwapBackward = movingBackward && previousNeighbor != null && nextValue <= previousNeighbor + epsilon;
+      if (!shouldSwapForward && !shouldSwapBackward) {
+        return {
+          value: candidateValues,
+          thumbIndex: pressedIndex,
+          didSwap: false
+        };
+      }
+      const targetIndex = shouldSwapForward ? pressedIndex + 1 : pressedIndex - 1;
+      const initialValuesForPush = candidateValues.map((_, index) => {
+        if (index === pressedIndex) {
+          return pressedValueAfterClamp;
+        }
+        const baseline = baselineValues[index];
+        if (baseline != null) {
+          return baseline;
+        }
+        return activeValues[index];
+      });
+      let nextValueForTarget = nextValue;
+      if (shouldSwapForward) {
+        nextValueForTarget = Math.max(nextValue, candidateValues[targetIndex]);
+      } else {
+        nextValueForTarget = Math.min(nextValue, candidateValues[targetIndex]);
+      }
+      const adjustedValues = (0, import_getPushedThumbValues.getPushedThumbValues)({
+        values: candidateValues,
+        index: targetIndex,
+        nextValue: nextValueForTarget,
+        min,
+        max,
+        step,
+        minStepsBetweenValues,
+        initialValues: initialValuesForPush
+      });
+      const neighborIndex = shouldSwapForward ? targetIndex - 1 : targetIndex + 1;
+      if (neighborIndex >= 0 && neighborIndex < adjustedValues.length) {
+        const previousValue = adjustedValues[neighborIndex - 1];
+        const nextValueAfter = adjustedValues[neighborIndex + 1];
+        let neighborLowerBound = previousValue != null ? previousValue + minValueDifference : min;
+        neighborLowerBound = Math.max(neighborLowerBound, min + neighborIndex * minValueDifference);
+        let neighborUpperBound = nextValueAfter != null ? nextValueAfter - minValueDifference : max;
+        neighborUpperBound = Math.min(
+          neighborUpperBound,
+          max - (adjustedValues.length - 1 - neighborIndex) * minValueDifference
+        );
+        const restoredValue = (0, import_clamp.clamp)(pressedValueAfterClamp, neighborLowerBound, neighborUpperBound);
+        adjustedValues[neighborIndex] = Number(restoredValue.toFixed(12));
+      }
+      return {
+        value: adjustedValues,
+        thumbIndex: targetIndex,
+        didSwap: true
+      };
+    }
+    case "push": {
+      const nextValues = (0, import_getPushedThumbValues.getPushedThumbValues)({
+        values: activeValues,
+        index: pressedIndex,
+        nextValue,
+        min,
+        max,
+        step,
+        minStepsBetweenValues
+      });
+      return {
+        value: nextValues,
+        thumbIndex: pressedIndex,
+        didSwap: false
+      };
+    }
+    case "none":
+    default: {
+      const candidateValues = activeValues.slice();
+      const previousNeighbor = candidateValues[pressedIndex - 1];
+      const nextNeighbor = candidateValues[pressedIndex + 1];
+      const lowerBound = previousNeighbor != null ? previousNeighbor + minValueDifference : min;
+      const upperBound = nextNeighbor != null ? nextNeighbor - minValueDifference : max;
+      const constrainedValue = (0, import_clamp.clamp)(nextValue, lowerBound, upperBound);
+      candidateValues[pressedIndex] = Number(constrainedValue.toFixed(12));
+      return {
+        value: candidateValues,
+        thumbIndex: pressedIndex,
+        didSwap: false
+      };
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveThumbCollision
+});

package/dist/cjs/utils/slider/roundValueToStep.cjs

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var roundValueToStep_exports = {};
+__export(roundValueToStep_exports, {
+  getDecimalPrecision: () => getDecimalPrecision,
+  roundValueToStep: () => roundValueToStep
+});
+module.exports = __toCommonJS(roundValueToStep_exports);
+function getDecimalPrecision(num) {
+  if (num === 0) {
+    return 0;
+  }
+  if (Math.abs(num) < 1) {
+    const parts = num.toExponential().split("e-");
+    const matissaDecimalPart = parts[0].split(".")[1];
+    return (matissaDecimalPart ? matissaDecimalPart.length : 0) + parseInt(parts[1], 10);
+  }
+  const decimalPart = num.toString().split(".")[1];
+  return decimalPart ? decimalPart.length : 0;
+}
+function roundValueToStep(value, step, min) {
+  const nearest = Math.round((value - min) / step) * step + min;
+  return Number(nearest.toFixed(Math.max(getDecimalPrecision(step), getDecimalPrecision(min))));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDecimalPrecision,
+  roundValueToStep
+});

package/dist/cjs/utils/slider/validateMinimumDistance.cjs

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validateMinimumDistance_exports = {};
+__export(validateMinimumDistance_exports, {
+  validateMinimumDistance: () => validateMinimumDistance
+});
+module.exports = __toCommonJS(validateMinimumDistance_exports);
+function validateMinimumDistance(values, step, minStepsBetweenValues) {
+  if (!Array.isArray(values)) {
+    return true;
+  }
+  const distances = values.reduce((acc, val, index, vals) => {
+    if (index === vals.length - 1) {
+      return acc;
+    }
+    acc.push(Math.abs(val - vals[index + 1]));
+    return acc;
+  }, []);
+  return Math.min(...distances) >= step * minStepsBetweenValues;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validateMinimumDistance
+});

package/dist/cjs/utils/slider/valueArrayToPercentages.cjs

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var valueArrayToPercentages_exports = {};
+__export(valueArrayToPercentages_exports, {
+  valueArrayToPercentages: () => valueArrayToPercentages
+});
+module.exports = __toCommonJS(valueArrayToPercentages_exports);
+var import_clamp = require("../clamp.cjs");
+var import_valueToPercent = require("../valueToPercent.cjs");
+function valueArrayToPercentages(values, min, max) {
+  const output = [];
+  for (let i = 0; i < values.length; i += 1) {
+    output.push((0, import_clamp.clamp)((0, import_valueToPercent.valueToPercent)(values[i], min, max), 0, 100));
+  }
+  return output;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  valueArrayToPercentages
+});