@treasuryspatial/map-kit 0.1.0

package/dist/footprint.d.ts

@@ -0,0 +1,17 @@
+import type { Feature, MultiPolygon, Polygon } from 'geojson';
+import type { FootprintStats } from './types';
+export declare function getOuterRing(geometry: Polygon | MultiPolygon): number[][];
+export declare function toPolygonFeature(feature: Feature<Polygon | MultiPolygon>): Feature<Polygon> | null;
+export declare function computeCentroid(ring: number[][]): {
+    lng: number;
+    lat: number;
+} | null;
+export declare function ensureClosedRing(ring: number[][]): number[][];
+export declare function toLocalMeters(ring: number[][], origin: {
+    lng: number;
+    lat: number;
+}, mapboxgl: typeof import('mapbox-gl')): number[][];
+export declare function buildGeoJsonPolygon(pointsLocal: number[][]): string;
+export declare function computeFootprintStats(pointsLocal: number[][]): FootprintStats;
+export declare function simplifyRing(pointsLocal: number[][], epsilon: number): number[][];
+//# sourceMappingURL=footprint.d.ts.map

package/dist/footprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"footprint.d.ts","sourceRoot":"","sources":["../src/footprint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAE9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,wBAAgB,YAAY,CAAC,QAAQ,EAAE,OAAO,GAAG,YAAY,GAAG,MAAM,EAAE,EAAE,CAKzE;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,GAAG,YAAY,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAgBlG;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAcrF;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,EAAE,CAM7D;AAED,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EAAE,EAAE,EAChB,MAAM,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EACpC,QAAQ,EAAE,cAAc,WAAW,CAAC,GACnC,MAAM,EAAE,EAAE,CAWZ;AAED,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,CAMnE;AAQD,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,GAAG,cAAc,CAyB7E;AAkCD,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,CAMjF"}

package/dist/footprint.js

