@ue-too/board 0.5.1 → 0.5.2

package/dist/camera/camera-mux/animation-and-lock/rotation-control-state-machine.d.ts

@@ -0,0 +1,131 @@
+import type { EventReactions, State, BaseContext } from "@ue-too/being";
+import { TemplateState, TemplateStateMachine } from "@ue-too/being";
+import { BoardCamera } from "../../interface";
+/**
+ * @description The states of the pan control state machine.
+ *
+ * @category Input Flow Control
+ */
+export type RotateControlStates = "ACCEPTING_USER_INPUT" | "TRANSITION" | "LOCKED_ON_OBJECT";
+/**
+ * @description The payload for the rotate by input event.
+ *
+ * @category Input Flow Control
+ */
+export type RotateByInputEventPayload = {
+    diff: number;
+};
+/**
+ * @description The payload for the rotate to input event.
+ *
+ * @category Input Flow Control
+ */
+export type RotateToInputEventPayload = {
+    target: number;
+};
+type EmptyPayload = {};
+/**
+ * @description The payload mapping for the events of the rotate control state machine.
+ *
+ * @category Input Flow Control
+ */
+export type RotateEventPayloadMapping = {
+    "userRotateByInput": RotateByInputEventPayload;
+    "userRotateToInput": RotateToInputEventPayload;
+    "transitionRotateByInput": RotateByInputEventPayload;
+    "transitionRotateToInput": RotateToInputEventPayload;
+    "lockedOnObjectRotateByInput": RotateByInputEventPayload;
+    "lockedOnObjectRotateToInput": RotateToInputEventPayload;
+    "unlock": EmptyPayload;
+    "initateTransition": EmptyPayload;
+};
+/**
+ * @description The context for the rotate control state machine.
+ *
+ * @category Input Flow Control
+ */
+export interface RotateContext extends BaseContext {
+    camera: BoardCamera;
+    rotateBy: (delta: number) => void;
+    rotateTo: (target: number) => void;
+}
+/**
+ * @description The pan control state machine.
+ * It's not created directly using the TemplateStateMachine class.
+ * A few helper functions are in place to make it easier to use. (user don't have to memorize the event names)
+ *
+ * @category Input Flow Control
+ */
+export declare class RotateControlStateMachine extends TemplateStateMachine<RotateEventPayloadMapping, RotateContext, RotateControlStates> {
+    constructor(states: Record<RotateControlStates, State<RotateEventPayloadMapping, RotateContext, RotateControlStates>>, initialState: RotateControlStates, context: RotateContext);
+    /**
+     * @description Notify the pan input event.
+     *
+     * @category Input Flow Control
+     */
+    notifyRotateByInput(diff: number): void;
+    /**
+     * @description Notify the rotate to animation input event.
+     *
+     * @category Input Flow Control
+     */
+    notifyRotateToAnimationInput(target: number): void;
+    /**
+     * @description Initate the transition.
+     *
+     * @category Input Flow Control
+     */
+    initateTransition(): void;
+}
+/**
+ * @description The accepting user input state of the rotate control state machine.
+ *
+ * @category Input Flow Control
+ */
+export declare class RotationAcceptingUserInputState extends TemplateState<RotateEventPayloadMapping, RotateContext, RotateControlStates> {
+    constructor();
+    eventReactions: EventReactions<RotateEventPayloadMapping, RotateContext, RotateControlStates>;
+    userRotateByInputHandler(context: RotateContext, payload: RotateByInputEventPayload): void;
+    userRotateToInputHandler(context: RotateContext, payload: RotateToInputEventPayload): void;
+    lockedOnObjectRotateByInputHandler(context: RotateContext, payload: RotateByInputEventPayload): void;
+    lockedOnObjectRotateToInputHandler(context: RotateContext, payload: RotateToInputEventPayload): void;
+}
+/**
+ * @description The transition state of the rotate control state machine.
+ *
+ * @category Input Flow Control
+ */
+export declare class RotationTransitionState extends TemplateState<RotateEventPayloadMapping, RotateContext, RotateControlStates> {
+    constructor();
+    eventReactions: EventReactions<RotateEventPayloadMapping, RotateContext, RotateControlStates>;
+    userRotateByInputHandler(context: RotateContext, payload: RotateByInputEventPayload): RotateControlStates;
+    userRotateToInputHandler(context: RotateContext, payload: RotateToInputEventPayload): RotateControlStates;
+    transitionRotateByInputHandler(context: RotateContext, payload: RotateByInputEventPayload): RotateControlStates;
+    transitionRotateToInputHandler(context: RotateContext, payload: RotateToInputEventPayload): RotateControlStates;
+    lockedOnObjectRotateByInputHandler(context: RotateContext, payload: RotateByInputEventPayload): RotateControlStates;
+    lockedOnObjectRotateToInputHandler(context: RotateContext, payload: RotateToInputEventPayload): RotateControlStates;
+}
+/**
+ * @description The locked on object state of the pan control state machine.
+ *
+ * @category Input Flow Control
+ */
+export declare class RotationLockedOnObjectState extends TemplateState<RotateEventPayloadMapping, RotateContext, RotateControlStates> {
+    constructor();
+    eventReactions: EventReactions<RotateEventPayloadMapping, RotateContext, RotateControlStates>;
+    lockedOnObjectRotateByInputHandler(context: RotateContext, payload: RotateByInputEventPayload): void;
+    lockedOnObjectRotateToInputHandler(context: RotateContext, payload: RotateToInputEventPayload): void;
+}
+/**
+ * @description Create the object containing the default pan control states.
+ *
+ * @category Input Flow Control
+ */
+export declare function createDefaultRotateControlStates(): Record<RotateControlStates, State<RotateEventPayloadMapping, RotateContext, RotateControlStates>>;
+/**
+ * @description Create the default rotate control state machine.
+ *
+ * @category Input Flow Control
+ */
+export declare function createDefaultRotateControlStateMachine(context: RotateContext): RotateControlStateMachine;
+export {};

