@reforma/components 0.0.0-stage → 0.1.0

package/dist/AngleControl/angle.js

@@ -0,0 +1,188 @@
+import { clamp as M, angleToDegrees as R, UNIT_PRECISION as l, angleFromDegrees as y } from "@reforma/lib";
+import { isAngleUnit as tn } from "@reforma/lib";
+const I = {
+  deg: l.deg ?? 0,
+  grad: l.grad ?? 2,
+  rad: l.rad ?? 3,
+  turn: l.turn ?? 3
+}, N = [0, 45, 90, 135, 180, 225, 270, 315], _ = 72, f = 2, $ = [1, 2, 3, 4, 6, 8, 12], x = 1e-3, T = 2, V = {
+  sm: {
+    size: 30,
+    handleRadius: 9 - f,
+    handleSize: 6
+  },
+  md: {
+    size: 36,
+    handleRadius: 11 - f,
+    handleSize: 8
+  },
+  lg: {
+    size: 56,
+    handleRadius: 18 - f,
+    handleSize: 10
+  }
+};
+function Z(n) {
+  return R(n);
+}
+function v(n, t) {
+  return y(n, t);
+}
+function c(n) {
+  return (n % 360 + 360) % 360;
+}
+function F(n) {
+  const t = c(n);
+  return t > 180 ? t - 360 : t;
+}
+function A(n, t = "unbounded") {
+  return t === "positive" ? c(n) : t === "signed" ? F(n) : n;
+}
+function P(n, t) {
+  const e = typeof t == "number" ? t : t?.[n] ?? I[n];
+  return Number.isFinite(e) ? Math.max(0, Math.trunc(e)) : I[n];
+}
+function b(n, t) {
+  if (!Number.isFinite(n))
+    return n;
+  const e = 10 ** t, r = Math.round((n + Number.EPSILON) * e) / e;
+  return Object.is(r, -0) ? 0 : r;
+}
+function D(n, t) {
+  return {
+    value: b(n.value, P(n.unit, t)),
+    unit: n.unit
+  };
+}
+function W(n, t, e, r) {
+  const i = D(n, t);
+  return {
+    value: M(e ?? -1 / 0, i.value, r ?? 1 / 0),
+    unit: i.unit
+  };
+}
+function z(n, t = {}) {
+  const e = P(n.unit, t.precision), r = t.trimTrailingZeros ?? !0, i = D(n, e).value.toFixed(e), o = r ? i.replace(/(\.\d*?)0+$/, "$1").replace(/\.$/, "") : i;
+  return `${o === "-0" ? "0" : o}${n.unit}`;
+}
+function O(n, t) {
+  return z(n, t).slice(0, -n.unit.length);
+}
+function S(n, t) {
+  let e = Math.abs(n), r = Math.abs(t);
+  for (; r !== 0; ) {
+    const i = e % r;
+    e = r, r = i;
+  }
+  return e || 1;
+}
+function L(n) {
+  let t = 0, e = 1, r = 1 / 0;
+  for (const d of $) {
+    const h = Math.round(n / Math.PI * d), p = h / d * Math.PI, g = Math.abs(p - n);
+    g < r && (t = h, e = d, r = g);
+  }
+  if (r > x)
+    return null;
+  if (t === 0)
+    return "0";
+  const i = S(t, e), o = t / i, s = e / i, a = o < 0 ? "-" : "", u = Math.abs(o), m = u === 1 ? "π" : `${u}π`;
+  return s === 1 ? `${a}${m}` : `${a}${m}/${s}`;
+}
+function C(n, t) {
+  const e = typeof t == "number" ? t : t?.rad ?? T, r = b(n / Math.PI, e);
+  return r === 0 ? "0" : r === 1 ? "π" : r === -1 ? "-π" : `${r.toFixed(e).replace(/(\.\d*?)0+$/, "$1").replace(/\.$/, "")}π`;
+}
+function G(n, t) {
+  return n.unit === "rad" ? L(n.value) ?? C(n.value, t?.precision) : O(n, t);
+}
+function j(n, t) {
+  return `${G(n, t)}${n.unit}`;
+}
+function w(n, t) {
+  const e = Math.abs(c(n) - c(t));
+  return Math.min(e, 360 - e);
+}
+function H(n, t, e = {}) {
+  const r = n.x - t.x, i = n.y - t.y, o = e.zero ?? "top", s = e.direction ?? "clockwise", a = o === "top" ? Math.atan2(r, -i) * (180 / Math.PI) : Math.atan2(i, r) * (180 / Math.PI);
+  return c(s === "clockwise" ? a : -a);
+}
+function K(n, t, e, r = {}) {
+  const i = r.zero ?? "top", a = ((r.direction ?? "clockwise") === "clockwise" ? n : -n) * (Math.PI / 180);
+  return i === "right" ? {
+    x: e.x + Math.cos(a) * t,
+    y: e.y + Math.sin(a) * t
+  } : {
+    x: e.x + Math.sin(a) * t,
+    y: e.y - Math.cos(a) * t
+  };
+}
+function X(n = _) {
+  return {
+    controlSize: n,
+    handleRadius: n * 0.375 - f,
+    handleSize: Math.max(10, n * 0.125),
+    presetRadius: n * 0.4 - f
+  };
+}
+function U(n, t = N) {
+  let e = t[0] ?? 0, r = 1 / 0;
+  for (const i of t) {
+    const o = w(n, i);
+    o < r && (e = i, r = o);
+  }
+  return c(e);
+}
+function E(n, t) {
+  const e = c(t), r = Math.trunc(n / 360) * 360;
+  return [r - 360 + e, r + e, r + 360 + e].reduce((o, s) => {
+    const a = Math.abs(o - n), u = Math.abs(s - n);
+    return u < a || u === a && s > o ? s : o;
+  });
+}
+function Y(n, t, e = "unbounded", r = "canonical") {
+  return r === "preserve-revolution" ? A(E(n, t), e) : A(t, e === "unbounded" ? "positive" : e);
+}
+function q(n, t, e) {
+  return M(t ?? -1 / 0, n, e ?? 1 / 0);
+}
+function B(n, t = N, e = 4) {
+  const r = U(n, t), i = E(n, r);
+  return Math.abs(i - n) <= e ? i : n;
+}
+function J(n, t) {
+  let e = c(t) - c(n);
+  return e > 180 ? e -= 360 : e < -180 && (e += 360), e;
+}
+export {
+  V as ANGLE_PREVIEW_GEOMETRY,
+  f as ANGLE_RING_WIDTH,
+  _ as DEFAULT_ANGLE_EXPANDED_SIZE,
+  I as DEFAULT_ANGLE_PRECISION,
+  N as DEFAULT_ANGLE_PRESETS,
+  w as angleDistance,
+  A as applyAngleValueRange,
+  Y as applyPresetDegrees,
+  E as applyPresetKeepingRevolution,
+  q as clampAngle,
+  z as formatAngle,
+  j as formatAngleDisplay,
+  G as formatAngleDisplayNumber,
+  O as formatAngleNumber,
+  v as fromDegrees,
+  X as getAngleDialGeometry,
+  H as getAngleFromPoint,
+  P as getAnglePrecision,
+  K as getPointOnCircle,
+  U as getPresetForAngle,
+  tn as isAngleUnit,
+  c as normalizeDegrees,
+  F as normalizeSignedDegrees,
+  b as roundAngleNumber,
+  D as roundAngleValue,
+  W as roundAngleValueInRange,
+  J as shortestAngleDelta,
+  B as snapDegreesToPresets,
+  Z as toDegrees
+};
+//# sourceMappingURL=angle.js.map

