react-babylon-map 0.0.1

package/dist/maplibre/es/main7.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"main7.mjs","sources":["../../../src/api/near-coordinates.tsx"],"sourcesContent":["import { Color4, FreeCamera, HemisphericLight, Scene, Vector3 } from '@babylonjs/core';\nimport { memo, useEffect, useRef, useState } from 'react';\nimport { useBabylonMap, BabylonMapContext } from '../core/use-babylon-map';\nimport type { BabylonMap } from '../core/use-babylon-map';\nimport { useCoords } from '../core/use-coords';\nimport { coordsToVector3 } from './coords-to-vector-3';\n\nexport interface NearCoordinatesProps {\n  longitude: number;\n  latitude: number;\n  altitude?: number;\n  children?: React.ReactNode;\n}\n\n/**\n * Place 3D content at a nearby coordinate (relative to the Canvas origin).\n * Uses the sub-scene approach like Coordinates but computes a relative offset\n * for the camera's world matrix.\n */\nexport const NearCoordinates = memo<NearCoordinatesProps>(({ children, ...coords }) => {\n  const { latitude, longitude, altitude } = useCoords();\n  const babylonMap = useBabylonMap();\n\n  const pos = coordsToVector3(coords, { latitude, longitude, altitude });\n\n  // Create a sub-scene for this coordinate portal\n  const [subScene] = useState(() => {\n    if (!babylonMap.engine) return null;\n    const sub = new Scene(babylonMap.engine);\n    sub.autoClear = false;\n    sub.clearColor = new Color4(0, 0, 0, 0);\n    return sub;\n  });\n\n  const cameraRef = useRef<FreeCamera | null>(null);\n\n  // Create camera + default light in sub-scene\n  useEffect(() => {\n    if (!subScene) return;\n    const cam = new FreeCamera('nearCoordsCam', new Vector3(pos[0], pos[1], pos[2]), subScene);\n    cam.inputs.clear();\n    cam.minZ = 0;\n    cameraRef.current = cam;\n\n    const light = new HemisphericLight('nearCoordsLight', new Vector3(0, 1, 0), subScene);\n    light.intensity = 1;\n\n    return () => { cam.dispose(); light.dispose(); };\n  }, [subScene]);\n\n  // Update camera position when offset changes\n  useEffect(() => {\n    if (!cameraRef.current) return;\n    cameraRef.current.position.set(pos[0], pos[1], pos[2]);\n  }, [pos]);\n\n  // Render the sub-scene each frame\n  useEffect(() => {\n    if (!subScene || !babylonMap.scene) return;\n    const mainScene = babylonMap.scene;\n\n    const observer = mainScene.onBeforeRenderObservable.add(() => {\n      if (!cameraRef.current) return;\n      // Use the same projection as the main scene but offset by local position\n      cameraRef.current.freezeProjectionMatrix(babylonMap.scene!.activeCamera!.getProjectionMatrix());\n      babylonMap.engine?.wipeCaches(true);\n      subScene.render(false);\n    });\n\n    return () => {\n      mainScene.onBeforeRenderObservable.remove(observer);\n    };\n  }, [subScene, babylonMap.scene, babylonMap]);\n\n  // Provide child context pointing at the sub-scene\n  const childMap: BabylonMap = {\n    ...babylonMap,\n    scene: subScene || undefined,\n  };\n\n  return (\n    <BabylonMapContext.Provider value={childMap}>\n      {children}\n    </BabylonMapContext.Provider>\n  );\n});\nNearCoordinates.displayName = 'NearCoordinates';\n"],"names":[],"mappings":";;;;;;AAmBO,MAAM,kBAAkB,KAA2B,CAAC,EAAE,UAAU,GAAG,aAAa;AACrF,QAAM,EAAE,UAAU,WAAW,aAAa,UAAU;AACpD,QAAM,aAAa;AAEnB,QAAM,MAAM,gBAAgB,QAAQ,EAAE,UAAU,WAAW,UAAU;AAGrE,QAAM,CAAC,QAAQ,IAAI,SAAS,MAAM;AAChC,QAAI,CAAC,WAAW;AAAe,aAAA;AAC/B,UAAM,MAAM,IAAI,MAAM,WAAW,MAAM;AACvC,QAAI,YAAY;AAChB,QAAI,aAAa,IAAI,OAAO,GAAG,GAAG,GAAG,CAAC;AAC/B,WAAA;AAAA,EAAA,CACR;AAEK,QAAA,YAAY,OAA0B,IAAI;AAGhD,YAAU,MAAM;AACd,QAAI,CAAC;AAAU;AACf,UAAM,MAAM,IAAI,WAAW,iBAAiB,IAAI,QAAQ,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,QAAQ;AACzF,QAAI,OAAO;AACX,QAAI,OAAO;AACX,cAAU,UAAU;AAEd,UAAA,QAAQ,IAAI,iBAAiB,mBAAmB,IAAI,QAAQ,GAAG,GAAG,CAAC,GAAG,QAAQ;AACpF,UAAM,YAAY;AAElB,WAAO,MAAM;AAAE,UAAI,QAAQ;AAAG,YAAM,QAAQ;AAAA,IAAA;AAAA,EAAG,GAC9C,CAAC,QAAQ,CAAC;AAGb,YAAU,MAAM;AACd,QAAI,CAAC,UAAU;AAAS;AACd,cAAA,QAAQ,SAAS,IAAI,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;AAAA,EAAA,GACpD,CAAC,GAAG,CAAC;AAGR,YAAU,MAAM;AACV,QAAA,CAAC,YAAY,CAAC,WAAW;AAAO;AACpC,UAAM,YAAY,WAAW;AAE7B,UAAM,WAAW,UAAU,yBAAyB,IAAI,MAAM;;AAC5D,UAAI,CAAC,UAAU;AAAS;AAExB,gBAAU,QAAQ,uBAAuB,WAAW,MAAO,aAAc,qBAAqB;AACnF,uBAAA,WAAA,mBAAQ,WAAW;AAC9B,eAAS,OAAO,KAAK;AAAA,IAAA,CACtB;AAED,WAAO,MAAM;AACD,gBAAA,yBAAyB,OAAO,QAAQ;AAAA,IAAA;AAAA,KAEnD,CAAC,UAAU,WAAW,OAAO,UAAU,CAAC;AAG3C,QAAM,WAAuB;AAAA,IAC3B,GAAG;AAAA,IACH,OAAO,YAAY;AAAA,EAAA;AAGrB,6BACG,kBAAkB,UAAlB,EAA2B,OAAO,UAChC,SACH,CAAA;AAEJ,CAAC;AACD,gBAAgB,cAAc;"}

