@tremolo-ui/dom 0.5.0 → 0.6.0

package/dist/index.d.cts

@@ -1,5 +1,4 @@
 import { PianoLayout, ValueRange } from "@tremolo-ui/functions";
-
 //#region src/canvas/animation.d.ts
 /** What the canvas looked like when a frame was drawn. */
 interface AnimationFrame {
@@ -13,7 +12,7 @@ interface AnimationFrame {
   deltaTime: number;
   /** Milliseconds since the instance was created. */
   elapsedTime: number;
-  /** Frames per second implied by `deltaTime`. */
+  /** Frames per second implied by `deltaTime`, or 0 when no time elapsed. */
   fps: number;
 }
 type CanvasDrawFunction = (context: CanvasRenderingContext2D, frame: AnimationFrame) => void;
@@ -34,7 +33,7 @@ interface AnimationCanvasOptions {
    */
   animate?: boolean;
   /**
-   * Size in CSS pixels. Ignored when `relativeSize` is on.
+   * Size in CSS pixels. Ignored when `resizable` is on.
    *
    * @default { width: 100, height: 100 }
    */
@@ -50,7 +49,7 @@ interface AnimationCanvasOptions {
    *
    * @default false
    */
-  relativeSize?: boolean;
+  resizable?: boolean;
   /**
    * Carry the drawing across a resize, so that the canvas does not blank for a
    * frame while the new size is drawn.
@@ -72,7 +71,7 @@ interface AnimationCanvasInstance {
    * render without restarting the animation, so the frame count and the
    * elapsed time keep running.
    *
-   * `relativeSize` and `contextAttributes` are fixed for the lifetime of the
+   * `resizable` and `contextAttributes` are fixed for the lifetime of the
    * instance and are ignored here.
    *
    * While `animate` is off this also draws a frame, since nothing else would.
@@ -94,16 +93,22 @@ declare function createAnimationCanvas(canvas: HTMLCanvasElement, options: Anima
 //#endregion
 //#region src/canvas/context.d.ts
 /**
- * The properties of a 2D context that survive `save()` / `restore()`, and so
- * are what has to be carried across a resize by hand: setting `canvas.width`
- * resets the context to its defaults.
+ * The assignable parts of a 2D context's drawing state. They have to be
+ * carried across a resize by hand because setting `canvas.width` resets the
+ * context to its defaults. The transform and line dash are handled separately
+ * by {@link DrawingContext} because they are exposed through methods.
  *
  * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/save
  */
-declare const drawingState: readonly ["strokeStyle", "fillStyle", "globalAlpha", "lineWidth", "lineCap", "lineJoin", "miterLimit", "lineDashOffset", "shadowOffsetX", "shadowOffsetY", "shadowBlur", "shadowColor", "globalCompositeOperation", "font", "textAlign", "textBaseline", "direction", "imageSmoothingEnabled"];
+declare const drawingState: readonly ["strokeStyle", "fillStyle", "globalAlpha", "lineWidth", "lineCap", "lineJoin", "miterLimit", "lineDashOffset", "shadowOffsetX", "shadowOffsetY", "shadowBlur", "shadowColor", "globalCompositeOperation", "filter", "font", "fontKerning", "fontStretch", "fontVariantCaps", "textAlign", "textBaseline", "direction", "letterSpacing", "textRendering", "wordSpacing", "imageSmoothingEnabled", "imageSmoothingQuality"];
 type DrawingState = (typeof drawingState)[number];
 type DrawingStateValue = CanvasRenderingContext2D[DrawingState];
-type DrawingContext = Pick<CanvasRenderingContext2D, DrawingState>;
+type DrawingContext = Pick<CanvasRenderingContext2D, DrawingState> & {
+  /** The current line dash sequence. */
+  lineDash: number[];
+  /** The current transformation matrix. */
+  transform: DOMMatrix;
+};
 declare function isDrawingState(value: unknown): value is DrawingState;
 //#endregion
 //#region src/midi/access.d.ts
@@ -112,14 +117,34 @@ declare const PERMISSION_DENIED = "PERMISSION_DENIED";
 /** @private */
 declare const NOT_SUPPORTED = "NOT_SUPPORTED";
 /** @private */
-type MIDIAccessError = typeof PERMISSION_DENIED | typeof NOT_SUPPORTED;
+declare const UNAVAILABLE = "UNAVAILABLE";
+/** @private */
+type MIDIAccessError = typeof PERMISSION_DENIED | typeof NOT_SUPPORTED | typeof UNAVAILABLE;
+type MIDIAccessOptions = {
+  /**
+   * Ask for system exclusive messages as well.
+   *
+   * Browsers treat this as a separate, more sensitive permission, so leave it
+   * off unless the app actually reads or sends sysex.
+   *
+   * @default false
+   */
+  sysex?: boolean;
+};
 type MIDIAccessState = {
   readonly midiAccess: MIDIAccess | null;
   readonly error: MIDIAccessError | null;
+  /**
+   * The inputs currently connected, in the order MIDIAccess lists them.
+   *
+   * Kept up to date as devices are plugged in and unplugged, so a UI listing
+   * the devices does not have to watch `statechange` itself.
+   */
+  readonly inputs: readonly MIDIInput[];
 };
 interface MIDIAccessInstance {
   /** Request MIDI access. Safe to call more than once. */
-  request: () => void;
+  request: (options?: MIDIAccessOptions) => void;
   getState: () => MIDIAccessState;
   /** Snapshot for server side rendering. Always the initial state. */
   getServerState: () => MIDIAccessState;
@@ -135,35 +160,70 @@ interface MIDIAccessInstance {
  */
 declare function createMIDIAccess(): MIDIAccessInstance;
 //#endregion
+//#region src/midi/input.d.ts
+/**
+ * Centre of the 14-bit pitch bend range: no bend.
+ *
+ * The range is not symmetric — 0 is 8192 below centre and 16383 is 8191 above
+ * — so a wheel at rest reports exactly this rather than half of the maximum.
+ */
+declare const PITCH_BEND_CENTER = 8192;
+/**
+ * Every handler is given the channel last, as 0-15. MIDI channels are written
+ * 1-16 on hardware, so add one before showing it to anyone.
+ */
+type MIDIInputHandlers = {
+  onNoteOnEvent?: (note: number, velocity: number, channel: number) => void;
+  onNoteOffEvent?: (note: number, channel: number) => void;
+  /**
+   * The 14-bit bend, 0-16383, centred at {@link PITCH_BEND_CENTER}.
+   *
+   * The two data bytes are little-endian — the first carries the low 7 bits —
+   * which is the other way round from every other message.
+   */
+  onPitchBendEvent?: (value: number, channel: number) => void;
+  /** `controller` is the CC number, `value` is 0-127. */
+  onControlChangeEvent?: (controller: number, value: number, channel: number) => void;
+  onProgramChangeEvent?: (program: number, channel: number) => void;
+  /** Pressure for one held note (polyphonic aftertouch). */
+  onAftertouchEvent?: (note: number, pressure: number, channel: number) => void;
+  /** Pressure for the whole channel, sent by keyboards with one sensor. */
+  onChannelPressureEvent?: (pressure: number, channel: number) => void;
+};
+interface MIDIInputInstance {
+  /** Replace the handlers, keeping the listeners in place. */
+  update: (handlers: MIDIInputHandlers) => void;
+  destroy: () => void;
+}
+/**
+ * Handle the channel voice messages of every connected input. To be used with
+ * {@link createMIDIAccess}. Internally uses {@link createMIDIMessage}, so
+ * devices plugged in later are picked up.
+ *
+ * System messages (clock, sysex, and the rest of `0xf0`-`0xff`) are not
+ * decoded here; reach for {@link createMIDIMessage} for those.
+ */
+declare function createMIDIInput(midiAccess: MIDIAccess | null, handlers: MIDIInputHandlers): MIDIInputInstance;
+//#endregion
 //#region src/midi/message.d.ts
 interface MIDIMessageInstance {
+  /** Replace the handler, keeping the listeners in place. */
+  update: (onMIDIMessage: (event: MIDIMessageEvent) => void) => void;
   destroy: () => void;
 }
 /**
  * Listen to raw `midimessage` events on every input of a MIDIAccess.
  *
+ * The set of inputs is followed rather than sampled: MIDIAccess fires
+ * `statechange` when a device is plugged in or unplugged, and the listeners
+ * move with it. A keyboard connected after access was granted works without
+ * the caller having to rebuild anything.
+ *
  * Use this when you need more detail than {@link createMIDIInput} provides.
  */
 declare function createMIDIMessage(midiAccess: MIDIAccess | null, onMIDIMessage: (event: MIDIMessageEvent) => void): MIDIMessageInstance;
 //#endregion
-//#region src/midi/input.d.ts
-type MIDIInputHandlers = {
-  onNoteOnEvent?: (note: number, velocity: number) => void;
-  onNoteOffEvent?: (note: number) => void;
-  onPitchBendEvent?: (msb: number, lsb: number) => void;
-};
-type MIDIInputInstance = MIDIMessageInstance;
-/**
- * Handle note on/off and pitch bend events. To be used with {@link createMIDIAccess}.
- * Internally uses {@link createMIDIMessage}.
- */
-declare function createMIDIInput(midiAccess: MIDIAccess | null, {
-  onNoteOnEvent,
-  onNoteOffEvent,
-  onPitchBendEvent
-}: MIDIInputHandlers): MIDIInputInstance;
-//#endregion
-//#region src/piano/input.d.ts
+//#region src/piano/index.d.ts
 /**
  * What asked for a note to sound.
  *
@@ -234,10 +294,13 @@ declare function createPianoInput(element: Element, options: PianoInputOptions):
 //#endregion
 //#region src/pointer/drag.d.ts
 type DragState = {
-  /** Total movement from the drag start, in screen coordinates. */x: number;
-  y: number; /** Movement since the previous event, in screen coordinates. */
+  /** Total movement from the drag start, in screen coordinates. */
+  x: number;
+  y: number;
+  /** Movement since the previous event, in screen coordinates. */
   deltaX: number;
-  deltaY: number; /** Pointer position in viewport coordinates. */
+  deltaY: number;
+  /** Pointer position in viewport coordinates. */
   clientX: number;
   clientY: number;
   /**
@@ -267,6 +330,40 @@ type DragOptions = {
    * restored once the last one is up.
    */
   cursor?: string;
+  /**
+   * Decide whether a pointerdown starts a drag at all.
+   *
+   * Checked before anything else — **before the pointer is captured** — so
+   * declining here leaves the whole gesture to whatever else is listening.
+   * Deciding later would be too late: the capture has already been taken from
+   * the element that was going to handle it.
+   *
+   * The use for it is a drag on a container that also holds draggable things
+   * of its own, such as a rubber-band selection that must not begin on top of
+   * one of the objects it would select.
+   */
+  shouldStart?: (event: PointerEvent) => boolean;
+  /**
+   * Hide the pointer and read its movement directly, instead of following it
+   * around the screen.
+   *
+   * A relative drag — a knob, a stepper — does not care where the pointer is,
+   * only how far it moved, and letting it wander has two costs: the cursor
+   * ends up far from what it is holding, and **the drag stops at the edge of
+   * the screen**, where the operating system pins the pointer and the
+   * coordinates stop changing. A fine drag reaches that edge quickly.
+   *
+   * **Not for a drag whose value is the position pointed at** — anything on
+   * `elementMapping`. `clientX` / `clientY` freeze while the pointer is
+   * locked, so there is no position left to read.
+   *
+   * The request needs a user gesture, which a pointerdown is, but it can still
+   * be refused; the drag then carries on as an ordinary one. Read on
+   * pointerdown, so `update()` reaches the next drag rather than the current.
+   *
+   * @default false
+   */
+  pointerLock?: boolean;
   /**
    * Track every pointer that goes down on the element, rather than only the
    * first. Each one gets its own `onDragStart` / `onDrag` / `onDragEnd` and
@@ -280,6 +377,10 @@ type DragOptions = {
   multiPointer?: boolean;
   onDragStart?: (state: DragState) => void;
   onDrag?: (state: DragState) => void;
+  /**
+   * Called exactly once for every drag that starts, whether tracking ends by
+   * pointer release, cancellation, capture or lock loss, or destruction.
+   */
   onDragEnd?: (state: DragState) => void;
 };
 interface DragInstance {
@@ -291,6 +392,7 @@ interface DragInstance {
    * here.
    */
   update: (options: DragOptions) => void;
+  /** End any active drags before removing the instance. */
   destroy: () => void;
 }
 /**
@@ -332,7 +434,7 @@ type XYInput<T> = [T] extends [readonly unknown[]] ? readonly [x: T, y: T] : T |
  */
 declare function toXY<T>(value: T | readonly [x: T, y: T]): XY<T>;
 //#endregion
-//#region src/pointer/dragValue.d.ts
+//#region src/pointer/drag-value.d.ts
 /**
  * How the 0-1 travel of one axis maps onto a value.
  *
@@ -377,20 +479,41 @@ interface DragValueMapping {
  * The element is read on every event, so it may be mounted after the drag is
  * set up and may change size while a drag is in progress.
  */
-declare function elementMapping(getElement: () => Element | null | undefined): DragValueMapping;
+declare function elementMapping(getElement: () => Element | null | undefined, { sensitivity }?: {
+  /**
+   * How much the movement counts, read on every move. `1` is the pointer
+   * position itself; `0.1` makes the same movement cover a tenth of the
+   * travel, which is what a fine-adjustment modifier wants.
+   *
+   * Anything but `1` turns the mapping relative: the value stops being the
+   * position pointed at and starts being where it stood when the sensitivity
+   * changed, plus the movement since. **The pointer and the value stay apart
+   * for the rest of the drag** rather than snapping back together when the
+   * key is released, since snapping would move the value nobody asked to
+   * move.
+   */
+  sensitivity?: (state: DragState) => number;
+}): DragValueMapping;
 /**
  * Move the value away from where it stood when the drag started, by the
  * distance dragged. The pointer position itself carries no meaning, so the
  * value can be adjusted from anywhere on the screen.
  */
-declare function relativeMapping({
-  pixelRange
-}?: {
+declare function relativeMapping({ pixelRange, sensitivity }?: {
   /**
    * Pixels of movement that span the whole range.
    * @default 100
    */
   pixelRange?: XYInput<number>;
+  /**
+   * How much the movement counts, read on every move. `1` is `pixelRange` as
+   * given; `0.1` makes the same movement cover a tenth of the range, which is
+   * what a fine-adjustment modifier wants.
+   *
+   * Changing it mid-drag does not disturb the value: the travel so far is
+   * folded into the origin and measuring starts again from there.
+   */
+  sensitivity?: (state: DragState) => number;
 }): DragValueMapping;
 interface DragValueOptions {
   /** Scaling of each axis; a single value applies to both. */
@@ -417,6 +540,16 @@ interface DragValueOptions {
   threshold?: number;
   /** @see DragOptions.cursor */
   cursor?: string;
+  /**
+   * @see DragOptions.pointerLock
+   *
+   * Only for a mapping that moves the value relative to where it stood, such
+   * as {@link relativeMapping}. {@link elementMapping} reads the pointer
+   * position, and there is none while it is locked.
+   */
+  pointerLock?: boolean;
+  /** @see DragOptions.shouldStart */
+  shouldStart?: (event: PointerEvent) => boolean;
   onChange?: (value: XY<number>, state: DragState) => void;
   onDragStart?: (value: XY<number>, state: DragState) => void;
   onDragEnd?: (value: XY<number>, state: DragState) => void;
@@ -442,6 +575,8 @@ declare function createDragValue(element: Element, options: DragValueOptions): D
 //#endregion
 //#region src/pointer/wheel.d.ts
 interface WheelOptions {
+  /** Replace the callback through {@link WheelInstance.update}. */
+  onWheel?: (event: WheelEvent) => void;
   /**
    * Only report events while the focus is inside the element.
    *
@@ -470,5 +605,65 @@ interface WheelInstance {
  */
 declare function createWheel(element: Element, onWheel: (event: WheelEvent) => void, options?: WheelOptions): WheelInstance;
 //#endregion
-export { type AnimationCanvasInstance, type AnimationCanvasOptions, type AnimationFrame, type AxisOptions, type CanvasDrawFunction, type CanvasInitFunction, type DragInstance, type DragOptions, type DragState, type DragValueInstance, type DragValueMapping, type DragValueOptions, type DrawingContext, type DrawingState, type DrawingStateValue, type MIDIAccessError, type MIDIAccessInstance, type MIDIAccessState, type MIDIInputHandlers, type MIDIInputInstance, type MIDIMessageInstance, type MappingContext, NOT_SUPPORTED, type NoteSource, PERMISSION_DENIED, type PianoInputInstance, type PianoInputOptions, type WheelInstance, type WheelOptions, type XY, type XYInput, createAnimationCanvas, createDrag, createDragValue, createMIDIAccess, createMIDIInput, createMIDIMessage, createPianoInput, createWheel, drawingState, elementMapping, isDrawingState, relativeMapping, toXY };
+//#region src/selection/box.d.ts
+/**
+ * A rectangle in the 0..1 space of whatever the box is drawn over, with `y`
+ * growing downwards — the same space the items are given in.
+ */
+interface SelectionBoxRect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+interface SelectionBoxOptions<Id> {
+  /**
+   * Everything the box can pick up, read on every move rather than taken as a
+   * snapshot: what is under the box changes while it is dragged, and an item
+   * may have moved since the last one.
+   */
+  items: () => Iterable<readonly [Id, XY<number>]>;
+  /** The box as it is dragged, and `null` once it is gone. */
+  onBoxChange?: (box: SelectionBoxRect | null) => void;
+  /** What the box covers, added to whatever it started from. */
+  onSelectionChange?: (ids: Id[]) => void;
+}
+interface SelectionBoxBeginOptions<Id> {
+  /**
+   * Add to `selection` rather than replacing it. Ctrl / meta rather than
+   * shift, for the controls where shift is the fine-adjustment key.
+   */
+  additive?: boolean;
+  /** What was selected before the box started. Only read when `additive`. */
+  selection?: readonly Id[];
+}
+interface SelectionBoxInstance<Id> {
+  /** Replace the given options, without interrupting a box in progress. */
+  update: (options: Partial<SelectionBoxOptions<Id>>) => void;
+  /** Start a box at `at`, which is one of its corners. */
+  begin: (at: XY<number>, options?: SelectionBoxBeginOptions<Id>) => void;
+  /** Drag the opposite corner to `to`. */
+  move: (to: XY<number>) => void;
+  /**
+   * Finish the box. The selection stays as it is.
+   *
+   * @returns whether a box was running, so that a caller can tell a drag from
+   *   a press that selected nothing.
+   */
+  end: () => boolean;
+  /** The box being dragged, or `null` when there is none. */
+  box: () => SelectionBoxRect | null;
+  destroy: () => void;
+}
+/** Whether the box covers the point, edges included. */
+declare function selectionBoxCovers(box: SelectionBoxRect, [x, y]: XY<number>): boolean;
+/**
+ * Selecting by dragging a box over a set of items.
+ *
+ * The drag itself is not here: the caller owns the pointer, and reports where
+ * it went in the same 0..1 space the items are given in.
+ */
+declare function createSelectionBox<Id>(options: SelectionBoxOptions<Id>): SelectionBoxInstance<Id>;
+//#endregion
+export { type AnimationCanvasInstance, type AnimationCanvasOptions, type AnimationFrame, type AxisOptions, type CanvasDrawFunction, type CanvasInitFunction, type DragInstance, type DragOptions, type DragState, type DragValueInstance, type DragValueMapping, type DragValueOptions, type DrawingContext, type DrawingState, type DrawingStateValue, type MIDIAccessError, type MIDIAccessInstance, type MIDIAccessOptions, type MIDIAccessState, type MIDIInputHandlers, type MIDIInputInstance, type MIDIMessageInstance, type MappingContext, NOT_SUPPORTED, type NoteSource, PERMISSION_DENIED, PITCH_BEND_CENTER, type PianoInputInstance, type PianoInputOptions, type SelectionBoxBeginOptions, type SelectionBoxInstance, type SelectionBoxOptions, type SelectionBoxRect, UNAVAILABLE, type WheelInstance, type WheelOptions, type XY, type XYInput, createAnimationCanvas, createDrag, createDragValue, createMIDIAccess, createMIDIInput, createMIDIMessage, createPianoInput, createSelectionBox, createWheel, drawingState, elementMapping, isDrawingState, relativeMapping, selectionBoxCovers, toXY };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/canvas/animation.ts","../src/canvas/context.ts","../src/midi/access.ts","../src/midi/message.ts","../src/midi/input.ts","../src/piano/input.ts","../src/pointer/drag.ts","../src/xy.ts","../src/pointer/dragValue.ts","../src/pointer/wheel.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/canvas/animation.ts","../src/canvas/context.ts","../src/midi/access.ts","../src/midi/input.ts","../src/midi/message.ts","../src/piano/index.ts","../src/pointer/drag.ts","../src/xy.ts","../src/pointer/drag-value.ts","../src/pointer/wheel.ts","../src/selection/box.ts"],"mappings":"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"}