insomni 0.2.0-alpha.0

package/dist/camera-view-DHmMiKvP.d.mts

@@ -0,0 +1,326 @@
+//#region src/math/vec2.d.ts
+interface Vec2 {
+  x: number;
+  y: number;
+}
+declare function vec2(x: number, y: number): Vec2;
+declare function add(a: Vec2, b: Vec2): Vec2;
+declare function sub(a: Vec2, b: Vec2): Vec2;
+declare function scale(v: Vec2, s: number): Vec2;
+declare function length(v: Vec2): number;
+declare function normalize(v: Vec2): Vec2;
+declare function dot(a: Vec2, b: Vec2): number;
+//#endregion
+//#region src/frame.d.ts
+interface FrameRect {
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+}
+declare const ZERO_RECT: FrameRect;
+/**
+ * Padding value for `Frame.padded()`:
+ *
+ * - `number` — applied to all four sides (absolute pixels).
+ * - `{ all }` — same as a number.
+ * - `{ top, right, bottom, left }` — per-side overrides (any missing key is 0).
+ * - `{ ratio }` — fractional inset based on the frame's shorter side
+ *   (e.g. `{ ratio: 0.1 }` = 10% of min(width, height) on every side).
+ */
+type Padding = number | {
+  all?: number;
+  top?: number;
+  right?: number;
+  bottom?: number;
+  left?: number;
+} | {
+  ratio: number;
+};
+interface Frame extends FrameRect {
+  /** Top-left corner of the frame. */
+  readonly topLeft: Vec2;
+  /** Top-right corner of the frame. */
+  readonly topRight: Vec2;
+  /** Bottom-left corner of the frame. */
+  readonly bottomLeft: Vec2;
+  /** Bottom-right corner of the frame. */
+  readonly bottomRight: Vec2;
+  /** Geometric center of the frame. */
+  readonly center: Vec2;
+  /** Plain-object rect (useful for `layer.pushRect`). */
+  readonly rect: FrameRect;
+  /**
+   * Return a nested frame inset by `padding` on each side. The outer frame is
+   * not mutated.
+   */
+  padded(padding: Padding): Frame;
+  /**
+   * Return a frame translated by `(dx, dy)` without changing width or height.
+   */
+  translated(dx: number, dy: number): Frame;
+  /**
+   * Return a frame whose origin is the same but width/height are replaced.
+   */
+  resized(width: number, height: number): Frame;
+}
+/** Create a frame from an `{x, y, width, height}` rect. */
+declare function createFrame(rect: FrameRect): Frame;
+/**
+ * Convenience: create a frame covering `(0, 0)` to `(width, height)`.
+ * Useful as the outermost container for a canvas or SVG viewport.
+ */
+declare function viewportFrame(width: number, height: number): Frame;
+//#endregion
+//#region src/math/mat3.d.ts
+/**
+ * 3×3 column-major matrix for 2D affine transforms.
+ *
+ * Layout: [col0.x, col0.y, col0.z, col1.x, col1.y, col1.z, col2.x, col2.y, col2.z]
+ *
+ *   | m[0]  m[3]  m[6] |
+ *   | m[1]  m[4]  m[7] |
+ *   | m[2]  m[5]  m[8] |
+ */
+type Mat3 = readonly [number, number, number, number, number, number, number, number, number];
+declare const IDENTITY: Mat3;
+declare function translation(tx: number, ty: number): Mat3;
+declare function scaling(sx: number, sy?: number): Mat3;
+declare function rotation(radians: number): Mat3;
+/** Scale around an arbitrary center point. */
+declare function scalingAt(sx: number, sy: number, cx: number, cy: number): Mat3;
+/** Rotate around an arbitrary center point. */
+declare function rotationAt(radians: number, cx: number, cy: number): Mat3;
+/** Matrix multiplication: result applies `b` first, then `a`. */
+declare function multiply(a: Mat3, b: Mat3): Mat3;
+/** Returns the inverse, or null if the matrix is singular. */
+declare function invert(m: Mat3): Mat3 | null;
+/** Apply the matrix to a 2D point. */
+declare function transformPoint(m: Mat3, x: number, y: number): Vec2;
+/** Orthographic projection: maps pixel coords (0,0)→NDC(-1,1), (w,h)→NDC(1,-1). */
+declare function projection(width: number, height: number): Mat3;
+//#endregion
+//#region src/viewport.d.ts
+/**
+ * Per-axis margin spec. A bare number applies to both axes. Values are
+ * fractions of the *visible* span and apply symmetrically to both edges.
+ */
+type PanBoundsMargin = number | {
+  x?: number;
+  y?: number;
+};
+interface PanBoundsMargins {
+  /** Pan-past-content allowance when content is larger than the viewport. */
+  overshoot?: PanBoundsMargin;
+  /** Content drift allowance when content fits inside the viewport. */
+  drift?: PanBoundsMargin;
+}
+interface CameraPanBoundsOptions extends PanBoundsMargins {
+  /**
+   * World-space rect that the camera is constrained to keep in view.
+   * Required for camera-mode clamping (no implicit content bounds exist).
+   */
+  content: FrameRect;
+}
+/**
+ * Structural shape the renderer / Layer / interaction pipeline needs from a
+ * viewport. Both core's `CameraViewport` and plot's `DataViewport` satisfy
+ * this — keeps core decoupled from the data-mode viewport that lives in plot.
+ */
+interface ViewportLike {
+  /** `"camera"` for core viewports; plot viewports report their own mode. */
+  readonly mode: string;
+  readonly frame: Frame;
+  readonly absoluteFrame: Frame;
+  readonly parent: ViewportLike | null;
+  readonly camera: ResolvedCameraState;
+  readonly clipRect: FrameRect;
+  onChange(cb: () => void): () => void;
+}
+/** Structural-shape alias for {@link ViewportLike}. */
+type Viewport = ViewportLike;
+interface CameraViewportOptions {
+  /** Frame in pixel space (relative to parent if `parent` is supplied). */
+  frame: Frame;
+  /** Optional parent viewport — `frame` is interpreted in the parent's space. */
+  parent?: ViewportLike;
+  /** Initial camera state. Any missing field defaults to its identity (0 / 1). */
+  camera?: CameraState;
+  /**
+   * Constrain the camera so that `content` stays in (or near) the viewport.
+   * When zoomed in, panning stops at content edges (plus margin); when zoomed
+   * out so content fits, content cannot leave the viewport. Zoom remains
+   * unrestricted.
+   */
+  panBounds?: CameraPanBoundsOptions;
+}
+type ZoomFactor = number | {
+  x?: number;
+  y?: number;
+};
+interface CameraViewport {
+  readonly mode: "camera";
+  /** Frame relative to `parent` (or absolute if no parent). */
+  readonly frame: Frame;
+  /** Frame in root / canvas space — walks the parent chain on each read. */
+  readonly absoluteFrame: Frame;
+  /** Parent viewport, if this is a nested viewport. */
+  readonly parent: ViewportLike | null;
+  /** Mutable rect equal to `absoluteFrame`, refreshed in place on each access. */
+  readonly clipRect: FrameRect;
+  /** Resolved camera state. */
+  readonly camera: ResolvedCameraState;
+  /** Pan by pixel deltas in this viewport's frame space. */
+  panBy(dxPx: number, dyPx: number): void;
+  /** Zoom around a screen-pixel anchor in the viewport's absolute frame space. */
+  zoomAt(anchorSx: number, anchorSy: number, factor: ZoomFactor): void;
+  /** Reset to initial camera. */
+  reset(): void;
+  /** Replace the frame (in the same space as the original frame). */
+  setFrame(frame: Frame): void;
+  /** Set the camera (any omitted field keeps its current value). */
+  setCamera(state: CameraState): void;
+  /** Alias for {@link setCamera}. */
+  jumpCamera(state: CameraState): void;
+  /**
+   * Convert a screen-space coordinate to world coordinates.
+   * Rotation is not applied, matching the interaction system's hit-testing.
+   */
+  screenToWorld(sx: number, sy: number): Vec2;
+  /** Inverse of {@link screenToWorld}. */
+  worldToScreen(wx: number, wy: number): Vec2;
+  /** Replace the pan-bound config (or clear it with `null`). */
+  setPanBounds(options: CameraPanBoundsOptions | null): void;
+  /** Subscribe to any view-state change. */
+  onChange(cb: () => void): () => void;
+  /** @internal */
+  _state: CameraInternal;
+}
+interface CameraData {
+  x: number;
+  y: number;
+  zoom: number;
+  rotation: number;
+}
+interface MutableFrameRect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+interface ResolvedAxisMargin {
+  x: number;
+  y: number;
+}
+interface ResolvedMargins {
+  overshoot: ResolvedAxisMargin;
+  drift: ResolvedAxisMargin;
+}
+interface CameraInternal {
+  mode: "camera";
+  frame: Frame;
+  parent: ViewportLike | null;
+  listeners: Set<() => void>;
+  notifying: boolean;
+  clipRect: MutableFrameRect;
+  camera: CameraData;
+  baseCamera: CameraData;
+  panBounds: {
+    content: FrameRect;
+    margins: ResolvedMargins;
+  } | null;
+}
+declare function createViewport(options: CameraViewportOptions): CameraViewport;
+/**
+ * Compute the world-space AABB visible within the camera viewport's frame
+ * (or a sub-rect of it). Useful for hit-testing and manual culling logic —
+ * `Renderer2D` applies render-time cull automatically.
+ *
+ * Rotation is ignored — the returned rect is the non-rotated AABB, which is
+ * a conservative over-approximation when the camera is rotated.
+ */
+declare function worldCullBounds(viewport: CameraViewport, rect?: FrameRect): FrameRect;
+//#endregion
+//#region src/shared/camera-view.d.ts
+interface CameraState {
+  /** World x coordinate shown at the viewport center. Default: 0 */
+  x?: number;
+  /** World y coordinate shown at the viewport center. Default: 0 */
+  y?: number;
+  /** Zoom factor — zooms around the viewport center. Default: 1 */
+  zoom?: number;
+  /** Rotation in radians around the viewport center. Default: 0 */
+  rotation?: number;
+}
+interface Bounds2D {
+  minX: number;
+  minY: number;
+  maxX: number;
+  maxY: number;
+}
+interface FitCameraToBoundsOptions {
+  /** Fraction of the viewport to use. 1 fills the viewport, 0.85 leaves 15% slack. */
+  padding?: number;
+}
+/** Shared camera state shape returned by `getCamera`. */
+type ResolvedCameraState = Readonly<{
+  x: number;
+  y: number;
+  zoom: number;
+  rotation: number;
+}>;
+/**
+ * Build the view matrix (world → screen-pixel) from camera state. Column-major
+ * 3×3: scale/rotate around the viewport center, translate so the camera
+ * position lands at the center.
+ */
+declare function viewFromCamera(cam: {
+  x: number;
+  y: number;
+  zoom: number;
+  rotation: number;
+}, viewportWidth: number, viewportHeight: number): Mat3;
+/**
+ * World → CSS-px view matrix matching what the renderer draws: the world camera
+ * baseline is **CSS px** (zoom=1 ⇒ 1 world unit = 1 CSS px), so this is simply
+ * `viewFromCamera(cam, deviceW/dpr, deviceH/dpr)`.
+ *
+ * The renderer builds the world view-projection over the CSS-px viewport and
+ * applies dpr once, matrix-side, when targeting the device backbuffer (see
+ * `viewProjectionForSpace`). The CSS-px screen position of a world point is
+ * therefore `viewFromCamera(cam, cssW, cssH) ∘ point` — independent of dpr. The
+ * `deviceW/deviceH/dpr` signature is retained so callers can keep passing device
+ * dims (`canvas.width/height`); CSS dims are recovered as `device ÷ dpr`.
+ */
+declare function worldToCssMatrix(cam: {
+  x: number;
+  y: number;
+  zoom: number;
+  rotation: number;
+}, deviceW: number, deviceH: number, dpr: number): Mat3;
+/**
+ * Build the world → screen-pixel view matrix for a camera anchored at the
+ * center of an arbitrary rect (`rx`, `ry`, `rw`, `rh`). World `(cam.x, cam.y)`
+ * maps to the rect center; `zoom` / `rotation` apply around that center.
+ * `viewFromCamera` is the special case where the rect covers the full target.
+ */
+declare function viewFromCameraInRect(cam: {
+  x: number;
+  y: number;
+  zoom: number;
+  rotation: number;
+}, rx: number, ry: number, rw: number, rh: number): Mat3;
+/** Resolve an `absoluteFrame`-shaped rect from a CameraViewport. */
+declare function cameraViewportRect(viewport: CameraViewport): FrameRect;
+/**
+ * Compute the camera state that fits `bounds` into `viewportWidth × viewportHeight`
+ * with optional padding factor in (0, 1].
+ */
+declare function cameraStateForBounds(bounds: Bounds2D, viewportWidth: number, viewportHeight: number, options?: FitCameraToBoundsOptions): {
+  x: number;
+  y: number;
+  zoom: number;
+  rotation: number;
+};
+//#endregion
+export { transformPoint as A, dot as B, invert as C, rotationAt as D, rotation as E, ZERO_RECT as F, vec2 as G, normalize as H, createFrame as I, viewportFrame as L, Frame as M, FrameRect as N, scaling as O, Padding as P, Vec2 as R, Mat3 as S, projection as T, scale as U, length as V, sub as W, ViewportLike as _, cameraStateForBounds as a, worldCullBounds as b, viewFromCameraInRect as c, CameraPanBoundsOptions as d, CameraViewport as f, Viewport as g, PanBoundsMargins as h, ResolvedCameraState as i, translation as j, scalingAt as k, worldToCssMatrix as l, PanBoundsMargin as m, CameraState as n, cameraViewportRect as o, CameraViewportOptions as p, FitCameraToBoundsOptions as r, viewFromCamera as s, Bounds2D as t, CameraInternal as u, ZoomFactor as v, multiply as w, IDENTITY as x, createViewport as y, add as z };

