@expofp/renderer 3.31.3 → 3.31.5

package/dist/controls/CameraControls.d.ts

@@ -2,41 +2,6 @@ import { type NonFunctionKeys } from '@react-three/fiber/dist/declarations/src/c
 import { MapControls as CameraControlsImpl, type SmoothTimeOption } from 'camera-controls';
 import { type Ref } from 'react';
 import { type OrthographicCamera, type PerspectiveCamera } from 'three';
-/**
- * The scene's camera controls, once {@link Controls} has mounted them.
- *
- * For **reading** them, and for handing them to something else that does the writing — a gesture
- * class, a measurement, a helper taking them as an argument. What the React Compiler rejects is
- * assigning to a *field* of a hook's return value, which is a build error rather than a bug; a
- * method call on it, or passing it along, is fine. A component with a write it cannot route through
- * a function uses {@link useControlsEffect}, which hands the controls over as an argument.
- * @returns The controls, or `undefined` until they mount.
- */
-export declare function useCameraControls(): CameraControlsImpl | undefined;
-/**
- * How far the plan is turned from north: clockwise, in radians, in `[0, 2π)`.
- *
- * The camera holds an azimuth, which runs the other way and over any range the user has spun it
- * through. Every reader of "which way is the plan facing" wants this instead, so the negation and
- * the wrap live here once rather than at each of them — the same getter the imperative renderer put
- * on its controller.
- * @param controls - The scene's controls.
- * @returns The bearing in radians.
- */
-export declare function bearing(controls: CameraControlsImpl): number;
-/**
- * Runs an effect against the scene's camera controls, for as long as the component is mounted.
- *
- * The controls arrive as an argument rather than from a hook, which is what lets the effect write to
- * them; and the "wait for them to mount" subscription lives here rather than in every caller, so a
- * component that claims a mouse action is three lines and says only what it claims. Together with
- * {@link useCameraControls} that is the whole surface — read them, or write to them in an effect.
- *
- * Re-runs when the controls change and whenever `effect` does, which — the React Compiler caching
- * the closure against what it captures — is whenever the component's own inputs move.
- * @param effect - What to do with the controls; may return a cleanup, as any effect may.
- */
-export declare function useControlsEffect(effect: (controls: CameraControlsImpl) => (() => void) | void): void;
 /** Props for {@link CameraControls}: camera-controls element props plus lifecycle callbacks. */
 export type CameraControlsProps = Partial<Omit<Pick<CameraControlsImpl, NonFunctionKeys<CameraControlsImpl>>, 'smoothTime' | 'controlSmoothTime'>> & {
     /** Ref to hold the camera-controls instance */
@@ -98,5 +63,46 @@ export type CameraControlsProps = Partial<Omit<Pick<CameraControlsImpl, NonFunct
  * @returns The controls instance as an R3F `<primitive>`.
  */
 export declare function CameraControls(props: CameraControlsProps): import("react").JSX.Element;
-export { CameraControlsImpl };
+/**
+ * The controls class, under the name the rest of this package calls it by.
+ *
+ * A **type** and not a value: the only code that needs the class itself is right here, and a type
+ * survives an import cycle where a class would not — so a handler this module's own parent loads
+ * can name it freely. Everything else the library offers arrives through
+ * {@link CameraControlsAction}.
+ */
+export { type CameraControlsImpl };
+/**
+ * The mouse and touch actions a handler claims, from the library's own enum.
+ *
+ * Beside the component rather than in a module of its own: a constant is the one thing Fast Refresh
+ * tolerates next to a component, and this one never changes.
+ */
+export declare const CameraControlsAction: Readonly<{
+    readonly NONE: 0;
+    readonly ROTATE_AZIMUTH: 1;
+    readonly ROTATE_POLAR: 2;
+    readonly ROTATE: number;
+    readonly TRUCK: 4;
+    readonly SCREEN_PAN: 8;
+    readonly OFFSET: 16;
+    readonly DOLLY: 32;
+    readonly ZOOM: 64;
+    readonly TOUCH_ROTATE_AZIMUTH: 128;
+    readonly TOUCH_ROTATE_POLAR: 256;
+    readonly TOUCH_ROTATE: number;
+    readonly TOUCH_TRUCK: 512;
+    readonly TOUCH_SCREEN_PAN: 1024;
+    readonly TOUCH_OFFSET: 2048;
+    readonly TOUCH_DOLLY: 4096;
+    readonly TOUCH_ZOOM: 8192;
+    readonly TOUCH_DOLLY_TRUCK: number;
+    readonly TOUCH_DOLLY_SCREEN_PAN: number;
+    readonly TOUCH_DOLLY_OFFSET: number;
+    readonly TOUCH_DOLLY_ROTATE: number;
+    readonly TOUCH_ZOOM_TRUCK: number;
+    readonly TOUCH_ZOOM_OFFSET: number;
+    readonly TOUCH_ZOOM_SCREEN_PAN: number;
+    readonly TOUCH_ZOOM_ROTATE: number;
+}>;
 //# sourceMappingURL=CameraControls.d.ts.map

package/dist/controls/CameraControls.js

@@ -5,57 +5,6 @@ import { MapControls as CameraControlsImpl } from 'camera-controls';
 import { useEffect, useState } from 'react';
 import { Box3, MathUtils, Matrix4, Quaternion, Raycaster, Sphere, Spherical, Vector2, Vector3, Vector4, } from 'three';
 import { useDebugPanel } from '../debug/debug-context';
-import { euclideanModulo } from '../utils/math';
-/**
- * The scene's camera controls, once {@link Controls} has mounted them.
- *
- * For **reading** them, and for handing them to something else that does the writing — a gesture
- * class, a measurement, a helper taking them as an argument. What the React Compiler rejects is
- * assigning to a *field* of a hook's return value, which is a build error rather than a bug; a
- * method call on it, or passing it along, is fine. A component with a write it cannot route through
- * a function uses {@link useControlsEffect}, which hands the controls over as an argument.
- * @returns The controls, or `undefined` until they mount.
- */
-export function useCameraControls() {
-    return useThree((state) => state.controls) ?? undefined;
-}
-/**
- * How far the plan is turned from north: clockwise, in radians, in `[0, 2π)`.
- *
- * The camera holds an azimuth, which runs the other way and over any range the user has spun it
- * through. Every reader of "which way is the plan facing" wants this instead, so the negation and
- * the wrap live here once rather than at each of them — the same getter the imperative renderer put
- * on its controller.
- * @param controls - The scene's controls.
- * @returns The bearing in radians.
- */
-export function bearing(controls) {
-    return euclideanModulo(-controls.azimuthAngle, 2 * Math.PI);
-}
-/**
- * Runs an effect against the scene's camera controls, for as long as the component is mounted.
- *
- * The controls arrive as an argument rather than from a hook, which is what lets the effect write to
- * them; and the "wait for them to mount" subscription lives here rather than in every caller, so a
- * component that claims a mouse action is three lines and says only what it claims. Together with
- * {@link useCameraControls} that is the whole surface — read them, or write to them in an effect.
- *
- * Re-runs when the controls change and whenever `effect` does, which — the React Compiler caching
- * the closure against what it captures — is whenever the component's own inputs move.
- * @param effect - What to do with the controls; may return a cleanup, as any effect may.
- */
-export function useControlsEffect(effect) {
-    const get = useThree((state) => state.get);
-    // A subscription, so this re-runs once the controls have mounted. Deliberately not the value the
-    // effect uses: that is read fresh from the store below.
-    const mounted = useThree((state) => state.controls);
-    useEffect(() => {
-        const controls = get().controls;
-        if (!controls)
-            return undefined;
-        return effect(controls) ?? undefined;
-    }, [effect, get, mounted]);
-}
 // Install the subset of THREE that camera-controls uses and register it with
 // R3F, once at module load — before any controls are constructed during render,
 // so the `new CameraControlsImpl(...)` below never runs uninstalled. Importing
@@ -229,11 +178,17 @@ export function CameraControls(props) {
  */
 function createControls(camera) {
     const controls = new CameraControlsImpl(camera);
-    const { NONE } = CameraControlsImpl.ACTION;
+    const { NONE } = CameraControlsAction;
     controls.mouseButtons = { left: NONE, middle: NONE, right: NONE, wheel: NONE };
     controls.touches = { one: NONE, two: NONE, three: NONE };
     return controls;
 }
-export { CameraControlsImpl };
+/**
+ * The mouse and touch actions a handler claims, from the library's own enum.
+ *
+ * Beside the component rather than in a module of its own: a constant is the one thing Fast Refresh
+ * tolerates next to a component, and this one never changes.
+ */
+export const CameraControlsAction = CameraControlsImpl.ACTION;
 const _target = new Vector3();
 const _spherical = new Spherical();

package/dist/controls/Controls.d.ts

@@ -0,0 +1,49 @@
+import { type ReactNode } from 'react';
+import { type PanConfig } from './handlers/Pan';
+import { type RollConfig } from './handlers/Roll';
+/**
+ * What the user may do with the plan.
+ *
+ * Each handler takes `false` to switch it off, `true` or nothing for its defaults, and — where it
+ * has any — an options object, whose own defaults the handler applies.
+ *
+ * **Pan and zoom default on; roll and pitch default to whether this is a development build**, so
+ * the renderer's own Storybook and dev server carry them and a production plan does not until a
+ * caller asks. An explicit value always wins, so a host driving roll from a user-facing setting
+ * never has to think about the dev default.
+ *
+ * The pitch and zoom **limits** are not here: they hold whether or not the matching gesture does,
+ * which makes them the camera's — see `CameraProps`.
+ */
+export interface ControlsConfig {
+    /** Left-drag and one-finger drag to pan the plan. Defaults on. */
+    pan?: boolean | PanConfig;
+    /** Wheel and two-finger pinch to zoom, toward the cursor. Defaults on. */
+    zoom?: boolean;
+    /** Right-drag and two-finger twist to turn the plan. Defaults to a development build. */
+    roll?: boolean | RollConfig;
+    /** Right-drag and two-finger vertical drag to tilt the plan. Defaults to a development build. */
+    pitch?: boolean;
+}
+/** Props for {@link Controls}. */
+export interface ControlsProps {
+    /** What the user may do with the plan; see {@link ControlsConfig}. */
+    config?: ControlsConfig;
+}
+/**
+ * The scene's camera controls, and the gesture handlers that drive them.
+ *
+ * Registered as R3F's default controls (`makeDefault`) so everything else reaches them through
+ * `state.controls`. Every mouse and touch action starts switched off, and each handler mounted
+ * below claims the ones it needs — so what a user can do is exactly the set of handlers standing
+ * here, and turning one off is unmounting it.
+ *
+ * **How far the camera may go is not decided here.** The zoom and pitch bounds constrain a
+ * programmatic move as much as a dragged one, so they belong to the camera; `Camera` writes them,
+ * beside the clipping planes derived from the same numbers. This component is only about what the
+ * user may do.
+ * @param props - What the user may do with the plan.
+ * @returns The controls and their handlers.
+ */
+export declare function Controls(props: ControlsProps): ReactNode;
+//# sourceMappingURL=Controls.d.ts.map

package/dist/controls/Controls.js

@@ -0,0 +1,54 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef } from 'react';
+import { CameraControls } from './CameraControls';
+import { Pan } from './handlers/Pan';
+import { Pitch } from './handlers/Pitch';
+import { Roll } from './handlers/Roll';
+import { Zoom } from './handlers/Zoom';
+/**
+ * The scene's camera controls, and the gesture handlers that drive them.
+ *
+ * Registered as R3F's default controls (`makeDefault`) so everything else reaches them through
+ * `state.controls`. Every mouse and touch action starts switched off, and each handler mounted
+ * below claims the ones it needs — so what a user can do is exactly the set of handlers standing
+ * here, and turning one off is unmounting it.
+ *
+ * **How far the camera may go is not decided here.** The zoom and pitch bounds constrain a
+ * programmatic move as much as a dragged one, so they belong to the camera; `Camera` writes them,
+ * beside the clipping planes derived from the same numbers. This component is only about what the
+ * user may do.
+ * @param props - What the user may do with the plan.
+ * @returns The controls and their handlers.
+ */
+export function Controls(props) {
+    const controlsRef = useRef(null);
+    const config = props.config ?? {};
+    const pan = config.pan ?? true;
+    const zoom = config.zoom ?? true;
+    const roll = config.roll ?? DEV;
+    const pitch = config.pitch ?? DEV;
+    useEffect(() => {
+        // Straight down by default. Set through `rotateTo` rather than by assigning `polarAngle`, which
+        // skips `Spherical.makeSafe` — and a polar angle of exactly zero causes trouble with roll on
+        // mobile. Nothing sets a target: the scene's fit puts the plan's centre on the world origin,
+        // which is where the controls already orbit.
+        void controlsRef.current.rotateTo(0, 0);
+    }, []);
+    return (_jsxs(_Fragment, { children: [_jsx(CameraControls, { ref: controlsRef, makeDefault: true, events: true, dollyToCursor: true, controlSmoothTime: { rotate: 0, truck: 0 } }), pan !== false && _jsx(Pan, { ...optionsOf(pan) }), zoom !== false && _jsx(Zoom, {}), roll !== false && _jsx(Roll, { ...optionsOf(roll) }), pitch !== false && _jsx(Pitch, {})] }));
+}
+/**
+ * The options a handler was configured with, if it was given any rather than a bare flag.
+ * @param config - What the caller wrote for it.
+ * @returns The options, or an empty set for a handler switched on without any.
+ */
+function optionsOf(config) {
+    return typeof config === 'object' ? config : {};
+}
+/**
+ * Whether this is a development build, which is what roll and pitch default to.
+ *
+ * Typed inline rather than through `vite/client`, matching `stories/support/screenshot.ts`: the
+ * library build compiles without those types, and the optional chain keeps a consumer whose bundler
+ * defines no `import.meta.env` from throwing on it.
+ */
+const DEV = import.meta.env?.DEV === true;

package/dist/controls/camera-api.d.ts

@@ -148,26 +148,6 @@ interface CameraContext {
     /** Device pixels per css pixel. */
     dpr: number;
 }
-/**
- * The scene's camera commands.
- *
- * A hook rather than a ref handed out from above, and that is the point: it only resolves inside a
- * component mounted under `<Renderer>`, and R3F mounts those only once the canvas and its context
- * exist — so "the camera cannot be driven before the scene is ready" is enforced by where the code
- * can live rather than by a null check every caller has to remember. A host that needs to drive the
- * camera from outside React publishes this object from an effect, which is exactly when it is safe.
- *
- * Before the controls mount every command is a no-op that resolves at once, which is the same frame
- * or two the hook's own consumers spend waiting for their effects.
- *
- * **The returned object is new on every render, deliberately.** This module is not memoized by hand
- * — the React Compiler is scoped to `.tsx` under `src/` (see `vitest.config.mts`), and reaching for
- * `useMemo` here would put a cache in the library that every consumer then has to trust. A consumer
- * that cannot re-subscribe cheaply should hold this in a ref rather than in a dependency list; that
- * way the decision, and its cost, sit with the code that knows how often it renders.
- * @returns The commands.
- */
-export declare function useCameraAPI(): CameraAPI;
 /**
  * The camera commands, over whatever the scene currently holds.
  *
@@ -202,5 +182,17 @@ export declare class CameraCommands implements CameraAPI {
     /** @inheritdoc */
     reset(axes?: CameraAxes, options?: TransitionOptions): Promise<void>;
 }
