@caperjs/core 0.1.1 → 0.2.0

package/lib/types/caper-app.d.ts

@@ -0,0 +1 @@
+/* caper.config.ts not found, skipping augmentation. */

package/lib/utils/bind.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bind.test.d.ts.map

package/lib/utils/bind.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind.test.d.ts","sourceRoot":"","sources":["../../src/utils/bind.test.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caperjs/core",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "title": "Caper",
   "description": "An opinionated HTML game framework built on PixiJS v8",
   "bin": {
@@ -12,35 +12,31 @@
     "lib",
     "src",
     "cli",
-    "config/vite.mjs",
-    "config/assetpack.mjs",
+    "build",
     "config/tsconfig.base.json",
-    "config/.prettierrc.json",
     "extras/llms.txt",
     "extras/css/accessibility.css",
     "extras/css/loader.css",
     "extras/css/fullscreen.css",
     "templates",
     "types",
-    "client.d.ts"
+    "client.d.ts",
+    "!build/**/*.test.mjs"
   ],
   "exports": {
     ".": {
       "types": "./lib/index.d.ts",
       "default": "./lib/caper.mjs"
     },
+    "./vite": {
+      "default": "./build/index.mjs"
+    },
     "./client": {
       "types": "./client.d.ts"
     },
     "./extras/llms.txt": {
       "default": "./extras/llms.txt"
     },
-    "./config/assetpack": {
-      "default": "./config/assetpack.mjs"
-    },
-    "./config/vite": {
-      "default": "./config/vite.mjs"
-    },
     "./tsconfig": {
       "default": "./config/tsconfig.base.json"
     },
@@ -55,6 +51,25 @@
     }
   },
   "sideEffects": false,
+  "scripts": {
+    "dev": "cd ./examples && pnpm dev",
+    "start": "cd ./examples && pnpm start",
+    "build": "pnpm generate-version && vite build",
+    "prepack": "pnpm build",
+    "visualize:examples": "cd ./examples && npx vite-bundle-visualizer",
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "docs": "pnpm build:docs",
+    "build:docs": "cd ./docs && pnpm build",
+    "dev:docs": "cd ./docs && pnpm dev",
+    "typedoc": "ppnpm generate-version && typedoc --out typedoc src",
+    "generate-version": "node ./scripts/generate-version.mjs",
+    "clean": "node ./scripts/clean.mjs",
+    "update-package-deps": "node ./scripts/update-package-deps.mjs",
+    "build-packages": "node ./scripts/build-packages.mjs"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/anthonysapp/caper.git"
@@ -73,13 +88,17 @@
     "standard-version": "^9.5.0",
     "turbo": "^2.0.3",
     "typedoc": "^0.28.1",
+    "vite": "^8.0.7",
     "vite-plugin-dts": "^4.5.3",
-    "vitest": "^3"
+    "vitest": "^3",
+    "workbox-window": "^7.4.0"
   },
   "peerDependencies": {
     "@pixi/sound": "^6.0.1",
     "gsap": "^3.15.0",
-    "pixi.js": "8.19.0"
+    "pixi.js": "8.19.0",
+    "vite": "^8.0.7",
+    "workbox-window": "^7.4.0"
   },
   "dependencies": {
     "@assetpack/core": "^1.7.0",
@@ -103,7 +122,6 @@
     "stats.js": "^0.17.0",
     "typed-signals": "^2.5.0",
     "typescript": "^5.9.0",
-    "vite": "^8.0.7",
     "vite-bundle-visualizer": "^1.2.1",
     "vite-plugin-pwa": "^1.2.0",
     "vite-plugin-singlefile": "^2.3.2",
@@ -116,23 +134,5 @@
     "workbox-strategies": "^7.4.0",
     "workbox-window": "^7.4.0",
     "zod": "^4.3.6"
-  },
-  "scripts": {
-    "dev": "cd ./examples && pnpm dev",
-    "start": "cd ./examples && pnpm start",
-    "build": "pnpm generate-version && vite build",
-    "visualize:examples": "cd ./examples && npx vite-bundle-visualizer",
-    "lint": "eslint \"src/**/*.ts\"",
-    "lint:fix": "eslint \"src/**/*.ts\" --fix",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "docs": "pnpm build:docs",
-    "build:docs": "cd ./docs && pnpm build",
-    "dev:docs": "cd ./docs && pnpm dev",
-    "typedoc": "ppnpm generate-version && typedoc --out typedoc src",
-    "generate-version": "node ./scripts/generate-version.mjs",
-    "clean": "node ./scripts/clean.mjs",
-    "update-package-deps": "node ./scripts/update-package-deps.mjs",
-    "build-packages": "node ./scripts/build-packages.mjs"
   }