package/dist/maplibre/es/main8.mjs

@@ -0,0 +1,14 @@
+import { earthRadius } from "./main14.mjs";
+const DEG2RAD = Math.PI / 180;
+const RAD2DEG = 180 / Math.PI;
+function vector3ToCoords(position, origin) {
+  const [x, y, z] = position;
+  const latitude = origin.latitude + -z / earthRadius * RAD2DEG;
+  const longitude = origin.longitude + x / earthRadius * RAD2DEG / Math.cos(origin.latitude * DEG2RAD);
+  const altitude = (origin.altitude || 0) + y;
+  return { latitude, longitude, altitude };
+}
+export {
+  vector3ToCoords
+};
+//# sourceMappingURL=main8.mjs.map

package/dist/maplibre/es/main8.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"main8.mjs","sources":["../../../src/api/vector-3-to-coords.ts"],"sourcesContent":["import { earthRadius } from '../core/earth-radius';\nimport { Coords } from './coords';\n\nconst DEG2RAD = Math.PI / 180;\nconst RAD2DEG = 180 / Math.PI;\n\nexport function vector3ToCoords(position: [number, number, number], origin: Coords): Coords {\n  const [x, y, z] = position;\n  const latitude = origin.latitude + (-z / earthRadius) * RAD2DEG;\n  const longitude = origin.longitude + (x / earthRadius) * RAD2DEG / Math.cos(origin.latitude * DEG2RAD);\n  const altitude = (origin.altitude || 0) + y;\n  return { latitude, longitude, altitude };\n}\n"],"names":[],"mappings":";AAGA,MAAM,UAAU,KAAK,KAAK;AAC1B,MAAM,UAAU,MAAM,KAAK;AAEX,SAAA,gBAAgB,UAAoC,QAAwB;AAC1F,QAAM,CAAC,GAAG,GAAG,CAAC,IAAI;AAClB,QAAM,WAAW,OAAO,WAAY,CAAC,IAAI,cAAe;AAClD,QAAA,YAAY,OAAO,YAAa,IAAI,cAAe,UAAU,KAAK,IAAI,OAAO,WAAW,OAAO;AAC/F,QAAA,YAAY,OAAO,YAAY,KAAK;AACnC,SAAA,EAAE,UAAU,WAAW;AAChC;"}

package/dist/maplibre/es/main9.mjs