package/dist/AngleControl/angle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"angle.js","sources":["../../src/AngleControl/angle.ts"],"sourcesContent":["import {\n    angleFromDegrees,\n    angleToDegrees,\n    clamp,\n    isAngleUnit,\n    parseAngleValue,\n    UNIT_PRECISION,\n} from '@reforma/lib';\n\nimport type { AngleUnit, AngleUnitValue } from '@reforma/lib';\nimport type { CSSProperties, Ref } from 'react';\n\nexport type { AngleUnit } from '@reforma/lib';\n\nexport type AngleString = `${ number }${ AngleUnit }`;\n\nexport interface AngleValue extends AngleUnitValue {}\n\nexport type AngleChangeSource = 'drag' | 'preset' | 'input' | 'keyboard';\n\nexport interface AngleChangeMeta {\n    source: AngleChangeSource;\n    degrees: number;\n    normalizedDegrees: number;\n    unit: AngleUnit;\n    committed: boolean;\n}\n\nexport type AngleControlSize = 'sm' | 'md' | 'lg';\n\nexport type AnglePrecision = number | Partial<Record<AngleUnit, number>>;\nexport type AngleValueRange = 'unbounded' | 'positive' | 'signed';\nexport type AnglePresetBehavior = 'canonical' | 'preserve-revolution';\n\nexport interface AngleControlProps {\n    ref?: Ref<HTMLButtonElement | null>;\n    value?: AngleValue;\n    defaultValue?: AngleValue;\n    onChange?: (value: AngleValue, meta: AngleChangeMeta) => void;\n    onChangeEnd?: (value: AngleValue, meta: AngleChangeMeta) => void;\n    unit?: AngleUnit;\n    presets?: readonly number[];\n    snap?: boolean;\n    snapThresholdDeg?: number;\n    isDisabled?: boolean;\n    isReadOnly?: boolean;\n    min?: number;\n    max?: number;\n    step?: number;\n    precision?: AnglePrecision;\n    valueRange?: AngleValueRange;\n    presetBehavior?: AnglePresetBehavior;\n    size?: AngleControlSize;\n    expandedSize?: number;\n    showInlineInput?: boolean;\n    className?: string;\n    popoverClassName?: string;\n    style?: CSSProperties;\n    isOpen?: boolean;\n    defaultOpen?: boolean;\n    onOpenChange?: (isOpen: boolean) => void;\n    ariaLabel?: string;\n    ariaLabelledBy?: string;\n}\n\nexport interface AnglePoint {\n    x: number;\n    y: number;\n}\n\nexport interface AngleDialGeometry {\n    controlSize: number;\n    handleRadius: number;\n    handleSize: number;\n    presetRadius: number;\n}\n\nexport interface AngleGeometryOptions {\n    /**\n     * 0deg is at 12 o'clock,\n     * positive values rotate clockwise.\n     */\n    zero?: 'top' | 'right';\n    direction?: 'clockwise' | 'counterclockwise';\n}\n\nexport const DEFAULT_ANGLE_PRECISION: Record<AngleUnit, number> = {\n    deg: UNIT_PRECISION.deg ?? 0,\n    grad: UNIT_PRECISION.grad ?? 2,\n    rad: UNIT_PRECISION.rad ?? 3,\n    turn: UNIT_PRECISION.turn ?? 3,\n};\n\nexport const DEFAULT_ANGLE_PRESETS = [0, 45, 90, 135, 180, 225, 270, 315] as const;\nexport const DEFAULT_ANGLE_EXPANDED_SIZE = 72;\nexport const ANGLE_RING_WIDTH = 2;\nconst RADIAN_PI_DENOMINATORS = [1, 2, 3, 4, 6, 8, 12] as const;\nconst PI_FRACTION_TOLERANCE_RADIANS = 0.001;\nconst PI_COEFFICIENT_PRECISION = 2;\n\nexport const ANGLE_PREVIEW_GEOMETRY: Record<AngleControlSize, {\n    size: number;\n    handleRadius: number;\n    handleSize: number;\n}> = {\n    sm: { size: 30, handleRadius: 9 - ANGLE_RING_WIDTH, handleSize: 6 },\n    md: { size: 36, handleRadius: 11 - ANGLE_RING_WIDTH, handleSize: 8 },\n    lg: { size: 56, handleRadius: 18 - ANGLE_RING_WIDTH, handleSize: 10 },\n};\n\nexport { isAngleUnit };\n\nexport const parseAngle = parseAngleValue;\n\nexport function toDegrees(value: AngleValue): number {\n    return angleToDegrees(value);\n}\n\nexport function fromDegrees(degrees: number, unit: AngleUnit): AngleValue {\n    return angleFromDegrees(degrees, unit);\n}\n\nexport function normalizeDegrees(degrees: number): number {\n    return ((degrees % 360) + 360) % 360;\n}\n\nexport function normalizeSignedDegrees(degrees: number): number {\n    const normalized = normalizeDegrees(degrees);\n\n    return normalized > 180 ? normalized - 360 : normalized;\n}\n\nexport function applyAngleValueRange(degrees: number, range: AngleValueRange = 'unbounded'): number {\n    if (range === 'positive') {\n        return normalizeDegrees(degrees);\n    }\n\n    if (range === 'signed') {\n        return normalizeSignedDegrees(degrees);\n    }\n\n    return degrees;\n}\n\nexport function getAnglePrecision(unit: AngleUnit, precision?: AnglePrecision): number {\n    const value = typeof precision === 'number'\n        ? precision\n        : precision?.[unit] ?? DEFAULT_ANGLE_PRECISION[unit];\n\n    return Number.isFinite(value) ? Math.max(0, Math.trunc(value)) : DEFAULT_ANGLE_PRECISION[unit];\n}\n\nexport function roundAngleNumber(value: number, precision: number): number {\n    if (!Number.isFinite(value)) {\n        return value;\n    }\n\n    const factor = 10 ** precision;\n    const rounded = Math.round((value + Number.EPSILON) * factor) / factor;\n\n    return Object.is(rounded, -0) ? 0 : rounded;\n}\n\nexport function roundAngleValue(value: AngleValue, precision?: AnglePrecision): AngleValue {\n    return {\n        value: roundAngleNumber(value.value, getAnglePrecision(value.unit, precision)),\n        unit: value.unit,\n    };\n}\n\nexport function roundAngleValueInRange(\n    value: AngleValue,\n    precision?: AnglePrecision,\n    min?: number,\n    max?: number\n): AngleValue {\n    const rounded = roundAngleValue(value, precision);\n\n    return {\n        value: clamp(min ?? -Infinity, rounded.value, max ?? Infinity),\n        unit: rounded.unit,\n    };\n}\n\nexport function formatAngle(value: AngleValue, options: {\n    precision?: AnglePrecision;\n    trimTrailingZeros?: boolean;\n} = {}): string {\n    const precision = getAnglePrecision(value.unit, options.precision);\n    const trimTrailingZeros = options.trimTrailingZeros ?? true;\n    const fixed = roundAngleValue(value, precision).value.toFixed(precision);\n    const formatted = trimTrailingZeros\n        ? fixed.replace(/(\\.\\d*?)0+$/, '$1').replace(/\\.$/, '')\n        : fixed;\n\n    return `${ formatted === '-0' ? '0' : formatted }${ value.unit }`;\n}\n\nexport function formatAngleNumber(value: AngleValue, options?: Parameters<typeof formatAngle>[1]): string {\n    return formatAngle(value, options).slice(0, -value.unit.length);\n}\n\nfunction gcd(a: number, b: number): number {\n    let left = Math.abs(a);\n    let right = Math.abs(b);\n\n    while (right !== 0) {\n        const next = left % right;\n\n        left = right;\n        right = next;\n    }\n\n    return left || 1;\n}\n\nfunction formatPiRadianNumber(value: number): string | null {\n    let bestNumerator = 0;\n    let bestDenominator = 1;\n    let bestDistance = Infinity;\n\n    for (const denominator of RADIAN_PI_DENOMINATORS) {\n        const numerator = Math.round((value / Math.PI) * denominator);\n        const candidate = (numerator / denominator) * Math.PI;\n        const distance = Math.abs(candidate - value);\n\n        if (distance < bestDistance) {\n            bestNumerator = numerator;\n            bestDenominator = denominator;\n            bestDistance = distance;\n        }\n    }\n\n    if (bestDistance > PI_FRACTION_TOLERANCE_RADIANS) {\n        return null;\n    }\n\n    if (bestNumerator === 0) {\n        return '0';\n    }\n\n    const divisor = gcd(bestNumerator, bestDenominator);\n    const numerator = bestNumerator / divisor;\n    const denominator = bestDenominator / divisor;\n    const sign = numerator < 0 ? '-' : '';\n    const absoluteNumerator = Math.abs(numerator);\n    const piPart = absoluteNumerator === 1 ? 'π' : `${ absoluteNumerator }π`;\n\n    return denominator === 1\n        ? `${ sign }${ piPart }`\n        : `${ sign }${ piPart }/${ denominator }`;\n}\n\nfunction formatPiCoefficientRadianNumber(value: number, precision?: AnglePrecision): string {\n    const coefficientPrecision = typeof precision === 'number'\n        ? precision\n        : precision?.rad ?? PI_COEFFICIENT_PRECISION;\n    const coefficient = roundAngleNumber(value / Math.PI, coefficientPrecision);\n\n    if (coefficient === 0) {\n        return '0';\n    }\n\n    if (coefficient === 1) {\n        return 'π';\n    }\n\n    if (coefficient === -1) {\n        return '-π';\n    }\n\n    const formatted = coefficient.toFixed(coefficientPrecision)\n        .replace(/(\\.\\d*?)0+$/, '$1')\n        .replace(/\\.$/, '');\n\n    return `${ formatted }π`;\n}\n\nexport function formatAngleDisplayNumber(value: AngleValue, options?: Parameters<typeof formatAngle>[1]): string {\n    if (value.unit === 'rad') {\n        return formatPiRadianNumber(value.value) ?? formatPiCoefficientRadianNumber(value.value, options?.precision);\n    }\n\n    return formatAngleNumber(value, options);\n}\n\nexport function formatAngleDisplay(value: AngleValue, options?: Parameters<typeof formatAngle>[1]): string {\n    return `${ formatAngleDisplayNumber(value, options) }${ value.unit }`;\n}\n\nexport function angleDistance(leftDeg: number, rightDeg: number): number {\n    const diff = Math.abs(normalizeDegrees(leftDeg) - normalizeDegrees(rightDeg));\n\n    return Math.min(diff, 360 - diff);\n}\n\nexport function getAngleFromPoint(\n    point: AnglePoint,\n    center: AnglePoint,\n    options: AngleGeometryOptions = {}\n): number {\n    const dx = point.x - center.x;\n    const dy = point.y - center.y;\n    const zero = options.zero ?? 'top';\n    const direction = options.direction ?? 'clockwise';\n    const rawDeg = zero === 'top'\n        ? Math.atan2(dx, -dy) * (180 / Math.PI)\n        : Math.atan2(dy, dx) * (180 / Math.PI);\n\n    return normalizeDegrees(direction === 'clockwise' ? rawDeg : -rawDeg);\n}\n\nexport function getPointOnCircle(\n    angleDeg: number,\n    radius: number,\n    center: AnglePoint,\n    options: AngleGeometryOptions = {}\n): AnglePoint {\n    const zero = options.zero ?? 'top';\n    const direction = options.direction ?? 'clockwise';\n    const directedDeg = direction === 'clockwise' ? angleDeg : -angleDeg;\n    const radians = directedDeg * (Math.PI / 180);\n\n    if (zero === 'right') {\n        return {\n            x: center.x + (Math.cos(radians) * radius),\n            y: center.y + (Math.sin(radians) * radius),\n        };\n    }\n\n    return {\n        x: center.x + (Math.sin(radians) * radius),\n        y: center.y - (Math.cos(radians) * radius),\n    };\n}\n\nexport function getAngleDialGeometry(controlSize = DEFAULT_ANGLE_EXPANDED_SIZE): AngleDialGeometry {\n    return {\n        controlSize,\n        handleRadius: (controlSize * 0.375) - ANGLE_RING_WIDTH,\n        handleSize: Math.max(10, controlSize * 0.125),\n        presetRadius: (controlSize * 0.4) - ANGLE_RING_WIDTH,\n    };\n}\n\nexport function getPresetForAngle(angleDeg: number, presets: readonly number[] = DEFAULT_ANGLE_PRESETS): number {\n    let closestPreset = presets[0] ?? 0;\n    let closestDistance = Infinity;\n\n    for (const preset of presets) {\n        const distance = angleDistance(angleDeg, preset);\n\n        if (distance < closestDistance) {\n            closestPreset = preset;\n            closestDistance = distance;\n        }\n    }\n\n    return normalizeDegrees(closestPreset);\n}\n\n/**\n * Presets stay near the current revolution instead of collapsing values to 0..360.\n * For negative values, the closest candidate is less surprising than raw floor/trunc.\n */\nexport function applyPresetKeepingRevolution(currentDeg: number, presetDeg: number): number {\n    const normalizedPreset = normalizeDegrees(presetDeg);\n    const base = Math.trunc(currentDeg / 360) * 360;\n    const candidates = [\n        base - 360 + normalizedPreset,\n        base + normalizedPreset,\n        base + 360 + normalizedPreset,\n    ];\n\n    return candidates.reduce((best, candidate) => {\n        const bestDistance = Math.abs(best - currentDeg);\n        const candidateDistance = Math.abs(candidate - currentDeg);\n\n        if (candidateDistance < bestDistance) {\n            return candidate;\n        }\n\n        if (candidateDistance === bestDistance && candidate > best) {\n            return candidate;\n        }\n\n        return best;\n    });\n}\n\nexport function applyPresetDegrees(\n    currentDeg: number,\n    presetDeg: number,\n    range: AngleValueRange = 'unbounded',\n    behavior: AnglePresetBehavior = 'canonical'\n): number {\n    if (behavior === 'preserve-revolution') {\n        return applyAngleValueRange(applyPresetKeepingRevolution(currentDeg, presetDeg), range);\n    }\n\n    return applyAngleValueRange(presetDeg, range === 'unbounded' ? 'positive' : range);\n}\n\nexport function clampAngle(deg: number, minDeg?: number, maxDeg?: number): number {\n    return clamp(minDeg ?? -Infinity, deg, maxDeg ?? Infinity);\n}\n\nexport function snapDegreesToPresets(\n    degrees: number,\n    presets: readonly number[] = DEFAULT_ANGLE_PRESETS,\n    thresholdDeg = 4\n): number {\n    const preset = getPresetForAngle(degrees, presets);\n    const snapped = applyPresetKeepingRevolution(degrees, preset);\n\n    return Math.abs(snapped - degrees) <= thresholdDeg ? snapped : degrees;\n}\n\nexport function shortestAngleDelta(fromDeg: number, toDeg: number): number {\n    let delta = normalizeDegrees(toDeg) - normalizeDegrees(fromDeg);\n\n    if (delta > 180) {\n        delta -= 360;\n    }\n    else if (delta < -180) {\n        delta += 360;\n    }\n\n    return delta;\n}\n"],"names":["DEFAULT_ANGLE_PRECISION","UNIT_PRECISION","DEFAULT_ANGLE_PRESETS","DEFAULT_ANGLE_EXPANDED_SIZE","ANGLE_RING_WIDTH","RADIAN_PI_DENOMINATORS","PI_FRACTION_TOLERANCE_RADIANS","PI_COEFFICIENT_PRECISION","ANGLE_PREVIEW_GEOMETRY","toDegrees","value","angleToDegrees","fromDegrees","degrees","unit","angleFromDegrees","normalizeDegrees","normalizeSignedDegrees","normalized","applyAngleValueRange","range","getAnglePrecision","precision","roundAngleNumber","factor","rounded","roundAngleValue","roundAngleValueInRange","min","max","clamp","formatAngle","options","trimTrailingZeros","fixed","formatted","formatAngleNumber","gcd","a","b","left","right","next","formatPiRadianNumber","bestNumerator","bestDenominator","bestDistance","denominator","numerator","candidate","distance","divisor","sign","absoluteNumerator","piPart","formatPiCoefficientRadianNumber","coefficientPrecision","coefficient","formatAngleDisplayNumber","formatAngleDisplay","angleDistance","leftDeg","rightDeg","diff","getAngleFromPoint","point","center","dx","dy","zero","direction","rawDeg","getPointOnCircle","angleDeg","radius","radians","getAngleDialGeometry","controlSize","getPresetForAngle","presets","closestPreset","closestDistance","preset","applyPresetKeepingRevolution","currentDeg","presetDeg","normalizedPreset","base","best","candidateDistance","applyPresetDegrees","behavior","clampAngle","deg","minDeg","maxDeg","snapDegreesToPresets","thresholdDeg","snapped","shortestAngleDelta","fromDeg","toDeg","delta"],"mappings":"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"}

