gesso-core 0.1.0

package/dist/testing.d.ts

@@ -0,0 +1,232 @@
+import { $t as Canvas2DRenderer, Aa as ScrollSink, Bs as TextMeasurer, Da as PointerControllerOptions, Ea as UiKeyboardController, Ha as UiFocusManager, If as UiInputDispatcher, La as UiGestureRecognizer, Lm as UiNodeType, Mm as LayoutRecord, Na as UiWheelController, Nc as UiGraph, Oa as UiPointerController, Qi as UiPlatformAdapter, Sp as LayoutResult, Xi as PlatformEventTarget, Zi as PlatformSurface, as as Canvas2DContext, bp as Constraints, ca as UiTouchScroller, dn as CanvasSurface, hi as LayoutEngine, io as UiHitTester, jp as UiNode, ka as ScrollContainerState, os as Canvas2DGradient, sa as TouchScrollerOptions, un as CanvasHost, xp as LayoutBox } from "./index-DuZEAhyZ.js";
+//#region src/layout/LayoutTestUtils.d.ts
+/**
+ * Shared helpers for layout specs: builds UiNode trees through
+ * the real graph and drives LayoutEngine.
+ */
+declare class LayoutHarness {
+  readonly graph: UiGraph;
+  readonly engine: LayoutEngine;
+  constructor(textMeasurer?: TextMeasurer);
+  createNode(id: string, type: UiNodeType): UiNode;
+  append(parent: UiNode, ...children: UiNode[]): void;
+  layout(node: UiNode, constraints?: Constraints): LayoutResult;
+  record(node: UiNode): LayoutRecord;
+  box(node: UiNode): LayoutBox;
+  boxOf(node: UiNode): LayoutBox;
+  /** Where the node is seen: scroll offsets and sticky shifts applied. */
+  visibleBox(node: UiNode): LayoutBox;
+}
+//#endregion
+//#region src/input/UiInputTestUtils.d.ts
+/**
+ * Shared harness for input specs.
+ *
+ * Builds real UiNode trees through UiGraph + LayoutEngine so hit
+ * testing, dispatch, focus and gestures are tested against actual
+ * layout geometry rather than hand-written boxes.
+ */
+declare class InputTestHarness {
+  readonly layout: LayoutHarness;
+  readonly root: UiNode;
+  readonly dispatcher: UiInputDispatcher;
+  /** Shared, so a spec can read back what a controller scrolled. */
+  readonly scrollSink: HarnessScrollSink;
+  /** A measurer is needed only by specs whose trees contain real text. */
+  constructor(width?: number, height?: number, textMeasurer?: TextMeasurer);
+  node(id: string, type: UiNodeType, props?: Record<string, unknown>): UiNode;
+  add(parent: UiNode, ...children: UiNode[]): void;
+  layoutTree(): void;
+  createHitTester(): UiHitTester;
+  createPointerController(): UiPointerController;
+  createGestureRecognizer(): UiGestureRecognizer;
+  createFocusManager(): UiFocusManager;
+  createKeyboardController(): UiKeyboardController;
+  createWheelController(): UiWheelController;
+  /**
+   * A pointer controller with a gesture recognizer behind it, for the
+   * specs that need a real Pan rather than a hand-made one.
+   */
+  createGesturePointerController(options?: PointerControllerOptions): UiPointerController;
+  createTouchScroller(options?: TouchScrollerOptions): UiTouchScroller;
+  createPlatformAdapter(): UiPlatformAdapter;
+  box(node: UiNode): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+}
+/**
+ * Minimal fake event target for testing the platform adapter.
+ */
+declare class FakeEventTarget implements PlatformEventTarget {
+  private readonly listeners;
+  addEventListener(type: string, listener: ((event: Event) => void) | null): void;
+  removeEventListener(type: string, listener: ((event: Event) => void) | null): void;
+  emit(type: string, event: Event): void;
+}
+/**
+ * Fake PlatformSurface for tests. Emits DOM-like events from plain
+ * objects so PointerEvent/WheelEvent/KeyboardEvent constructors are
+ * not required in the test environment.
+ */
+declare class FakePlatformSurface implements PlatformSurface {
+  readonly pointerTarget: FakeEventTarget;
+  readonly keyboardTarget: FakeEventTarget;
+  localX: number;
+  localY: number;
+  /** The last `touch-action` the adapter asked for; '' before any. */
+  touchAction: string;
+  clientToLocal(_clientX: number, _clientY: number): {
+    x: number;
+    y: number;
+  };
+  setTouchAction(value: string): void;
+}
+/**
+ * ScrollSink backed by the harness LayoutEngine. Updates the
+ * container's scrollX/scrollY properties, then re-lays out so the
+ * engine re-reads and clamps the offset, mirroring how the app layer
+ * drives scroll through node properties.
+ */
+declare class HarnessScrollSink implements ScrollSink {
+  private readonly harness;
+  /** Every scroll asked for, in order, so a spec can read the behaviour hint. */
+  readonly calls: {
+    node: UiNode;
+    dx: number;
+    dy: number;
+    behavior: string;
+  }[];
+  /** Containers whose scrollbars were revealed. */
+  readonly revealed: UiNode[];
+  constructor(harness: InputTestHarness);
+  containerState(node: UiNode): ScrollContainerState | undefined;
+  scrollBy(node: UiNode, dx: number, dy: number, behavior?: string): void;
+  scrollContainers(): Iterable<UiNode>;
+  revealScrollbars(node: UiNode): void;
+}
+//#endregion
+//#region src/rendering/RenderTestUtils.d.ts
+interface RecordedCall {
+  name: string;
+  args: unknown[];
+}
+/**
+ * The gradient a recording context hands back, carrying what it was
+ * asked for so a test can read the whole paint rather than a `[object
+ * CanvasGradient]`. A real one is opaque, which is exactly what makes
+ * a gradient hard to assert on without this.
+ */
+declare class RecordedGradient implements Canvas2DGradient {
+  readonly kind: 'linear' | 'radial';
+  readonly args: readonly number[];
+  readonly stops: {
+    offset: number;
+    color: string;
+  }[];
+  constructor(kind: 'linear' | 'radial', args: readonly number[]);
+  addColorStop(offset: number, color: string): void;
+}
+/**
+ * Deterministic Canvas2D spy: records every call and style
+ * assignment so tests can assert the exact draw sequence.
+ */
+declare class RecordingCanvasContext implements Canvas2DContext {
+  readonly calls: RecordedCall[];
+  private _fillStyle;
+  private _strokeStyle;
+  private _lineWidth;
+  private _lineJoin;
+  private _globalAlpha;
+  private _font;
+  private _textAlign;
+  private _textBaseline;
+  /**
+   * Tracking, which is a context property rather than part of the font
+   * shorthand — and sticky, so a spec can check it was cleared as well
+   * as that it was set.
+   */
+  letterSpacing: string;
+  get fillStyle(): string | Canvas2DGradient | CanvasPattern;
+  set fillStyle(value: string | Canvas2DGradient | CanvasPattern);
+  get strokeStyle(): string | Canvas2DGradient | CanvasPattern;
+  set strokeStyle(value: string | Canvas2DGradient | CanvasPattern);
+  get lineWidth(): number;
+  set lineWidth(value: number);
+  get lineJoin(): CanvasLineJoin;
+  set lineJoin(value: CanvasLineJoin);
+  get globalAlpha(): number;
+  set globalAlpha(value: number);
+  get font(): string;
+  set font(value: string);
+  get textAlign(): CanvasTextAlign;
+  set textAlign(value: CanvasTextAlign);
+  get textBaseline(): CanvasTextBaseline;
+  set textBaseline(value: CanvasTextBaseline);
+  save(): void;
+  restore(): void;
+  translate(x: number, y: number): void;
+  scale(x: number, y: number): void;
+  rotate(angle: number): void;
+  setTransform(a: number, b: number, c: number, d: number, e: number, f: number): void;
+  clearRect(x: number, y: number, width: number, height: number): void;
+  fillRect(x: number, y: number, width: number, height: number): void;
+  strokeRect(x: number, y: number, width: number, height: number): void;
+  beginPath(): void;
+  moveTo(x: number, y: number): void;
+  lineTo(x: number, y: number): void;
+  arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
+  closePath(): void;
+  rect(x: number, y: number, width: number, height: number): void;
+  clip(): void;
+  fill(): void;
+  stroke(): void;
+  fillText(text: string, x: number, y: number, maxWidth?: number): void;
+  measureText(text: string): TextMetrics;
+  drawImage(image: ImageBitmap, dx: number, dy: number, dw: number, dh: number): void;
+  createLinearGradient(x0: number, y0: number, x1: number, y1: number): RecordedGradient;
+  createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): RecordedGradient;
+  private record;
+}
+declare function callNames(context: RecordingCanvasContext): string[];
+declare function callsOf(context: RecordingCanvasContext, name: string): RecordedCall[];
+declare function callArgs(context: RecordingCanvasContext, name: string): unknown[][];
+declare function savedDepth(context: RecordingCanvasContext): number;
+/**
+ * A canvas host backed by a recording context.
+ */
+declare class FakeCanvasHost implements CanvasHost {
+  private readonly context;
+  width: number;
+  height: number;
+  private contextRequests;
+  constructor(context: Canvas2DContext | null);
+  getContext(_contextId: '2d'): CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D | null;
+  get contextRequestCount(): number;
+}
+/**
+ * Shared harness: a real UiGraph + LayoutEngine + Canvas2DRenderer
+ * over a recording context. Deterministic layout comes from the
+ * CharacterCountTextMeasurer, shared by layout and renderer.
+ */
+declare class RenderHarness {
+  readonly graph: UiGraph;
+  readonly measurer: TextMeasurer;
+  readonly engine: LayoutEngine;
+  readonly context: RecordingCanvasContext;
+  readonly host: FakeCanvasHost;
+  readonly surface: CanvasSurface;
+  readonly renderer: Canvas2DRenderer;
+  constructor(logicalWidth?: number, logicalHeight?: number, dpr?: number);
+  createNode(id: string, type: UiNodeType): UiNode;
+  append(parent: UiNode, ...children: UiNode[]): void;
+  layout(node: UiNode, constraints?: Constraints): LayoutResult;
+  render(node: UiNode): void;
+  record(node: UiNode): LayoutRecord;
+  box(node: UiNode): LayoutBox;
+}
+//#endregion
+export { FakeCanvasHost, FakeEventTarget, FakePlatformSurface, InputTestHarness, type RecordedCall, RecordingCanvasContext, RenderHarness, callArgs, callNames, callsOf, savedDepth };
+//# sourceMappingURL=testing.d.ts.map