@tremolo-ui/dom 0.7.0 → 0.9.0

package/dist/internal.cjs

@@ -0,0 +1,530 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_xy = require("./xy-5Oc6JeJr.cjs");
+let _tremolo_ui_functions = require("@tremolo-ui/functions");
+//#region src/input/check-steps.ts
+/** Positions probed across the travel. The ends are left out so that the
+* clamp at `min` and `max` cannot be mistaken for a press that does nothing. */
+const PROBES = [
+	.1,
+	.2,
+	.3,
+	.4,
+	.5,
+	.6,
+	.7,
+	.8,
+	.9
+];
+const NONE = {
+	shiftKey: false,
+	altKey: false,
+	ctrlKey: false,
+	metaKey: false
+};
+const MODIFIER_STATE = {
+	shift: {
+		...NONE,
+		shiftKey: true
+	},
+	alt: {
+		...NONE,
+		altKey: true
+	},
+	ctrl: {
+		...NONE,
+		ctrlKey: true
+	},
+	meta: {
+		...NONE,
+		metaKey: true
+	}
+};
+/** The held keys that select each entry of a modifier-aware input option. */
+function entries(options) {
+	if (Array.isArray(options)) return [NONE];
+	return Object.keys(options).map((key) => MODIFIER_STATE[key] ?? NONE);
+}
+/**
+* Press every entry of `options` at nine points along the travel and report
+* whether anything came of it.
+*
+* Run against `applyDelta` itself rather than against a reading of `step`:
+* the whole point is that the amount, the step and the scale interact, and
+* the pipeline is the only thing that knows how.
+*/
+function probe(options, range, format) {
+	const { min, max, scale = _tremolo_ui_functions.linearScale } = range;
+	const outcome = {
+		moved: false,
+		visible: false
+	};
+	for (const modifiers of entries(options)) for (const position of PROBES) {
+		const value = scale.denormalize(position, min, max);
+		const up = require_xy.applyDelta(value, 1, options, range, modifiers);
+		const down = require_xy.applyDelta(value, -1, options, range, modifiers);
+		if (up !== value || down !== value) outcome.moved = true;
+		if (!format) continue;
+		const shown = format(value);
+		if (format(up) !== shown || format(down) !== shown) outcome.visible = true;
+	}
+	return outcome;
+}
+/**
+* The warnings to show when a key press or a wheel notch cannot produce a
+* change the user can see. Empty when there is nothing to say.
+*
+* Two settings that are each fine on their own can cancel out, and nothing
+* fails when they do — the control simply sits there:
+*
+* - **`step` coarser than the amount.** `keyboard={['raw', 0.1]}` with
+*   `step={1}` rounds every press straight back to where it started
+* - **the display coarser than the amount.** A `format` showing two decimals
+*   of a kHz value cannot show a press worth 1 Hz
+*
+* The second is only reported when the press is invisible at *every* point
+* along the travel. A display that rounds is a deliberate choice and is
+* normally right — it is being too coarse everywhere that makes it a mistake.
+*
+* **Meant for development builds only.** It probes the whole travel, so call
+* it behind an inline `process.env.NODE_ENV` check: the bundler then drops
+* the call, and this function and its messages with it.
+*/
+function checkSteps({ component, axis, range, keyboard, wheel, format }) {
+	if (!range || !(range.min < range.max)) return [];
+	const where = axis ? `${component} (${axis})` : component;
+	const warnings = [];
+	for (const [name, options] of [["keyboard", keyboard], ["wheel", wheel]]) {
+		if (!options) continue;
+		const { moved, visible } = probe(options, range, format);
+		if (!moved) warnings.push(`[tremolo-ui] ${where}: \`${name}\` cannot move the value.` + (range.step !== void 0 ? ` Each press is smaller than \`step\` (${range.step}), so it rounds` : " Each press rounds") + " straight back to where it started.");
+		else if (format && !visible) warnings.push(`[tremolo-ui] ${where}: \`${name}\` moves the value, but \`format\` shows the same text before and after, everywhere in the range. The display is too coarse for it to be seen.`);
+	}
+	return warnings;
+}
+//#endregion
+//#region src/input/direction.ts
+/** Is `key` one of the four arrow keys? */
+function isArrowKey(key) {
+	return key === "ArrowRight" || key === "ArrowLeft" || key === "ArrowUp" || key === "ArrowDown";
+}
+/**
+* The direction an arrow key moves a single value: right and up raise it.
+* `null` for any other key.
+*/
+function arrowKeyDirection(key) {
+	if (!isArrowKey(key)) return null;
+	return key === "ArrowRight" || key === "ArrowUp" ? 1 : -1;
+}
+/**
+* The axis and direction an arrow key moves a position on screen. `null` for
+* any other key.
+*
+* The key picks the axis, whichever element inside the control holds the
+* focus: a two-dimensional control is one control to the person moving it.
+*/
+function arrowKeyMove(key) {
+	if (!isArrowKey(key)) return null;
+	return {
+		axis: key === "ArrowRight" || key === "ArrowLeft" ? 0 : 1,
+		direction: key === "ArrowLeft" || key === "ArrowUp" ? -1 : 1
+	};
+}
+/**
+* The direction one wheel event moves a single value: scrolling up raises it.
+* `null` when the event carries no movement the control reads.
+*/
+function wheelDirection(event, { horizontal = false } = {}) {
+	if (horizontal && event.deltaX !== 0) return event.deltaX > 0 ? 1 : -1;
+	if (event.deltaY === 0) return null;
+	return event.deltaY > 0 ? -1 : 1;
+}
+/**
+* The axis and direction one wheel event moves a position on screen. `null`
+* when the event carries no movement.
+*
+* Scrolling moves y, and shift switches to x. Browsers turn shift+wheel into
+* horizontal scrolling: `deltaY` comes out empty and `deltaX` carries the
+* movement. Reading whichever axis moved keeps shift working as the x-axis
+* modifier — and picks up a trackpad's own horizontal gesture, which never
+* had a modifier.
+*/
+function wheelMove(event) {
+	const horizontal = event.deltaX !== 0;
+	const delta = horizontal ? event.deltaX : event.deltaY;
+	if (delta === 0) return null;
+	return {
+		axis: horizontal || event.shiftKey ? 0 : 1,
+		direction: delta < 0 ? -1 : 1
+	};
+}
+//#endregion
+//#region src/number-input/stepper-drag.ts
+/**
+* Drag up and down on the steppers of a number input to move its value, one
+* `step` every `pixels` — up raises it, as on a knob.
+*
+* Counted from where the drag started moving rather than added up per
+* event, so rounding cannot accumulate. The start is taken on the first
+* move, not on pointerdown: a stepper button acts on pointerdown, so by then
+* the value may already have been nudged once, and the drag carries on from
+* there.
+*/
+function createStepperDrag(element, options) {
+	let opts = options;
+	let origin = null;
+	let moved = false;
+	/**
+	* Which sensitivity the drag is counting at, and where the previous event
+	* was — a key produces no pointer event of its own, so a change is only
+	* seen on the next move and has to be dated back to the one before it.
+	*/
+	let factor = 1;
+	let previousY = 0;
+	const drag = require_xy.createDrag(element, {
+		threshold: 1,
+		cursor: opts.cursor ?? "ns-resize",
+		pointerLock: opts.pointerLock,
+		onDragStart: (state) => {
+			origin = null;
+			moved = false;
+			factor = require_xy.selectModifier(opts.sensitivity ?? require_xy.DEFAULT_DRAG_SENSITIVITY, state.event).value;
+		},
+		onDrag: (state) => {
+			const { y } = state;
+			if (!origin) {
+				origin = {
+					y,
+					value: opts.getValue()
+				};
+				previousY = y;
+				return;
+			}
+			const sensitivity = opts.sensitivity ?? require_xy.DEFAULT_DRAG_SENSITIVITY;
+			const next = require_xy.selectModifier(sensitivity, state.event).value;
+			if (next !== factor) {
+				origin = {
+					y: previousY,
+					value: opts.getValue()
+				};
+				factor = next;
+			}
+			previousY = y;
+			const steps = Math.round(-(y - origin.y) / (opts.pixels ?? 1));
+			if (steps === 0) return;
+			moved = true;
+			const step = opts.range.step ?? 1;
+			const amounts = require_xy.mapModifier(sensitivity, (f) => ["raw", step * f]);
+			opts.onChange(require_xy.applyDelta(origin.value, steps, amounts, opts.range, state.event));
+		},
+		onDragEnd: () => {
+			moved = false;
+		}
+	});
+	return {
+		update: (next) => {
+			opts = {
+				...opts,
+				...next
+			};
+			if ("pointerLock" in next) drag.update({ pointerLock: opts.pointerLock });
+			if ("cursor" in next) drag.update({ cursor: opts.cursor ?? "ns-resize" });
+		},
+		moved: () => moved,
+		destroy: () => drag.destroy()
+	};
+}
+//#endregion
+//#region src/number-input/value.ts
+/**
+* The ranges a number input moves its value across, with the open ends
+* filled in.
+*
+* A normalized amount needs a finite span even when an end is unbounded or
+* clamping is off. Safe integers provide one without overflowing the span a
+* scale calculates. A raw amount needs no span, so its open ends can cover
+* every finite number instead of stopping at the safe-integer range.
+*/
+function numberInputRanges({ min, max, step, scale, clampValue = true }) {
+	const lo = clampValue ? min : void 0;
+	const hi = clampValue ? max : void 0;
+	return {
+		normalized: {
+			min: lo ?? Number.MIN_SAFE_INTEGER,
+			max: hi ?? Number.MAX_SAFE_INTEGER,
+			step,
+			scale
+		},
+		raw: {
+			min: lo ?? -Number.MAX_VALUE,
+			max: hi ?? Number.MAX_VALUE,
+			step,
+			scale
+		}
+	};
+}
+/**
+* Move a number input's value by one press of a key, a wheel notch or a
+* stepper, picking the range that suits the kind of amount. See `applyDelta`.
+*/
+function nudgeNumberInput(value, direction, options, ranges, modifiers) {
+	const [mode] = require_xy.selectModifier(options, modifiers).value;
+	return require_xy.applyDelta(value, direction, options, mode === "raw" ? ranges.raw : ranges.normalized, modifiers);
+}
+/**
+* Where the value stands against the ends: whether it can go no further
+* down or up, and whether it lies outside them — which only an unclamped
+* input, or a value set from outside, can do.
+*/
+function numberInputBounds(value, { min, max, clampValue = true }) {
+	return {
+		atMin: clampValue && min !== void 0 && value <= min,
+		atMax: clampValue && max !== void 0 && value >= max,
+		outOfRange: min !== void 0 && value < min || max !== void 0 && value > max
+	};
+}
+/**
+* The value typed text commits to, or `null` when there is no number in it.
+*
+* Text with no number is not a value: the input should go back to what it
+* was showing rather than commit a zero the user never typed. What is read
+* is clamped here and not while typing, since clamping as the user types
+* would make "1500" impossible to enter into an input whose max is 100.
+*/
+function commitNumberInputText(text, parse, { min, max, clampValue = true }) {
+	const parsed = parse(text);
+	if (!Number.isFinite(parsed)) return null;
+	let committed = parsed;
+	if (clampValue && min !== void 0) committed = Math.max(committed, min);
+	if (clampValue && max !== void 0) committed = Math.min(committed, max);
+	return committed;
+}
+//#endregion
+//#region src/number-input/text.ts
+/**
+* Reading a number out of the text of a number input, and keeping the caret
+* in place while the number under it changes.
+*
+* The text is whatever `format` made of the value — `"440 Hz"`, `"-6.0 dB"` —
+* or a half-typed entry, so none of this assumes the text is a number alone.
+*/
+/** The signs a number can carry. U+2212 is what some `Intl.NumberFormat` locales write. */
+const SIGNS = "+-−";
+/**
+* Where the number is in the text: from its first digit to its last, with the
+* sign and the decimal point in front of it. Whatever is left on either side
+* is taken for the unit, so it does not matter whether a space separates them,
+* or what the number looks like — `+6.0`, `1e+21`, `1,000` and `1:30` are each
+* one number. `null` when the text has no digit at all.
+*/
+function numberSpan(text) {
+	const first = text.search(/\d/);
+	if (first === -1) return null;
+	let start = first;
+	if (text[start - 1] === ".") start -= 1;
+	if (start > 0 && SIGNS.includes(text[start - 1])) start -= 1;
+	return {
+		start,
+		end: text.search(/\d\D*$/) + 1
+	};
+}
+/** A plain number, and nothing else: no grouping, no other separators. */
+const PLAIN_NUMBER = /^[+\-\u2212]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+\-\u2212]?\d+)?$/;
+/**
+* The number in the text, with the unit after it ignored: the default `parse`
+* of a number input.
+*
+* `NaN`, which leaves the value alone, whenever the number cannot be read
+* safely, rather than a part of it: text with no number, a number that is not
+* a plain one (`1,000` would otherwise read as 1, and `1:30` as 1), and text
+* with something in front of the number, which can change what it means (the
+* `L` of a pan reading `L 30`). A `format` that writes any of those needs its
+* own `parse`.
+*/
+function parseNumberText(text) {
+	const span = numberSpan(text);
+	if (!span || text.slice(0, span.start).trim() !== "") return NaN;
+	const number = text.slice(span.start, span.end);
+	return PLAIN_NUMBER.test(number) ? Number(number.replace(/\u2212/g, "-")) : NaN;
+}
+/**
+* The index the caret is measured against: the decimal point, or where one
+* would go if the number has none — in front of an exponent, if there is one.
+*
+* Measuring from an end instead would slide the caret across a digit whenever
+* the number changed length — `9.9` to `10.0` gains a character in front, `10`
+* to `9` loses one, and so does `9e+9` to `1e+10` behind — which is exactly
+* what stepping does.
+*/
+function decimalAnchor(text, span) {
+	const number = text.slice(span.start, span.end);
+	const exponent = number.search(/[eE][+\-\u2212]?\d/);
+	const mantissa = exponent === -1 ? number : number.slice(0, exponent);
+	const dot = mantissa.indexOf(".");
+	return span.start + (dot === -1 ? mantissa.length : dot);
+}
+const NO_NUMBER = {
+	start: 0,
+	end: 0
+};
+/**
+* Where the caret is, relative to the decimal point, so that it can be put
+* back at the same digit once the value has changed. See
+* {@link caretAtDecimalOffset}.
+*/
+function caretDecimalOffset(text, caret) {
+	return caret - decimalAnchor(text, numberSpan(text) ?? NO_NUMBER);
+}
+/**
+* The caret position `offset` characters from the decimal point of the new
+* text, kept within the number.
+*
+* @example
+* // The caret sits in front of the point of "9.9" when ArrowUp turns it
+* // into "10.0"
+* const offset = caretDecimalOffset('9.9', 1) // 0
+* caretAtDecimalOffset('10.0', offset) // 2: still in front of the point
+*/
+function caretAtDecimalOffset(text, offset) {
+	const span = numberSpan(text) ?? NO_NUMBER;
+	const place = decimalAnchor(text, span) + offset;
+	return Math.max(span.start, Math.min(place, span.end));
+}
+//#endregion
+//#region src/options/replace.ts
+/**
+* The `update()` argument that leaves an instance with exactly `next` as its
+* options.
+*
+* `update()` merges into what the instance has, which suits a wrapper that
+* pushes one setting at a time. A wrapper handed the whole new set instead —
+* a Svelte action, a Vue composable — has to clear what the new set no longer
+* carries, or a handler taken away, or an option left to its default, keeps
+* working.
+*
+* @example
+* instance.update(replaceOptions(previous, next))
+*/
+function replaceOptions(previous, next) {
+	return {
+		...Object.fromEntries(Object.keys(previous ?? {}).map((key) => [key, void 0])),
+		...next
+	};
+}
+//#endregion
+//#region src/slider/decimal-digits.ts
+/**
+* How many digits a number carries after the decimal point.
+*
+* `Slider.Marks` builds its labels by multiplying an interval, which leaves
+* binary debris in the last digits (`0.1 * 3` is `0.30000000000000004`). The
+* count is what tells `toFixed` how far to round that back.
+*
+* The exponent form has to be handled separately: `String(1e-7)` is `'1e-7'`,
+* which has no decimal point at all, so reading the text after the point
+* reports no digits and the interval rounds away to whole numbers.
+*/
+function decimalDigits(x) {
+	if (!Number.isFinite(x)) return 0;
+	const text = String(x);
+	const e = text.indexOf("e");
+	if (e === -1) return text.split(".")[1]?.length ?? 0;
+	const fraction = text.slice(0, e).split(".")[1]?.length ?? 0;
+	return Math.max(0, fraction - Number(text.slice(e + 1)));
+}
+//#endregion
+//#region src/slider/marks.ts
+/**
+* The marks `options` asks for between `min` and `max`, in ascending order.
+*
+* Each value is a whole multiple of the interval, rounded to the digits the
+* interval has: stepping by 0.1 would otherwise put binary debris in the
+* labels (`0.1 * 3` is `0.30000000000000004`).
+*/
+function sliderMarks(options, min, max, step) {
+	const { per, mark = true, label = true } = typeof options === "object" ? options : { per: options };
+	const optionsList = [];
+	const interval = per === "step" ? step : per;
+	const count = Math.floor(max / interval) - Math.ceil(min / interval) + 1;
+	for (let i = 0; i < count; i++) {
+		const value = (0, _tremolo_ui_functions.toFixed)(interval * (Math.ceil(min / interval) + i), decimalDigits(interval));
+		optionsList.push({
+			value,
+			mark,
+			label
+		});
+	}
+	return optionsList;
+}
+//#endregion
+//#region src/style.ts
+/**
+* A number as a CSS length, for a custom property.
+*
+* A custom property takes whatever text it is given, so `--size: 50` comes out
+* as the invalid `50` rather than `50px`. React appends `px` to a bare number
+* only for the properties it knows take a length, and a custom property is
+* never one of them; Vue and Svelte append nothing at all. Anything already a
+* string is passed through, so `'3rem'` and `'100%'` still work.
+*/
+function cssLength(value) {
+	return typeof value === "number" ? `${value}px` : value;
+}
+/**
+* Take an element out of sight while leaving it in the accessibility tree and
+* in the tab order.
+*
+* `display: none` and `visibility: hidden` would remove it from both, and the
+* native control underneath a headless component is what carries the ARIA and
+* the keyboard behaviour. `pointer-events: none` is safe because nothing is
+* ever clicked here directly: a `<label>` forwards its click, and a drag is
+* handled by the part that is visible.
+*
+* Every value is a string with its unit, so the object can be handed to any
+* framework's `style` binding as it is.
+*/
+const visuallyHiddenStyle = {
+	position: "absolute",
+	width: "1px",
+	height: "1px",
+	padding: "0",
+	margin: "-1px",
+	overflow: "hidden",
+	clip: "rect(0, 0, 0, 0)",
+	clipPath: "inset(50%)",
+	whiteSpace: "nowrap",
+	border: "0",
+	pointerEvents: "none"
+};
+//#endregion
+exports.POINTS_EDITOR_DEFAULT_KEYBOARD = require_xy.POINTS_EDITOR_DEFAULT_KEYBOARD;
+exports.POINTS_EDITOR_DEFAULT_WHEEL = require_xy.POINTS_EDITOR_DEFAULT_WHEEL;
+exports.POINT_AXIS = require_xy.POINT_AXIS;
+exports.applyDelta = require_xy.applyDelta;
+exports.arrowKeyDirection = arrowKeyDirection;
+exports.arrowKeyMove = arrowKeyMove;
+exports.blackKeyWidth = require_xy.blackKeyWidth;
+exports.caretAtDecimalOffset = caretAtDecimalOffset;
+exports.caretDecimalOffset = caretDecimalOffset;
+exports.checkSteps = checkSteps;
+exports.clampPoint = require_xy.clampPoint;
+exports.commitNumberInputText = commitNumberInputText;
+exports.createStepperDrag = createStepperDrag;
+exports.cssLength = cssLength;
+exports.fitWhiteKeyWidth = require_xy.fitWhiteKeyWidth;
+exports.getNoteRangeArray = require_xy.getNoteRangeArray;
+exports.nudgeNumberInput = nudgeNumberInput;
+exports.numberInputBounds = numberInputBounds;
+exports.numberInputRanges = numberInputRanges;
+exports.numberSpan = numberSpan;
+exports.parseNumberText = parseNumberText;
+exports.partitionByAccept = require_xy.partitionByAccept;
+exports.pianoWidth = require_xy.pianoWidth;
+exports.replaceOptions = replaceOptions;
+exports.selectModifier = require_xy.selectModifier;
+exports.sliderMarks = sliderMarks;
+exports.toXY = require_xy.toXY;
+exports.visuallyHiddenStyle = visuallyHiddenStyle;
+exports.wheelDirection = wheelDirection;
+exports.wheelMove = wheelMove;
+
+//# sourceMappingURL=internal.cjs.map