package/dist/camera/camera-mux/animation-and-lock/zoom-control-state-machine.d.ts

@@ -0,0 +1,143 @@
+import type { State, EventReactions, BaseContext } from "@ue-too/being";
+import { TemplateState, TemplateStateMachine } from "@ue-too/being";
+import { Point } from "@ue-too/math";
+/**
+ * @description The possible states of the zoom control state machine.
+ *
+ * @category Input Flow Control
+ */
+export type ZoomControlStates = "ACCEPTING_USER_INPUT" | "TRANSITION" | "LOCKED_ON_OBJECT";
+/**
+ * @description The payload for the zoom by at input event.
+ *
+ * @category Input Flow Control
+ */
+export type ZoomByAtInputPayload = {
+    deltaZoom: number;
+    anchorPoint: Point;
+};
+/**
+ * @description The payload for the zoom to at input event.
+ *
+ * @category Input Flow Control
+ */
+export type ZoomToAtInputPayload = {
+    targetZoom: number;
+    anchorPoint: Point;
+};
+/**
+ * @description The payload for the zoom by payload.
+ *
+ * @category Input Flow Control
+ */
+export type ZoomByPayload = {
+    deltaZoom: number;
+};
+/**
+ * @description The payload for the zoom to payload.
+ *
+ * @category Input Flow Control
+ */
+export type ZoomToPayload = {
+    targetZoom: number;
+};
+/**
+ * @description The payload mapping for the events of the zoom control state machine.
+ *
+ * @category Input Flow Control
+ */
+export type ZoomEventPayloadMapping = {
+    "userZoomByAtInput": ZoomByAtInputPayload;
+    "userZoomToAtInput": ZoomToAtInputPayload;
+    "transitionZoomByAtInput": ZoomByAtInputPayload;
+    "transitionZoomToAtInput": ZoomToAtInputPayload;
+    "transitionZoomByAtCenterInput": ZoomByPayload;
+    "transitionZoomToAtCenterInput": ZoomToAtInputPayload;
+    "transitionZoomToAtWorldInput": ZoomToAtInputPayload;
+    "lockedOnObjectZoomByAtInput": ZoomByAtInputPayload;
+    "lockedOnObjectZoomToAtInput": ZoomToAtInputPayload;
+    "unlock": {};
+    "initiateTransition": {};
+};
+/**
+ * @description The context for the zoom control state machine.
+ *
+ * @category Input Flow Control
+ */
+export interface ZoomContext extends BaseContext {
+    zoomToAt: (targetZoom: number, at: Point) => void;
+    zoomByAt: (delta: number, at: Point) => void;
+    zoomTo: (targetZoom: number) => void;
+    zoomBy: (delta: number) => void;
+    zoomToAtWorld: (targetZoom: number, at: Point) => void;
+    zoomByAtWorld: (delta: number, at: Point) => void;
+}
+/**
+ * @description The accepting user input state of the zoom control state machine.
+ *
+ * @category Input Flow Control
+ */
+export declare class ZoomAcceptingUserInputState extends TemplateState<ZoomEventPayloadMapping, ZoomContext, ZoomControlStates> {
+    private _eventReactions;
+    get eventReactions(): EventReactions<ZoomEventPayloadMapping, ZoomContext, ZoomControlStates>;
+    userZoomByAtInput(context: ZoomContext, payload: ZoomEventPayloadMapping["userZoomByAtInput"]): void;
+    userZoomToAtInput(context: ZoomContext, payload: ZoomEventPayloadMapping["userZoomToAtInput"]): void;
+}
+/**
+ * @description The transition state of the zoom control state machine.
+ *
+ * @category Input Flow Control
+ */
+export declare class ZoomTransitionState extends TemplateState<ZoomEventPayloadMapping, ZoomContext, ZoomControlStates> {
+    constructor();
+    private _eventReactions;
+    get eventReactions(): EventReactions<ZoomEventPayloadMapping, ZoomContext, ZoomControlStates>;
+    lockedOnObjectZoomByAtInput(context: ZoomContext, payload: ZoomEventPayloadMapping["lockedOnObjectZoomByAtInput"]): void;
+    lockedOnObjectZoomToAtInput(context: ZoomContext, payload: ZoomEventPayloadMapping["lockedOnObjectZoomToAtInput"]): void;
+    userZoomByAtInput(context: ZoomContext, payload: ZoomEventPayloadMapping["userZoomByAtInput"]): void;
+    userZoomToAtInput(context: ZoomContext, payload: ZoomEventPayloadMapping["userZoomToAtInput"]): void;
+    transitionZoomByAtInput(context: ZoomContext, payload: ZoomEventPayloadMapping["transitionZoomByAtInput"]): void;
+    transitionZoomByAtCenterInput(context: ZoomContext, payload: ZoomEventPayloadMapping["transitionZoomByAtCenterInput"]): void;
+    transitionZoomToAtInput(context: ZoomContext, payload: ZoomEventPayloadMapping["transitionZoomToAtInput"]): void;
+    transitionZoomToAtCenterInput(context: ZoomContext, payload: ZoomEventPayloadMapping["transitionZoomToAtCenterInput"]): void;
+    transitionZoomToAtWorldInput(context: ZoomContext, payload: ZoomEventPayloadMapping["transitionZoomToAtWorldInput"]): void;
+}
+/**
+ * @description The locked on object state of the zoom control state machine.
+ *
+ * @category Input Flow Control
+ */
+export declare class ZoomLockedOnObjectState extends TemplateState<ZoomEventPayloadMapping, ZoomContext, ZoomControlStates> {
+    constructor();
+    private _eventReactions;
+    get eventReactions(): EventReactions<ZoomEventPayloadMapping, ZoomContext, ZoomControlStates>;
+    lockedOnObjectZoomByAtInput(context: ZoomContext, payload: ZoomEventPayloadMapping["lockedOnObjectZoomByAtInput"]): void;
+    lockedOnObjectZoomToAtInput(context: ZoomContext, payload: ZoomEventPayloadMapping["lockedOnObjectZoomToAtInput"]): void;
+    userZoomByAtInput(context: ZoomContext, payload: ZoomEventPayloadMapping["userZoomByAtInput"]): void;
+    userZoomToAtInput(context: ZoomContext, payload: ZoomEventPayloadMapping["userZoomToAtInput"]): void;
+}
+/**
+ * @description The zoom control state machine.
+ *
+ * @category Input Flow Control
+ */
+export declare class ZoomControlStateMachine extends TemplateStateMachine<ZoomEventPayloadMapping, ZoomContext, ZoomControlStates> {
+    constructor(states: Record<ZoomControlStates, State<ZoomEventPayloadMapping, ZoomContext, ZoomControlStates>>, initialState: ZoomControlStates, context: ZoomContext);
+    notifyZoomByAtInput(delta: number, at: Point): void;
+    notifyZoomByAtInputAnimation(delta: number, at: Point): void;
+    notifyZoomToAtCenterInput(targetZoom: number, at: Point): void;
+    notifyZoomToAtWorldInput(targetZoom: number, at: Point): void;
+    initateTransition(): void;
+}
+/**
+ * @description Create the object containing the default zoom control states.
+ *
+ * @category Input Flow Control
+ */
+export declare function createDefaultZoomControlStates(): Record<ZoomControlStates, State<ZoomEventPayloadMapping, ZoomContext, ZoomControlStates>>;
+/**
+ * @description Create the default zoom control state machine.
+ *
+ * @category Input Flow Control
+ */
+export declare function createDefaultZoomControlStateMachine(context: ZoomContext): ZoomControlStateMachine;