@@ -0,0 +1,26 @@
+import { useCoordsToMatrix } from "./main13.mjs";
+import { useRender } from "./main16.mjs";
+import { useRoot } from "./main17.mjs";
+function useCanvasInLayer(props, fromLngLat, map) {
+  const { latitude, longitude, altitude, frameloop } = props;
+  const origin = useCoordsToMatrix({
+    latitude,
+    longitude,
+    altitude,
+    fromLngLat
+  });
+  const { onRemove, scene, camera, babylonMap } = useRoot(fromLngLat, map, props);
+  const render = useRender({ origin, frameloop, scene, camera, map, babylonMap });
+  return {
+    id: props.id,
+    beforeId: props.beforeId,
+    onRemove,
+    render,
+    type: "custom",
+    renderingMode: "3d"
+  };
+}
+export {
+  useCanvasInLayer
+};
+//# sourceMappingURL=main9.mjs.map

package/dist/maplibre/es/main9.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"main9.mjs","sources":["../../../src/core/canvas-in-layer/use-canvas-in-layer.tsx"],"sourcesContent":["import { CanvasProps } from '../../api/canvas-props';\nimport { FromLngLat, MapInstance } from '../generic-map';\nimport { useCoordsToMatrix } from '../use-coords-to-matrix';\nimport { useRender } from './use-render';\nimport { useRoot } from './use-root';\n\n/** Get all the properties needed to render as a map `<Layer>` */\nexport function useCanvasInLayer(props: CanvasProps, fromLngLat: FromLngLat, map: MapInstance) {\n  const { latitude, longitude, altitude, frameloop } = props;\n\n  const origin = useCoordsToMatrix({\n    latitude, longitude, altitude, fromLngLat,\n  });\n\n  const { onRemove, scene, camera, babylonMap } = useRoot(fromLngLat, map, props);\n\n  const render = useRender({ origin, frameloop, scene, camera, map, babylonMap });\n\n  return {\n    id: props.id,\n    beforeId: props.beforeId,\n    onRemove,\n    render,\n    type: 'custom' as const,\n    renderingMode: '3d' as const,\n  };\n}\n"],"names":[],"mappings":";;;AAOgB,SAAA,iBAAiB,OAAoB,YAAwB,KAAkB;AAC7F,QAAM,EAAE,UAAU,WAAW,UAAU,cAAc;AAErD,QAAM,SAAS,kBAAkB;AAAA,IAC/B;AAAA,IAAU;AAAA,IAAW;AAAA,IAAU;AAAA,EAAA,CAChC;AAEK,QAAA,EAAE,UAAU,OAAO,QAAQ,eAAe,QAAQ,YAAY,KAAK,KAAK;AAExE,QAAA,SAAS,UAAU,EAAE,QAAQ,WAAW,OAAO,QAAQ,KAAK,WAAA,CAAY;AAEvE,SAAA;AAAA,IACL,IAAI,MAAM;AAAA,IACV,UAAU,MAAM;AAAA,IAChB;AAAA,IACA;AAAA,IACA,MAAM;AAAA,IACN,eAAe;AAAA,EAAA;AAEnB;"}

package/dist/maplibre/types/api/canvas-props.d.ts

@@ -0,0 +1,9 @@
+import { PropsWithChildren } from 'react';
+import { Coords } from './coords';
+export interface CanvasProps extends Coords, PropsWithChildren {
+    id?: string;
+    beforeId?: string;
+    frameloop?: 'always' | 'demand';
+    /** render on a separated `<canvas>` that sits on top of the map provider */
+    overlay?: boolean;
+}

package/dist/maplibre/types/api/coordinates.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+export interface CoordinatesProps {
+    longitude: number;
+    latitude: number;
+    altitude?: number;
+    children?: React.ReactNode;
+}
+/**
+ * Place 3D content at specific geographic coordinates inside a `<Canvas>`.
+ * Creates a sub-scene with its own camera synced to the given geo position,
+ * mirroring react-three-map's createPortal approach.
+ */
+export declare const Coordinates: import("react").NamedExoticComponent<CoordinatesProps>;

package/dist/maplibre/types/api/coords-to-vector-3.d.ts

@@ -0,0 +1,3 @@
+import { Coords } from './coords';
+export declare function averageMercatorScale(originLat: number, pointLat: number, steps?: number): number;
+export declare function coordsToVector3(point: Coords, origin: Coords): [number, number, number];

package/dist/maplibre/types/api/coords.d.ts

@@ -0,0 +1,5 @@
+export interface Coords {
+    longitude: number;
+    latitude: number;
+    altitude?: number;
+}

package/dist/maplibre/types/api/index.d.ts

@@ -0,0 +1,7 @@
+export * from './canvas-props';
+export * from './coordinates';
+export * from './coords';
+export * from './coords-to-vector-3';
+export * from './near-coordinates';
+export * from './vector-3-to-coords';
+export { useBabylonMap, BabylonMapContext } from '../core/use-babylon-map';