package/dist/AngleControl/index.d.ts

@@ -0,0 +1,4 @@
+export { ANGLE_PREVIEW_GEOMETRY, ANGLE_RING_WIDTH, angleDistance, applyAngleValueRange, applyPresetDegrees, applyPresetKeepingRevolution, clampAngle, DEFAULT_ANGLE_EXPANDED_SIZE, DEFAULT_ANGLE_PRESETS, formatAngle, formatAngleDisplay, formatAngleDisplayNumber, formatAngleNumber, getAngleDialGeometry, getAngleFromPoint, getPointOnCircle, getPresetForAngle, normalizeDegrees, normalizeSignedDegrees, roundAngleValue, shortestAngleDelta, snapDegreesToPresets, toDegrees, } from './angle';
+export { AngleControl } from './AngleControl';
+export type { AngleChangeMeta, AngleChangeSource, AngleControlProps, AngleControlSize, AngleDialGeometry, AngleGeometryOptions, AnglePoint, AnglePrecision, AnglePresetBehavior, AngleString, AngleUnit, AngleValue, AngleValueRange, } from './angle';
+//# sourceMappingURL=index.d.ts.map

package/dist/AngleControl/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/AngleControl/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,sBAAsB,EACtB,gBAAgB,EAChB,aAAa,EACb,oBAAoB,EACpB,kBAAkB,EAClB,4BAA4B,EAC5B,UAAU,EACV,2BAA2B,EAC3B,qBAAqB,EACrB,WAAW,EACX,kBAAkB,EAClB,wBAAwB,EACxB,iBAAiB,EACjB,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,sBAAsB,EACtB,eAAe,EACf,kBAAkB,EAClB,oBAAoB,EACpB,SAAS,GACZ,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,YAAY,EACR,eAAe,EACf,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,iBAAiB,EACjB,oBAAoB,EACpB,UAAU,EACV,cAAc,EACd,mBAAmB,EACnB,WAAW,EACX,SAAS,EACT,UAAU,EACV,eAAe,GAClB,MAAM,SAAS,CAAC"}