package/dist/camera/camera-mux/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./interface";
+export * from "./relay";
+export * from "./animation-and-lock";

package/dist/camera/camera-mux/interface.d.ts

@@ -0,0 +1,12 @@
+import type { Point } from "@ue-too/math";
+/**
+ * @description The interface for the input flow control.
+ * It should at least have user input handlers for pan, zoom and rotation.
+ *
+ * @category Input Flow Control
+ */
+export interface CameraMux {
+    notifyPanInput(diff: Point): void;
+    notifyZoomInput(deltaZoomAmount: number, anchorPoint: Point): void;
+    notifyRotationInput(deltaRotation: number): void;
+}

package/dist/camera/camera-mux/relay.d.ts

@@ -0,0 +1,27 @@
+import { ObservableBoardCamera } from "../interface";
+import { CameraRig } from "../camera-rig";
+import { CameraMux } from "./interface";
+import { Point } from "@ue-too/math";
+/**
+ * @description The simple relay flow control.
+ * This would be the default flow control for {@link Board}.
+ *
+ * @category Input Flow Control
+ */
+export declare class Relay implements CameraMux {
+    private _cameraRig;
+    constructor(cameraRig?: CameraRig);
+    notifyPanInput(diff: Point): void;
+    notifyZoomInput(deltaZoomAmount: number, anchorPoint: Point): void;
+    notifyRotationInput(deltaRotation: number): void;
+}
+/**
+ * @description Create a default relay control center.
+ *
+ * @category Input Flow Control
+ */
+export declare function createDefaultCameraMux(camera: ObservableBoardCamera): CameraMux;
+/**
+ *
+ */
+export declare function createDefaultCameraMuxWithCameraRig(cameraRig: CameraRig): CameraMux;