package/dist/maplibre/types/api/near-coordinates.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+export interface NearCoordinatesProps {
+    longitude: number;
+    latitude: number;
+    altitude?: number;
+    children?: React.ReactNode;
+}
+/**
+ * Place 3D content at a nearby coordinate (relative to the Canvas origin).
+ * Uses the sub-scene approach like Coordinates but computes a relative offset
+ * for the camera's world matrix.
+ */
+export declare const NearCoordinates: import("react").NamedExoticComponent<NearCoordinatesProps>;

package/dist/maplibre/types/api/use-map.d.ts

@@ -0,0 +1,3 @@
+import { MapInstance } from '../core/generic-map';
+/** Access the underlying map instance from inside a `<Canvas>`. */
+export declare const useMap: <T extends MapInstance = MapInstance>() => T;

package/dist/maplibre/types/api/vector-3-to-coords.d.ts

@@ -0,0 +1,2 @@
+import { Coords } from './coords';
+export declare function vector3ToCoords(position: [number, number, number], origin: Coords): Coords;

package/dist/maplibre/types/core/canvas-in-layer/use-canvas-in-layer.d.ts

@@ -0,0 +1,15 @@
+import { CanvasProps } from '../../api/canvas-props';
+import { FromLngLat, MapInstance } from '../generic-map';
+/** Get all the properties needed to render as a map `<Layer>` */
+export declare function useCanvasInLayer(props: CanvasProps, fromLngLat: FromLngLat, map: MapInstance): {
+    id: string | undefined;
+    beforeId: string | undefined;
+    onRemove: () => void;
+    render: (_gl: WebGL2RenderingContext, projViewMx: number[] | {
+        defaultProjectionData: {
+            mainMatrix: Record<string, number>;
+        };
+    }) => void;
+    type: "custom";
+    renderingMode: "3d";
+};

package/dist/maplibre/types/core/canvas-in-layer/use-render.d.ts

@@ -0,0 +1,15 @@
+import { FreeCamera, Matrix, Scene } from '@babylonjs/core';
+import { MapInstance } from '../generic-map';
+import { BabylonMap } from '../use-babylon-map';
+export declare function useRender({ map, origin, scene, camera, frameloop, babylonMap, }: {
+    map: MapInstance;
+    origin: Matrix;
+    scene: Scene;
+    camera: FreeCamera;
+    frameloop?: 'always' | 'demand';
+    babylonMap: BabylonMap;
+}): (_gl: WebGL2RenderingContext, projViewMx: number[] | {
+    defaultProjectionData: {
+        mainMatrix: Record<string, number>;
+    };
+}) => void;

package/dist/maplibre/types/core/canvas-in-layer/use-root.d.ts

@@ -0,0 +1,11 @@
+import { Engine, FreeCamera, Scene } from '@babylonjs/core';
+import { CanvasProps } from '../../api/canvas-props';
+import { BabylonMap } from '../use-babylon-map';
+import { FromLngLat, MapInstance } from '../generic-map';
+export declare function useRoot(fromLngLat: FromLngLat, map: MapInstance, { longitude, latitude, altitude, frameloop, ...props }: CanvasProps): {
+    onRemove: () => void;
+    engine: Engine;
+    scene: Scene;
+    camera: FreeCamera;
+    babylonMap: BabylonMap<MapInstance>;
+};

package/dist/maplibre/types/core/canvas-overlay/canvas-portal.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { CanvasProps } from '../../api/canvas-props';
+import { FromLngLat, MapInstance } from '../generic-map';
+interface CanvasPortalProps extends CanvasProps {
+    setOnRender: (callback: () => (mx: number[]) => void) => void;
+    map: MapInstance;
+    fromLngLat: FromLngLat;
+}
+export declare const CanvasPortal: import("react").NamedExoticComponent<CanvasPortalProps>;
+export {};

package/dist/maplibre/types/core/canvas-overlay/init-canvas-fc.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { CanvasProps } from '../../api/canvas-props';
+import { FromLngLat, MapInstance } from '../generic-map';
+interface InitCanvasFCProps extends CanvasProps {
+    map: MapInstance;
+    setOnRender: (callback: () => (mx: number[]) => void) => void;
+    frameloop?: 'always' | 'demand';
+    fromLngLat: FromLngLat;
+}
+export declare const InitCanvasFC: import("react").NamedExoticComponent<InitCanvasFCProps>;
+export {};

package/dist/maplibre/types/core/canvas-overlay/render.d.ts

@@ -0,0 +1 @@
+export type Render = (gl: WebGLRenderingContext, matrix: number[]) => void;

package/dist/maplibre/types/core/canvas-overlay/sync-camera-fc.d.ts

