@tremolo-ui/dom 0.4.0 → 0.5.0

package/dist/index.d.ts

@@ -1,3 +1,111 @@
+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 {
+  /** Width of the canvas in CSS pixels. */
+  width: number;
+  /** Height of the canvas in CSS pixels. */
+  height: number;
+  /** Frames drawn so far, starting at 0. */
+  count: number;
+  /** Milliseconds since the previous frame. */
+  deltaTime: number;
+  /** Milliseconds since the instance was created. */
+  elapsedTime: number;
+  /** Frames per second implied by `deltaTime`. */
+  fps: number;
+}
+type CanvasDrawFunction = (context: CanvasRenderingContext2D, frame: AnimationFrame) => void;
+type CanvasInitFunction = (context: CanvasRenderingContext2D, size: {
+  width: number;
+  height: number;
+}) => void;
+interface AnimationCanvasOptions {
+  /** Called for every frame. */
+  draw: CanvasDrawFunction;
+  /** Called once, after the first size is known and before the first frame. */
+  init?: CanvasInitFunction;
+  /**
+   * Keep drawing on every animation frame. When off, a frame is drawn only on
+   * a resize or an explicit {@link AnimationCanvasInstance.redraw}.
+   *
+   * @default true
+   */
+  animate?: boolean;
+  /**
+   * Size in CSS pixels. Ignored when `relativeSize` is on.
+   *
+   * @default { width: 100, height: 100 }
+   */
+  size?: {
+    width: number;
+    height: number;
+  };
+  /**
+   * Follow the size of the canvas's parent element instead of `size`.
+   *
+   * Fixed for the lifetime of the instance: it decides whether a
+   * `ResizeObserver` is attached.
+   *
+   * @default false
+   */
+  relativeSize?: boolean;
+  /**
+   * Carry the drawing across a resize, so that the canvas does not blank for a
+   * frame while the new size is drawn.
+   *
+   * @default true
+   */
+  reduceFlickering?: boolean;
+  /**
+   * Passed to `getContext('2d', …)`. Read once when the context is created, so
+   * it is fixed for the lifetime of the instance.
+   *
+   * @see https://developer.mozilla.org/docs/Web/API/HTMLCanvasElement/getContext#contextattributes
+   */
+  contextAttributes?: CanvasRenderingContext2DSettings;
+}
+interface AnimationCanvasInstance {
+  /**
+   * Replace the given options. Lets a wrapper feed a fresh `draw` in on every
+   * 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
+   * instance and are ignored here.
+   *
+   * While `animate` is off this also draws a frame, since nothing else would.
+   */
+  update: (options: Partial<AnimationCanvasOptions>) => void;
+  /** Draw one frame now, whether or not `animate` is on. */
+  redraw: () => void;
+  destroy: () => void;
+}
+/**
+ * Drive a canvas from `requestAnimationFrame`, keeping its backing store in
+ * step with the device pixel ratio and, optionally, with the size of its
+ * parent.
+ *
+ * Drawing code works in CSS pixels: the context is scaled by the device pixel
+ * ratio, and `width` / `height` of each {@link AnimationFrame} are CSS pixels.
+ */
+declare function createAnimationCanvas(canvas: HTMLCanvasElement, options: AnimationCanvasOptions): AnimationCanvasInstance;
+//#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.
+ *
+ * @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"];
+type DrawingState = (typeof drawingState)[number];
+type DrawingStateValue = CanvasRenderingContext2D[DrawingState];
+type DrawingContext = Pick<CanvasRenderingContext2D, DrawingState>;
+declare function isDrawingState(value: unknown): value is DrawingState;
+//#endregion
 //#region src/midi/access.d.ts
 /** @private */
 declare const PERMISSION_DENIED = "PERMISSION_DENIED";
@@ -55,6 +163,75 @@ declare function createMIDIInput(midiAccess: MIDIAccess | null, {
   onPitchBendEvent
 }: MIDIInputHandlers): MIDIInputInstance;
 //#endregion
