@expofp/renderer 3.31.2 → 3.31.4

package/dist/debug/index.js

@@ -1,28 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Canvas } from '@react-three/fiber';
 import { lazy, Suspense, use } from 'react';
-/**
- * The one debug chunk, shared by every consumer: the internal mount's context-patch gate, the
- * overlay in both mounts' trees, and {@link prepareDebug}. Memoized so `use()` sees a stable
- * promise and the chunk is fetched once.
- */
-let debugChunk;
-function loadDebugChunk() {
-    debugChunk ??= import('./components/DebugTools');
-    return debugChunk;
-}
-/**
- * Loads the debug chunk ahead of time — for a host that creates its own WebGL context.
- *
- * The chunk's evaluation is what instruments context creation for the GPU-memory panel
- * (webgl-memory patches `getContext` as it loads), so a context created before it exists can never
- * report memory figures. The renderer's own mount orders this itself; a MapLibre host does it by
- * awaiting this before constructing the map, when debug is on. Idempotent, and the only eager cost
- * is the call: the debug code still lives in its own lazy chunk.
- */
-export async function prepareDebug() {
-    await loadDebugChunk();
-}
+import { loadDebugChunk } from './debug-chunk';
 const DebugTools = lazy(() => import('./components/DebugTools').then((module) => ({ default: module.DebugTools })));
 /**
  * The renderer's own Canvas with the debug ordering folded in: when `debugEnabled`, it suspends —

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { type CameraAPI, type CameraAxes, type CameraState, type ControlsConfig, type InertiaConfig, type PanConfig, type RollConfig, type TransitionOptions, useCameraAPI, useCameraMoveStart, useCameraState, type ZoomToOptions, } from './controls';
-export { prepareDebug } from './debug';
+export { prepareDebug } from './debug/debug-chunk';
 export * from './Renderer';
 export { type CameraProps, type SmoothTime } from './space/Camera';
 export { type CanvasPoint, type CanvasPointLike, type PlanPoint, type PlanPointLike, } from './space/Space';

package/dist/index.js

@@ -3,7 +3,7 @@
 // renderer's internals.
 export { useCameraAPI, useCameraMoveStart, useCameraState, } from './controls';
 // The debug chunk's preload, for an external host that must create its context instrumented.
-export { prepareDebug } from './debug';
+export { prepareDebug } from './debug/debug-chunk';
 export * from './Renderer';
 export { useViewport } from './space/viewport';
 export * from './types/defs';

package/dist/space/VisibleRect.d.ts

@@ -42,31 +42,4 @@ export interface VisibleRectProps {
  * @returns Nothing; this renders no scene node.
  */
 export declare function VisibleRect(props: VisibleRectProps): null;
-/**
- * How far the plan has to shrink to fit inside the rect: `1` when it already does.
- *
- * **Measured against the plan's own footprint, not the canvas's.** Fitting the canvas into the rect
- * would compose two contain-fits — plan into canvas, then canvas into rect — and a product of two
- * independent minima is not the minimum the imperative renderer took over the same pair. The two
- * agree only when the same axis binds both, and disagree in the commonest configuration there is: a
- * wide hall on a portrait phone, where the plan already fits the clear band and fitting the canvas
- * into it would shrink the plan by two thirds for nothing.
- *
- * Measured against the plan, the factorization telescopes back to what the imperative renderer
- * computed in one step:
- *
- * ```
- * fitScale · framingScale = min(W/a, H/b) · min(w/(a·fit), h/(b·fit)) = min(w/a, h/b)
- * ```
- *
- * The clamp only guards a rect larger than the canvas; for a rect inside it the result is already
- * at most `1`, because the fit leaves the plan touching at least one edge.
- * @param rect - The region to frame the plan inside, in css pixels.
- * @param viewbox - The scene's viewbox, in plan units.
- * @param width - The canvas width in css pixels.
- * @param height - The canvas height in css pixels.
- * @param dpr - Device pixels per css pixel.
- * @returns The scale, in `(0, 1]`.
- */
-export declare function framingScale(rect: Box, viewbox: Box, width: number, height: number, dpr: number): number;
 //# sourceMappingURL=VisibleRect.d.ts.map