package/dist/camera/camera-rig/camera-rig.d.ts

@@ -0,0 +1,207 @@
+import { PanHandlerConfig } from "./pan-handler";
+import { ZoomHandlerConfig } from "./zoom-handler";
+import type { RotationHandlerConfig } from "./rotation-handler";
+import { ObservableBoardCamera } from "../interface";
+import { PanContext } from "../camera-mux/animation-and-lock/pan-control-state-machine";
+import { ZoomContext } from "../camera-mux/animation-and-lock/zoom-control-state-machine";
+import { Point } from "@ue-too/math";
+import { RotateContext } from "../camera-mux/animation-and-lock/rotation-control-state-machine";
+/**
+ * @description The config for the camera rig.
+ * Camera rig combines pan, zoom and rotation handlers.
+ *
+ * @category Input Flow Control
+ */
+export type CameraRigConfig = PanHandlerConfig & ZoomHandlerConfig & RotationHandlerConfig;
+export interface CameraRig extends PanContext, ZoomContext, RotateContext {
+    camera: ObservableBoardCamera;
+    config: CameraRigConfig;
+    configure(config: Partial<CameraRigConfig>): void;
+    update(): void;
+}
+/**
+ * @description The camera rig.
+ *
+ * This is a consolidated handler function for pan, zoom and rotation.
+ * Essentially, it is a controller that controls the camera, so you don't have to figure out some of the math that is involved in panning, zooming and rotating the camera.
+ *
+ * @category Camera
+ */
+export declare class CameraRigWithUpdateBatcher implements CameraRig {
+    private _panBy;
+    private _panTo;
+    private _zoomTo;
+    private _zoomBy;
+    private _rotateBy;
+    private _rotateTo;
+    private _config;
+    private _camera;
+    private _positionBatcher;
+    private _zoomBatcher;
+    private _rotationBatcher;
+    constructor(config: PanHandlerConfig & ZoomHandlerConfig, camera?: ObservableBoardCamera);
+    /**
+     * @description Zoom to a certain zoom level at a certain point. The point is in the viewport coordinate system.
+     */
+    zoomToAt(targetZoom: number, at: Point): void;
+    /**
+     * @description Zoom by a certain amount at a certain point. The point is in the viewport coordinate system.
+     */
+    zoomByAt(delta: number, at: Point): void;
+    /**
+     * @description Zoom to a certain zoom level with respect to the center of the viewport.
+     */
+    zoomTo(targetZoom: number): void;
+    /**
+     * @description Zoom by a certain amount with respect to the center of the viewport.
+     */
+    zoomBy(delta: number): void;
+    /**
+     * @description Zoom to a certain zoom level with respect to a point in the world coordinate system.
+     */
+    zoomToAtWorld(targetZoom: number, at: Point): void;
+    /**
+     * @description Zoom by a certain amount with respect to a point in the world coordinate system.
+     */
+    zoomByAtWorld(delta: number, at: Point): void;
+    /**
+     * @description Pan to a certain point. (target is in the world coordinate system)
+     */
+    private _actualPanByWorld;
+    /**
+     * @description Pan to a certain point. (target is in the world coordinate system)
+     */
+    private _actualPanToWorld;
+    panByWorld(delta: Point): void;
+    panByViewPort(delta: Point): void;
+    panToWorld(target: Point): void;
+    panToViewPort(target: Point): void;
+    /**
+     * @description Rotate by a certain amount.
+     */
+    rotateBy(delta: number): void;
+    /**
+     * @description Rotate to a certain angle.
+     */
+    rotateTo(target: number): void;
+    set limitEntireViewPort(limit: boolean);
+    /**
+     * @description Whether the entire view port is limited.
+     */
+    get limitEntireViewPort(): boolean;
+    get camera(): ObservableBoardCamera;
+    get config(): CameraRigConfig;
+    set config(config: CameraRigConfig);
+    updatePosition(): void;
+    updateZoom(): void;
+    updateRotation(): void;
+    update(): void;
+    private _zoomToAtViewPort;
+    private _zoomToAtWorld;
+    private _zoomByAtViewPort;
+    private _zoomByAtWorld;
+    /**
+     * @description Configure the camera rig.
+     */
+    configure(config: Partial<CameraRigConfig>): void;
+    /**
+     * @description Cleanup the camera rig.
+     */
+    cleanup(): void;
+    /**
+     * @description Setup the camera rig.
+     */
+    setup(): void;
+}
+/**
+ * @description Create a default camera rig with update batcher.
+ *
+ * @category Camera
+ */
+export declare function createDefaultCameraRigWithUpdateBatcher(camera: ObservableBoardCamera): CameraRigWithUpdateBatcher;
+export declare class DefaultCameraRig implements CameraRig {
+    private _panBy;
+    private _panTo;
+    private _zoomTo;
+    private _zoomBy;
+    private _rotateBy;
+    private _rotateTo;
+    private _config;
+    private _camera;
+    constructor(config: PanHandlerConfig & ZoomHandlerConfig, camera?: ObservableBoardCamera);
+    /**
+     * @description Zoom to a certain zoom level at a certain point. The point is in the viewport coordinate system.
+     */
+    zoomToAt(targetZoom: number, at: Point): void;
+    /**
+     * @description Zoom by a certain amount at a certain point. The point is in the viewport coordinate system.
+     */
+    zoomByAt(delta: number, at: Point): void;
+    /**
+     * @description Zoom to a certain zoom level with respect to the center of the viewport.
+     */
+    zoomTo(targetZoom: number): void;
+    /**
+     * @description Zoom by a certain amount with respect to the center of the viewport.
+     */
+    zoomBy(delta: number): void;
+    /**
+     * @description Zoom to a certain zoom level with respect to a point in the world coordinate system.
+     */
+    zoomToAtWorld(targetZoom: number, at: Point): void;
+    /**
+     * @description Zoom by a certain amount with respect to a point in the world coordinate system.
+     */
+    zoomByAtWorld(delta: number, at: Point): void;
+    /**
+     * @description Pan By a certain amount. (delta is in the viewport coordinate system)
+     */
+    panByViewPort(delta: Point): void;
+    /**
+     * @description Pan to a certain point. (target is in the world coordinate system)
+     */
+    panByWorld(delta: Point): void;
+    /**
+     * @description Pan to a certain point. (target is in the world coordinate system)
+     */
+    panToWorld(target: Point): void;
+    /**
+     * @description Pan to a certain point. (target is in the viewport coordinate system)
+     */
+    panToViewPort(target: Point): void;
+    /**
+     * @description Rotate by a certain amount.
+     */
+    rotateBy(delta: number): void;
+    /**
+     * @description Rotate to a certain angle.
+     */
+    rotateTo(target: number): void;
+    set limitEntireViewPort(limit: boolean);
+    /**
+     * @description Whether the entire view port is limited.
+     */
+    get limitEntireViewPort(): boolean;
+    get camera(): ObservableBoardCamera;
+    get config(): CameraRigConfig;
+    set config(config: CameraRigConfig);
+    /**
+     * @description Configure the camera rig.
+     */
+    configure(config: Partial<CameraRigConfig>): void;
+    /**
+     * @description Cleanup the camera rig.
+     */
+    cleanup(): void;
+    /**
+     * @description Setup the camera rig.
+     */
+    setup(): void;
+    update(): void;
+}
+/**
+ * @description Create a default camera rig.
+ *
+ * @category Camera
+ */
+export declare function createDefaultCameraRig(camera: ObservableBoardCamera): CameraRig;