package/dist/frame-mHNdKRpF.mjs

@@ -0,0 +1,135 @@
+//#region src/frame.ts
+const ZERO_RECT = {
+	x: 0,
+	y: 0,
+	width: 0,
+	height: 0
+};
+function resolvePadding(padding, width, height) {
+	if (typeof padding === "number") return {
+		top: padding,
+		right: padding,
+		bottom: padding,
+		left: padding
+	};
+	if ("ratio" in padding) {
+		const side = Math.min(width, height) * padding.ratio;
+		return {
+			top: side,
+			right: side,
+			bottom: side,
+			left: side
+		};
+	}
+	const all = padding.all ?? 0;
+	return {
+		top: padding.top ?? all,
+		right: padding.right ?? all,
+		bottom: padding.bottom ?? all,
+		left: padding.left ?? all
+	};
+}
+var FrameImpl = class FrameImpl {
+	x;
+	y;
+	width;
+	height;
+	constructor(x, y, width, height) {
+		this.x = x;
+		this.y = y;
+		this.width = Math.max(0, width);
+		this.height = Math.max(0, height);
+	}
+	get topLeft() {
+		return {
+			x: this.x,
+			y: this.y
+		};
+	}
+	get topRight() {
+		return {
+			x: this.x + this.width,
+			y: this.y
+		};
+	}
+	get bottomLeft() {
+		return {
+			x: this.x,
+			y: this.y + this.height
+		};
+	}
+	get bottomRight() {
+		return {
+			x: this.x + this.width,
+			y: this.y + this.height
+		};
+	}
+	get center() {
+		return {
+			x: this.x + this.width / 2,
+			y: this.y + this.height / 2
+		};
+	}
+	get rect() {
+		return {
+			x: this.x,
+			y: this.y,
+			width: this.width,
+			height: this.height
+		};
+	}
+	padded(padding) {
+		const p = resolvePadding(padding, this.width, this.height);
+		return new FrameImpl(this.x + p.left, this.y + p.top, this.width - p.left - p.right, this.height - p.top - p.bottom);
+	}
+	translated(dx, dy) {
+		return new FrameImpl(this.x + dx, this.y + dy, this.width, this.height);
+	}
+	resized(width, height) {
+		return new FrameImpl(this.x, this.y, width, height);
+	}
+};
+/** Create a frame from an `{x, y, width, height}` rect. */
+function createFrame(rect) {
+	return new FrameImpl(rect.x, rect.y, rect.width, rect.height);
+}
+/**
+* Convenience: create a frame covering `(0, 0)` to `(width, height)`.
+* Useful as the outermost container for a canvas or SVG viewport.
+*/
+function viewportFrame(width, height) {
+	return new FrameImpl(0, 0, width, height);
+}
+/**
+* Grow a rect outward by `pad` on every side. Damage rects are padded before
+* scissoring so the analytic anti-aliased fringe of geometry at the rect edge
+* is fully repainted and no hairline seam survives at the boundary.
+*/
+function padFrameRect(r, pad) {
+	return {
+		x: r.x - pad,
+		y: r.y - pad,
+		width: r.width + pad * 2,
+		height: r.height + pad * 2
+	};
+}
+/**
+* Geometric intersection of two rects. A `null` second rect means "no clip", so
+* the first rect passes through unchanged. Non-overlapping rects yield a
+* zero-area rect (scissors to nothing). Width/height are floored at zero.
+*/
+function intersectFrameRect(a, b) {
+	if (!b) return a;
+	const x = Math.max(a.x, b.x);
+	const y = Math.max(a.y, b.y);
+	const right = Math.min(a.x + a.width, b.x + b.width);
+	const bottom = Math.min(a.y + a.height, b.y + b.height);
+	return {
+		x,
+		y,
+		width: Math.max(0, right - x),
+		height: Math.max(0, bottom - y)
+	};
+}
+//#endregion
+export { viewportFrame as a, padFrameRect as i, createFrame as n, intersectFrameRect as r, ZERO_RECT as t };