package/dist/AngleControl/index.js

@@ -0,0 +1,29 @@
+import { ANGLE_PREVIEW_GEOMETRY as r, ANGLE_RING_WIDTH as n, DEFAULT_ANGLE_EXPANDED_SIZE as g, DEFAULT_ANGLE_PRESETS as t, angleDistance as o, applyAngleValueRange as a, applyPresetDegrees as A, applyPresetKeepingRevolution as s, clampAngle as D, formatAngle as E, formatAngleDisplay as m, formatAngleDisplayNumber as p, formatAngleNumber as i, getAngleDialGeometry as P, getAngleFromPoint as _, getPointOnCircle as N, getPresetForAngle as G, normalizeDegrees as f, normalizeSignedDegrees as u, roundAngleValue as y, shortestAngleDelta as L, snapDegreesToPresets as R, toDegrees as T } from "./angle.js";
+import { AngleControl as I } from "./AngleControl.js";
+export {
+  r as ANGLE_PREVIEW_GEOMETRY,
+  n as ANGLE_RING_WIDTH,
+  I as AngleControl,
+  g as DEFAULT_ANGLE_EXPANDED_SIZE,
+  t as DEFAULT_ANGLE_PRESETS,
+  o as angleDistance,
+  a as applyAngleValueRange,
+  A as applyPresetDegrees,
+  s as applyPresetKeepingRevolution,
+  D as clampAngle,
+  E as formatAngle,
+  m as formatAngleDisplay,
+  p as formatAngleDisplayNumber,
+  i as formatAngleNumber,
+  P as getAngleDialGeometry,
+  _ as getAngleFromPoint,
+  N as getPointOnCircle,
+  G as getPresetForAngle,
+  f as normalizeDegrees,
+  u as normalizeSignedDegrees,
+  y as roundAngleValue,
+  L as shortestAngleDelta,
+  R as snapDegreesToPresets,
+  T as toDegrees
+};
+//# sourceMappingURL=index.js.map

package/dist/AngleControl/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/dist/AngleControl/useAngleInteraction.d.ts

@@ -0,0 +1,23 @@
+import type { AngleChangeSource, AnglePoint, AnglePresetBehavior, AngleValueRange } from './angle';
+interface UseAngleInteractionOptions {
+    center: AnglePoint;
+    handlePoint: AnglePoint;
+    degrees: number;
+    normalizedDegrees: number;
+    presets: readonly number[];
+    snap: boolean;
+    snapThresholdDeg: number;
+    valueRange: AngleValueRange;
+    presetBehavior: AnglePresetBehavior;
+    isDisabled: boolean | undefined;
+    onChangeDegrees: (degrees: number, source: AngleChangeSource, committed: boolean) => void;
+    onDragStart?: () => void;
+    onDragEnd?: () => void;
+}
+export declare function useAngleInteraction({ center, handlePoint, degrees, normalizedDegrees, presets, snap, snapThresholdDeg, valueRange, presetBehavior, isDisabled, onChangeDegrees, onDragStart, onDragEnd, }: UseAngleInteractionOptions): {
+    isDragging: boolean;
+    applyPreset: (preset: number) => void;
+    handleInteractionProps: import("@react-types/shared").DOMAttributes<import("react-aria-components").FocusableElement>;
+};
+export {};
+//# sourceMappingURL=useAngleInteraction.d.ts.map