package/dist/camera/camera-rig/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./zoom-handler";
+export * from "./pan-handler";
+export * from "./rotation-handler";
+export * from "./camera-rig";
+export * from "./update-batcher";

package/dist/camera/camera-rig/pan-handler.d.ts

@@ -0,0 +1,113 @@
+import { Point } from "@ue-too/math";
+import { BoardCamera } from "../interface";
+/**
+ * @description Configuration for the pan handler functions.
+ *
+ * @category Camera
+ */
+export type PanHandlerConfig = PanHandlerRestrictionConfig & PanHandlerClampConfig;
+export type PanHandlerClampConfig = {
+    /**
+     * @description Whether to limit the pan to the entire view port.
+     */
+    limitEntireViewPort: boolean;
+    /**
+     * @description Whether to clamp the translation.
+     */
+    clampTranslation: boolean;
+};
+export type PanHandlerRestrictionConfig = {
+    /**
+     * @description Whether to restrict the x translation.
+     */
+    restrictXTranslation: boolean;
+    /**
+     * @description Whether to restrict the y translation.
+     */
+    restrictYTranslation: boolean;
+    /**
+     * @description Whether to restrict the relative x translation. (because the camera can be rotated, the relative x translation is the horizontal direction of what the user sees on the screen)
+     */
+    restrictRelativeXTranslation: boolean;
+    /**
+     * @description Whether to restrict the relative y translation. (because the camera can be rotated, the relative y translation is the vertical direction of what the user sees on the screen)
+     */
+    restrictRelativeYTranslation: boolean;
+};
+/**
+ * @description Function Type that is used to define the "pan to" handler.
+ * The destination is in "stage/context/world" space.
+ * This is structured as a handler pipeline.
+ * @see {@link createHandlerChain}
+ * @category Camera
+ */
+export type PanToHandlerFunction = (destination: Point, camera: BoardCamera, config: PanHandlerConfig) => Point;
+/**
+ * @description Function Type that is used to define the "pan by" handler.
+ * The delta is in "stage/context/world" space.
+ * This is structured as a handler pipeline.
+ * @see {@link createHandlerChain}
+ * @category Camera
+ */
+export type PanByHandlerFunction = (delta: Point, camera: BoardCamera, config: PanHandlerConfig) => Point;
+/**
+ * @description Helper function that creates a default "pan to" handler.
+ * The default pan to handler will first restrict the pan to the view port, then clamp the pan to the boundaries, and then pan to the destination.
+ *
+ * @see {@link createHandlerChain} to create your own custom pan handler pipeline. (you can also use this function as a part of your own custom pan handler pipeline)
+ * @category Camera
+ */
+export declare function createDefaultPanToHandler(): PanToHandlerFunction;
+/**
+ * @description Helper function that creates a default "pan by" handler.
+ * The resulting pan by handler takes in a delta that is in "stage/context/world" space.
+ * The default pan by handler will first restrict the pan by the view port, then clamp the pan by the boundaries, and then pan by the delta.
+ *
+ * @see {@link createHandlerChain} to create your own custom pan handler pipeline. (you can also use this function as a part of your own custom pan handler pipeline)
+ * @category Camera
+ */
+export declare function createDefaultPanByHandler(): PanByHandlerFunction;
+/**
+ * @description Function that is part of the "pan to" handler pipeline. It restricts the "pan to" destination to within a single axis based on the config. (relative to the current camera position)
+ * You can use this function standalone to restrict the "pan to" destination to within a single axis based on the config.
+ * But it is recommended to use this kind of function as part of the pan handler pipeline. (to include this function in your own custom pan handler pipeline)
+ *
+ * @category Camera
+ */
+export declare function restrictPanToHandler(destination: Point, camera: BoardCamera, config: PanHandlerRestrictionConfig): Point;
+/**
+ * @description Function that is part of the "pan by" handler pipeline. It restricts the pan delta to within a single axis based on the config. (relative to the current camera position)
+ * You can use this function standalone to restrict the pan delta to within a single axis based on the config.
+ * But it is recommended to use this kind of function as part of the pan handler pipeline. (to include this function in your own custom pan handler pipeline)
+ *
+ * @category Camera
+ */
+export declare function restrictPanByHandler(delta: Point, camera: BoardCamera, config: PanHandlerRestrictionConfig): Point;
+/**
+ * @description Function that is part of the "pan to" handler pipeline. It clamps the pan destination within the boundaries of the view port.
+ * You can use this function standalone to clamp the pan destination within the boundaries of the view port.
+ * But it is recommended to use this kind of function as part of the pan handler pipeline. (to include this function in your own custom pan handler pipeline)
+ *
+ * @category Camera
+ */
+export declare function clampToHandler(destination: Point, camera: BoardCamera, config: PanHandlerClampConfig): Point;
+/**
+ * @description Function that is part of the "pan by" handler pipeline. It clamps the pan delta within the boundaries of the view port.
+ * You can use this function standalone to clamp the pan delta within the boundaries of the view port.
+ * But it is recommended to use this kind of function as part of the pan handler pipeline. (to include this function in your own custom pan handler pipeline)
+ *
+ * @category Camera
+ */
+export declare function clampByHandler(delta: Point, camera: BoardCamera, config: PanHandlerClampConfig): Point;
+/**
+ * @description Helper function that converts the delta to comply with the restrictions of the config.
+ *
+ * @category Camera
+ */
+export declare function convertDeltaToComplyWithRestriction(delta: Point, camera: BoardCamera, config: PanHandlerRestrictionConfig): Point;
+/**
+ * @description Helper function that converts the user input delta to the camera delta.
+ *
+ * @category Camera
+ */
+export declare function convertUserInputDeltaToCameraDelta(delta: Point, camera: BoardCamera): Point;