-}
+}

package/src/core/Application.ts

@@ -140,7 +140,7 @@ export class Application extends PIXIPApplication implements IApplication {
   public static instance: IApplication;
 
   // method binding root
-  private readonly __caper_method_binding_root = true;
+  private static readonly __caper_method_binding_root = true;
 
   // debug overlay (lazy, see getter)
   private _debugContainer: PIXIContainer;

package/src/core/interfaces/IApplicationOptions.ts

@@ -2,6 +2,7 @@ import type {
   ActionMap,
   BreakpointsConfig,
   FocusManagerPluginOptions,
+  GesturePluginOptions,
   i18nOptions,
   InputManagerOptions,
   LoadSceneMethod,
@@ -66,6 +67,7 @@ export interface IApplicationOptions extends ApplicationOptions {
   scenesLocation: string;
   actions: Partial<ActionMap>;
   input: Partial<InputManagerOptions>;
+  gesture?: Partial<GesturePluginOptions>;
   focus: Partial<FocusManagerPluginOptions>;
   splash: Partial<SplashOptions>;
   defaultScene: AppTypeOverrides['Scenes'];

package/src/core/interfaces/ICoreSignals.ts

@@ -3,7 +3,11 @@ import type {
   ChannelMutedDetail,
   ChannelVolumeDetail,
   FocusChangeDetail,
+  GestureChangeDetail,
+  GestureEndDetail,
+  GestureStartDetail,
   IAudioInstance,
+  InputController,
   KeyboardEventDetail,
   PopupSignalDetail,
   SoundDetail,
@@ -43,6 +47,11 @@ export interface ICoreSignals {
   onGamepadDisconnected: Signal<(gamepad: Gamepad) => void>;
   onControllerActivated: Signal<(controller: string) => void>;
   onControllerDeactivated: Signal<(controller: string) => void>;
+  onControllerChanged: Signal<(controller: InputController) => void>;
+  // GesturePlugin;
+  onGestureStart: Signal<(detail: GestureStartDetail) => void>;
+  onGestureChange: Signal<(detail: GestureChangeDetail) => void>;
+  onGestureEnd: Signal<(detail: GestureEndDetail) => void>;
   // KeyboardManager;
   onGlobalKeyDown: Signal<(detail: KeyboardEventDetail) => void>;
   onGlobalKeyUp: Signal<(detail: KeyboardEventDetail) => void>;

package/src/display/Container.ts

@@ -60,7 +60,7 @@ export interface IContainer {
  * It represents a container for PIXI.js display objects.
  */
 export class Container extends Animated(WithSignals(Factory())) implements IContainer {
-  private readonly __caper_method_binding_root = true;
+  private static readonly __caper_method_binding_root = true;
 
   public onDestroy: Signal<() => void> = new Signal();
 

package/src/display/ParticleContainer.ts

@@ -35,7 +35,7 @@ export interface IParticleContainer {
  */
 export class ParticleContainer extends PIXIParticleContainer implements IParticleContainer {
   onDestroy: Signal<() => void> = new Signal();
-  __caper_method_binding_root = true;
+  static __caper_method_binding_root = true;
   private __config: ParticleContainerConfig;
 
   /**

package/src/plugins/Plugin.ts

@@ -114,7 +114,7 @@ export interface PluginListItem {
 }
 
 export class Plugin<O = any> implements IPlugin<O> {
-  private readonly __caper_method_binding_root = true;
+  private static readonly __caper_method_binding_root = true;
   // A collection of signal connections.
   protected _signalConnections: SignalConnections = new SignalConnections();
 

package/src/plugins/defaults.ts

@@ -13,6 +13,7 @@ import { ActionsPlugin } from './actions';
 import { AudioManagerPlugin } from './audio';
 import { BreakpointPlugin } from './breakpoints';
 import { FocusManagerPlugin } from './focus';
+import { GesturePlugin } from './gesture';
 import { i18nPlugin } from './i18nPlugin';
 import { InputPlugin } from './input';
 
@@ -62,6 +63,11 @@ export const defaultPlugins: ImportList<IPlugin> = [
     module: InputPlugin,
     namedExport: 'InputPlugin',
   },
+  {
+    id: 'gesture',
+    module: GesturePlugin,
+    namedExport: 'GesturePlugin',
+  },
   {
     id: 'keyboard',
     module: KeyboardPlugin,

package/src/plugins/gesture/GesturePlugin.ts

@@ -0,0 +1,215 @@
+import type { IApplication } from '../../core';
+import { Signal } from '../../signals';
+import type { IPlugin } from '../Plugin';
+import { Plugin } from '../Plugin';
+import type { GestureFrame, PointerSample } from './gestureMath';
+import { computeFrame, frameDelta } from './gestureMath';
+import type { GestureChangeDetail, GestureEndDetail, GesturePluginOptions, GestureStartDetail } from './types';
+import { defaultGestureOptions } from './types';
+
+type GestureState = 'idle' | 'pending' | 'active';
+
+/** Below this, `totalScale` is reported as `1` rather than dividing by a near-zero spread. */
+const SPREAD_EPSILON = 0.01;
+
+export interface IGesturePlugin extends IPlugin<GesturePluginOptions> {
+  readonly onGestureStart: Signal<(detail: GestureStartDetail) => void>;
+  readonly onGestureChange: Signal<(detail: GestureChangeDetail) => void>;
+  readonly onGestureEnd: Signal<(detail: GestureEndDetail) => void>;
+  readonly isActive: boolean;
+  readonly pointerCount: number;
+}
+
+/**
+ * Multi-touch gesture recognizer: pinch zoom and two-finger pan combined
+ * into one gesture, the way map apps work. There is no mode and no toggle —
+ * a pinch that also drifts pans, a two-finger drag that also spreads zooms.
+ *
+ * One finger is never a camera gesture; games are expected to use it for
+ * aim/build/UI as normal. Rotation is deliberately not recognised.
+ *
+ * Listens on raw DOM pointer events — `pointerdown` on `app.canvas`,
+ * `pointermove`/`pointerup`/`pointercancel` on `window` — rather than PixiJS
+ * federated events, so it sees every pointer regardless of scene-graph hit
+ * testing, and lift-outside is always seen.
+ *
+ * @example
+ * ```ts
+ * app.signal.onGestureChange.connect(({ dx, dy, scale, centerX, centerY }) => {
+ *   camera.pinchZoomAt(scale, centerX, centerY);
+ *   camera.panBy(dx, dy);
+ * });
+ * ```
+ */
+export class GesturePlugin extends Plugin<GesturePluginOptions> implements IGesturePlugin {
+  public readonly id = 'gesture';
+
+  public readonly onGestureStart = new Signal<(detail: GestureStartDetail) => void>();
+  public readonly onGestureChange = new Signal<(detail: GestureChangeDetail) => void>();
+  public readonly onGestureEnd = new Signal<(detail: GestureEndDetail) => void>();
+
+  private _pointers = new Map<number, PointerSample>();
+  private _state: GestureState = 'idle';
+  private _startFrame: GestureFrame | null = null;
+  private _lastFrame: GestureFrame | null = null;
+  private _canvas: HTMLCanvasElement | null = null;
+  private _previousTouchAction = '';
+
+  get isActive(): boolean {
+    return this._state === 'active';
+  }
+
+  get pointerCount(): number {
+    return this._pointers.size;
+  }
+
+  async initialize(options: Partial<GesturePluginOptions> = {}, app: IApplication): Promise<void> {
+    this._options = { ...defaultGestureOptions, ...options };
+    if (!this._options.enabled) return;
+
+    const canvas = app.canvas as HTMLCanvasElement;
+    this._canvas = canvas;
+    if (this._options.preventDefault) {
+      this._previousTouchAction = canvas.style.touchAction;
+      canvas.style.touchAction = 'none';
+    }
+
+    canvas.addEventListener('pointerdown', this._onPointerDown);
+    window.addEventListener('pointermove', this._onPointerMove);
+    window.addEventListener('pointerup', this._onPointerUp);
+    window.addEventListener('pointercancel', this._onPointerCancel);
+  }
+
+  public destroy(): void {
+    if (this._canvas) {
+      this._canvas.removeEventListener('pointerdown', this._onPointerDown);
+      if (this._options.preventDefault) {
+        this._canvas.style.touchAction = this._previousTouchAction;
+      }
+      this._canvas = null;
+    }
+    window.removeEventListener('pointermove', this._onPointerMove);
+    window.removeEventListener('pointerup', this._onPointerUp);
+    window.removeEventListener('pointercancel', this._onPointerCancel);
+
+    this._pointers.clear();
+    this._state = 'idle';
+    this._startFrame = null;
+    this._lastFrame = null;
+
+    this.onGestureStart.disconnectAll();
+    this.onGestureChange.disconnectAll();
+    this.onGestureEnd.disconnectAll();
+    super.destroy();
+  }
+
+  protected getCoreSignals(): string[] {
+    return ['onGestureStart', 'onGestureChange', 'onGestureEnd'];
+  }
+
+  private _onPointerDown = (e: PointerEvent): void => {
+    if (!this._options.pointerTypes!.includes(e.pointerType)) return;
+
+    const before = this._state;
+    const hadTwoOrMore = this._pointers.size >= 2;
+    this._pointers.set(e.pointerId, { id: e.pointerId, x: e.clientX, y: e.clientY });
+
+    if (this._state === 'idle' && this._pointers.size === 2) {
+      const frame = computeFrame([...this._pointers.values()]);
+      this._startFrame = frame;
+      this._lastFrame = frame;
+      this._state = 'pending';
+    } else if (this._state !== 'idle' && hadTwoOrMore) {
+      // a 3rd+ finger joined mid-gesture — rebase without emitting so it doesn't jump the frame
+      this._lastFrame = computeFrame([...this._pointers.values()]);
+    }
+
+    this._maybePreventDefault(e, before, this._state);
+  };
+
+  private _onPointerMove = (e: PointerEvent): void => {
+    if (!this._pointers.has(e.pointerId)) return;
+    this._pointers.set(e.pointerId, { id: e.pointerId, x: e.clientX, y: e.clientY });
+
+    const before = this._state;
+
+    if (this._pointers.size >= 2) {
+      const next = computeFrame([...this._pointers.values()]);
+
+      if (this._state === 'pending') {
+        const delta = frameDelta(this._lastFrame!, next);
+        const spreadDelta = Math.abs(next.spread - this._lastFrame!.spread);
+        const centroidDelta = Math.hypot(delta.dx, delta.dy);
+        if (spreadDelta >= this._options.pinchThreshold! || centroidDelta >= this._options.panThreshold!) {
+          this._lastFrame = next; // rebase — discard the threshold slack, no jump
+          this._state = 'active';
+          this.onGestureStart.emit({
+            centerX: next.centerX,
+            centerY: next.centerY,
+            pointerCount: this._pointers.size,
+          });
+        }
+      } else if (this._state === 'active') {
+        const delta = frameDelta(this._lastFrame!, next);
+        const totalScale = this._computeTotalScale(next);
+        this._lastFrame = next;
+        this.onGestureChange.emit({
+          centerX: next.centerX,
+          centerY: next.centerY,
+          dx: delta.dx,
+          dy: delta.dy,
+          scale: delta.scale,
+          totalScale,
+          pointerCount: this._pointers.size,
+        });
+      }
+    }
+
+    this._maybePreventDefault(e, before, this._state);
+  };
+
+  private _onPointerUp = (e: PointerEvent): void => {
+    this._endPointer(e);
+  };
+
+  private _onPointerCancel = (e: PointerEvent): void => {
+    this._endPointer(e);
+  };
+
+  private _endPointer(e: PointerEvent): void {
+    if (!this._pointers.has(e.pointerId)) return;
+
+    const before = this._state;
+    this._pointers.delete(e.pointerId);
+
+    if (this._pointers.size < 2) {
+      if (this._state === 'active' && this._lastFrame) {
+        this.onGestureEnd.emit({
+          centerX: this._lastFrame.centerX,
+          centerY: this._lastFrame.centerY,
+          totalScale: this._computeTotalScale(this._lastFrame),
+        });
+      }
+      this._state = 'idle';
+      this._startFrame = null;
+      this._lastFrame = null;
+    } else if (this._state !== 'idle') {
+      // a finger lifted but 2+ remain — rebase without emitting so it doesn't jump the frame
+      this._lastFrame = computeFrame([...this._pointers.values()]);
+    }
+
+    this._maybePreventDefault(e, before, this._state);
+  }
+
+  private _computeTotalScale(frame: GestureFrame): number {
+    if (!this._startFrame || this._startFrame.spread < SPREAD_EPSILON) return 1;
+    return frame.spread / this._startFrame.spread;
+  }
+
+  /** Preventable only for tracked pointer events while a gesture is pending or active. */
+  private _maybePreventDefault(e: PointerEvent, before: GestureState, after: GestureState): void {
+    if (this._options.preventDefault && (before !== 'idle' || after !== 'idle')) {
+      e.preventDefault();
+    }
+  }
+}

package/src/plugins/gesture/gestureMath.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from 'vitest';
+
+import { computeFrame, frameDelta } from './gestureMath';
+import type { PointerSample } from './gestureMath';
+
+describe('computeFrame', () => {
+  it('returns a zero frame for no pointers', () => {
+    expect(computeFrame([])).toEqual({ centerX: 0, centerY: 0, spread: 0 });
+  });
+
+  it('centers on the single pointer with zero spread', () => {
+    const p: PointerSample[] = [{ id: 1, x: 10, y: 20 }];
+    expect(computeFrame(p)).toEqual({ centerX: 10, centerY: 20, spread: 0 });
+  });
+
+  it('computes the centroid of two pointers', () => {
+    const p: PointerSample[] = [
+      { id: 1, x: 0, y: 0 },
+      { id: 2, x: 100, y: 0 },
+    ];
+    const frame = computeFrame(p);
+    expect(frame.centerX).toBe(50);
+    expect(frame.centerY).toBe(0);
+  });
+
+  it('spread is half the pair distance for two pointers', () => {
+    const p: PointerSample[] = [
+      { id: 1, x: 0, y: 0 },
+      { id: 2, x: 100, y: 0 },
+    ];
+    expect(computeFrame(p).spread).toBe(50);
+  });
+
+  it('generalises spread to 3+ pointers as the mean radial distance', () => {
+    const p: PointerSample[] = [
+      { id: 1, x: 0, y: 0 },
+      { id: 2, x: 100, y: 0 },
+      { id: 3, x: 50, y: 100 },
+    ];
+    // centroid = (50, 33.33...)
+    const frame = computeFrame(p);
+    expect(frame.centerX).toBeCloseTo(50);
+    expect(frame.centerY).toBeCloseTo(33.333, 2);
+    expect(frame.spread).toBeGreaterThan(0);
+  });
+});
+
+describe('frameDelta', () => {
+  it('computes centroid translation', () => {
+    const prev = { centerX: 0, centerY: 0, spread: 50 };
+    const next = { centerX: 10, centerY: -5, spread: 50 };
+    const delta = frameDelta(prev, next);
+    expect(delta.dx).toBe(10);
+    expect(delta.dy).toBe(-5);
+    expect(delta.scale).toBe(1);
+  });
+
+  it('computes the spread ratio as scale', () => {
+    const prev = { centerX: 0, centerY: 0, spread: 50 };
+    const next = { centerX: 0, centerY: 0, spread: 100 };
+    expect(frameDelta(prev, next).scale).toBe(2);
+  });
+
+  it('guards a near-zero previous spread by returning scale: 1', () => {
+    const prev = { centerX: 0, centerY: 0, spread: 0 };
+    const next = { centerX: 0, centerY: 0, spread: 100 };
+    expect(frameDelta(prev, next).scale).toBe(1);
+  });
+
+  it('guards a previous spread just under the epsilon', () => {
+    const prev = { centerX: 0, centerY: 0, spread: 0.005 };
+    const next = { centerX: 0, centerY: 0, spread: 50 };
+    expect(frameDelta(prev, next).scale).toBe(1);
+  });
+});

package/src/plugins/gesture/gestureMath.ts

@@ -0,0 +1,59 @@
+/**
+ * Pure multi-touch gesture math — centroid, spread and frame-to-frame deltas.
+ * No Pixi/caper imports so it stays trivially unit-testable.
+ */
+
+export interface PointerSample {
+  id: number;
+  x: number;
+  y: number;
+}
+
+export interface GestureFrame {
+  centerX: number;
+  centerY: number;
+  /** Mean distance from the centroid across all tracked pointers. */
+  spread: number;
+}
+
+/** Below this, `frameDelta` treats the previous spread as unusable and returns `scale: 1`. */
+const SPREAD_EPSILON = 0.01;
+
+/**
+ * Centroid and mean radial spread of a set of pointers. For two pointers,
+ * `spread` is half the pair distance; since only the *ratio* between two
+ * frames is ever used, this generalises to 3+ fingers for free.
+ */
+export function computeFrame(pointers: PointerSample[]): GestureFrame {
+  const count = pointers.length;
+  if (count === 0) return { centerX: 0, centerY: 0, spread: 0 };
+
+  let sumX = 0;
+  let sumY = 0;
+  for (const p of pointers) {
+    sumX += p.x;
+    sumY += p.y;
+  }
+  const centerX = sumX / count;
+  const centerY = sumY / count;
+
+  let sumDist = 0;
+  for (const p of pointers) {
+    sumDist += Math.hypot(p.x - centerX, p.y - centerY);
+  }
+  const spread = sumDist / count;
+
+  return { centerX, centerY, spread };
+}
+
+/**
+ * Centroid translation and spread ratio between two frames. `scale` is
+ * guarded to `1` when `prev.spread` is too small to divide by, so a
+ * near-zero starting spread can't produce a huge or infinite jump.
+ */
+export function frameDelta(prev: GestureFrame, next: GestureFrame): { dx: number; dy: number; scale: number } {
+  const dx = next.centerX - prev.centerX;
+  const dy = next.centerY - prev.centerY;
+  const scale = prev.spread < SPREAD_EPSILON ? 1 : next.spread / prev.spread;
+  return { dx, dy, scale };
+}

package/src/plugins/gesture/index.ts

@@ -0,0 +1,2 @@
+export * from './GesturePlugin';
+export * from './types';

package/src/plugins/gesture/types.ts

@@ -0,0 +1,54 @@
+/** The shape of the `gesture:` key in `caper.config.ts`, and the plugin's resolved options. */
+export interface GesturePluginOptions {
+  /** @default true */
+  enabled?: boolean;
+  /** @default ['touch'] */
+  pointerTypes?: string[];
+  /** Pixels of spread change to cross before a pending gesture goes active. @default 8 */
+  pinchThreshold?: number;
+  /** Pixels of centroid movement to cross before a pending gesture goes active. @default 8 */
+  panThreshold?: number;
+  /** Also sets `canvas.style.touchAction = 'none'` while enabled. @default true */
+  preventDefault?: boolean;
+}
+
+export const defaultGestureOptions: Required<GesturePluginOptions> = {
+  enabled: true,
+  pointerTypes: ['touch'],
+  pinchThreshold: 8,
+  panThreshold: 8,
+  preventDefault: true,
+};
+
+export interface GestureStartDetail {
+  /** Client CSS pixels. */
+  centerX: number;
+  /** Client CSS pixels. */
+  centerY: number;
+  pointerCount: number;
+}
+
+export interface GestureChangeDetail {
+  /** Client CSS pixels. */
+  centerX: number;
+  /** Client CSS pixels. */
+  centerY: number;
+  /** Client-pixel delta since the previous frame. */
+  dx: number;
+  /** Client-pixel delta since the previous frame. */
+  dy: number;
+  /** Spread ratio since the previous frame. */
+  scale: number;
+  /** Spread ratio since the gesture started. */
+  totalScale: number;
+  pointerCount: number;
+}
+
+export interface GestureEndDetail {
+  /** Client CSS pixels. */
+  centerX: number;
+  /** Client CSS pixels. */
+  centerY: number;
+  /** Spread ratio since the gesture started. */
+  totalScale: number;
+}

package/src/plugins/index.ts

@@ -5,6 +5,7 @@ export * from './DataAdapter';
 export * from './audio';
 export * from './focus';
 export * from './FullScreenPlugin';
+export * from './gesture';
 export * from './i18nPlugin';
 export * from './input';
 export * from './KeyboardPlugin';