package/dist/internal.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.cjs","names":["linearScale","applyDelta","createDrag","selectModifier","DEFAULT_DRAG_SENSITIVITY","mapModifier","applyDelta","selectModifier","applyDelta","toFixed"],"sources":["../src/input/check-steps.ts","../src/input/direction.ts","../src/number-input/stepper-drag.ts","../src/number-input/value.ts","../src/number-input/text.ts","../src/options/replace.ts","../src/slider/decimal-digits.ts","../src/slider/marks.ts","../src/style.ts"],"sourcesContent":["import { linearScale, type ValueRange } from '@tremolo-ui/functions'\n\nimport { applyDelta } from './apply-delta'\nimport {\n  type InputEventOption,\n  type ModifierState,\n  type ModifierValue,\n} from './modifiers'\n\n/** Positions probed across the travel. The ends are left out so that the\n * clamp at `min` and `max` cannot be mistaken for a press that does nothing. */\nconst PROBES = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\n\nconst NONE: ModifierState = {\n  shiftKey: false,\n  altKey: false,\n  ctrlKey: false,\n  metaKey: false,\n}\n\nconst MODIFIER_STATE: Record<string, ModifierState> = {\n  shift: { ...NONE, shiftKey: true },\n  alt: { ...NONE, altKey: true },\n  ctrl: { ...NONE, ctrlKey: true },\n  meta: { ...NONE, metaKey: true },\n}\n\n/** The held keys that select each entry of a modifier-aware input option. */\nfunction entries(options: ModifierValue<InputEventOption>): ModifierState[] {\n  if (Array.isArray(options)) return [NONE]\n  return Object.keys(options).map((key) => MODIFIER_STATE[key] ?? NONE)\n}\n\ninterface Outcome {\n  /** The press changed the value at least once across the travel. */\n  moved: boolean\n  /** The change reached the displayed text at least once. */\n  visible: boolean\n}\n\n/**\n * Press every entry of `options` at nine points along the travel and report\n * whether anything came of it.\n *\n * Run against `applyDelta` itself rather than against a reading of `step`:\n * the whole point is that the amount, the step and the scale interact, and\n * the pipeline is the only thing that knows how.\n */\nfunction probe(\n  options: ModifierValue<InputEventOption>,\n  range: ValueRange,\n  format?: (value: number) => string,\n): Outcome {\n  const { min, max, scale = linearScale } = range\n  const outcome: Outcome = { moved: false, visible: false }\n  for (const modifiers of entries(options)) {\n    for (const position of PROBES) {\n      const value = scale.denormalize(position, min, max)\n      const up = applyDelta(value, 1, options, range, modifiers)\n      const down = applyDelta(value, -1, options, range, modifiers)\n      if (up !== value || down !== value) outcome.moved = true\n      if (!format) continue\n      const shown = format(value)\n      if (format(up) !== shown || format(down) !== shown) outcome.visible = true\n    }\n  }\n  return outcome\n}\n\nexport interface CheckStepsOptions {\n  /** The component, for the message. */\n  component: string\n  /** The axis, for a component that has more than one. */\n  axis?: string\n  /**\n   * The range to probe, or `null` to check nothing. An unbounded input has no\n   * travel to sample, so `NumberInput` passes `null` when `min` and `max` are\n   * not both there.\n   */\n  range: ValueRange | null\n  keyboard?: ModifierValue<InputEventOption> | null\n  wheel?: ModifierValue<InputEventOption> | null\n  /**\n   * How the value is displayed, where the component shows one. Called with\n   * probe values only.\n   */\n  format?: (value: number) => string\n}\n\n/**\n * The warnings to show when a key press or a wheel notch cannot produce a\n * change the user can see. Empty when there is nothing to say.\n *\n * Two settings that are each fine on their own can cancel out, and nothing\n * fails when they do — the control simply sits there:\n *\n * - **`step` coarser than the amount.** `keyboard={['raw', 0.1]}` with\n *   `step={1}` rounds every press straight back to where it started\n * - **the display coarser than the amount.** A `format` showing two decimals\n *   of a kHz value cannot show a press worth 1 Hz\n *\n * The second is only reported when the press is invisible at *every* point\n * along the travel. A display that rounds is a deliberate choice and is\n * normally right — it is being too coarse everywhere that makes it a mistake.\n *\n * **Meant for development builds only.** It probes the whole travel, so call\n * it behind an inline `process.env.NODE_ENV` check: the bundler then drops\n * the call, and this function and its messages with it.\n */\nexport function checkSteps({\n  component,\n  axis,\n  range,\n  keyboard,\n  wheel,\n  format,\n}: CheckStepsOptions): string[] {\n  if (!range || !(range.min < range.max)) return []\n  const where = axis ? `${component} (${axis})` : component\n  const warnings: string[] = []\n  for (const [name, options] of [\n    ['keyboard', keyboard],\n    ['wheel', wheel],\n  ] as const) {\n    if (!options) continue\n    const { moved, visible } = probe(options, range, format)\n    if (!moved) {\n      warnings.push(\n        `[tremolo-ui] ${where}: \\`${name}\\` cannot move the value.` +\n          (range.step !== undefined\n            ? ` Each press is smaller than \\`step\\` (${range.step}), so it rounds`\n            : ' Each press rounds') +\n          ' straight back to where it started.',\n      )\n    } else if (format && !visible) {\n      warnings.push(\n        `[tremolo-ui] ${where}: \\`${name}\\` moves the value, but \\`format\\`` +\n          ' shows the same text before and after, everywhere in the range.' +\n          ' The display is too coarse for it to be seen.',\n      )\n    }\n  }\n  return warnings\n}\n","/**\n * Which way an input moves a value, before any amount is applied.\n *\n * `applyDelta` takes the direction as given, since which key or which sign of\n * `deltaY` counts as \"up\" differs per control. The answers are collected here\n * so that every wrapper gives the same one: a knob that turns the other way\n * in one framework would be a bug nobody could see from the code.\n *\n * Two families, by what the control looks like:\n *\n * - **one value** (`Knob`, `Slider`, `NumberInput`): right and up raise it\n * - **a position on screen** (`XYPad`, `PointsEditor`): in screen coordinates,\n *   x growing rightwards and y growing downwards, plus which axis moves\n *\n * A control that runs the other way (`reverse`) flips the result itself.\n */\n\n/** One of the four arrow keys, as `KeyboardEvent.key` names it. */\nexport type ArrowKey = 'ArrowRight' | 'ArrowLeft' | 'ArrowUp' | 'ArrowDown'\n\n/** Is `key` one of the four arrow keys? */\nexport function isArrowKey(key: string): key is ArrowKey {\n  return (\n    key === 'ArrowRight' ||\n    key === 'ArrowLeft' ||\n    key === 'ArrowUp' ||\n    key === 'ArrowDown'\n  )\n}\n\n/** A move along one of the two axes of a position on screen. */\nexport interface AxisMove {\n  /** 0 = x, 1 = y. */\n  axis: 0 | 1\n  /** `1` towards the right or the bottom, `-1` towards the left or the top. */\n  direction: 1 | -1\n}\n\n/**\n * The direction an arrow key moves a single value: right and up raise it.\n * `null` for any other key.\n */\nexport function arrowKeyDirection(key: string): 1 | -1 | null {\n  if (!isArrowKey(key)) return null\n  return key === 'ArrowRight' || key === 'ArrowUp' ? 1 : -1\n}\n\n/**\n * The axis and direction an arrow key moves a position on screen. `null` for\n * any other key.\n *\n * The key picks the axis, whichever element inside the control holds the\n * focus: a two-dimensional control is one control to the person moving it.\n */\nexport function arrowKeyMove(key: string): AxisMove | null {\n  if (!isArrowKey(key)) return null\n  return {\n    axis: key === 'ArrowRight' || key === 'ArrowLeft' ? 0 : 1,\n    direction: key === 'ArrowLeft' || key === 'ArrowUp' ? -1 : 1,\n  }\n}\n\nexport interface WheelDirectionOptions {\n  /**\n   * Read horizontal scrolling as well, for a control laid out horizontally:\n   * scrolling right raises the value. Vertical scrolling still counts when\n   * there is no horizontal movement.\n   *\n   * @default false\n   */\n  horizontal?: boolean\n}\n\n/**\n * The direction one wheel event moves a single value: scrolling up raises it.\n * `null` when the event carries no movement the control reads.\n */\nexport function wheelDirection(\n  event: Pick<WheelEvent, 'deltaX' | 'deltaY'>,\n  { horizontal = false }: WheelDirectionOptions = {},\n): 1 | -1 | null {\n  if (horizontal && event.deltaX !== 0) return event.deltaX > 0 ? 1 : -1\n  if (event.deltaY === 0) return null\n  return event.deltaY > 0 ? -1 : 1\n}\n\n/**\n * The axis and direction one wheel event moves a position on screen. `null`\n * when the event carries no movement.\n *\n * Scrolling moves y, and shift switches to x. Browsers turn shift+wheel into\n * horizontal scrolling: `deltaY` comes out empty and `deltaX` carries the\n * movement. Reading whichever axis moved keeps shift working as the x-axis\n * modifier — and picks up a trackpad's own horizontal gesture, which never\n * had a modifier.\n */\nexport function wheelMove(\n  event: Pick<WheelEvent, 'deltaX' | 'deltaY' | 'shiftKey'>,\n): AxisMove | null {\n  const horizontal = event.deltaX !== 0\n  const delta = horizontal ? event.deltaX : event.deltaY\n  if (delta === 0) return null\n  return {\n    axis: horizontal || event.shiftKey ? 0 : 1,\n    direction: delta < 0 ? -1 : 1,\n  }\n}\n","import { type ValueRange } from '@tremolo-ui/functions'\n\nimport { applyDelta } from '../input/apply-delta'\nimport { DEFAULT_DRAG_SENSITIVITY } from '../input/defaults'\nimport {\n  mapModifier,\n  selectModifier,\n  type InputEventOption,\n  type ModifierValue,\n} from '../input/modifiers'\nimport { createDrag } from '../pointer/drag'\n\nexport interface StepperDragOptions {\n  /** The value now, read when the drag starts moving it. */\n  getValue: () => number\n  /**\n   * The range the value moves across. Its `step` is what one step of the drag\n   * is worth; see `numberInputRanges` for the one a number input uses.\n   */\n  range: ValueRange\n  /**\n   * How many pixels of vertical movement make one step.\n   *\n   * @default 1\n   */\n  pixels?: number\n  /**\n   * How much a step is worth, per modifier key: `0.1` makes the same movement\n   * count a tenth as much. Pressing or releasing the key mid-drag does not\n   * move the value.\n   *\n   * @default { default: 1, shift: 0.1 }\n   */\n  sensitivity?: ModifierValue<number>\n  /** Hide the pointer and keep it from hitting the edge of the screen. */\n  pointerLock?: boolean\n  /**\n   * The cursor to show while dragging. Applied to the element itself, as\n   * `createDrag` does.\n   *\n   * @default 'ns-resize'\n   */\n  cursor?: string\n  /** Called with the new value whenever the drag moves it. */\n  onChange: (value: number) => void\n}\n\nexport interface StepperDragInstance {\n  /** Replace the given options. `pointerLock` reaches the next drag. */\n  update: (options: Partial<StepperDragOptions>) => void\n  /**\n   * Whether the drag in progress has moved the value. A stepper button's\n   * press-and-hold repeat stands down once it has, so the value is not moved\n   * twice.\n   */\n  moved: () => boolean\n  destroy: () => void\n}\n\n/**\n * Drag up and down on the steppers of a number input to move its value, one\n * `step` every `pixels` — up raises it, as on a knob.\n *\n * Counted from where the drag started moving rather than added up per\n * event, so rounding cannot accumulate. The start is taken on the first\n * move, not on pointerdown: a stepper button acts on pointerdown, so by then\n * the value may already have been nudged once, and the drag carries on from\n * there.\n */\nexport function createStepperDrag(\n  element: Element,\n  options: StepperDragOptions,\n): StepperDragInstance {\n  let opts = options\n  let origin: { y: number; value: number } | null = null\n  let moved = false\n  /**\n   * Which sensitivity the drag is counting at, and where the previous event\n   * was — a key produces no pointer event of its own, so a change is only\n   * seen on the next move and has to be dated back to the one before it.\n   */\n  let factor = 1\n  let previousY = 0\n\n  const drag = createDrag(element, {\n    threshold: 1,\n    cursor: opts.cursor ?? 'ns-resize',\n    pointerLock: opts.pointerLock,\n    onDragStart: (state) => {\n      origin = null\n      moved = false\n      factor = selectModifier(\n        opts.sensitivity ?? DEFAULT_DRAG_SENSITIVITY,\n        state.event,\n      ).value\n    },\n    onDrag: (state) => {\n      const { y } = state\n      if (!origin) {\n        origin = { y, value: opts.getValue() }\n        previousY = y\n        return\n      }\n\n      const sensitivity = opts.sensitivity ?? DEFAULT_DRAG_SENSITIVITY\n      // Pressing or releasing the key mid-drag must not move the value, so the\n      // travel so far is folded into the origin and measuring starts again\n      // from the previous event: that event's own distance belongs to the new\n      // sensitivity.\n      const next = selectModifier(sensitivity, state.event).value\n      if (next !== factor) {\n        origin = { y: previousY, value: opts.getValue() }\n        factor = next\n      }\n      previousY = y\n\n      const steps = Math.round(-(y - origin.y) / (opts.pixels ?? 1))\n      if (steps === 0) return\n      moved = true\n\n      // The sensitivity as an amount per step, carried over as a modifier map\n      // rather than resolved here: that keeps `step` out of the pipeline for\n      // a modifier entry, since naming one is a request to move off the grid.\n      const step = opts.range.step ?? 1\n      const amounts = mapModifier(sensitivity, (f): InputEventOption => [\n        'raw',\n        step * f,\n      ])\n      opts.onChange(\n        applyDelta(origin.value, steps, amounts, opts.range, state.event),\n      )\n    },\n    onDragEnd: () => {\n      moved = false\n    },\n  })\n\n  return {\n    update: (next) => {\n      opts = { ...opts, ...next }\n      if ('pointerLock' in next) drag.update({ pointerLock: opts.pointerLock })\n      if ('cursor' in next) drag.update({ cursor: opts.cursor ?? 'ns-resize' })\n    },\n    moved: () => moved,\n    destroy: () => drag.destroy(),\n  }\n}\n","import { type Scale, type ValueRange } from '@tremolo-ui/functions'\n\nimport { applyDelta } from '../input/apply-delta'\nimport {\n  selectModifier,\n  type InputEventOption,\n  type ModifierState,\n  type ModifierValue,\n} from '../input/modifiers'\n\n/**\n * The value a number input edits, and how far it may go.\n *\n * Unlike a slider, either end may be left open, and `clampValue: false` lets\n * the value past the ends that are set.\n */\nexport interface NumberInputValueOptions {\n  min?: number\n  max?: number\n  step?: number\n  scale?: Scale\n  /**\n   * Keep the value between `min` and `max`.\n   *\n   * @default true\n   */\n  clampValue?: boolean\n}\n\n/** The ranges {@link nudgeNumberInput} moves a value across. */\nexport interface NumberInputRanges {\n  /** For a `normalized` amount, which needs a finite span to take a share of. */\n  normalized: ValueRange\n  /** For a `raw` amount, which does not. */\n  raw: ValueRange\n}\n\n/**\n * The ranges a number input moves its value across, with the open ends\n * filled in.\n *\n * A normalized amount needs a finite span even when an end is unbounded or\n * clamping is off. Safe integers provide one without overflowing the span a\n * scale calculates. A raw amount needs no span, so its open ends can cover\n * every finite number instead of stopping at the safe-integer range.\n */\nexport function numberInputRanges({\n  min,\n  max,\n  step,\n  scale,\n  clampValue = true,\n}: NumberInputValueOptions): NumberInputRanges {\n  const lo = clampValue ? min : undefined\n  const hi = clampValue ? max : undefined\n  return {\n    normalized: {\n      min: lo ?? Number.MIN_SAFE_INTEGER,\n      max: hi ?? Number.MAX_SAFE_INTEGER,\n      step,\n      scale,\n    },\n    raw: {\n      min: lo ?? -Number.MAX_VALUE,\n      max: hi ?? Number.MAX_VALUE,\n      step,\n      scale,\n    },\n  }\n}\n\n/**\n * Move a number input's value by one press of a key, a wheel notch or a\n * stepper, picking the range that suits the kind of amount. See `applyDelta`.\n */\nexport function nudgeNumberInput(\n  value: number,\n  direction: number,\n  options: ModifierValue<InputEventOption>,\n  ranges: NumberInputRanges,\n  modifiers?: ModifierState,\n): number {\n  const [mode] = selectModifier(options, modifiers).value\n  return applyDelta(\n    value,\n    direction,\n    options,\n    mode === 'raw' ? ranges.raw : ranges.normalized,\n    modifiers,\n  )\n}\n\n/**\n * Where the value stands against the ends: whether it can go no further\n * down or up, and whether it lies outside them — which only an unclamped\n * input, or a value set from outside, can do.\n */\nexport function numberInputBounds(\n  value: number,\n  { min, max, clampValue = true }: NumberInputValueOptions,\n) {\n  return {\n    atMin: clampValue && min !== undefined && value <= min,\n    atMax: clampValue && max !== undefined && value >= max,\n    outOfRange:\n      (min !== undefined && value < min) || (max !== undefined && value > max),\n  }\n}\n\n/**\n * The value typed text commits to, or `null` when there is no number in it.\n *\n * Text with no number is not a value: the input should go back to what it\n * was showing rather than commit a zero the user never typed. What is read\n * is clamped here and not while typing, since clamping as the user types\n * would make \"1500\" impossible to enter into an input whose max is 100.\n */\nexport function commitNumberInputText(\n  text: string,\n  parse: (text: string) => number,\n  { min, max, clampValue = true }: NumberInputValueOptions,\n): number | null {\n  const parsed = parse(text)\n  if (!Number.isFinite(parsed)) return null\n  let committed = parsed\n  if (clampValue && min !== undefined) committed = Math.max(committed, min)\n  if (clampValue && max !== undefined) committed = Math.min(committed, max)\n  return committed\n}\n","/**\n * Reading a number out of the text of a number input, and keeping the caret\n * in place while the number under it changes.\n *\n * The text is whatever `format` made of the value — `\"440 Hz\"`, `\"-6.0 dB\"` —\n * or a half-typed entry, so none of this assumes the text is a number alone.\n */\n\n/** The signs a number can carry. U+2212 is what some `Intl.NumberFormat` locales write. */\nconst SIGNS = '+-\\u2212'\n\n/** Where the number is in the text; the rest, on either side, is the unit. */\nexport interface NumberSpan {\n  start: number\n  end: number\n}\n\n/**\n * Where the number is in the text: from its first digit to its last, with the\n * sign and the decimal point in front of it. Whatever is left on either side\n * is taken for the unit, so it does not matter whether a space separates them,\n * or what the number looks like — `+6.0`, `1e+21`, `1,000` and `1:30` are each\n * one number. `null` when the text has no digit at all.\n */\nexport function numberSpan(text: string): NumberSpan | null {\n  const first = text.search(/\\d/)\n  if (first === -1) return null\n  let start = first\n  if (text[start - 1] === '.') start -= 1\n  if (start > 0 && SIGNS.includes(text[start - 1])) start -= 1\n  return { start, end: text.search(/\\d\\D*$/) + 1 }\n}\n\n/** A plain number, and nothing else: no grouping, no other separators. */\nconst PLAIN_NUMBER =\n  /^[+\\-\\u2212]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+\\-\\u2212]?\\d+)?$/\n\n/**\n * The number in the text, with the unit after it ignored: the default `parse`\n * of a number input.\n *\n * `NaN`, which leaves the value alone, whenever the number cannot be read\n * safely, rather than a part of it: text with no number, a number that is not\n * a plain one (`1,000` would otherwise read as 1, and `1:30` as 1), and text\n * with something in front of the number, which can change what it means (the\n * `L` of a pan reading `L 30`). A `format` that writes any of those needs its\n * own `parse`.\n */\nexport function parseNumberText(text: string): number {\n  const span = numberSpan(text)\n  if (!span || text.slice(0, span.start).trim() !== '') return NaN\n  const number = text.slice(span.start, span.end)\n  return PLAIN_NUMBER.test(number)\n    ? Number(number.replace(/\\u2212/g, '-'))\n    : NaN\n}\n\n/**\n * The index the caret is measured against: the decimal point, or where one\n * would go if the number has none — in front of an exponent, if there is one.\n *\n * Measuring from an end instead would slide the caret across a digit whenever\n * the number changed length — `9.9` to `10.0` gains a character in front, `10`\n * to `9` loses one, and so does `9e+9` to `1e+10` behind — which is exactly\n * what stepping does.\n */\nfunction decimalAnchor(text: string, span: NumberSpan) {\n  const number = text.slice(span.start, span.end)\n  const exponent = number.search(/[eE][+\\-\\u2212]?\\d/)\n  const mantissa = exponent === -1 ? number : number.slice(0, exponent)\n  const dot = mantissa.indexOf('.')\n  return span.start + (dot === -1 ? mantissa.length : dot)\n}\n\nconst NO_NUMBER: NumberSpan = { start: 0, end: 0 }\n\n/**\n * Where the caret is, relative to the decimal point, so that it can be put\n * back at the same digit once the value has changed. See\n * {@link caretAtDecimalOffset}.\n */\nexport function caretDecimalOffset(text: string, caret: number): number {\n  return caret - decimalAnchor(text, numberSpan(text) ?? NO_NUMBER)\n}\n\n/**\n * The caret position `offset` characters from the decimal point of the new\n * text, kept within the number.\n *\n * @example\n * // The caret sits in front of the point of \"9.9\" when ArrowUp turns it\n * // into \"10.0\"\n * const offset = caretDecimalOffset('9.9', 1) // 0\n * caretAtDecimalOffset('10.0', offset) // 2: still in front of the point\n */\nexport function caretAtDecimalOffset(text: string, offset: number): number {\n  const span = numberSpan(text) ?? NO_NUMBER\n  const place = decimalAnchor(text, span) + offset\n  return Math.max(span.start, Math.min(place, span.end))\n}\n","/**\n * The `update()` argument that leaves an instance with exactly `next` as its\n * options.\n *\n * `update()` merges into what the instance has, which suits a wrapper that\n * pushes one setting at a time. A wrapper handed the whole new set instead —\n * a Svelte action, a Vue composable — has to clear what the new set no longer\n * carries, or a handler taken away, or an option left to its default, keeps\n * working.\n *\n * @example\n * instance.update(replaceOptions(previous, next))\n */\nexport function replaceOptions<T extends object>(\n  previous: T | undefined,\n  next: T | undefined,\n): Partial<T> {\n  const cleared = Object.fromEntries(\n    Object.keys(previous ?? {}).map((key) => [key, undefined]),\n  ) as Partial<T>\n  return { ...cleared, ...next }\n}\n","/**\n * How many digits a number carries after the decimal point.\n *\n * `Slider.Marks` builds its labels by multiplying an interval, which leaves\n * binary debris in the last digits (`0.1 * 3` is `0.30000000000000004`). The\n * count is what tells `toFixed` how far to round that back.\n *\n * The exponent form has to be handled separately: `String(1e-7)` is `'1e-7'`,\n * which has no decimal point at all, so reading the text after the point\n * reports no digits and the interval rounds away to whole numbers.\n */\nexport function decimalDigits(x: number): number {\n  if (!Number.isFinite(x)) return 0\n\n  const text = String(x)\n  const e = text.indexOf('e')\n  if (e === -1) return text.split('.')[1]?.length ?? 0\n\n  const fraction = text.slice(0, e).split('.')[1]?.length ?? 0\n  // A negative exponent pushes the point further right, a positive one pulls\n  // it back past the digits that are there.\n  return Math.max(0, fraction - Number(text.slice(e + 1)))\n}\n","import { toFixed } from '@tremolo-ui/functions'\n\nimport { decimalDigits } from './decimal-digits'\n\n/**\n * How `Slider.Marks` fills itself in when it is given no children: one option\n * every `per`, or every `step` of the slider. The object form turns off the\n * mark or the label for the whole set; a single option is customized by\n * writing `Slider.MarksOption` out instead.\n */\nexport type MarksOptions =\n  | 'step'\n  | number\n  | {\n      per: 'step' | number\n      mark?: boolean\n      label?: boolean\n    }\n\n/** One mark along a slider, as {@link sliderMarks} lays them out. */\nexport interface SliderMark {\n  value: number\n  mark: boolean\n  label: boolean\n}\n\n/**\n * The marks `options` asks for between `min` and `max`, in ascending order.\n *\n * Each value is a whole multiple of the interval, rounded to the digits the\n * interval has: stepping by 0.1 would otherwise put binary debris in the\n * labels (`0.1 * 3` is `0.30000000000000004`).\n */\nexport function sliderMarks(\n  options: MarksOptions,\n  min: number,\n  max: number,\n  step: number,\n): SliderMark[] {\n  const {\n    per,\n    mark = true,\n    label = true,\n  } = typeof options === 'object' ? options : { per: options }\n  const optionsList: SliderMark[] = []\n  const interval = per === 'step' ? step : per\n  const count = Math.floor(max / interval) - Math.ceil(min / interval) + 1\n  for (let i = 0; i < count; i++) {\n    const value = toFixed(\n      interval * (Math.ceil(min / interval) + i),\n      decimalDigits(interval),\n    )\n    optionsList.push({ value: value, mark: mark, label: label })\n  }\n  return optionsList\n}\n","/**\n * A number as a CSS length, for a custom property.\n *\n * A custom property takes whatever text it is given, so `--size: 50` comes out\n * as the invalid `50` rather than `50px`. React appends `px` to a bare number\n * only for the properties it knows take a length, and a custom property is\n * never one of them; Vue and Svelte append nothing at all. Anything already a\n * string is passed through, so `'3rem'` and `'100%'` still work.\n */\nexport function cssLength(\n  value: number | string | undefined,\n): string | undefined {\n  return typeof value === 'number' ? `${value}px` : value\n}\n\n/**\n * Take an element out of sight while leaving it in the accessibility tree and\n * in the tab order.\n *\n * `display: none` and `visibility: hidden` would remove it from both, and the\n * native control underneath a headless component is what carries the ARIA and\n * the keyboard behaviour. `pointer-events: none` is safe because nothing is\n * ever clicked here directly: a `<label>` forwards its click, and a drag is\n * handled by the part that is visible.\n *\n * Every value is a string with its unit, so the object can be handed to any\n * framework's `style` binding as it is.\n */\nexport const visuallyHiddenStyle = {\n  position: 'absolute',\n  width: '1px',\n  height: '1px',\n  padding: '0',\n  margin: '-1px',\n  overflow: 'hidden',\n  clip: 'rect(0, 0, 0, 0)',\n  clipPath: 'inset(50%)',\n  whiteSpace: 'nowrap',\n  border: '0',\n  pointerEvents: 'none',\n} as const\n"],"mappings":"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"}