@ue-too/board 0.5.1

package/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;

package/camera/camera-rig/rotation-handler.d.ts

@@ -0,0 +1,78 @@
+import { BoardCamera } from "../interface";
+/**
+ * @description This is the configuration for the rotation handler functions.
+ * This is the configuration object that is passed to the rotation handler functions.
+ *
+ * @category Camera
+ */
+export type RotationHandlerConfig = RotationHandlerRestrictConfig & RotationHandlerClampConfig;
+export type RotationHandlerRestrictConfig = {
+    /**
+     * @description Whether to restrict the rotation. (if true, rotation input will be ignored)
+     */
+    restrictRotation: boolean;
+};
+export type RotationHandlerClampConfig = {
+    /**
+     * @description Whether to clamp the rotation if the rotation is out of the rotation boundaries.
+     */
+    clampRotation: boolean;
+};
+/**
+ * @description The function that is used to rotate the camera by a specific delta.
+ * The delta is in radians.
+ * This is structured as a handler pipeline.
+ *
+ * @see {@link createHandlerChain}
+ * @category Camera
+ */
+export type RotateByHandlerFunction = (delta: number, camera: BoardCamera, config: RotationHandlerConfig) => number;
+/**
+ * @description The function that is used to rotate the camera to a specific target rotation.
+ * The target rotation is in radians.
+ * This is structured as a handler pipeline.
+ *
+ * @see {@link createHandlerChain}
+ * @category Camera
+ */
+export type RotateToHandlerFunction = (targetRotation: number, camera: BoardCamera, config: RotationHandlerConfig) => number;
+/**
+ * @description This is the clamp handler for the "rotate by" handler pipeline.
+ * It clamps the delta to the range of the camera's rotation boundaries.
+ *
+ * @category Camera
+ */
+export declare function clampRotateByHandler(delta: number, camera: BoardCamera, config: RotationHandlerClampConfig): number;
+/**
+ * @description This is the restrict handler for the "rotate by" handler pipeline.
+ * It restricts the delta to the range of the camera's rotation boundaries.
+ *
+ * @category Camera
+ */
+export declare function restrictRotateByHandler(delta: number, camera: BoardCamera, config: RotationHandlerRestrictConfig): number;
+/**
+ * @description This is the clamp handler for the "rotate to" handler pipeline.
+ * It clamps the target rotation to the range of the camera's rotation boundaries.
+ *
+ * @category Camera
+ */
+export declare function clampRotateToHandler(targetRotation: number, camera: BoardCamera, config: RotationHandlerClampConfig): number;
+/**
+ * @description This is the restrict handler for the "rotate to" handler pipeline.
+ * It restricts the target rotation to the range of the camera's rotation boundaries.
+ *
+ * @category Camera
+ */
+export declare function restrictRotateToHandler(targetRotation: number, camera: BoardCamera, config: RotationHandlerRestrictConfig): number;
+/**
+ * @description This is the create default handler chain function for the "rotate by" handler pipeline.
+ *
+ * @category Camera
+ */
+export declare function createDefaultRotateByHandler(): RotateByHandlerFunction;
+/**
+ * @description This is the create default handler chain function for the "rotate to" handler pipeline.
+ *
+ * @category Camera
+ */
+export declare function createDefaultRotateToHandler(): RotateToHandlerFunction;

package/camera/camera-rig/update-batcher/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./position-update-batcher";
+export * from "./rotation-update-batcher";
+export * from "./zoom-udpate-batcher";

package/camera/camera-rig/update-batcher/position-update-batcher.d.ts