@@ -0,0 +1,12 @@
+import { RefObject } from 'react';
+import { Coords } from '../../api/coords';
+import { MapInstance } from '../generic-map';
+interface SyncCameraFCProps extends Coords {
+    setOnRender?: (callback: () => (mx: number[]) => void) => void;
+    onReady?: () => void;
+    map: MapInstance;
+    canvasRef: RefObject<HTMLCanvasElement | null>;
+}
+/** React component to sync the Babylon camera with the map provider on each render. */
+export declare const SyncCameraFC: import("react").NamedExoticComponent<SyncCameraFCProps>;
+export {};

package/dist/maplibre/types/core/coords-to-matrix.d.ts

@@ -0,0 +1,9 @@
+import { Matrix } from '@babylonjs/core';
+import { FromLngLat } from './generic-map';
+import { Coords } from '../api/coords';
+/** Calculate Babylon.js Matrix from coordinates.
+ *  Returns a Babylon Matrix (world transform at the given geo coord).
+ *  Matches the pattern from MapLibre + Babylon.js integration demo. */
+export declare function coordsToMatrix({ longitude, latitude, altitude, fromLngLat }: Coords & {
+    fromLngLat: FromLngLat;
+}): Matrix;

package/dist/maplibre/types/core/earth-radius.d.ts

@@ -0,0 +1 @@
+export declare const earthRadius = 6371008.8;

package/dist/maplibre/types/core/generic-map.d.ts

@@ -0,0 +1,49 @@
+/** Generic interface of Mapbox/Maplibre `LayerProps` */
+export interface LayerProps {
+    id: string;
+    type: 'custom';
+    renderingMode: '3d';
+    onRemove?(map: MapInstance, gl: WebGLRenderingContext): void;
+    onAdd?(map: MapInstance, gl: WebGLRenderingContext): void;
+    prerender?(gl: WebGLRenderingContext, matrix: number[]): void;
+    render(gl: WebGLRenderingContext, matrix: number[]): void;
+}
+/** Generic interface of Mapbox/Maplibre `LngLatLike` */
+export type LngLatLike = {
+    lng: number;
+    lat: number;
+} | {
+    lon: number;
+    lat: number;
+} | [
+    number,
+    number
+];
+/** Generic interface of Mapbox/Maplibre `static MercatorCoordinate.fromLngLat` */
+export type FromLngLat = (lngLatLike: LngLatLike, altitude?: number) => MercatorCoordinate;
+/** Generic interface of Mapbox/Maplibre typeof `MercatorCoordinate` */
+export interface MercatorCoordinate {
+    x: number;
+    y: number;
+    z?: number;
+    meterInMercatorCoordinateUnits(): number;
+}
+/** Generic interface of Mapbox/Maplibre `Map` */
+export interface MapInstance {
+    getCanvas(): HTMLCanvasElement;
+    /** MapLibre only */
+    getPixelRatio?: () => number;
+    triggerRepaint(): void;
+    on<T extends keyof MapEventType>(type: T, listener: (ev: MapEventType[T] & Object) => void): void;
+    off<T extends keyof MapEventType>(type: T, listener: (ev: MapEventType[T] & Object) => void): void;
+}
+/** Generic interface of Mapbox/Maplibre `MapEventType` */
+export type MapEventType = {
+    resize: MapEvent;
+};
+/** Generic interface of `MapLibreEvent` or `MapBoxEvent` */
+export interface MapEvent<TOrig = unknown> {
+    type: string;
+    target: MapInstance;
+    originalEvent: TOrig;
+}

package/dist/maplibre/types/core/matrix-utils.d.ts

@@ -0,0 +1,7 @@
+import { Matrix } from '@babylonjs/core';
+/** Column-major (MapLibre) → transposed flat array (Babylon row-major layout) */
+export declare function transposeMatrix(m: number[]): number[];
+/** MapLibre column-major matrix → Babylon.js Matrix */
+export declare function columnMajorToBabylonMatrix(m: number[]): Matrix;
+/** Extract a flat column-major array from a Babylon Matrix (for MapLibre interop) */
+export declare function babylonMatrixToColumnMajor(m: Matrix): number[];

package/dist/maplibre/types/core/sync-camera.d.ts

@@ -0,0 +1,7 @@
+import { FreeCamera, Matrix } from '@babylonjs/core';
+/** Synchronise a Babylon camera with the map's view-projection matrix.
+ *  @param camera   The Babylon camera to update.
+ *  @param origin   Babylon world matrix for the Canvas origin.
+ *  @param mapCamMx Flat array from MapLibre's view-projection (column-major).
+ */
+export declare function syncCamera(camera: FreeCamera, origin: Matrix, mapCamMx: number[]): void;