package/dist/AngleControl/useAngleInteraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAngleInteraction.d.ts","sourceRoot":"","sources":["../../src/AngleControl/useAngleInteraction.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAUnG,UAAU,0BAA0B;IAChC,MAAM,EAAE,UAAU,CAAC;IACnB,WAAW,EAAE,UAAU,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,IAAI,EAAE,OAAO,CAAC;IACd,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,eAAe,CAAC;IAC5B,cAAc,EAAE,mBAAmB,CAAC;IACpC,UAAU,EAAE,OAAO,GAAG,SAAS,CAAC;IAChC,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC;IAC1F,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;CAC1B;AAED,wBAAgB,mBAAmB,CAAC,EAChC,MAAM,EACN,WAAW,EACX,OAAO,EACP,iBAAiB,EACjB,OAAO,EACP,IAAI,EACJ,gBAAgB,EAChB,UAAU,EACV,cAAc,EACd,UAAU,EACV,eAAe,EACf,WAAW,EACX,SAAS,GACZ,EAAE,0BAA0B;;0BAIgB,MAAM;;EAmElD"}

package/dist/AngleControl/useAngleInteraction.js

@@ -0,0 +1,58 @@
+import { useRef as k, useState as w, useCallback as S } from "react";
+import { useMove as E } from "react-aria";
+import { applyPresetDegrees as F, getAngleFromPoint as K, shortestAngleDelta as R, snapDegreesToPresets as X } from "./angle.js";
+function G({
+  center: u,
+  handlePoint: P,
+  degrees: o,
+  normalizedDegrees: v,
+  presets: p,
+  snap: c,
+  snapThresholdDeg: i,
+  valueRange: g,
+  presetBehavior: f,
+  isDisabled: a,
+  onChangeDegrees: r,
+  onDragStart: y,
+  onDragEnd: M
+}) {
+  const s = k(null), [x, n] = w(!1), A = S((e) => {
+    a || r(F(o, e, g, f), "preset", !0);
+  }, [o, a, r, f, g]), z = S((e, N, O) => {
+    const t = s.current;
+    if (!t)
+      return;
+    t.point = {
+      x: t.point.x + e,
+      y: t.point.y + N
+    };
+    const m = K(t.point, u), d = R(t.lastNormalizedDegrees, m), l = t.lastDegrees + d, D = c || O ? X(l, p, i) : l;
+    t.lastDegrees = l, t.lastNormalizedDegrees = m, t.lastOutputDegrees = D, t.moved ||= Math.abs(d) > 0.1, n(t.moved), r(D, "drag", !1);
+  }, [u, r, p, c, i]), {
+    moveProps: I
+  } = E({
+    onMoveStart: () => {
+      n(!1), y?.(), s.current = {
+        lastDegrees: o,
+        lastNormalizedDegrees: v,
+        lastOutputDegrees: o,
+        point: P,
+        moved: !1
+      };
+    },
+    onMove: (e) => z(e.deltaX, e.deltaY, e.shiftKey),
+    onMoveEnd: () => {
+      const e = s.current;
+      e?.moved && r(e.lastOutputDegrees, "drag", !0), s.current = null, M?.(), n(!1);
+    }
+  });
+  return {
+    isDragging: x,
+    applyPreset: A,
+    handleInteractionProps: a ? {} : I
+  };
+}
+export {
+  G as useAngleInteraction
+};
+//# sourceMappingURL=useAngleInteraction.js.map

package/dist/AngleControl/useAngleInteraction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAngleInteraction.js","sources":["../../src/AngleControl/useAngleInteraction.ts"],"sourcesContent":["import { useCallback, useRef, useState } from 'react';\nimport { useMove } from 'react-aria';\n\nimport {\n    applyPresetDegrees,\n    getAngleFromPoint,\n    shortestAngleDelta,\n    snapDegreesToPresets,\n} from './angle';\n\nimport type { AngleChangeSource, AnglePoint, AnglePresetBehavior, AngleValueRange } from './angle';\n\ninterface AngleDragState {\n    lastDegrees: number;\n    lastNormalizedDegrees: number;\n    lastOutputDegrees: number;\n    point: AnglePoint;\n    moved: boolean;\n}\n\ninterface UseAngleInteractionOptions {\n    center: AnglePoint;\n    handlePoint: AnglePoint;\n    degrees: number;\n    normalizedDegrees: number;\n    presets: readonly number[];\n    snap: boolean;\n    snapThresholdDeg: number;\n    valueRange: AngleValueRange;\n    presetBehavior: AnglePresetBehavior;\n    isDisabled: boolean | undefined;\n    onChangeDegrees: (degrees: number, source: AngleChangeSource, committed: boolean) => void;\n    onDragStart?: () => void;\n    onDragEnd?: () => void;\n}\n\nexport function useAngleInteraction({\n    center,\n    handlePoint,\n    degrees,\n    normalizedDegrees,\n    presets,\n    snap,\n    snapThresholdDeg,\n    valueRange,\n    presetBehavior,\n    isDisabled,\n    onChangeDegrees,\n    onDragStart,\n    onDragEnd,\n}: UseAngleInteractionOptions) {\n    const dragStateRef = useRef<AngleDragState | null>(null);\n    const [isDragging, setIsDragging] = useState(false);\n\n    const applyPreset = useCallback((preset: number) => {\n        if (isDisabled) {\n            return;\n        }\n\n        onChangeDegrees(applyPresetDegrees(degrees, preset, valueRange, presetBehavior), 'preset', true);\n    }, [degrees, isDisabled, onChangeDegrees, presetBehavior, valueRange]);\n\n    const updateDrag = useCallback((deltaX: number, deltaY: number, shiftKey: boolean) => {\n        const dragState = dragStateRef.current;\n\n        if (!dragState) {\n            return;\n        }\n\n        dragState.point = {\n            x: dragState.point.x + deltaX,\n            y: dragState.point.y + deltaY,\n        };\n\n        const pointerAngle = getAngleFromPoint(dragState.point, center);\n        const delta = shortestAngleDelta(dragState.lastNormalizedDegrees, pointerAngle);\n        const rawDegrees = dragState.lastDegrees + delta;\n        const shouldSnap = snap || shiftKey;\n        const nextDegrees = shouldSnap\n            ? snapDegreesToPresets(rawDegrees, presets, snapThresholdDeg)\n            : rawDegrees;\n\n        dragState.lastDegrees = rawDegrees;\n        dragState.lastNormalizedDegrees = pointerAngle;\n        dragState.lastOutputDegrees = nextDegrees;\n        dragState.moved ||= Math.abs(delta) > 0.1;\n        setIsDragging(dragState.moved);\n        onChangeDegrees(nextDegrees, 'drag', false);\n    }, [center, onChangeDegrees, presets, snap, snapThresholdDeg]);\n\n    const { moveProps } = useMove({\n        onMoveStart: () => {\n            setIsDragging(false);\n            onDragStart?.();\n            dragStateRef.current = {\n                lastDegrees: degrees,\n                lastNormalizedDegrees: normalizedDegrees,\n                lastOutputDegrees: degrees,\n                point: handlePoint,\n                moved: false,\n            };\n        },\n        onMove: event => updateDrag(event.deltaX, event.deltaY, event.shiftKey),\n        onMoveEnd: () => {\n            const dragState = dragStateRef.current;\n\n            if (dragState?.moved) {\n                onChangeDegrees(dragState.lastOutputDegrees, 'drag', true);\n            }\n\n            dragStateRef.current = null;\n            onDragEnd?.();\n            setIsDragging(false);\n        },\n    });\n\n    return {\n        isDragging,\n        applyPreset,\n        handleInteractionProps: isDisabled ? {} : moveProps,\n    };\n}\n"],"names":["useAngleInteraction","center","handlePoint","degrees","normalizedDegrees","presets","snap","snapThresholdDeg","valueRange","presetBehavior","isDisabled","onChangeDegrees","onDragStart","onDragEnd","dragStateRef","useRef","isDragging","setIsDragging","useState","applyPreset","useCallback","preset","applyPresetDegrees","updateDrag","deltaX","deltaY","shiftKey","dragState","pointerAngle","getAngleFromPoint","delta","shortestAngleDelta","rawDegrees","nextDegrees","snapDegreesToPresets","moveProps","useMove","event"],"mappings":";;;AAGO,SAASA,EAAoB;AAAA,EAClC,QAAAC;AAAA,EACA,aAAAC;AAAA,EACA,SAAAC;AAAA,EACA,mBAAAC;AAAA,EACA,SAAAC;AAAA,EACA,MAAAC;AAAA,EACA,kBAAAC;AAAA,EACA,YAAAC;AAAA,EACA,gBAAAC;AAAA,EACA,YAAAC;AAAA,EACA,iBAAAC;AAAA,EACA,aAAAC;AAAA,EACA,WAAAC;AACF,GAAG;AACD,QAAMC,IAAeC,EAAO,IAAI,GAC1B,CAACC,GAAYC,CAAa,IAAIC,EAAS,EAAK,GAC5CC,IAAcC,EAAY,CAAAC,MAAU;AACxC,IAAIX,KAGJC,EAAgBW,EAAmBnB,GAASkB,GAAQb,GAAYC,CAAc,GAAG,UAAU,EAAI;AAAA,EACjG,GAAG,CAACN,GAASO,GAAYC,GAAiBF,GAAgBD,CAAU,CAAC,GAC/De,IAAaH,EAAY,CAACI,GAAQC,GAAQC,MAAa;AAC3D,UAAMC,IAAYb,EAAa;AAC/B,QAAI,CAACa;AACH;AAEF,IAAAA,EAAU,QAAQ;AAAA,MAChB,GAAGA,EAAU,MAAM,IAAIH;AAAA,MACvB,GAAGG,EAAU,MAAM,IAAIF;AAAA,IAAA;AAEzB,UAAMG,IAAeC,EAAkBF,EAAU,OAAO1B,CAAM,GACxD6B,IAAQC,EAAmBJ,EAAU,uBAAuBC,CAAY,GACxEI,IAAaL,EAAU,cAAcG,GAErCG,IADa3B,KAAQoB,IACMQ,EAAqBF,GAAY3B,GAASE,CAAgB,IAAIyB;AAC/F,IAAAL,EAAU,cAAcK,GACxBL,EAAU,wBAAwBC,GAClCD,EAAU,oBAAoBM,GAC9BN,EAAU,UAAU,KAAK,IAAIG,CAAK,IAAI,KACtCb,EAAcU,EAAU,KAAK,GAC7BhB,EAAgBsB,GAAa,QAAQ,EAAK;AAAA,EAC5C,GAAG,CAAChC,GAAQU,GAAiBN,GAASC,GAAMC,CAAgB,CAAC,GACvD;AAAA,IACJ,WAAA4B;AAAA,EAAA,IACEC,EAAQ;AAAA,IACV,aAAa,MAAM;AACjB,MAAAnB,EAAc,EAAK,GACnBL,IAAA,GACAE,EAAa,UAAU;AAAA,QACrB,aAAaX;AAAA,QACb,uBAAuBC;AAAA,QACvB,mBAAmBD;AAAA,QACnB,OAAOD;AAAA,QACP,OAAO;AAAA,MAAA;AAAA,IAEX;AAAA,IACA,QAAQ,OAASqB,EAAWc,EAAM,QAAQA,EAAM,QAAQA,EAAM,QAAQ;AAAA,IACtE,WAAW,MAAM;AACf,YAAMV,IAAYb,EAAa;AAC/B,MAAIa,GAAW,SACbhB,EAAgBgB,EAAU,mBAAmB,QAAQ,EAAI,GAE3Db,EAAa,UAAU,MACvBD,IAAA,GACAI,EAAc,EAAK;AAAA,IACrB;AAAA,EAAA,CACD;AACD,SAAO;AAAA,IACL,YAAAD;AAAA,IACA,aAAAG;AAAA,IACA,wBAAwBT,IAAa,KAAKyB;AAAA,EAAA;AAE9C;"}