@@ -0,0 +1,147 @@
+export function getOuterRing(geometry) {
+    if (geometry.type === 'Polygon') {
+        return geometry.coordinates?.[0] ?? [];
+    }
+    return geometry.coordinates?.[0]?.[0] ?? [];
+}
+export function toPolygonFeature(feature) {
+    if (!feature.geometry)
+        return null;
+    const geometry = feature.geometry;
+    if (geometry.type === 'Polygon') {
+        return { type: 'Feature', properties: feature.properties ?? {}, geometry };
+    }
+    if (geometry.type === 'MultiPolygon') {
+        const coords = geometry.coordinates?.[0];
+        if (!coords)
+            return null;
+        return {
+            type: 'Feature',
+            properties: feature.properties ?? {},
+            geometry: { type: 'Polygon', coordinates: coords },
+        };
+    }
+    return null;
+}
+export function computeCentroid(ring) {
+    if (!ring.length)
+        return null;
+    let minLng = Number.POSITIVE_INFINITY;
+    let maxLng = Number.NEGATIVE_INFINITY;
+    let minLat = Number.POSITIVE_INFINITY;
+    let maxLat = Number.NEGATIVE_INFINITY;
+    ring.forEach(([lng, lat]) => {
+        if (lng < minLng)
+            minLng = lng;
+        if (lng > maxLng)
+            maxLng = lng;
+        if (lat < minLat)
+            minLat = lat;
+        if (lat > maxLat)
+            maxLat = lat;
+    });
+    if (!Number.isFinite(minLng) || !Number.isFinite(minLat))
+        return null;
+    return { lng: (minLng + maxLng) / 2, lat: (minLat + maxLat) / 2 };
+}
+export function ensureClosedRing(ring) {
+    if (ring.length < 3)
+        return ring;
+    const [x0, y0] = ring[0];
+    const [x1, y1] = ring[ring.length - 1];
+    if (x0 === x1 && y0 === y1)
+        return ring;
+    return [...ring, [x0, y0]];
+}
+export function toLocalMeters(ring, origin, mapboxgl) {
+    const originMc = mapboxgl.MercatorCoordinate.fromLngLat(origin);
+    const unitsPerMeter = originMc.meterInMercatorCoordinateUnits();
+    return ring
+        .map(([lng, lat]) => {
+        const mc = mapboxgl.MercatorCoordinate.fromLngLat({ lng, lat });
+        const dx = (mc.x - originMc.x) / unitsPerMeter;
+        const dy = (originMc.y - mc.y) / unitsPerMeter; // north-positive
+        return [Number(dx.toFixed(3)), Number(dy.toFixed(3))];
+    })
+        .filter((pt) => Number.isFinite(pt[0]) && Number.isFinite(pt[1]));
+}
+export function buildGeoJsonPolygon(pointsLocal) {
+    const ring = ensureClosedRing(pointsLocal);
+    return JSON.stringify({
+        type: 'Polygon',
+        coordinates: [ring],
+    });
+}
+function distance(a, b) {
+    const dx = a[0] - b[0];
+    const dy = a[1] - b[1];
+    return Math.hypot(dx, dy);
+}
+export function computeFootprintStats(pointsLocal) {
+    const ring = ensureClosedRing(pointsLocal);
+    const vertexCount = ring.length;
+    let area = 0;
+    let perimeter = 0;
+    let minEdge = Number.POSITIVE_INFINITY;
+    let maxEdge = 0;
+    for (let i = 0; i < ring.length - 1; i += 1) {
+        const [x1, y1] = ring[i];
+        const [x2, y2] = ring[i + 1];
+        area += x1 * y2 - x2 * y1;
+        const edge = distance(ring[i], ring[i + 1]);
+        perimeter += edge;
+        if (edge < minEdge)
+            minEdge = edge;
+        if (edge > maxEdge)
+            maxEdge = edge;
+    }
+    area = Math.abs(area) / 2;
+    if (!Number.isFinite(minEdge))
+        minEdge = 0;
+    const warnings = [];
+    if (vertexCount > 200)
+        warnings.push('Footprint is very detailed (>200 vertices).');
+    if (minEdge > 0 && minEdge < 0.5)
+        warnings.push('Footprint has tiny edges (<0.5m).');
+    return { vertexCount, area, perimeter, minEdge, maxEdge, warnings };
+}
+function perpendicularDistance(point, lineStart, lineEnd) {
+    const [x, y] = point;
+    const [x1, y1] = lineStart;
+    const [x2, y2] = lineEnd;
+    const dx = x2 - x1;
+    const dy = y2 - y1;
+    if (dx === 0 && dy === 0)
+        return Math.hypot(x - x1, y - y1);
+    const t = ((x - x1) * dx + (y - y1) * dy) / (dx * dx + dy * dy);
+    const projX = x1 + t * dx;
+    const projY = y1 + t * dy;
+    return Math.hypot(x - projX, y - projY);
+}
+function simplifyRdp(points, epsilon) {
+    if (points.length <= 2)
+        return points;
+    let maxDistance = 0;
+    let index = 0;
+    for (let i = 1; i < points.length - 1; i += 1) {
+        const dist = perpendicularDistance(points[i], points[0], points[points.length - 1]);
+        if (dist > maxDistance) {
+            maxDistance = dist;
+            index = i;
+        }
+    }
+    if (maxDistance > epsilon) {
+        const left = simplifyRdp(points.slice(0, index + 1), epsilon);
+        const right = simplifyRdp(points.slice(index), epsilon);
+        return [...left.slice(0, -1), ...right];
+    }
+    return [points[0], points[points.length - 1]];
+}
+export function simplifyRing(pointsLocal, epsilon) {
+    if (epsilon <= 0)
+        return ensureClosedRing(pointsLocal);
+    const ring = ensureClosedRing(pointsLocal);
+    const open = ring.slice(0, -1);
+    const simplified = simplifyRdp(open, epsilon);
+    return ensureClosedRing(simplified);
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './footprint';
+export * from './mapLayers';
+export * from './mapThreeLayer';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './footprint';
+export * from './mapLayers';
+export * from './mapThreeLayer';

package/dist/mapLayers.d.ts

@@ -0,0 +1,8 @@
+import type { Feature, Polygon } from 'geojson';
+export type FootprintLayerController = {
+    setHover: (feature: Feature<Polygon> | null) => void;
+    setSelected: (feature: Feature<Polygon> | null) => void;
+    destroy: () => void;
+};
+export declare function ensureFootprintLayers(map: mapboxgl.Map): FootprintLayerController;
+//# sourceMappingURL=mapLayers.d.ts.map

package/dist/mapLayers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapLayers.d.ts","sourceRoot":"","sources":["../src/mapLayers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAKhD,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,KAAK,IAAI,CAAC;IACrD,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,KAAK,IAAI,CAAC;IACxD,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC;AAiBF,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,QAAQ,CAAC,GAAG,GAAG,wBAAwB,CAkFjF"}

package/dist/mapLayers.js

@@ -0,0 +1,95 @@
+const EMPTY_FC = { type: 'FeatureCollection', features: [] };
+function ensureCompositeSource(map) {
+    if (!map.getSource('composite')) {
+        map.addSource('composite', {
+            type: 'vector',
+            url: 'mapbox://mapbox.mapbox-streets-v8',
+        });
+    }
+}
+function ensureLayer(map, layer, beforeId) {
+    if (!map.getLayer(layer.id)) {
+        map.addLayer(layer, beforeId);
+    }
+}
+export function ensureFootprintLayers(map) {
+    ensureCompositeSource(map);
+    ensureLayer(map, {
+        id: 'building-footprints-fill',
+        type: 'fill',
+        source: 'composite',
+        'source-layer': 'building',
+        paint: {
+            'fill-color': '#000000',
+            'fill-opacity': 0.01,
+        },
+    });
+    ensureLayer(map, {
+        id: 'building-footprints-outline',
+        type: 'line',
+        source: 'composite',
+        'source-layer': 'building',
+        paint: {
+            'line-color': '#ffffff',
+            'line-width': 1,
+            'line-opacity': 0.5,
+        },
+    });
+    if (!map.getSource('footprint-hover')) {
+        map.addSource('footprint-hover', {
+            type: 'geojson',
+            data: EMPTY_FC,
+        });
+    }
+    ensureLayer(map, {
+        id: 'footprint-hover-line',
+        type: 'line',
+        source: 'footprint-hover',
+        paint: {
+            'line-color': '#f8d34a',
+            'line-width': 2,
+            'line-opacity': 0.9,
+        },
+    });
+    if (!map.getSource('footprint-selected')) {
+        map.addSource('footprint-selected', {
+            type: 'geojson',
+            data: EMPTY_FC,
+        });
+    }
+    ensureLayer(map, {
+        id: 'footprint-selected-line',
+        type: 'line',
+        source: 'footprint-selected',
+        paint: {
+            'line-color': '#6ee7ff',
+            'line-width': 3,
+            'line-opacity': 1,
+        },
+    });
+    const setSource = (id, feature) => {
+        const src = map.getSource(id);
+        if (!src)
+            return;
+        if (!feature) {
+            src.setData(EMPTY_FC);
+            return;
+        }
+        src.setData({ type: 'FeatureCollection', features: [feature] });
+    };
+    return {
+        setHover: (feature) => setSource('footprint-hover', feature),
+        setSelected: (feature) => setSource('footprint-selected', feature),
+        destroy: () => {
+            const layers = ['footprint-selected-line', 'footprint-hover-line', 'building-footprints-outline', 'building-footprints-fill'];
+            layers.forEach((id) => {
+                if (map.getLayer(id))
+                    map.removeLayer(id);
+            });
+            if (map.getSource('footprint-selected'))
+                map.removeSource('footprint-selected');
+            if (map.getSource('footprint-hover'))
+                map.removeSource('footprint-hover');
+        },
+    };
+}

package/dist/mapThreeLayer.d.ts

@@ -0,0 +1,18 @@
+import * as THREE from 'three';
+export type MapThreeLayer = {
+    layer: mapboxgl.CustomLayerInterface;
+    setGroup: (group: THREE.Group | null) => void;
+    setOrigin: (origin: {
+        lng: number;
+        lat: number;
+    } | null) => void;
+    setZOffsetMeters: (offset: number) => void;
+    dispose: () => void;
+};
+export type MapThreeLayerOptions = {
+    id: string;
+    zOffsetMeters?: number;
+    onInit?: (scene: THREE.Scene, renderer: THREE.WebGLRenderer, camera: THREE.Camera) => void;
+};
+export declare function createMapThreeLayer(options: MapThreeLayerOptions): MapThreeLayer;
+//# sourceMappingURL=mapThreeLayer.d.ts.map

package/dist/mapThreeLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapThreeLayer.d.ts","sourceRoot":"","sources":["../src/mapThreeLayer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,QAAQ,CAAC,oBAAoB,CAAC;IACrC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,GAAG,IAAI,KAAK,IAAI,CAAC;IAC9C,SAAS,EAAE,CAAC,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,KAAK,IAAI,CAAC;IACjE,gBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3C,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC;CAC5F,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,oBAAoB,GAAG,aAAa,CA0FhF"}

package/dist/mapThreeLayer.js

@@ -0,0 +1,87 @@
+import mapboxgl from 'mapbox-gl';
+import * as THREE from 'three';
+export function createMapThreeLayer(options) {
+    const { id, zOffsetMeters = 0.02, onInit } = options;
+    let mapRef = null;
+    let scene = null;
+    let camera = null;
+    let renderer = null;
+    let rootGroup = null;
+    let meshGroup = null;
+    let mercatorOrigin = null;
+    let meterScale = 1;
+    let zOffset = zOffsetMeters;
+    const layer = {
+        id,
+        type: 'custom',
+        renderingMode: '3d',
+        onAdd: (map, gl) => {
+            mapRef = map;
+            scene = new THREE.Scene();
+            camera = new THREE.Camera();
+            renderer = new THREE.WebGLRenderer({
+                canvas: map.getCanvas(),
+                context: gl,
+                antialias: true,
+            });
+            renderer.autoClear = false;
+            renderer.outputColorSpace = THREE.SRGBColorSpace;
+            renderer.toneMapping = THREE.NeutralToneMapping;
+            renderer.toneMappingExposure = 1.05;
+            rootGroup = new THREE.Group();
+            rootGroup.matrixAutoUpdate = false;
+            scene.add(rootGroup);
+            if (meshGroup)
+                rootGroup.add(meshGroup);
+            if (onInit && renderer && camera)
+                onInit(scene, renderer, camera);
+        },
+        render: (_gl, matrix) => {
+            if (!renderer || !scene || !camera || !rootGroup)
+                return;
+            camera.projectionMatrix = new THREE.Matrix4().fromArray(matrix);
+            if (mercatorOrigin) {
+                const translate = new THREE.Matrix4().makeTranslation(mercatorOrigin.x, mercatorOrigin.y, (mercatorOrigin.z ?? 0) + zOffset * meterScale);
+                const scale = new THREE.Matrix4().makeScale(meterScale, -meterScale, meterScale);
+                rootGroup.matrix = new THREE.Matrix4().multiplyMatrices(translate, scale);
+                rootGroup.matrixWorldNeedsUpdate = true;
+            }
+            renderer.resetState();
+            renderer.render(scene, camera);
+            mapRef?.triggerRepaint();
+        },
+    };
+    return {
+        layer,
+        setGroup: (group) => {
+            meshGroup = group;
+            if (rootGroup) {
+                rootGroup.clear();
+                if (meshGroup)
+                    rootGroup.add(meshGroup);
+            }
+        },
+        setOrigin: (origin) => {
+            if (!origin) {
+                mercatorOrigin = null;
+                return;
+            }
+            mercatorOrigin = mapboxgl.MercatorCoordinate.fromLngLat(origin);
+            meterScale = mercatorOrigin.meterInMercatorCoordinateUnits();
+        },
+        setZOffsetMeters: (offset) => {
+            zOffset = offset;
+        },
+        dispose: () => {
+            if (rootGroup) {
+                rootGroup.clear();
+            }
+            meshGroup = null;
+            scene = null;
+            camera = null;
+            renderer = null;
+            mapRef = null;
+            mercatorOrigin = null;
+        },
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,26 @@
+export type MapView = {
+    center: {
+        lng: number;
+        lat: number;
+    };
+    zoom: number;
+    bearing: number;
+    pitch: number;
+};
+export type MapFootprintSelection = {
+    geojson: string;
+    origin: {
+        lng: number;
+        lat: number;
+    };
+    mapView: MapView;
+};
+export type FootprintStats = {
+    vertexCount: number;
+    area: number;
+    perimeter: number;
+    minEdge: number;
+    maxEdge: number;
+    warnings: string[];
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG;IACpB,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IACrC,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@treasuryspatial/map-kit",
+  "version": "0.1.0",
+  "type": "module",
+  "license": "UNLICENSED",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "mapbox-gl": "^3.13.0",
+    "three": "^0.178.0"
+  },
+  "devDependencies": {
+    "mapbox-gl": "^3.13.0",
+    "three": "^0.178.0",
+    "@types/mapbox-gl": "^2.7.21",
+    "@types/geojson": "^7946.0.16"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "typecheck": "tsc -b --pretty false --noEmit"
+  }
+}