@@ -0,0 +1,58 @@
+import { Observer, SubscriptionOptions } from "../../../utils/observable";
+export type Position = {
+    x: number;
+    y: number;
+};
+export type Velocity = {
+    vx: number;
+    vy: number;
+};
+export type DestinationUpdate = Position & {
+    type: 'destination';
+};
+export type DeltaUpdate = Position & {
+    type: 'delta';
+};
+export type PositionUpdate = DestinationUpdate | DeltaUpdate;
+export declare class CameraPositionUpdateBatcher {
+    private nextPosition;
+    private delta;
+    private observable;
+    private queuePositionUpdateCount;
+    private queuePositionUpdateToCount;
+    private queuePositionUpdateByCount;
+    private lastUpdateCount;
+    constructor();
+    /**
+     * Queue an absolute position update to be processed in the next animation frame
+     */
+    queuePositionUpdate(x: number, y: number): void;
+    /**
+     * Queue a position update to a specific destination to be processed in the next animation frame
+     * This will override any pending delta updates
+     */
+    queuePositionUpdateTo(destination: Position): void;
+    /**
+     * Queue a position update by delta to be processed in the next animation frame
+     * This will be ignored if there's a pending destination update
+     */
+    queuePositionUpdateBy(delta: Position): void;
+    /**
+     * Process and clear all queued position updates
+     * @returns the update to apply to the position, with type information
+     */
+    processQueuedUpdates(): PositionUpdate | null;
+    /**
+     * Subscribe to position updates
+     */
+    subscribe(observer: Observer<[PositionUpdate]>, options?: SubscriptionOptions): () => void;
+    /**
+     * Get debug information about queue method calls since last update
+     */
+    getDebugInfo(): {
+        lastUpdateTotalCalls: number;
+        queuePositionUpdateCalls: number;
+        queuePositionUpdateToCalls: number;
+        queuePositionUpdateByCalls: number;
+    };
+}

package/camera/camera-rig/update-batcher/rotation-update-batcher.d.ts

@@ -0,0 +1,54 @@
+import { Observer, SubscriptionOptions } from "../../../utils/observable";
+export type Rotation = number;
+export type RotationVelocity = number;
+export type RotationDestinationUpdate = {
+    type: 'destination';
+    destination: Rotation;
+};
+export type RotationDeltaUpdate = {
+    type: 'delta';
+    delta: Rotation;
+};
+export type RotationUpdate = RotationDestinationUpdate | RotationDeltaUpdate;
+export declare class CameraRotationUpdateBatcher {
+    private nextRotation;
+    private delta;
+    private observable;
+    private queueRotationUpdateCount;
+    private queueRotationUpdateToCount;
+    private queueRotationUpdateByCount;
+    private lastUpdateCount;
+    constructor();
+    /**
+     * Queue an absolute rotation update to be processed in the next animation frame
+     */
+    queueRotationUpdate(rotation: Rotation): void;
+    /**
+     * Queue a rotation update to a specific destination to be processed in the next animation frame
+     * This will override any pending delta updates
+     */
+    queueRotationUpdateTo(destination: Rotation): void;
+    /**
+     * Queue a rotation update by delta to be processed in the next animation frame
+     * This will be ignored if there's a pending destination update
+     */
+    queueRotationUpdateBy(delta: Rotation): void;
+    /**
+     * Process and clear all queued rotation updates
+     * @returns the update to apply to the rotation, with type information
+     */
+    processQueuedUpdates(): RotationUpdate | null;
+    /**
+     * Subscribe to rotation updates
+     */
+    subscribe(observer: Observer<[RotationUpdate]>, options?: SubscriptionOptions): () => void;
+    /**
+     * Get debug information about queue method calls since last update
+     */
+    getDebugInfo(): {
+        lastUpdateTotalCalls: number;
+        queueRotationUpdateCalls: number;
+        queueRotationUpdateToCalls: number;
+        queueRotationUpdateByCalls: number;
+    };
+}

package/camera/camera-rig/update-batcher/zoom-udpate-batcher.d.ts