package/dist/AngleControl/useAngleSlider.d.ts

@@ -0,0 +1,26 @@
+import type { InputHTMLAttributes, RefObject } from 'react';
+import type { AngleChangeSource, AnglePrecision, AngleValueRange } from './angle';
+import type { AngleState } from './useAngleState';
+interface UseAngleSliderOptions {
+    rootRef: RefObject<HTMLDivElement | null>;
+    angle: AngleState;
+    step?: number;
+    precision?: AnglePrecision;
+    valueRange: AngleValueRange;
+    isDisabled?: boolean;
+    ariaLabel: string;
+    ariaLabelledBy?: string;
+    onChangeDegrees: (degrees: number, source: AngleChangeSource, committed: boolean) => void;
+}
+export declare function useAngleSlider({ rootRef, angle, step, precision, valueRange, isDisabled, ariaLabel, ariaLabelledBy, onChangeDegrees, }: UseAngleSliderOptions): {
+    groupProps: import("@react-types/shared").DOMAttributes<import("react-aria-components").FocusableElement>;
+    inputProps: InputHTMLAttributes<HTMLInputElement>;
+    inputRef: RefObject<HTMLInputElement | null>;
+    isDragging: boolean;
+    isFocused: boolean;
+    focusThumb: () => void;
+    startThumbDrag: () => void;
+    endThumbDrag: () => void;
+};
+export {};
+//# sourceMappingURL=useAngleSlider.d.ts.map

package/dist/AngleControl/useAngleSlider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAngleSlider.d.ts","sourceRoot":"","sources":["../../src/AngleControl/useAngleSlider.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,mBAAmB,EAAiB,SAAS,EAAE,MAAM,OAAO,CAAC;AAC3E,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAyB,eAAe,EAAE,MAAM,SAAS,CAAC;AACzG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAOlD,UAAU,qBAAqB;IAC3B,OAAO,EAAE,SAAS,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;IAC1C,KAAK,EAAE,UAAU,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC;CAC7F;AA6DD,wBAAgB,cAAc,CAAC,EAC3B,OAAO,EACP,KAAK,EACL,IAAI,EACJ,SAAS,EACT,UAAU,EACV,UAAU,EACV,SAAS,EACT,cAAc,EACd,eAAe,GAClB,EAAE,qBAAqB;;;;;;;;;EAwFvB"}

package/dist/AngleControl/useAngleSlider.js