package/dist/maplibre/types/core/use-babylon-map.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="react" />
+import { Engine, Scene } from '@babylonjs/core';
+import { FromLngLat, MapInstance } from './generic-map';
+/** Context object shared between both rendering modes. */
+export interface BabylonMap<T extends MapInstance = MapInstance> {
+    /** Map provider instance */
+    map: T;
+    /** Column-major view-projection matrix from the map provider */
+    viewProjMx: number[];
+    /** Mercator coordinate factory */
+    fromLngLat: FromLngLat;
+    /** Babylon Engine (may be null during init) */
+    engine?: Engine;
+    /** Babylon Scene (may be null during init) */
+    scene?: Scene;
+    /** Current origin coordinates (set by Canvas) */
+    coords?: {
+        longitude: number;
+        latitude: number;
+        altitude?: number;
+    };
+}
+export declare const BabylonMapContext: import("react").Context<BabylonMap<MapInstance> | null>;
+/** Access the current BabylonMap context (map, scene, engine, viewProjMx). */
+export declare function useBabylonMap<T extends MapInstance = MapInstance>(): BabylonMap<T>;
+/** Initialise / update the BabylonMap context value. */
+export declare function createBabylonMap<T extends MapInstance>(opts: {
+    map: T;
+    fromLngLat: FromLngLat;
+    engine?: Engine;
+    scene?: Scene;
+}): BabylonMap<T>;

package/dist/maplibre/types/core/use-coords-to-matrix.d.ts

@@ -0,0 +1,6 @@
+import { Matrix } from '@babylonjs/core';
+import { coordsToMatrix } from './coords-to-matrix';
+type Props = Parameters<typeof coordsToMatrix>[0];
+/** Calculate a Babylon Matrix from coordinates (memoised). */
+export declare function useCoordsToMatrix({ latitude, longitude, altitude, fromLngLat }: Props): Matrix;
+export {};

package/dist/maplibre/types/core/use-coords.d.ts

@@ -0,0 +1,5 @@
+import { Coords } from '../api/coords';
+/** Read the current coordinates from context. */
+export declare function useCoords(): Coords;
+/** Update the coordinates stored on the context. */
+export declare function useSetCoords({ longitude, latitude, altitude }: Coords): void;

package/dist/maplibre/types/core/use-function.d.ts

@@ -0,0 +1 @@
+export declare const useFunction: <T extends (...args: any[]) => any>(callback: T) => T;

package/dist/maplibre/types/maplibre/canvas.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { CanvasProps } from '../api/canvas-props';
+/** `react-babylon-map` canvas inside `MapLibre` */
+export declare const Canvas: import("react").NamedExoticComponent<CanvasProps>;

package/dist/maplibre/types/maplibre.index.d.ts

@@ -0,0 +1,4 @@
+import type { Map } from 'maplibre-gl';
+export * from './api';
+export * from './maplibre/canvas';
+export declare const useMap: () => Map;

package/dist/types/api/canvas-props.d.ts

@@ -0,0 +1,9 @@
+import { PropsWithChildren } from 'react';
+import { Coords } from './coords';
+export interface CanvasProps extends Coords, PropsWithChildren {
+    id?: string;
+    beforeId?: string;
+    frameloop?: 'always' | 'demand';
+    /** render on a separated `<canvas>` that sits on top of the map provider */
+    overlay?: boolean;
+}

package/dist/types/api/coordinates.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+export interface CoordinatesProps {
+    longitude: number;
+    latitude: number;
+    altitude?: number;
+    children?: React.ReactNode;
+}
+/**
+ * Place 3D content at specific geographic coordinates inside a `<Canvas>`.
+ * Creates a sub-scene with its own camera synced to the given geo position,
+ * mirroring react-three-map's createPortal approach.
+ */
+export declare const Coordinates: import("react").NamedExoticComponent<CoordinatesProps>;

package/dist/types/api/coords-to-vector-3.d.ts

@@ -0,0 +1,3 @@
+import { Coords } from './coords';
+export declare function averageMercatorScale(originLat: number, pointLat: number, steps?: number): number;
+export declare function coordsToVector3(point: Coords, origin: Coords): [number, number, number];

package/dist/types/api/coords.d.ts

@@ -0,0 +1,5 @@
+export interface Coords {
+    longitude: number;
+    latitude: number;
+    altitude?: number;
+}

package/dist/types/api/index.d.ts

@@ -0,0 +1,7 @@
+export * from './canvas-props';
+export * from './coordinates';
+export * from './coords';
+export * from './coords-to-vector-3';
+export * from './near-coordinates';
+export * from './vector-3-to-coords';
+export { useBabylonMap, BabylonMapContext } from '../core/use-babylon-map';