+/**
+ * How far the plan is turned from north: clockwise, in radians, in `[0, 2π)`.
+ *
+ * The camera holds an azimuth, which runs the other way and over any range the user has spun it
+ * through. Every reader of "which way is the plan facing" wants this instead, so the negation and
+ * the wrap live here once rather than at each of them — the same getter the imperative renderer put
+ * on its controller. Beside the rest of "where the camera is", which is the only question it
+ * answers.
+ * @param controls - The scene's controls.
+ * @returns The bearing in radians.
+ */
+export declare function bearing(controls: CameraControlsImpl): number;
 export {};
 //# sourceMappingURL=camera-api.d.ts.map

package/dist/controls/camera-api.js

@@ -1,46 +1,7 @@
 import { angleDiff, degToRad } from '@expofp/geometry';
-import { useThree } from '@react-three/fiber';
 import { Vector3 } from 'three';
-import { useCamera } from '../space/camera-handle';
-import { useCanvasSize } from '../space/canvas-size';
-import { useSpace } from '../space/Space';
-import { bearing, useCameraControls } from './CameraControls';
+import { euclideanModulo } from '../utils/math';
 import { fitBox, framingRegion } from './zoom-to';
-/**
- * The scene's camera commands.
- *
- * A hook rather than a ref handed out from above, and that is the point: it only resolves inside a
- * component mounted under `<Renderer>`, and R3F mounts those only once the canvas and its context
- * exist — so "the camera cannot be driven before the scene is ready" is enforced by where the code
- * can live rather than by a null check every caller has to remember. A host that needs to drive the
- * camera from outside React publishes this object from an effect, which is exactly when it is safe.
- *
- * Before the controls mount every command is a no-op that resolves at once, which is the same frame
- * or two the hook's own consumers spend waiting for their effects.
- *
- * **The returned object is new on every render, deliberately.** This module is not memoized by hand
- * — the React Compiler is scoped to `.tsx` under `src/` (see `vitest.config.mts`), and reaching for
- * `useMemo` here would put a cache in the library that every consumer then has to trust. A consumer
- * that cannot re-subscribe cheaply should hold this in a ref rather than in a dependency list; that
- * way the decision, and its cost, sit with the code that knows how often it renders.
- * @returns The commands.
- */
-export function useCameraAPI() {
-    const get = useThree((state) => state.get);
-    const controls = useCameraControls();
-    const camera = useCamera();
-    const space = useSpace();
-    const { width, height, dpr } = useCanvasSize();
-    return new CameraCommands({
-        controls,
-        camera,
-        space,
-        view: () => get().camera.view,
-        width,
-        height,
-        dpr,
-    });
-}
 /**
  * The camera commands, over whatever the scene currently holds.
  *
@@ -161,6 +122,20 @@ export class CameraCommands {
         await Promise.all(moves);
     }
 }
+/**
+ * How far the plan is turned from north: clockwise, in radians, in `[0, 2π)`.
+ *
+ * The camera holds an azimuth, which runs the other way and over any range the user has spun it
+ * through. Every reader of "which way is the plan facing" wants this instead, so the negation and
+ * the wrap live here once rather than at each of them — the same getter the imperative renderer put
+ * on its controller. Beside the rest of "where the camera is", which is the only question it
+ * answers.
+ * @param controls - The scene's controls.
+ * @returns The bearing in radians.
+ */
+export function bearing(controls) {
+    return euclideanModulo(-controls.azimuthAngle, 2 * Math.PI);
+}
 /**
  * Takes a point on the plan into world coordinates.
  * @param space - The scene's space.

package/dist/controls/handlers/Inertia.d.ts

@@ -1,4 +1,3 @@
-import { type CameraControlsImpl } from '../CameraControls';
 /**
  * How the glide a pan leaves behind is measured, and how it slows.
  *
@@ -43,69 +42,4 @@ export interface InertiaConfig {
  * @returns Nothing; this renders no scene node.
  */
 export declare function Inertia(props: InertiaConfig): null;