@@ -0,0 +1,124 @@
+import { useRef as _, useMemo as I, useCallback as l } from "react";
+import { useSlider as N, useSliderThumb as U, mergeProps as K } from "react-aria";
+import { useSliderState as R } from "react-stately";
+import { getAnglePrecision as V, toDegrees as B, formatAngleNumber as H } from "./angle.js";
+const L = {
+  deg: 1,
+  grad: 1 / 0.9,
+  rad: Math.PI / 180,
+  turn: 1 / 360
+}, p = 0, g = 15;
+function Y(r, t) {
+  const o = {
+    deg: "degrees",
+    grad: "gradians",
+    rad: "radians",
+    turn: "turns"
+  };
+  return `${H(r, {
+    precision: t
+  })} ${o[r.unit]}`;
+}
+function $(r, t, o, a) {
+  let s;
+  if (a === "signed")
+    s = {
+      min: -180,
+      max: 180
+    };
+  else if (a === "positive")
+    s = {
+      min: 0,
+      max: 360
+    };
+  else {
+    const c = Math.floor(r / 360) * 360;
+    s = {
+      min: c,
+      max: c + 360
+    };
+  }
+  const u = t ?? Math.min(s.min, r), d = o ?? Math.max(s.max, r), m = Math.min(u, d), n = Math.max(u, d);
+  return m === n ? {
+    min: m - 1,
+    max: n + 1
+  } : {
+    min: m,
+    max: n
+  };
+}
+function v(r, t) {
+  const o = B({
+    value: r ?? L[t],
+    unit: t
+  });
+  return Number.isFinite(o) && o > 0 ? o : 1;
+}
+function q({
+  rootRef: r,
+  angle: t,
+  step: o,
+  precision: a,
+  valueRange: s,
+  isDisabled: u,
+  ariaLabel: d,
+  ariaLabelledBy: m,
+  onChangeDegrees: n
+}) {
+  const c = _(null), f = $(t.degrees, t.minDegrees, t.maxDegrees, s), x = Math.min(Math.max(t.degrees, f.min), f.max), T = v(o, t.unit), y = I(() => new Intl.NumberFormat(void 0, {
+    maximumFractionDigits: V(t.unit, a)
+  }), [t.unit, a]), S = l((e) => {
+    typeof e == "number" && n(e, "keyboard", !0);
+  }, [n]), h = {
+    value: x,
+    minValue: f.min,
+    maxValue: f.max,
+    step: T,
+    orientation: "horizontal",
+    isDisabled: u,
+    "aria-label": d,
+    "aria-labelledby": m,
+    onChange: S
+  }, i = R({
+    ...h,
+    numberFormatter: y
+  }), {
+    groupProps: D
+  } = N(h, i, r), {
+    inputProps: k,
+    isDragging: A,
+    isFocused: F
+  } = U({
+    index: p,
+    trackRef: r,
+    inputRef: c,
+    isDisabled: u,
+    "aria-label": d,
+    "aria-labelledby": m
+  }, i), b = l(() => {
+    i.setFocusedThumb(p), c.current?.focus();
+  }, [i]), M = l(() => {
+    b(), i.setThumbDragging(p, !0);
+  }, [b, i]), P = l(() => {
+    i.setThumbDragging(p, !1);
+  }, [i]), w = l((e) => {
+    u || !e.shiftKey || (e.key === "ArrowUp" || e.key === "ArrowRight" ? (e.preventDefault(), n(t.degrees + g, "keyboard", !0)) : (e.key === "ArrowDown" || e.key === "ArrowLeft") && (e.preventDefault(), n(t.degrees - g, "keyboard", !0)));
+  }, [t.degrees, u, n]), E = K(k, {
+    "aria-valuetext": Y(t.value, a),
+    onKeyDown: w
+  });
+  return {
+    groupProps: D,
+    inputProps: E,
+    inputRef: c,
+    isDragging: A,
+    isFocused: F,
+    focusThumb: b,
+    startThumbDrag: M,
+    endThumbDrag: P
+  };
+}
+export {
+  q as useAngleSlider
+};
+//# sourceMappingURL=useAngleSlider.js.map

package/dist/AngleControl/useAngleSlider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAngleSlider.js","sources":["../../src/AngleControl/useAngleSlider.ts"],"sourcesContent":["import { useCallback, useMemo, useRef } from 'react';\nimport { mergeProps, useSlider, useSliderThumb } from 'react-aria';\nimport { useSliderState } from 'react-stately';\n\nimport {\n    formatAngleNumber,\n    getAnglePrecision,\n    toDegrees,\n} from './angle';\n\nimport type { InputHTMLAttributes, KeyboardEvent, RefObject } from 'react';\nimport type { AngleChangeSource, AnglePrecision, AngleUnit, AngleValue, AngleValueRange } from './angle';\nimport type { AngleState } from './useAngleState';\n\ninterface AngleSliderBounds {\n    min: number;\n    max: number;\n}\n\ninterface UseAngleSliderOptions {\n    rootRef: RefObject<HTMLDivElement | null>;\n    angle: AngleState;\n    step?: number;\n    precision?: AnglePrecision;\n    valueRange: AngleValueRange;\n    isDisabled?: boolean;\n    ariaLabel: string;\n    ariaLabelledBy?: string;\n    onChangeDegrees: (degrees: number, source: AngleChangeSource, committed: boolean) => void;\n}\n\nconst DEFAULT_STEP_BY_UNIT: Record<AngleUnit, number> = {\n    deg: 1,\n    grad: 1 / 0.9,\n    rad: Math.PI / 180,\n    turn: 1 / 360,\n};\n\nconst SLIDER_THUMB_INDEX = 0;\nconst SHIFT_KEY_STEP_DEGREES = 15;\n\nfunction formatAriaValue(value: AngleValue, precision?: AnglePrecision): string {\n    const unitLabel: Record<AngleUnit, string> = {\n        deg: 'degrees',\n        grad: 'gradians',\n        rad: 'radians',\n        turn: 'turns',\n    };\n\n    return `${ formatAngleNumber(value, { precision }) } ${ unitLabel[value.unit] }`;\n}\n\nfunction sliderBoundsForAngle(\n    degrees: number,\n    minDegrees: number | undefined,\n    maxDegrees: number | undefined,\n    valueRange: AngleValueRange\n): AngleSliderBounds {\n    let fallback: AngleSliderBounds;\n\n    if (valueRange === 'signed') {\n        fallback = { min: -180, max: 180 };\n    }\n    else if (valueRange === 'positive') {\n        fallback = { min: 0, max: 360 };\n    }\n    else {\n        const revolutionStart = Math.floor(degrees / 360) * 360;\n\n        fallback = { min: revolutionStart, max: revolutionStart + 360 };\n    }\n\n    const min = minDegrees ?? Math.min(fallback.min, degrees);\n    const max = maxDegrees ?? Math.max(fallback.max, degrees);\n    const lower = Math.min(min, max);\n    const upper = Math.max(min, max);\n\n    if (lower === upper) {\n        return { min: lower - 1, max: upper + 1 };\n    }\n\n    return { min: lower, max: upper };\n}\n\nfunction stepDegreesForUnit(step: number | undefined, unit: AngleUnit): number {\n    const degrees = toDegrees({ value: step ?? DEFAULT_STEP_BY_UNIT[unit], unit });\n\n    return (Number.isFinite(degrees) && degrees > 0) ? degrees : 1;\n}\n\nexport function useAngleSlider({\n    rootRef,\n    angle,\n    step,\n    precision,\n    valueRange,\n    isDisabled,\n    ariaLabel,\n    ariaLabelledBy,\n    onChangeDegrees,\n}: UseAngleSliderOptions) {\n    const inputRef = useRef<HTMLInputElement | null>(null);\n    const bounds = sliderBoundsForAngle(angle.degrees, angle.minDegrees, angle.maxDegrees, valueRange);\n    const value = Math.min(Math.max(angle.degrees, bounds.min), bounds.max);\n    const sliderStep = stepDegreesForUnit(step, angle.unit);\n    const numberFormatter = useMemo(() => new Intl.NumberFormat(undefined, {\n        maximumFractionDigits: getAnglePrecision(angle.unit, precision),\n    }), [angle.unit, precision]);\n\n    const handleChange = useCallback((nextDegrees: number | number[]) => {\n        if (typeof nextDegrees === 'number') {\n            onChangeDegrees(nextDegrees, 'keyboard', true);\n        }\n    }, [onChangeDegrees]);\n\n    const sliderProps = {\n        value,\n        minValue: bounds.min,\n        maxValue: bounds.max,\n        step: sliderStep,\n        orientation: 'horizontal' as const,\n        isDisabled,\n        'aria-label': ariaLabel,\n        'aria-labelledby': ariaLabelledBy,\n        onChange: handleChange,\n    };\n    const state = useSliderState({\n        ...sliderProps,\n        numberFormatter,\n    });\n    const { groupProps } = useSlider(sliderProps, state, rootRef);\n    const {\n        inputProps: sliderInputProps,\n        isDragging,\n        isFocused,\n    } = useSliderThumb({\n        index: SLIDER_THUMB_INDEX,\n        trackRef: rootRef,\n        inputRef,\n        isDisabled,\n        'aria-label': ariaLabel,\n        'aria-labelledby': ariaLabelledBy,\n    }, state);\n\n    const focusThumb = useCallback(() => {\n        state.setFocusedThumb(SLIDER_THUMB_INDEX);\n        inputRef.current?.focus();\n    }, [state]);\n\n    const startThumbDrag = useCallback(() => {\n        focusThumb();\n        state.setThumbDragging(SLIDER_THUMB_INDEX, true);\n    }, [focusThumb, state]);\n\n    const endThumbDrag = useCallback(() => {\n        state.setThumbDragging(SLIDER_THUMB_INDEX, false);\n    }, [state]);\n\n    const handleKeyDown = useCallback((event: KeyboardEvent<HTMLInputElement>) => {\n        if (isDisabled || !event.shiftKey) {\n            return;\n        }\n\n        if (event.key === 'ArrowUp' || event.key === 'ArrowRight') {\n            event.preventDefault();\n            onChangeDegrees(angle.degrees + SHIFT_KEY_STEP_DEGREES, 'keyboard', true);\n        }\n        else if (event.key === 'ArrowDown' || event.key === 'ArrowLeft') {\n            event.preventDefault();\n            onChangeDegrees(angle.degrees - SHIFT_KEY_STEP_DEGREES, 'keyboard', true);\n        }\n    }, [angle.degrees, isDisabled, onChangeDegrees]);\n\n    const inputProps = mergeProps(sliderInputProps, {\n        'aria-valuetext': formatAriaValue(angle.value, precision),\n        onKeyDown: handleKeyDown,\n    }) as InputHTMLAttributes<HTMLInputElement>;\n\n    return {\n        groupProps,\n        inputProps,\n        inputRef,\n        isDragging,\n        isFocused,\n        focusThumb,\n        startThumbDrag,\n        endThumbDrag,\n    };\n}\n"],"names":["DEFAULT_STEP_BY_UNIT","SLIDER_THUMB_INDEX","SHIFT_KEY_STEP_DEGREES","formatAriaValue","value","precision","unitLabel","formatAngleNumber","sliderBoundsForAngle","degrees","minDegrees","maxDegrees","valueRange","fallback","revolutionStart","min","max","lower","upper","stepDegreesForUnit","step","unit","toDegrees","useAngleSlider","rootRef","angle","isDisabled","ariaLabel","ariaLabelledBy","onChangeDegrees","inputRef","useRef","bounds","sliderStep","numberFormatter","useMemo","getAnglePrecision","handleChange","useCallback","nextDegrees","sliderProps","state","useSliderState","groupProps","useSlider","sliderInputProps","isDragging","isFocused","useSliderThumb","focusThumb","startThumbDrag","endThumbDrag","handleKeyDown","event","inputProps","mergeProps"],"mappings":"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"}