package/dist/index-CmMZCMJT.d.mts

@@ -0,0 +1,39 @@
+//#region src/reactivity/signals.d.ts
+interface ReadableSignal<T> {
+  get(): T;
+  peek(): T;
+  subscribe(fn: (v: T) => void): () => void;
+}
+interface Signal<T> extends ReadableSignal<T> {
+  set(v: T): void;
+  update(fn: (cur: T) => T): void;
+  /**
+   * Drop all subscribers (push + tracking) and silence further `set` / `update`.
+   * Existing unsubscribe closures stay valid (they were already idempotent).
+   * Use when an owner is being torn down and you want to break references that
+   * external subscribers might hold to the owner's internals.
+   */
+  dispose(): void;
+}
+interface Computed<T> extends ReadableSignal<T> {}
+interface SignalOptions<T> {
+  equals?: (a: T, b: T) => boolean;
+}
+declare function signal<T>(initial: T, opts?: SignalOptions<T>): Signal<T>;
+declare function computed<T>(fn: () => T, opts?: SignalOptions<T>): Computed<T>;
+type Scheduler = (run: () => void) => void;
+type EffectDisposer = () => void;
+type EffectFn = () => void | EffectDisposer;
+declare function setDefaultScheduler(s: Scheduler): void;
+declare function syncScheduler(): Scheduler;
+declare function microtaskFlush(): Scheduler;
+interface EffectOptions {
+  scheduler?: Scheduler;
+}
+declare function effect(fn: EffectFn, options?: EffectOptions): EffectDisposer;
+/** Run `fn` with no current tracking context. Reads inside don't register. */
+declare function untrack<T>(fn: () => T): T;
+declare function isSignal<T>(v: unknown): v is ReadableSignal<T>;
+declare function toSignal<T>(value: T | ReadableSignal<T>): ReadableSignal<T>;
+//#endregion
+export { untrack as _, ReadableSignal as a, SignalOptions as c, isSignal as d, microtaskFlush as f, toSignal as g, syncScheduler as h, EffectOptions as i, computed as l, signal as m, EffectDisposer as n, Scheduler as o, setDefaultScheduler as p, EffectFn as r, Signal as s, Computed as t, effect as u };