-/**
- * The default glide easing: an exponential ease-in, so most of the speed is shed early and the last
- * of it trails off.
- * @param t - How much of the glide's time is left, from `1` to `0`.
- * @returns How much of the original speed to carry, from `1` to `0`.
- */
-export declare function easeInertia(t: number): number;
-/**
- * Carries a pan on after the pointer lifts.
- *
- * Framework-free on purpose: everything here is arithmetic over the camera's target and a list of
- * timestamps, which is the half worth testing without a canvas around it. {@link Inertia} is the
- * React half — when to connect, when to configure, when to step.
- *
- * **The speed comes from where the target actually went**, not from the pointer. Every interaction
- * frame records the target; when the pointer lifts, the oldest sample at least `minSampleMs` old is
- * diffed against the current target. A flick that ended in a stall therefore glides at the
- * stall's speed, because the samples covering the stall are the recent ones.
- */
-export declare class InertiaController {
-    private minSampleMs;
-    private durationMs;
-    private speedThreshold;
-    private ease;
-    private controls?;
-    private samples;
-    private target;
-    private delta;
-    private velocity;
-    private active;
-    private elapsedMs;
-    private prevFactor;
-    /**
-     * Takes every value rather than defaulting any: what an omitted option means is `resolveControls`'s
-     * to answer, and answering it twice is how the two drift apart.
-     * @param options - How the glide is measured and how it slows.
-     */
-    constructor(options: Required<InertiaConfig>);
-    /**
-     * Sets how the glide is measured and how it slows. Every field is optional, so a partial update
-     * leaves the rest as it was.
-     * @param options - The values to change.
-     */
-    configure(options: InertiaConfig): void;
-    /**
-     * Starts watching a controls instance for the interactions a glide follows.
-     * @param controls - The controls to watch and to move.
-     */
-    connect(controls: CameraControlsImpl): void;
-    /** Stops watching, and abandons any glide in flight. */
-    disconnect(): void;
-    /**
-     * Advances a glide in flight by one frame.
-     *
-     * The speed applied is the average of this frame's easing factor and the last one's, which
-     * integrates the curve over the frame rather than sampling it at one end — so the distance
-     * covered does not depend on how the frames happened to fall.
-     * @param delta - Time since the last frame, in seconds.
-     * @returns Whether the camera moved, and so whether another frame is wanted.
-     */
-    update(delta: number): boolean;
-    private onControlStart;
-    private onControl;
-    private onControlEnd;
-}
 //# sourceMappingURL=Inertia.d.ts.map