package/dist/space/VisibleRect.js

@@ -92,7 +92,7 @@ export function VisibleRect(props) {
  * @param dpr - Device pixels per css pixel.
  * @returns The scale, in `(0, 1]`.
  */
-export function framingScale(rect, viewbox, width, height, dpr) {
+function framingScale(rect, viewbox, width, height, dpr) {
     const fit = fitScale(viewbox, width * dpr, height * dpr);
     // The plan's footprint on the canvas at zoom 1, in device pixels — the viewbox fit sizes one
     // world unit to one device pixel, so this is the viewbox scaled and nothing more.

package/dist/space/layout-measure.d.ts

@@ -1,5 +1,5 @@
 import { type Camera } from 'three';
-import { type CameraControlsImpl } from '../controls/CameraControls';
+import { type CameraControlsImpl } from '../controls';
 import { type Space } from './Space';
 /**
  * How much of the plan one device pixel spans, in plan units — what everything sized in pixels is

package/dist/space/layout-measure.js

@@ -1,6 +1,6 @@
 import { Point } from '@expofp/geometry';
 import { Matrix4, Ray, Vector2, Vector4 } from 'three';
-import { bearing } from '../controls/CameraControls';
+import { bearing } from '../controls';
 import { euclideanModulo } from '../utils/math';
 import { isOrthographic, isPerspective } from './camera-kind';
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expofp/renderer",
-  "version": "3.31.2",
+  "version": "3.31.4",
   "repository": {
     "type": "git",
     "url": "https://github.com/expofp/efp-app.git",
@@ -42,7 +42,7 @@
     "troika-three-text": "^0.52.5",
     "tslib": "^2.3.0",
     "webgl-memory": "^1.1.3",
-    "@expofp/geometry": "3.31.2"
+    "@expofp/geometry": "3.31.4"
   },
   "devDependencies": {
     "@react-three/test-renderer": "^9.1.0",

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

@@ -1,13 +0,0 @@
-/**
- * Runs a handler when a camera movement begins — a gesture and a command alike, one call per
- * movement rather than one per frame. The event the imperative renderer published as
- * `navigation:change`, under a name that says what happened.
- *
- * A camera-level event rather than the controls themselves, so a caller resetting an idle timer or
- * dismissing an overlay never learns which library drives the camera. For as long as the component
- * is mounted; where the camera *is* once it settles is `useCameraState`'s business.
- * @param handler - Called as each movement starts. Re-subscribed when its identity changes, so pass
- *   a stable function — under the React Compiler an inline closure over stable values is one.
- */
-export declare function useCameraMoveStart(handler: () => void): void;
-//# sourceMappingURL=camera-move.d.ts.map

package/dist/controls/camera-move.js

@@ -1,18 +0,0 @@
-import { useControlsEffect } from './CameraControls';
-/**
- * Runs a handler when a camera movement begins — a gesture and a command alike, one call per
- * movement rather than one per frame. The event the imperative renderer published as
- * `navigation:change`, under a name that says what happened.
- *
- * A camera-level event rather than the controls themselves, so a caller resetting an idle timer or
- * dismissing an overlay never learns which library drives the camera. For as long as the component
- * is mounted; where the camera *is* once it settles is `useCameraState`'s business.
- * @param handler - Called as each movement starts. Re-subscribed when its identity changes, so pass
- *   a stable function — under the React Compiler an inline closure over stable values is one.
- */
-export function useCameraMoveStart(handler) {
-    useControlsEffect((controls) => {
-        controls.addEventListener('transitionstart', handler);
-        return () => controls.removeEventListener('transitionstart', handler);
-    });
-}

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

@@ -1,40 +0,0 @@
-import { Point } from '@expofp/geometry';
-/** Where the camera is, at the moment it was asked. */
-export interface CameraState {
-    /** The point on the plan it is looking at, in plan units. */
-    center: Point;
-    /** How far in it is zoomed, as a factor: `1` frames the whole viewbox. */
-    zoom: number;
-    /** Which way the plan is turned, in degrees clockwise from north, in `[0, 360)`. */
-    roll: number;
-    /** How far the plan is tilted away from face-on, in degrees. */
-    pitch: number;
-    /**
-     * How much of the plan one device pixel spans, in plan units — the factor anything sized in
-     * pixels is laid out against, and the quantity the imperative renderer published as `ptScale`.
-     */
-    pixelSize: number;
-}
-/**
- * Reads where the camera is.
- *
- * A **getter**, not a value: nothing here belongs in render output — a component that re-rendered
- * whenever the camera moved would re-render on every frame of every pan — and every caller wants it
- * at a moment of its own choosing, in an event handler, an effect, or a snapshot a host asked for.
- * That is the same reading discipline `Space` documents, for the same reason.
- *
- * The five numbers come from four different places, which is why this exists at all rather than
- * being arithmetic a caller could do: the target from the controls and the plan it lands on from the
- * space, the zoom factor from the camera's handle, and the pixel size from the re-layout registry —
- * which is what the plan's own labels are sized against, so a caller measuring against anything else
- * would disagree with what is drawn.
- *
- * Outside a mounted scene, or in the frames before the controls publish themselves, it reports the
- * camera at rest: the middle of the plan, framed whole, facing north.
- *
- * As with {@link useCameraAPI}, the reader is **new on every render** and this module memoizes
- * nothing; a consumer that needs a settled identity holds it in a ref.
- * @returns A function that reads the current state.
- */
-export declare function useCameraState(): () => CameraState;
-//# sourceMappingURL=camera-state.d.ts.map

package/dist/controls/camera-state.js

@@ -1,65 +0,0 @@
-import { Point, radToDeg } from '@expofp/geometry';
-import { use } from 'react';
-import { Vector3 } from 'three';
-import { LayoutTargetsContext } from '../events/layout-targets';
-import { useCamera } from '../space/camera-handle';
-import { useSpace } from '../space/Space';
-import { bearing, useCameraControls } from './CameraControls';
-/**
- * Reads where the camera is.
- *
- * A **getter**, not a value: nothing here belongs in render output — a component that re-rendered
- * whenever the camera moved would re-render on every frame of every pan — and every caller wants it
- * at a moment of its own choosing, in an event handler, an effect, or a snapshot a host asked for.
- * That is the same reading discipline `Space` documents, for the same reason.
- *
- * The five numbers come from four different places, which is why this exists at all rather than
- * being arithmetic a caller could do: the target from the controls and the plan it lands on from the
- * space, the zoom factor from the camera's handle, and the pixel size from the re-layout registry —
- * which is what the plan's own labels are sized against, so a caller measuring against anything else
- * would disagree with what is drawn.
- *
- * Outside a mounted scene, or in the frames before the controls publish themselves, it reports the
- * camera at rest: the middle of the plan, framed whole, facing north.
- *
- * As with {@link useCameraAPI}, the reader is **new on every render** and this module memoizes
- * nothing; a consumer that needs a settled identity holds it in a ref.
- * @returns A function that reads the current state.
- */
-export function useCameraState() {
-    const controls = useCameraControls();
-    const camera = useCamera();
-    const space = useSpace();
-    const targets = use(LayoutTargetsContext);
-    return () => readCameraState({ controls, camera, space, targets });
-}
-/**
- * Reads the camera, from whatever the scene holds at the moment of asking.
- * @param context - What the scene holds.
- * @returns Where the camera is.
- */
-function readCameraState(context) {
-    const { controls, camera, space, targets } = context;
-    const pixelSize = targets?.pixelSize ?? 1;
-    // A fresh centre every time: a caller that keeps the point it was handed must never find it
-    // moved under them.
-    if (!controls)
-        return { ...atRest(), pixelSize };
-    controls.getTarget(_target);
-    return {
-        center: space.worldToPlan(_target, new Point()),
-        zoom: camera?.zoomFactor ?? 1,
-        roll: radToDeg(bearing(controls)),
-        pitch: radToDeg(controls.polarAngle),
-        pixelSize,
-    };
-}
-/**
- * The camera as it stands before anything has moved it, which is what a read outside a mounted
- * scene reports: the middle of the plan, framed whole, facing north.
- * @returns The state.
- */
-function atRest() {
-    return { center: new Point(), zoom: 1, roll: 0, pitch: 0, pixelSize: 1 };
-}
-const _target = new Vector3();