@@ -0,0 +1,60 @@
+import { Observer, SubscriptionOptions } from "../../../utils/observable";
+import { Point } from "@ue-too/math";
+export type DestinationZoomUpdate = {
+    type: 'destination';
+    destination: number;
+    anchor?: Point;
+};
+export type DeltaZoomUpdate = {
+    type: 'delta';
+    delta: number;
+    anchor?: Point;
+};
+export type ZoomUpdate = {
+    anchorCoordinateSystem: 'world' | 'viewport';
+    update: DestinationZoomUpdate | DeltaZoomUpdate;
+};
+export declare class CameraZoomUpdateBatcher {
+    private nextZoom;
+    private observable;
+    private anchor;
+    private delta;
+    private anchorCoordinateSystem;
+    private queueZoomUpdateCount;
+    private queueZoomUpdateToCount;
+    private lastUpdateCount;
+    constructor();
+    /**
+     * Queue a zoom update to a specific destination to be processed in the next animation frame
+     */
+    queueZoomUpdateTo(destination: number, anchor?: Point): void;
+    /**
+     * Queue a zoom update by delta to be processed in the next animation frame
+     */
+    queueZoomUpdateBy(delta: number, anchor?: Point): void;
+    /**
+     * Queue a zoom update by delta at a world anchor to be processed in the next animation frame
+     */
+    queueZoomByAtWorld(delta: number, worldAnchor: Point): void;
+    /**
+     * Queue a zoom update to a specific destination at a world anchor to be processed in the next animation frame
+     */
+    queueZoomToAtWorld(destination: number, worldAnchor: Point): void;
+    /**
+     * Process and clear all queued zoom updates
+     * @returns the update to apply to the zoom level, with type information
+     */
+    processQueuedUpdates(): ZoomUpdate | null;
+    /**
+     * Subscribe to zoom updates
+     */
+    subscribe(observer: Observer<[ZoomUpdate]>, options?: SubscriptionOptions): () => void;
+    /**
+     * Get debug information about queue method calls since last update
+     */
+    getDebugInfo(): {
+        lastUpdateTotalCalls: number;
+        queueZoomUpdateCalls: number;
+        queueZoomUpdateToCalls: number;
+    };
+}

package/camera/camera-rig/zoom-handler.d.ts

@@ -0,0 +1,77 @@
+import { BoardCamera } from "../interface";
+/**
+ * @description The configuration for the base zoom handler.
+ *
+ * @category Camera
+ */
+export type ZoomHandlerConfig = ZoomHandlerClampConfig & ZoomHandlerRestrictConfig;
+export type ZoomHandlerClampConfig = {
+    /**
+     * @description Whether to clamp the zoom level.
+     */
+    clampZoom: boolean;
+};
+export type ZoomHandlerRestrictConfig = {
+    /**
+     * @description Whether to restrict the zoom level.
+     */
+    restrictZoom: boolean;
+};
+/**
+ * @description The function signature for the zoom to handler.
+ *
+ * @category Camera
+ */
+export type ZoomToHandlerFunction = (destination: number, camera: BoardCamera, config: ZoomHandlerConfig) => number;
+/**
+ * @description The function signature for the zoom by handler.
+ *
+ * @category Camera
+ */
+export type ZoomByHandlerFunction = (delta: number, camera: BoardCamera, config: ZoomHandlerConfig) => number;
+/**
+ * @description The function that is part of the zoom to handler pipeline.
+ * Clamps the zoom level to the zoom boundaries.
+ *
+ * @see {@link createHandlerChain}
+ * @category Camera
+ */
+export declare function clampZoomToHandler(destination: number, camera: BoardCamera, config: ZoomHandlerClampConfig): number;
+/**
+ * @description The function that is part of the zoom by handler pipeline.
+ * Clamps the zoom level to the zoom boundaries.
+ *
+ * @see {@link createHandlerChain}
+ * @category Camera
+ */
+export declare function clampZoomByHandler(delta: number, camera: BoardCamera, config: ZoomHandlerClampConfig): number;
+/**
+ * @description The function that is part of the zoom to handler pipeline.
+ * Restricts the zoom level to the zoom boundaries.
+ *
+ * @see {@link createHandlerChain}
+ * @category Camera
+ */
+export declare function restrictZoomToHandler(destination: number, camera: BoardCamera, config: ZoomHandlerRestrictConfig): number;
+/**
+ * @description The function that is part of the zoom by handler pipeline.
+ * Restricts the zoom level to the zoom boundaries.
+ *
+ * @see {@link createHandlerChain}
+ * @category Camera
+ */
+export declare function restrictZoomByHandler(delta: number, camera: BoardCamera, config: ZoomHandlerRestrictConfig): number;
+/**
+ * @description The function that creates the default zoom to only handler.
+ * clamp -> restrict -> base
+ * @see {@link createHandlerChain}
+ * @category Camera
+ */
+export declare function createDefaultZoomToOnlyHandler(): ZoomToHandlerFunction;
+/**
+ * @description The function that creates the default zoom by only handler.
+ * clamp -> restrict -> base
+ * @see {@link createHandlerChain}
+ * @category Camera
+ */
+export declare function createDefaultZoomByOnlyHandler(): ZoomByHandlerFunction;