package/dist/types/api/near-coordinates.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+export interface NearCoordinatesProps {
+    longitude: number;
+    latitude: number;
+    altitude?: number;
+    children?: React.ReactNode;
+}
+/**
+ * Place 3D content at a nearby coordinate (relative to the Canvas origin).
+ * Uses the sub-scene approach like Coordinates but computes a relative offset
+ * for the camera's world matrix.
+ */
+export declare const NearCoordinates: import("react").NamedExoticComponent<NearCoordinatesProps>;

package/dist/types/api/use-map.d.ts

@@ -0,0 +1,3 @@
+import { MapInstance } from '../core/generic-map';
+/** Access the underlying map instance from inside a `<Canvas>`. */
+export declare const useMap: <T extends MapInstance = MapInstance>() => T;

package/dist/types/api/vector-3-to-coords.d.ts

@@ -0,0 +1,2 @@
+import { Coords } from './coords';
+export declare function vector3ToCoords(position: [number, number, number], origin: Coords): Coords;

package/dist/types/core/canvas-in-layer/use-canvas-in-layer.d.ts

@@ -0,0 +1,15 @@
+import { CanvasProps } from '../../api/canvas-props';
+import { FromLngLat, MapInstance } from '../generic-map';
+/** Get all the properties needed to render as a map `<Layer>` */
+export declare function useCanvasInLayer(props: CanvasProps, fromLngLat: FromLngLat, map: MapInstance): {
+    id: string | undefined;
+    beforeId: string | undefined;
+    onRemove: () => void;
+    render: (_gl: WebGL2RenderingContext, projViewMx: number[] | {
+        defaultProjectionData: {
+            mainMatrix: Record<string, number>;
+        };
+    }) => void;
+    type: "custom";
+    renderingMode: "3d";
+};

package/dist/types/core/canvas-in-layer/use-render.d.ts

@@ -0,0 +1,15 @@
+import { FreeCamera, Matrix, Scene } from '@babylonjs/core';
+import { MapInstance } from '../generic-map';
+import { BabylonMap } from '../use-babylon-map';
+export declare function useRender({ map, origin, scene, camera, frameloop, babylonMap, }: {
+    map: MapInstance;
+    origin: Matrix;
+    scene: Scene;
+    camera: FreeCamera;
+    frameloop?: 'always' | 'demand';
+    babylonMap: BabylonMap;
+}): (_gl: WebGL2RenderingContext, projViewMx: number[] | {
+    defaultProjectionData: {
+        mainMatrix: Record<string, number>;
+    };
+}) => void;

package/dist/types/core/canvas-in-layer/use-root.d.ts

@@ -0,0 +1,11 @@
+import { Engine, FreeCamera, Scene } from '@babylonjs/core';
+import { CanvasProps } from '../../api/canvas-props';
+import { BabylonMap } from '../use-babylon-map';
+import { FromLngLat, MapInstance } from '../generic-map';
+export declare function useRoot(fromLngLat: FromLngLat, map: MapInstance, { longitude, latitude, altitude, frameloop, ...props }: CanvasProps): {
+    onRemove: () => void;
+    engine: Engine;
+    scene: Scene;
+    camera: FreeCamera;
+    babylonMap: BabylonMap<MapInstance>;
+};

package/dist/types/core/canvas-overlay/canvas-portal.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { CanvasProps } from '../../api/canvas-props';
+import { FromLngLat, MapInstance } from '../generic-map';
+interface CanvasPortalProps extends CanvasProps {
+    setOnRender: (callback: () => (mx: number[]) => void) => void;
+    map: MapInstance;
+    fromLngLat: FromLngLat;
+}
+export declare const CanvasPortal: import("react").NamedExoticComponent<CanvasPortalProps>;
+export {};

package/dist/types/core/canvas-overlay/init-canvas-fc.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { CanvasProps } from '../../api/canvas-props';
+import { FromLngLat, MapInstance } from '../generic-map';
+interface InitCanvasFCProps extends CanvasProps {
+    map: MapInstance;
+    setOnRender: (callback: () => (mx: number[]) => void) => void;
+    frameloop?: 'always' | 'demand';
+    fromLngLat: FromLngLat;
+}
+export declare const InitCanvasFC: import("react").NamedExoticComponent<InitCanvasFCProps>;
+export {};

package/dist/types/core/canvas-overlay/render.d.ts

@@ -0,0 +1 @@
+export type Render = (gl: WebGLRenderingContext, matrix: number[]) => void;

package/dist/types/core/canvas-overlay/sync-camera-fc.d.ts