+//#region src/piano/input.d.ts
+/**
+ * What asked for a note to sound.
+ *
+ * A note stops only once everything that asked for it has let go, so two
+ * fingers on one key, or a key held by both the mouse and a MIDI keyboard,
+ * behave the way they look.
+ *
+ * Pointers use `pointer:<pointerId>`; everything else names its own source.
+ */
+type NoteSource = string;
+interface PianoInputOptions {
+  /** Geometry of the drawn keyboard, used to find the note under a pointer. */
+  layout: PianoLayout;
+  /**
+   * Let a pointer slide from one key to the next while it is down. With it off,
+   * the key that was pressed keeps sounding until the pointer is released.
+   *
+   * @default true
+   */
+  glissando?: boolean;
+  /**
+   * Highest note that can sound. Above it a note is refused, whichever source
+   * asks for it.
+   *
+   * @default 127
+   */
+  midiMax?: number;
+  /** Called when a note starts sounding, not for each source that asks. */
+  onPlayNote?: (note: number, velocity?: number) => void;
+  /** Called once the last source holding a note has let go. */
+  onStopNote?: (note: number) => void;
+  /** Called whenever {@link PianoInputInstance.activeNotes} would change. */
+  onActiveNotesChange?: (notes: number[]) => void;
+}
+interface PianoInputInstance {
+  /**
+   * Replace the given options. Lets a wrapper feed a fresh layout in without
+   * tearing down the listeners, which would abort a drag in progress.
+   */
+  update: (options: Partial<PianoInputOptions>) => void;
+  /**
+   * Start a note from something other than a pointer: a keyboard shortcut, a
+   * MIDI message, an imperative call.
+   */
+  noteOn: (note: number, options?: {
+    source?: NoteSource;
+    velocity?: number;
+  }) => void;
+  /** Release a note held by `source`. */
+  noteOff: (note: number, options?: {
+    source?: NoteSource;
+  }) => void;
+  /** The notes currently sounding, ascending. */
+  activeNotes: () => number[];
+  destroy: () => void;
+}
+/**
+ * Drive a piano keyboard with pointers, and own what is sounding.
+ *
+ * Every way of playing a note goes through the one instance — pointers here,
+ * keyboard shortcuts and MIDI through {@link PianoInputInstance.noteOn} — so
+ * there is a single answer to what is currently held, and drawing the keys is
+ * left entirely to the wrapper.
+ *
+ * Tracks every pointer at once, so a chord can be played with several fingers.
+ */
+declare function createPianoInput(element: Element, options: PianoInputOptions): PianoInputInstance;
+//#endregion
 //#region src/pointer/drag.d.ts
 type DragState = {
   /** Total movement from the drag start, in screen coordinates. */x: number;
@@ -63,28 +240,57 @@ type DragState = {
   deltaY: number; /** Pointer position in viewport coordinates. */
   clientX: number;
   clientY: number;
+  /**
+   * Which pointer this is. Always the same value for one drag; with
+   * {@link DragOptions.multiPointer} it tells concurrent drags apart.
+   */
+  pointerId: number;
   event: PointerEvent;
 };
 type DragOptions = {
   /**
-   * Minimum movement in pixels before `onDrag` fires.
+   * Minimum movement in pixels before `onDrag` fires. Movement below it is
+   * carried over to the next event rather than discarded, so a slow drag still
+   * reports once it adds up.
+   *
    * Prevents `onDrag` from firing on, for example, a double click.
-   * Values below 1 are clamped to 1.
    *
-   * @default 1
+   * @default 0
    */
   threshold?: number;
   /**
    * CSS cursor to show while dragging. Applied to the element itself: pointer
    * capture keeps it in effect even once the pointer leaves the element, so
    * there is no need to touch the document.
+   *
+   * With {@link DragOptions.multiPointer} it is set for the first pointer and
+   * restored once the last one is up.
    */
   cursor?: string;
+  /**
+   * Track every pointer that goes down on the element, rather than only the
+   * first. Each one gets its own `onDragStart` / `onDrag` / `onDragEnd` and
+   * carries its own totals; {@link DragState.pointerId} says which is which.
+   *
+   * Fixed for the lifetime of the instance: switching part way through a drag
+   * has no meaning, so `update()` ignores it.
+   *
+   * @default false
+   */
+  multiPointer?: boolean;
   onDragStart?: (state: DragState) => void;
   onDrag?: (state: DragState) => void;
   onDragEnd?: (state: DragState) => void;
 };
 interface DragInstance {
+  /**
+   * Replace the given options. Lets a wrapper feed fresh handlers in without
+   * tearing down the listeners, which would abort a drag in progress.
+   *
+   * `multiPointer` is fixed for the lifetime of the instance and is ignored
+   * here.
+   */
+  update: (options: DragOptions) => void;
   destroy: () => void;
 }
 /**
@@ -95,17 +301,165 @@ interface DragInstance {
  * element gets `touch-action: none` so that touch dragging does not scroll the
  * page, plus `user-select: none` so that a long press does not start a text
  * selection instead.
+ *
+ * One pointer at a time by default; see {@link DragOptions.multiPointer}.
+ */
+declare function createDrag(element: Element, options?: DragOptions): DragInstance;
+//#endregion
+//#region src/xy.d.ts
+/**
+ * A pair of per-axis values. The tuple elements are labelled, so editors show
+ * `[x: number, y: number]` rather than a bare pair.
  */
-declare function createDrag(element: Element, {
-  threshold: _threshold,
-  cursor,
-  onDragStart,
-  onDrag,
-  onDragEnd
-}?: DragOptions): DragInstance;
+type XY<T> = [x: T, y: T];
+/**
+ * A setting that may be given once for both axes, or per axis.
+ *
+ * A single value is told from a pair with `Array.isArray`, so the single form
+ * is only offered while `T` cannot itself be an array. Where it can, the pair
+ * is the only way to write it, since a lone array would be read as a pair.
+ */
+type XYInput<T> = [T] extends [readonly unknown[]] ? readonly [x: T, y: T] : T | readonly [x: T, y: T];
+/**
+ * Spread a setting that may have been given as a single value.
+ *
+ * The parameter is written out rather than taken as `XYInput<T>`: a
+ * conditional type cannot be narrowed, so the constraint stays where it is
+ * declared and this takes both forms.
+ *
+ * The pair is copied rather than passed along, so that the result is a tuple
+ * the caller owns even when a readonly one was given.
+ */
+declare function toXY<T>(value: T | readonly [x: T, y: T]): XY<T>;
+//#endregion
+//#region src/pointer/dragValue.d.ts
+/**
+ * How the 0-1 travel of one axis maps onto a value.
+ *
+ * Extends `ValueRange` so that a drag and an `applyDelta` nudge from a wheel
+ * or an arrow key share one description of the scaling.
+ */
+interface AxisOptions extends ValueRange {
+  /**
+   * Flip the axis so that its far end is `min`.
+   *
+   * Positions follow the screen: x grows to the right, y downwards. A vertical
+   * slider whose maximum is at the top therefore reverses its y axis.
+   *
+   * @default false
+   */
+  reverse?: boolean;
+}
+/** Where the value of each axis currently sits, as a position (see {@link DragValueMapping}). */
+interface MappingContext {
+  position: () => XY<number>;
+}
+/**
+ * Turns pointer movement into a position on each axis: 0 is the `min` end of
+ * the travel and 1 the `max` end, before `reverse` and the scaling of
+ * {@link AxisOptions} are applied.
+ *
+ * A mapping holds the state of the drag in progress, so an instance belongs to
+ * a single {@link createDragValue} instance.
+ */
+interface DragValueMapping {
+  /**
+   * @returns the position, or null when it cannot be determined and the event
+   * should be ignored.
+   */
+  start: (state: DragState, context: MappingContext) => XY<number> | null;
+  move: (state: DragState, context: MappingContext) => XY<number> | null;
+}
+/**
+ * Map the pointer onto the bounding rect of an element: the value *is* the
+ * position pointed at, so the middle of the element is 0.5.
+ *
+ * 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;
+/**
+ * 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
+}?: {
+  /**
+   * Pixels of movement that span the whole range.
+   * @default 100
+   */
+  pixelRange?: XYInput<number>;
+}): DragValueMapping;
+interface DragValueOptions {
+  /** Scaling of each axis; a single value applies to both. */
+  axis: XYInput<AxisOptions>;
+  /** How pointer movement becomes a position. */
+  mapping: DragValueMapping;
+  /**
+   * The current value of each axis. Read when a drag starts, by mappings that
+   * move the value relative to it, such as {@link relativeMapping}.
+   */
+  getValue?: () => XY<number>;
+  /**
+   * Report the value on pointer down, before any movement.
+   *
+   * Enable it where the pointer position *is* the value, so that a plain click
+   * jumps to it. Leave it off where the element being dragged is an object in
+   * its own right, so that grabbing its edge does not shift it under the
+   * pointer.
+   *
+   * @default false
+   */
+  updateOnPointerDown?: boolean;
+  /** @see DragOptions.threshold */
+  threshold?: number;
+  /** @see DragOptions.cursor */
+  cursor?: string;
+  onChange?: (value: XY<number>, state: DragState) => void;
+  onDragStart?: (value: XY<number>, state: DragState) => void;
+  onDragEnd?: (value: XY<number>, state: DragState) => void;
+}
+interface DragValueInstance {
+  /**
+   * Replace the given options. Lets a wrapper feed fresh values in without
+   * tearing down the listeners, which would abort a drag in progress.
+   *
+   * `mapping` is fixed for the lifetime of the instance and is ignored here.
+   */
+  update: (options: Partial<DragValueOptions>) => void;
+  destroy: () => void;
+}
+/**
+ * Drive a value with a pointer drag.
+ *
+ * Combines {@link createDrag} with the scaling of `@tremolo-ui/functions`: the
+ * mapping decides where the pointer sits on the 0-1 travel of each axis, and
+ * the axis options turn that into a value.
+ */
+declare function createDragValue(element: Element, options: DragValueOptions): DragValueInstance;
 //#endregion
 //#region src/pointer/wheel.d.ts