package/dist/AngleControl/useAngleState.d.ts

@@ -0,0 +1,25 @@
+import { type AngleChangeMeta, type AngleChangeSource, type AnglePrecision, type AngleUnit, type AngleValue, type AngleValueRange } from './angle';
+interface UseAngleStateOptions {
+    value?: AngleValue;
+    defaultValue?: AngleValue;
+    unit?: AngleUnit;
+    min?: number;
+    max?: number;
+    precision?: AnglePrecision;
+    valueRange?: AngleValueRange;
+    onChange?: (value: AngleValue, meta: AngleChangeMeta) => void;
+    onChangeEnd?: (value: AngleValue, meta: AngleChangeMeta) => void;
+}
+export interface AngleState {
+    value: AngleValue;
+    unit: AngleUnit;
+    degrees: number;
+    normalizedDegrees: number;
+    minDegrees: number | undefined;
+    maxDegrees: number | undefined;
+    setDegrees: (degrees: number, source: AngleChangeSource, committed: boolean) => AngleValue;
+    setValue: (value: AngleValue, source: AngleChangeSource, committed: boolean) => AngleValue;
+}
+export declare function useAngleState({ value: controlledValue, defaultValue, unit: unitProp, min, max, precision, valueRange, onChange, onChangeEnd, }: UseAngleStateOptions): AngleState;
+export {};
+//# sourceMappingURL=useAngleState.d.ts.map

package/dist/AngleControl/useAngleState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAngleState.d.ts","sourceRoot":"","sources":["../../src/AngleControl/useAngleState.ts"],"names":[],"mappings":"AAEA,OAAO,EAOH,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,eAAe,EACvB,MAAM,SAAS,CAAC;AAEjB,UAAU,oBAAoB;IAC1B,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,YAAY,CAAC,EAAE,UAAU,CAAC;IAC1B,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,eAAe,KAAK,IAAI,CAAC;IAC9D,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,eAAe,KAAK,IAAI,CAAC;CACpE;AAED,MAAM,WAAW,UAAU;IACvB,KAAK,EAAE,UAAU,CAAC;IAClB,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,SAAS,EAAE,OAAO,KAAK,UAAU,CAAC;IAC3F,QAAQ,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,iBAAiB,EAAE,SAAS,EAAE,OAAO,KAAK,UAAU,CAAC;CAC9F;AAID,wBAAgB,aAAa,CAAC,EAC1B,KAAK,EAAE,eAAe,EACtB,YAAY,EACZ,IAAI,EAAE,QAAQ,EACd,GAAG,EACH,GAAG,EACH,SAAS,EACT,UAAwB,EACxB,QAAQ,EACR,WAAW,GACd,EAAE,oBAAoB,GAAG,UAAU,CAwDnC"}

package/dist/AngleControl/useAngleState.js

@@ -0,0 +1,51 @@
+import { useState as E, useMemo as G, useCallback as k } from "react";
+import { toDegrees as u, clampAngle as y, applyAngleValueRange as B, roundAngleValueInRange as C, fromDegrees as A, normalizeDegrees as F } from "./angle.js";
+const I = {
+  value: 0,
+  unit: "deg"
+};
+function N({
+  value: V,
+  defaultValue: K,
+  unit: o,
+  min: t,
+  max: s,
+  precision: l,
+  valueRange: d = "unbounded",
+  onChange: f,
+  onChangeEnd: v
+}) {
+  const [M, _] = E(K ?? {
+    ...I,
+    unit: o ?? I.unit
+  }), p = V !== void 0, z = V ?? M, e = o ?? z.unit, r = t == null ? void 0 : u({
+    value: t,
+    unit: e
+  }), c = s == null ? void 0 : u({
+    value: s,
+    unit: e
+  }), L = y(B(u(z), d), r, c), U = G(() => C(A(L, e), l, t, s), [s, t, l, L, e]), b = u(U), D = k((g, i, a) => {
+    const m = o ?? g.unit, q = y(B(u(g), d), r, c), n = C(A(q, m), l, t, s), w = u(n), S = {
+      source: i,
+      degrees: w,
+      normalizedDegrees: F(w),
+      unit: m,
+      committed: a
+    };
+    return p || _(n), f?.(n, S), a && v?.(n, S), n;
+  }, [p, s, c, t, r, f, v, l, o, d]), j = k((g, i, a) => D(A(g, e), i, a), [D, e]);
+  return {
+    value: U,
+    unit: e,
+    degrees: b,
+    normalizedDegrees: F(b),
+    minDegrees: r,
+    maxDegrees: c,
+    setDegrees: j,
+    setValue: D
+  };
+}
+export {
+  N as useAngleState
+};
+//# sourceMappingURL=useAngleState.js.map