@@ -0,0 +1,12 @@
+import { RefObject } from 'react';
+import { Coords } from '../../api/coords';
+import { MapInstance } from '../generic-map';
+interface SyncCameraFCProps extends Coords {
+    setOnRender?: (callback: () => (mx: number[]) => void) => void;
+    onReady?: () => void;
+    map: MapInstance;
+    canvasRef: RefObject<HTMLCanvasElement | null>;
+}
+/** React component to sync the Babylon camera with the map provider on each render. */
+export declare const SyncCameraFC: import("react").NamedExoticComponent<SyncCameraFCProps>;
+export {};

package/dist/types/core/coords-to-matrix.d.ts

@@ -0,0 +1,9 @@
+import { Matrix } from '@babylonjs/core';
+import { FromLngLat } from './generic-map';
+import { Coords } from '../api/coords';
+/** Calculate Babylon.js Matrix from coordinates.
+ *  Returns a Babylon Matrix (world transform at the given geo coord).
+ *  Matches the pattern from MapLibre + Babylon.js integration demo. */
+export declare function coordsToMatrix({ longitude, latitude, altitude, fromLngLat }: Coords & {
+    fromLngLat: FromLngLat;
+}): Matrix;

package/dist/types/core/earth-radius.d.ts

@@ -0,0 +1 @@
+export declare const earthRadius = 6371008.8;

package/dist/types/core/generic-map.d.ts

@@ -0,0 +1,49 @@
+/** Generic interface of Mapbox/Maplibre `LayerProps` */
+export interface LayerProps {
+    id: string;
+    type: 'custom';
+    renderingMode: '3d';
+    onRemove?(map: MapInstance, gl: WebGLRenderingContext): void;
+    onAdd?(map: MapInstance, gl: WebGLRenderingContext): void;
+    prerender?(gl: WebGLRenderingContext, matrix: number[]): void;
+    render(gl: WebGLRenderingContext, matrix: number[]): void;
+}
+/** Generic interface of Mapbox/Maplibre `LngLatLike` */
+export type LngLatLike = {
+    lng: number;
+    lat: number;
+} | {
+    lon: number;
+    lat: number;
+} | [
+    number,
+    number
+];
+/** Generic interface of Mapbox/Maplibre `static MercatorCoordinate.fromLngLat` */
+export type FromLngLat = (lngLatLike: LngLatLike, altitude?: number) => MercatorCoordinate;
+/** Generic interface of Mapbox/Maplibre typeof `MercatorCoordinate` */
+export interface MercatorCoordinate {
+    x: number;
+    y: number;
+    z?: number;
+    meterInMercatorCoordinateUnits(): number;
+}
+/** Generic interface of Mapbox/Maplibre `Map` */
+export interface MapInstance {
+    getCanvas(): HTMLCanvasElement;
+    /** MapLibre only */
+    getPixelRatio?: () => number;
+    triggerRepaint(): void;
+    on<T extends keyof MapEventType>(type: T, listener: (ev: MapEventType[T] & Object) => void): void;
+    off<T extends keyof MapEventType>(type: T, listener: (ev: MapEventType[T] & Object) => void): void;
+}
+/** Generic interface of Mapbox/Maplibre `MapEventType` */
+export type MapEventType = {
+    resize: MapEvent;
+};
+/** Generic interface of `MapLibreEvent` or `MapBoxEvent` */
+export interface MapEvent<TOrig = unknown> {
+    type: string;
+    target: MapInstance;
+    originalEvent: TOrig;
+}

package/dist/types/core/matrix-utils.d.ts

@@ -0,0 +1,7 @@
+import { Matrix } from '@babylonjs/core';
+/** Column-major (MapLibre) → transposed flat array (Babylon row-major layout) */
+export declare function transposeMatrix(m: number[]): number[];
+/** MapLibre column-major matrix → Babylon.js Matrix */
+export declare function columnMajorToBabylonMatrix(m: number[]): Matrix;
+/** Extract a flat column-major array from a Babylon Matrix (for MapLibre interop) */
+export declare function babylonMatrixToColumnMajor(m: Matrix): number[];

package/dist/types/core/sync-camera.d.ts

@@ -0,0 +1,7 @@
+import { FreeCamera, Matrix } from '@babylonjs/core';
+/** Synchronise a Babylon camera with the map's view-projection matrix.
+ *  @param camera   The Babylon camera to update.
+ *  @param origin   Babylon world matrix for the Canvas origin.
+ *  @param mapCamMx Flat array from MapLibre's view-projection (column-major).
+ */
+export declare function syncCamera(camera: FreeCamera, origin: Matrix, mapCamMx: number[]): void;