+interface WheelOptions {
+  /**
+   * Only report events while the focus is inside the element.
+   *
+   * A control that reacts to the wheel on hover alone takes the scroll away
+   * from the page, so passing over one in a long form silently changes its
+   * value. Requiring focus makes that an explicit act.
+   *
+   * The check is `contains`, not an identity test: the element that actually
+   * takes focus is usually a descendant, such as a thumb or an `<input>`, and
+   * a caller may have replaced it with markup of their own.
+   *
+   * @default false
+   */
+  requireFocus?: boolean;
+}
 interface WheelInstance {
+  /** Replace the given options, keeping the listener in place. */
+  update: (options: WheelOptions) => void;
   destroy: () => void;
 }
 /**
@@ -114,7 +468,7 @@ interface WheelInstance {
  * The listener is registered with `passive: false` so that the handler can call
  * `preventDefault()` to stop the page from scrolling.
  */
-declare function createWheel(element: Element, onWheel: (event: WheelEvent) => void): WheelInstance;
+declare function createWheel(element: Element, onWheel: (event: WheelEvent) => void, options?: WheelOptions): WheelInstance;
 //#endregion
-export { type DragInstance, type DragOptions, type DragState, type MIDIAccessError, type MIDIAccessInstance, type MIDIAccessState, type MIDIInputHandlers, type MIDIInputInstance, type MIDIMessageInstance, NOT_SUPPORTED, PERMISSION_DENIED, type WheelInstance, createDrag, createMIDIAccess, createMIDIInput, createMIDIMessage, createWheel };
+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 };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/midi/access.ts","../src/midi/message.ts","../src/midi/input.ts","../src/pointer/drag.ts","../src/pointer/wheel.ts"],"mappings":";;cACa,iBAAA;;cAEA,aAAA;;KAGD,eAAA,UAAyB,iBAAA,UAA2B,aAAA;AAAA,KAEpD,eAAA;EAAA,SACD,UAAA,EAAY,UAAA;EAAA,SACZ,KAAA,EAAO,eAAA;AAAA;AAAA,UAQD,kBAAA;EAZL;EAcV,OAAA;EACA,QAAA,QAAgB,eAAA;EAfmB;EAiBnC,cAAA,QAAsB,eAAA;EAfZ;EAiBV,SAAA,GAAY,QAAA;EACZ,OAAA;AAAA;;;;;;;iBASc,gBAAA,CAAA,GAAoB,kBAAA;;;UCnCnB,mBAAA;EACf,OAAA;AAAA;;;;ADEF;;iBCMgB,iBAAA,CACd,UAAA,EAAY,UAAA,SACZ,aAAA,GAAgB,KAAA,EAAO,gBAAA,YACtB,mBAAA;;;KCJS,iBAAA;EACV,aAAA,IAAiB,IAAA,UAAc,QAAA;EAC/B,cAAA,IAAkB,IAAA;EAClB,gBAAA,IAAoB,GAAA,UAAa,GAAA;AAAA;AAAA,KAGvB,iBAAA,GAAoB,mBAAA;;;;;iBAMhB,eAAA,CACd,UAAA,EAAY,UAAA;EACV,aAAA;EAAe,cAAA;EAAgB;AAAA,GAAoB,iBAAA,GACpD,iBAAA;;;KCvBS,SAAA;EHCC,iEGCX,CAAA;EACA,CAAA,UHF4B;EGI5B,MAAA;EACA,MAAA,UHHwB;EGKxB,OAAA;EACA,OAAA;EACA,KAAA,EAAO,YAAA;AAAA;AAAA,KAGG,WAAA;;;;AHLZ;;;;EGaE,SAAA;EHZqB;;;;;EGmBrB,MAAA;EAEA,WAAA,IAAe,KAAA,EAAO,SAAA;EACtB,MAAA,IAAU,KAAA,EAAO,SAAA;EACjB,SAAA,IAAa,KAAA,EAAO,SAAA;AAAA;AAAA,UAGL,YAAA;EACf,OAAA;AAAA;;;;;;;AHDF;;;iBGiCgB,UAAA,CACd,OAAA,EAAS,OAAA;EAEP,SAAA,EAAW,UAAA;EACX,MAAA;EACA,WAAA;EACA,MAAA;EACA;AAAA,IACC,WAAA,GACF,YAAA;;;UC7Ec,aAAA;EACf,OAAA;AAAA;;;;AJEF;;;iBIOgB,WAAA,CACd,OAAA,EAAS,OAAA,EACT,OAAA,GAAU,KAAA,EAAO,UAAA,YAChB,aAAA"}
+{"version":3,"file":"index.d.ts","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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"}