package/dist/controls/handlers/Inertia.js

@@ -1,7 +1,7 @@
 import { useFrame, useThree } from '@react-three/fiber';
 import { useEffect, useState } from 'react';
 import { Vector3 } from 'three';
-import { useControlsEffect } from '../CameraControls';
+import { useControlsEffect } from '../hooks';
 /**
  * The glide a lifted pointer leaves behind.
  *
@@ -44,7 +44,7 @@ export function Inertia(props) {
  * @param t - How much of the glide's time is left, from `1` to `0`.
  * @returns How much of the original speed to carry, from `1` to `0`.
  */
-export function easeInertia(t) {
+function easeInertia(t) {
     return Math.pow(2, 10 * (t - 1));
 }
 /**
@@ -59,7 +59,7 @@ export function easeInertia(t) {
  * diffed against the current target. A flick that ended in a stall therefore glides at the
  * stall's speed, because the samples covering the stall are the recent ones.
  */
-export class InertiaController {
+class InertiaController {
     minSampleMs;
     durationMs;
     speedThreshold;

package/dist/controls/handlers/Pan.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { CameraControlsImpl, useControlsEffect } from '../CameraControls';
+import { CameraControlsAction } from '../CameraControls';
+import { useControlsEffect } from '../hooks';
 import { Inertia } from './Inertia';
 /**
  * Panning: a left-drag, and a one-finger drag.
@@ -18,15 +19,14 @@ import { Inertia } from './Inertia';
 export function Pan(props) {
     const inertia = props.inertia ?? true;
     useControlsEffect((controls) => {
-        controls.mouseButtons.left = ACTION.SCREEN_PAN;
-        controls.touches.one = ACTION.TOUCH_SCREEN_PAN;
+        controls.mouseButtons.left = CameraControlsAction.SCREEN_PAN;
+        controls.touches.one = CameraControlsAction.TOUCH_SCREEN_PAN;
         return () => {
-            controls.mouseButtons.left = ACTION.NONE;
-            controls.touches.one = ACTION.NONE;
+            controls.mouseButtons.left = CameraControlsAction.NONE;
+            controls.touches.one = CameraControlsAction.NONE;
         };
     });
     if (inertia === false)
         return null;
     return _jsx(Inertia, { ...(inertia === true ? {} : inertia) });
 }
-const ACTION = CameraControlsImpl.ACTION;

package/dist/controls/handlers/Pitch.d.ts

@@ -1,19 +1,3 @@
-import { type Point2Like } from '@expofp/geometry';
-import { type MjolnirGestureEvent } from 'mjolnir.js';
-import { Vector2 } from 'three';
-import { CameraControlsImpl } from '../CameraControls';
-/**
- * How far a two-finger gesture has got toward being judged a pitch.
- *
- * Split out from the gesture that holds it so {@link beginsVertically} can be exercised on its own:
- * the arbitration is the subtle part, and it is pure arithmetic over two movements and a clock.
- */
-export interface PitchVerdict {
-    /** Whether this gesture is a pitch — `undefined` while the fingers have not said. */
-    isValid?: boolean;
-    /** When the first of the two fingers moved, so the second can be given a moment to follow. */
-    firstMove?: number;
-}
 /**
  * Pitching: a right-drag, and two fingers dragged vertically together.
  *
@@ -32,63 +16,4 @@ export interface PitchVerdict {
  * @returns Nothing; this renders no scene node.
  */
 export declare function Pitch(): null;
-/**
- * Two fingers dragged vertically together, tilting the plan.
- *
- * A class rather than fields on the component, for two reasons that agree: the React Compiler
- * refuses a direct write to anything `useState` returned, and the gesture's arbitration is worth
- * testing without a canvas around it. {@link Pitch} is the React half.
- */
-export declare class PitchGesture {
-    private verdict;
-    private lastPoints?;
-    private prevTwoFingerAction?;
-    private p0;
-    private p1;
-    /**
-     * Remembers where the fingers started, and rules the gesture out when they are stacked one above
-     * the other — from there a vertical drag is indistinguishable from a pinch.
-     * @param event - The gesture event that began the drag.
-     */
-    start(event: MjolnirGestureEvent): void;
-    /**
-     * Tilts the plan by how far the fingers moved down the screen, once the gesture has been judged
-     * a pitch.
-     * @param event - The gesture event carrying the drag so far.
-     * @param controls - The controls to tilt.
-     */
-    move(event: MjolnirGestureEvent, controls: CameraControlsImpl): void;
-    /**
-     * Puts back the two-finger action this suppressed, if it suppressed one, and forgets the gesture.
-     *
-     * Nothing is restored when the captured action was already `NONE`: there was nothing to suppress,
-     * and writing it back would claim a field this handler does not own.
-     * @param controls - The controls to restore, if they are still there.
-     */
-    end(controls: CameraControlsImpl | undefined): void;
-}
-/**
- * Whether a two-finger gesture is a pitch, judged from how the fingers first moved.
- *
- * Judged once and then held: the verdict is returned unchanged as soon as it has one, so a drag
- * that started as a pitch stays one even if the fingers wander, and one that did not can never
- * become one. A `false` verdict is what makes a pinch or a twist stay a pinch or a twist.
- *
- * The two fingers rarely start moving on the same frame, so one moving alone is not by itself a
- * verdict — the other is given {@link ALLOWED_SINGLE_TOUCH_TIME} to follow, and only when it fails
- * to is the gesture ruled out.
- * @param a - How far the first finger moved since the last event.
- * @param b - How far the second finger moved since the last event.
- * @param timeStamp - When this event happened, in milliseconds.
- * @param verdict - How far the judgement has got; updated in place.
- * @returns Whether this is a pitch — `false` both for "not a pitch" and for "not yet decided", the
- *   two cases a caller treats alike by doing nothing.
- */
-export declare function beginsVertically(a: Vector2, b: Vector2, timeStamp: number, verdict: PitchVerdict): boolean;
-/**
- * Whether a movement is more down-the-screen than across it.
- * @param vector - The movement to judge.
- * @returns Whether it is vertical.
- */
-export declare function isVertical(vector: Point2Like): boolean;
 //# sourceMappingURL=Pitch.d.ts.map

package/dist/controls/handlers/Pitch.js

@@ -1,8 +1,9 @@
 import { degToRad } from '@expofp/geometry';
 import { useState } from 'react';
 import { Vector2 } from 'three';
-import { CameraControlsImpl, useCameraControls, useControlsEffect } from '../CameraControls';
+import { CameraControlsAction } from '../CameraControls';
 import { canvasPoint, useGesture } from '../gestures';
+import { useCameraControls, useControlsEffect } from '../hooks';
 /**
  * Pitching: a right-drag, and two fingers dragged vertically together.
  *
@@ -25,9 +26,9 @@ export function Pitch() {
     const controls = useCameraControls();
     const [gesture] = useState(() => new PitchGesture());
     useControlsEffect((controls) => {
-        controls.mouseButtons.right |= ACTION.ROTATE_POLAR;
+        controls.mouseButtons.right |= CameraControlsAction.ROTATE_POLAR;
         return () => {
-            controls.mouseButtons.right &= ~ACTION.ROTATE_POLAR;
+            controls.mouseButtons.right &= ~CameraControlsAction.ROTATE_POLAR;
             // Unmounting mid-gesture would otherwise leave the two-finger action switched off for
             // whichever handler owns it.
             gesture.end(controls);
@@ -53,7 +54,7 @@ export function Pitch() {
  * refuses a direct write to anything `useState` returned, and the gesture's arbitration is worth
  * testing without a canvas around it. {@link Pitch} is the React half.
  */
-export class PitchGesture {
+class PitchGesture {
     verdict = {};
     lastPoints;
     prevTwoFingerAction;
@@ -96,7 +97,7 @@ export class PitchGesture {
         // assumed, so whatever the zoom handler put there is what comes back at the end of the gesture.
         if (this.prevTwoFingerAction === undefined) {
             this.prevTwoFingerAction = controls.touches.two;
-            controls.touches.two = ACTION.NONE;
+            controls.touches.two = CameraControlsAction.NONE;
         }
         lastPoints[0].add(this.p0);
         lastPoints[1].add(this.p1);
@@ -136,7 +137,7 @@ export class PitchGesture {
  * @returns Whether this is a pitch — `false` both for "not a pitch" and for "not yet decided", the
  *   two cases a caller treats alike by doing nothing.
  */
-export function beginsVertically(a, b, timeStamp, verdict) {
+function beginsVertically(a, b, timeStamp, verdict) {
     verdict.isValid = judge(a, b, timeStamp, verdict);
     return verdict.isValid === true;
 }
@@ -145,7 +146,7 @@ export function beginsVertically(a, b, timeStamp, verdict) {
  * @param vector - The movement to judge.
  * @returns Whether it is vertical.
  */
-export function isVertical(vector) {
+function isVertical(vector) {
     return Math.abs(vector.y) > Math.abs(vector.x);
 }
 /**
@@ -182,7 +183,6 @@ function judge(a, b, timeStamp, verdict) {
 function byPointerId(event) {
     return event.pointers.slice().sort((a, b) => a.pointerId - b.pointerId);
 }
-const ACTION = CameraControlsImpl.ACTION;
 /** How far the plan tilts per pixel the fingers travel down the screen, in degrees. */
 const DEGREES_PER_PIXEL = -0.5;
 /** How far a finger must travel before it counts as having moved, in pixels. */