package/camera/default-camera.d.ts

@@ -0,0 +1,170 @@
+import { Point } from '@ue-too/math';
+import { Boundaries } from './utils/position';
+import { TransformationMatrix } from './utils/matrix';
+import { UnSubscribe } from './update-publisher';
+import { ZoomLevelLimits } from './utils/zoom';
+import { RotationLimits } from './utils/rotation';
+import { CameraEventMap, CameraState } from './update-publisher';
+import { ObservableBoardCamera } from './interface';
+import { SubscriptionOptions } from '../utils/observable';
+export declare const DEFAULT_BOARD_CAMERA_VIEWPORT_WIDTH = 1000;
+export declare const DEFAULT_BOARD_CAMERA_VIEWPORT_HEIGHT = 1000;
+export declare const DEFAULT_BOARD_CAMERA_ZOOM_BOUNDARIES: ZoomLevelLimits;
+export declare const DEFAULT_BOARD_CAMERA_BOUNDARIES: Boundaries;
+export declare const DEFAULT_BOARD_CAMERA_ROTATION_BOUNDARIES: RotationLimits;
+/**
+ * @description The default board camera. This is basically the same as the {@link BaseCamera} class.
+ * But it's observable.
+ *
+ * @category Camera
+ */
+export default class DefaultBoardCamera implements ObservableBoardCamera {
+    private _baseCamera;
+    private _observer;
+    /**
+     * @param position The position of the camera in the world coordinate system
+     * @param rotation The rotation of the camera in the world coordinate system
+     * @param zoomLevel The zoom level of the camera
+     * @param viewPortWidth The width of the viewport. (The width of the canvas in css pixels)
+     * @param viewPortHeight The height of the viewport. (The height of the canvas in css pixels)
+     * @param boundaries The boundaries of the camera in the world coordinate system
+     * @param zoomLevelBoundaries The boundaries of the zoom level of the camera
+     * @param rotationBoundaries The boundaries of the rotation of the camera
+     */
+    constructor(viewPortWidth?: number, viewPortHeight?: number, position?: Point, rotation?: number, zoomLevel?: number, boundaries?: Boundaries, zoomLevelBoundaries?: ZoomLevelLimits, rotationBoundaries?: RotationLimits);
+    /**
+     * @description The boundaries of the camera in the world coordinate system.
+     *
+     * @category Camera
+     */
+    get boundaries(): Boundaries | undefined;
+    set boundaries(boundaries: Boundaries | undefined);
+    /**
+     * @description The width of the viewport. (The width of the canvas in css pixels)
+     *
+     * @category Camera
+     */
+    get viewPortWidth(): number;
+    set viewPortWidth(width: number);
+    /**
+     * @description The height of the viewport. (The height of the canvas in css pixels)
+     *
+     * @category Camera
+     */
+    get viewPortHeight(): number;
+    set viewPortHeight(height: number);
+    /**
+     * @description The position of the camera in the world coordinate system.
+     *
+     * @category Camera
+     */
+    get position(): Point;
+    /**
+     * @description This function is used to set the position of the camera.
+     * @param destination The destination point of the camera.
+     * @returns Whether the position is set successfully.
+     *
+     * @description This function has a guard that checks if the destination point is within the boundaries of the camera.
+     * If the destination point is not within the boundaries, the function will return false and the position will not be updated.
+     * If the destination point is within the boundaries, the function will return true and the position will be updated.
+     */
+    setPosition(destination: Point): boolean;
+    /**
+     * @description The zoom level of the camera.
+     *
+     * @category Camera
+     */
+    get zoomLevel(): number;
+    /**
+     * @description The boundaries of the zoom level of the camera.
+     *
+     * @category Camera
+     */
+    get zoomBoundaries(): ZoomLevelLimits | undefined;
+    set zoomBoundaries(zoomBoundaries: ZoomLevelLimits | undefined);
+    setMaxZoomLevel(maxZoomLevel: number): boolean;
+    setMinZoomLevel(minZoomLevel: number): boolean;
+    setZoomLevel(zoomLevel: number): boolean;
+    /**
+     * @description The rotation of the camera in the world coordinate system.
+     *
+     * @category Camera
+     */
+    get rotation(): number;
+    /**
+     * @description The boundaries of the rotation of the camera.
+     *
+     * @category Camera
+     */
+    get rotationBoundaries(): RotationLimits | undefined;
+    set rotationBoundaries(rotationBoundaries: RotationLimits | undefined);
+    /**
+     * @description The order of the transformation is as follows:
+     * 1. Scale (scale the context using the device pixel ratio)
+     * 2. Translation (move the origin of the context to the center of the canvas)
+     * 3. Rotation (rotate the context negatively the rotation of the camera)
+     * 4. Zoom (scale the context using the zoom level of the camera)
+     * 5. Translation (move the origin of the context to the position of the camera in the context coordinate system)
+     *
+     * @param devicePixelRatio The device pixel ratio of the canvas
+     * @param alignCoorindate Whether to align the coordinate system to the camera's position
+     * @returns The transformation matrix
+     */
+    getTransform(devicePixelRatio: number, alignCoorindate: boolean): TransformationMatrix;
+    /**
+     * @description This function is used to set the rotation of the camera.
+     * @param rotation The rotation of the camera in the world coordinate system.
+     * @returns Whether the rotation is set successfully.
+     */
+    setRotation(rotation: number): boolean;
+    /**
+     * @description The origin of the camera in the window coordinate system.
+     * @deprecated
+     *
+     * @param centerInWindow The center of the camera in the window coordinate system.
+     * @returns The origin of the camera in the window coordinate system.
+     */
+    getCameraOriginInWindow(centerInWindow: Point): Point;
+    /**
+     * @description Converts a point from the viewport coordinate system to the world coordinate system.
+     *
+     * @param point The point in the viewport coordinate system.
+     * @returns The point in the world coordinate system.
+     */
+    convertFromViewPort2WorldSpace(point: Point): Point;
+    /**
+     * @description Converts a point from the world coordinate system to the viewport coordinate system.
+     *
+     * @param point The point in the world coordinate system.
+     * @returns The point in the viewport coordinate system.
+     */
+    convertFromWorld2ViewPort(point: Point): Point;
+    /**
+     * @description Inverts a point from the world coordinate system to the viewport coordinate system.
+     *
+     * @param point The point in the world coordinate system.
+     * @returns The point in the viewport coordinate system.
+     */
+    invertFromWorldSpace2ViewPort(point: Point): Point;
+    setHorizontalBoundaries(min: number, max: number): void;
+    setVerticalBoundaries(min: number, max: number): void;
+    /**
+     * @description This function is used to subscribe to the camera events.
+     * @param eventName The name of the event to subscribe to.
+     * @param callback The callback function to be called when the event is triggered.
+     * @param options The options for the subscription.
+     * @returns The unsubscribe function.
+     */
+    on<K extends keyof CameraEventMap>(eventName: K, callback: (event: CameraEventMap[K], cameraState: CameraState) => void, options?: SubscriptionOptions): UnSubscribe;
+    getTRS(devicePixelRatio: number, alignCoordinateSystem: boolean): {
+        scale: {
+            x: number;
+            y: number;
+        };
+        rotation: number;
+        translation: {
+            x: number;
+            y: number;
+        };
+    };
+}

package/camera/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./base";
+export * from './utils';
+export * from './default-camera';
+export * from './interface';
+export * from './update-publisher';
+export * from './camera-rig';
+export * from './camera-mux';
+export { default as DefaultBoardCamera } from './default-camera';