@deck.gl-community/editable-layers 9.0.0-alpha.1

package/dist/index.d.ts

@@ -0,0 +1,60 @@
+export { ArrowStyles, DEFAULT_ARROWS, MAX_ARROWS } from './lib/style';
+export { SELECTION_TYPE } from './lib/deck-renderer/deck-drawer';
+export { default as Feature } from './lib/feature';
+export { default as LayerMouseEvent } from './lib/layer-mouse-event';
+export { default as NebulaLayer } from './lib/nebula-layer';
+export { default as JunctionsLayer } from './lib/layers/junctions-layer';
+export { default as TextsLayer } from './lib/layers/texts-layer';
+export { default as SegmentsLayer } from './lib/layers/segments-layer';
+export { default as NebulaCore } from './lib/nebula';
+export { PROJECTED_PIXEL_SIZE_MULTIPLIER } from './lib/constants';
+export { toDeckColor } from './utils';
+export type { Color, Style, Viewport } from './types';
+export { default as EditableGeoJsonLayer } from './editable-layers/editable-geojson-layer';
+export { default as EditableH3ClusterLayer } from './editable-layers/editable-h3-cluster-layer';
+export { default as SelectionLayer } from './editable-layers/selection-layer';
+export { default as ElevatedEditHandleLayer } from './editable-layers/elevated-edit-handle-layer';
+export { default as PathOutlineLayer } from './editable-layers/path-outline-layer/path-outline-layer';
+export { default as PathMarkerLayer } from './editable-layers/path-marker-layer/path-marker-layer';
+export { default as JunctionScatterplotLayer } from './editable-layers/junction-scatterplot-layer';
+import * as utils from './utils';
+export { utils };
+export type { EditMode } from './edit-modes/edit-mode';
+export type { GeoJsonEditModeType } from './edit-modes/geojson-edit-mode';
+export type { GeoJsonEditModeConstructor } from './edit-modes/geojson-edit-mode';
+export { GeoJsonEditMode } from './edit-modes/geojson-edit-mode';
+export { ModifyMode } from './edit-modes/modify-mode';
+export { ResizeCircleMode } from './edit-modes/resize-circle-mode';
+export { TranslateMode } from './edit-modes/translate-mode';
+export { ScaleMode } from './edit-modes/scale-mode';
+export { RotateMode } from './edit-modes/rotate-mode';
+export { DuplicateMode } from './edit-modes/duplicate-mode';
+export { ExtendLineStringMode } from './edit-modes/extend-line-string-mode';
+export { SplitPolygonMode } from './edit-modes/split-polygon-mode';
+export { ExtrudeMode } from './edit-modes/extrude-mode';
+export { ElevationMode } from './edit-modes/elevation-mode';
+export { TransformMode } from './edit-modes/transform-mode';
+export { DrawPointMode } from './edit-modes/draw-point-mode';
+export { DrawLineStringMode } from './edit-modes/draw-line-string-mode';
+export { DrawPolygonMode } from './edit-modes/draw-polygon-mode';
+export { DrawRectangleMode } from './edit-modes/draw-rectangle-mode';
+export { DrawSquareMode } from './edit-modes/draw-square-mode';
+export { DrawRectangleFromCenterMode } from './edit-modes/draw-rectangle-from-center-mode';
+export { DrawSquareFromCenterMode } from './edit-modes/draw-square-from-center-mode';
+export { DrawCircleByDiameterMode } from './edit-modes/draw-circle-by-diameter-mode';
+export { DrawCircleFromCenterMode } from './edit-modes/draw-circle-from-center-mode';
+export { DrawEllipseByBoundingBoxMode } from './edit-modes/draw-ellipse-by-bounding-box-mode';
+export { DrawEllipseUsingThreePointsMode } from './edit-modes/draw-ellipse-using-three-points-mode';
+export { DrawRectangleUsingThreePointsMode } from './edit-modes/draw-rectangle-using-three-points-mode';
+export { Draw90DegreePolygonMode } from './edit-modes/draw-90degree-polygon-mode';
+export { DrawPolygonByDraggingMode } from './edit-modes/draw-polygon-by-dragging-mode';
+export { ImmutableFeatureCollection } from './edit-modes/immutable-feature-collection';
+export { ViewMode } from './edit-modes/view-mode';
+export { MeasureDistanceMode } from './edit-modes/measure-distance-mode';
+export { MeasureAreaMode } from './edit-modes/measure-area-mode';
+export { MeasureAngleMode } from './edit-modes/measure-angle-mode';
+export { CompositeMode } from './edit-modes/composite-mode';
+export { SnappableMode } from './edit-modes/snappable-mode';
+export { default as _memoize } from './memoize';
+export type { ScreenCoordinates, EditAction, Pick, ClickEvent, PointerMoveEvent, StartDraggingEvent, StopDraggingEvent, DraggingEvent, ModeProps, GuideFeatureCollection, Tooltip, } from './edit-modes/types';
+export type { Position, PointCoordinates, LineStringCoordinates, PolygonCoordinates, MultiPointCoordinates, MultiLineStringCoordinates, MultiPolygonCoordinates, AnyCoordinates, Point, LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon, Geometry, Polygonal, BoundingBoxArray, FeatureOf, FeatureWithProps, FeatureCollection, AnyGeoJson, } from './geojson-types';

package/dist/index.js

@@ -0,0 +1,62 @@
+export { ArrowStyles, DEFAULT_ARROWS, MAX_ARROWS } from './lib/style';
+export { SELECTION_TYPE } from './lib/deck-renderer/deck-drawer';
+export { default as Feature } from './lib/feature';
+export { default as LayerMouseEvent } from './lib/layer-mouse-event';
+export { default as NebulaLayer } from './lib/nebula-layer';
+export { default as JunctionsLayer } from './lib/layers/junctions-layer';
+export { default as TextsLayer } from './lib/layers/texts-layer';
+export { default as SegmentsLayer } from './lib/layers/segments-layer';
+export { default as NebulaCore } from './lib/nebula';
+export { PROJECTED_PIXEL_SIZE_MULTIPLIER } from './lib/constants';
+// Utils
+export { toDeckColor } from './utils';
+// Layers
+export { default as EditableGeoJsonLayer } from './editable-layers/editable-geojson-layer';
+export { default as EditableH3ClusterLayer } from './editable-layers/editable-h3-cluster-layer';
+export { default as SelectionLayer } from './editable-layers/selection-layer';
+export { default as ElevatedEditHandleLayer } from './editable-layers/elevated-edit-handle-layer';
+// Layers moved from deck.gl
+export { default as PathOutlineLayer } from './editable-layers/path-outline-layer/path-outline-layer';
+export { default as PathMarkerLayer } from './editable-layers/path-marker-layer/path-marker-layer';
+export { default as JunctionScatterplotLayer } from './editable-layers/junction-scatterplot-layer';
+// Types
+import * as utils from './utils';
+export { utils };
+export { GeoJsonEditMode } from './edit-modes/geojson-edit-mode';
+// Alter modes
+export { ModifyMode } from './edit-modes/modify-mode';
+export { ResizeCircleMode } from './edit-modes/resize-circle-mode';
+export { TranslateMode } from './edit-modes/translate-mode';
+export { ScaleMode } from './edit-modes/scale-mode';
+export { RotateMode } from './edit-modes/rotate-mode';
+export { DuplicateMode } from './edit-modes/duplicate-mode';
+export { ExtendLineStringMode } from './edit-modes/extend-line-string-mode';
+export { SplitPolygonMode } from './edit-modes/split-polygon-mode';
+export { ExtrudeMode } from './edit-modes/extrude-mode';
+export { ElevationMode } from './edit-modes/elevation-mode';
+export { TransformMode } from './edit-modes/transform-mode';
+// Draw modes
+export { DrawPointMode } from './edit-modes/draw-point-mode';
+export { DrawLineStringMode } from './edit-modes/draw-line-string-mode';
+export { DrawPolygonMode } from './edit-modes/draw-polygon-mode';
+export { DrawRectangleMode } from './edit-modes/draw-rectangle-mode';
+export { DrawSquareMode } from './edit-modes/draw-square-mode';
+export { DrawRectangleFromCenterMode } from './edit-modes/draw-rectangle-from-center-mode';
+export { DrawSquareFromCenterMode } from './edit-modes/draw-square-from-center-mode';
+export { DrawCircleByDiameterMode } from './edit-modes/draw-circle-by-diameter-mode';
+export { DrawCircleFromCenterMode } from './edit-modes/draw-circle-from-center-mode';
+export { DrawEllipseByBoundingBoxMode } from './edit-modes/draw-ellipse-by-bounding-box-mode';
+export { DrawEllipseUsingThreePointsMode } from './edit-modes/draw-ellipse-using-three-points-mode';
+export { DrawRectangleUsingThreePointsMode } from './edit-modes/draw-rectangle-using-three-points-mode';
+export { Draw90DegreePolygonMode } from './edit-modes/draw-90degree-polygon-mode';
+export { DrawPolygonByDraggingMode } from './edit-modes/draw-polygon-by-dragging-mode';
+export { ImmutableFeatureCollection } from './edit-modes/immutable-feature-collection';
+// Other modes
+export { ViewMode } from './edit-modes/view-mode';
+export { MeasureDistanceMode } from './edit-modes/measure-distance-mode';
+export { MeasureAreaMode } from './edit-modes/measure-area-mode';
+export { MeasureAngleMode } from './edit-modes/measure-angle-mode';
+export { CompositeMode } from './edit-modes/composite-mode';
+export { SnappableMode } from './edit-modes/snappable-mode';
+// Experimental
+export { default as _memoize } from './memoize';

package/dist/lib/constants.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A multiplier for screen-space width/scale for Arc, Line, Icon and Text layers.
+ * Required in order to maintain the same appearance after upgrading to deck.gl v8.5.
+ * https://github.com/visgl/deck.gl/blob/master/docs/upgrade-guide.md
+ */
+export declare const PROJECTED_PIXEL_SIZE_MULTIPLIER: number;

package/dist/lib/constants.js

@@ -0,0 +1,6 @@
+/**
+ * A multiplier for screen-space width/scale for Arc, Line, Icon and Text layers.
+ * Required in order to maintain the same appearance after upgrading to deck.gl v8.5.
+ * https://github.com/visgl/deck.gl/blob/master/docs/upgrade-guide.md
+ */
+export const PROJECTED_PIXEL_SIZE_MULTIPLIER = 2 / 3;

package/dist/lib/deck-renderer/deck-cache.d.ts

@@ -0,0 +1,14 @@
+export default class DeckCache<TORIG, TCONV> {
+    objects: TCONV[];
+    originals: TORIG[];
+    updateTrigger: number;
+    _idToPosition: Map<string, number>;
+    _getData: () => TORIG[];
+    _convert: (arg0: TORIG) => TCONV;
+    constructor(getData: () => TORIG[], convert: (arg0: TORIG) => TCONV);
+    updateAllDeckObjects(): void;
+    updateDeckObjectsByIds(ids: string[]): void;
+    triggerUpdate(): void;
+    getDeckObjectById(id: string): TCONV | null | undefined;
+    getOriginalById(id: string): TORIG | null | undefined;
+}

package/dist/lib/deck-renderer/deck-cache.js

@@ -0,0 +1,51 @@
+export default class DeckCache {
+    objects;
+    originals;
+    updateTrigger;
+    _idToPosition;
+    _getData;
+    _convert;
+    constructor(getData, convert) {
+        this.objects = [];
+        this.originals = [];
+        this.updateTrigger = 0;
+        this._idToPosition = new Map();
+        this._getData = getData;
+        this._convert = convert;
+    }
+    updateAllDeckObjects() {
+        if (!this._getData || !this._convert)
+            return;
+        this.originals.length = 0;
+        this.objects.length = 0;
+        this._idToPosition.clear();
+        this._getData().forEach((d) => {
+            this._idToPosition.set(d.id, this.objects.length);
+            this.originals.push(d);
+            this.objects.push(this._convert(d));
+        });
+        this.triggerUpdate();
+    }
+    updateDeckObjectsByIds(ids) {
+        if (!this._getData || !this._convert)
+            return;
+        ids.forEach((id) => {
+            const p = this._idToPosition.get(id);
+            if (p !== undefined) {
+                this.objects[p] = this._convert(this.originals[p]);
+            }
+        });
+        this.triggerUpdate();
+    }
+    triggerUpdate() {
+        this.updateTrigger++;
+    }
+    getDeckObjectById(id) {
+        const p = this._idToPosition.get(id);
+        return p !== undefined ? this.objects[p] : null;
+    }
+    getOriginalById(id) {
+        const p = this._idToPosition.get(id);
+        return p !== undefined ? this.originals[p] : null;
+    }
+}

package/dist/lib/deck-renderer/deck-drawer.d.ts

@@ -0,0 +1,63 @@
+import { PolygonLayer } from '@deck.gl/layers';
+import { polygon } from '@turf/helpers';
+import { Color } from '../../types';
+export declare const SELECTION_TYPE: {
+    NONE: any;
+    RECTANGLE: string;
+    POLYGON: string;
+};
+export default class DeckDrawer {
+    nebula: Record<string, any>;
+    usePolygon: boolean;
+    validPolygon: boolean;
+    landPoints: [number, number][];
+    mousePoints: [number, number][];
+    constructor(nebula: Record<string, any>);
+    _getLayerIds(): any;
+    _selectFromPickingInfos(pickingInfos: Record<string, any>[]): void;
+    _getBoundingBox(): Record<string, any>;
+    _selectRectangleObjects(): void;
+    _selectPolygonObjects(): void;
+    _getMousePosFromEvent(event: Record<string, any>): [number, number];
+    handleEvent(event: Record<string, any>, lngLat: [number, number], selectionType: number): {
+        redraw: boolean;
+        deactivate: boolean;
+    };
+    reset(): void;
+    _makeStartPointHighlight(center: [number, number]): number[];
+    render(): (PolygonLayer<any, {
+        id: "DeckDrawerView";
+        data: any[];
+        fp64: boolean;
+        opacity: 1;
+        pickable: false;
+        lineWidthMinPixels: 2;
+        lineWidthMaxPixels: 2;
+        lineDashJustified: true;
+        getLineColor: (obj: {
+            lineColor?: Color;
+        }) => Color;
+        getFillColor: (obj: {
+            fillColor?: Color;
+        }) => Color;
+        getPolygon: (o: {
+            polygon?: any;
+        }) => any;
+    }> | PolygonLayer<any, {
+        id: "DeckDrawerPick";
+        data: any[];
+        getLineColor: (obj: {
+            lineColor?: Color;
+        }) => Color;
+        getFillColor: (obj: {
+            fillColor?: Color;
+        }) => Color;
+        fp64: boolean;
+        opacity: 1;
+        stroked: false;
+        pickable: true;
+        getPolygon: (o: {
+            polygon?: any;
+        }) => any;
+    }>)[];
+}

package/dist/lib/deck-renderer/deck-drawer.js

@@ -0,0 +1,232 @@
+import { PolygonLayer } from '@deck.gl/layers';
+import { point, polygon } from '@turf/helpers';
+import turfBbox from '@turf/bbox';
+import turfBboxPolygon from '@turf/bbox-polygon';
+import turfBuffer from '@turf/buffer';
+import turfDifference from '@turf/difference';
+import turfDistance from '@turf/distance';
+const POLYGON_LINE_COLOR = [0, 255, 0, 255];
+const POLYGON_FILL_COLOR = [255, 255, 255, 90];
+const POLYGON_LINE_WIDTH = 2;
+// const POLYGON_DASHES = [20, 20];
+const POLYGON_THRESHOLD = 0.01;
+const EXPANSION_KM = 10;
+const LAYER_ID_VIEW = 'DeckDrawerView';
+const LAYER_ID_PICK = 'DeckDrawerPick';
+export const SELECTION_TYPE = {
+    NONE: null,
+    RECTANGLE: 'rectangle',
+    POLYGON: 'polygon',
+};
+export default class DeckDrawer {
+    nebula;
+    usePolygon;
+    validPolygon;
+    landPoints;
+    mousePoints;
+    constructor(nebula) {
+        this.nebula = nebula;
+        this.usePolygon = false;
+        this.validPolygon = true;
+        this.landPoints = [];
+        this.mousePoints = [];
+    }
+    _getLayerIds() {
+        // TODO: sort by mouse priority
+        return this.nebula.deckgl.props.layers
+            .filter((l) => l && l.props && l.props.nebulaLayer && l.props.nebulaLayer.enableSelection)
+            .map((l) => l.id);
+    }
+    _selectFromPickingInfos(pickingInfos) {
+        const objects = pickingInfos.map(({ layer, index, object }) => object.original || layer.props.nebulaLayer.deckCache.originals[index]);
+        this.nebula.props.onSelection(objects);
+    }
+    _getBoundingBox() {
+        const { mousePoints } = this;
+        const allX = mousePoints.map((mousePoint) => mousePoint[0]);
+        const allY = mousePoints.map((mousePoint) => mousePoint[1]);
+        const x = Math.min(...allX);
+        const y = Math.min(...allY);
+        const maxX = Math.max(...allX);
+        const maxY = Math.max(...allY);
+        return { x, y, width: maxX - x, height: maxY - y };
+    }
+    _selectRectangleObjects() {
+        if (this.landPoints.length !== 2)
+            return;
+        const [x1, y1] = this.mousePoints[0];
+        const [x2, y2] = this.mousePoints[1];
+        const pickingInfos = this.nebula.deckgl.pickObjects({
+            x: Math.min(x1, x2),
+            y: Math.min(y1, y2),
+            width: Math.abs(x2 - x1),
+            height: Math.abs(y2 - y1),
+            layerIds: this._getLayerIds(),
+        });
+        this._selectFromPickingInfos(pickingInfos);
+    }
+    _selectPolygonObjects() {
+        const pickingInfos = this.nebula.deckgl.pickObjects({
+            ...this._getBoundingBox(),
+            layerIds: [LAYER_ID_PICK, ...this._getLayerIds()],
+        });
+        this._selectFromPickingInfos(pickingInfos.filter((item) => item.layer.id !== LAYER_ID_PICK));
+    }
+    _getMousePosFromEvent(event) {
+        const { offsetX, offsetY } = event;
+        return [offsetX, offsetY];
+    }
+    // eslint-disable-next-line max-statements, complexity
+    handleEvent(event, lngLat, selectionType) {
+        // capture all events (mouse-up is needed to prevent us stuck in moving map)
+        if (event.type !== 'mouseup')
+            event.stopPropagation();
+        // @ts-expect-error revisit selectionType type
+        this.usePolygon = selectionType === SELECTION_TYPE.POLYGON;
+        let redraw = false;
+        let deactivate = false;
+        const { usePolygon, landPoints, mousePoints } = this;
+        if (event.type === 'mousedown') {
+            if (usePolygon && landPoints.length) {
+                // if landPoints.length is zero we want to insert two points (so we let it run the else)
+                // also don't insert if polygon is invalid
+                if (this.landPoints.length < 3 || this.validPolygon) {
+                    landPoints.push(lngLat);
+                    mousePoints.push(this._getMousePosFromEvent(event));
+                }
+            }
+            else {
+                this.landPoints = [lngLat, lngLat];
+                const m = this._getMousePosFromEvent(event);
+                this.mousePoints = [m, m];
+            }
+            redraw = true;
+        }
+        else if (event.type === 'mousemove' && landPoints.length) {
+            // update last point
+            landPoints[landPoints.length - 1] = lngLat;
+            mousePoints[mousePoints.length - 1] = this._getMousePosFromEvent(event);
+            redraw = true;
+        }
+        else if (event.type === 'mouseup') {
+            if (usePolygon) {
+                // check to see if completed
+                // TODO: Maybe double-click to finish?
+                if (landPoints.length > 4 &&
+                    turfDistance(landPoints[0], landPoints[landPoints.length - 1]) < POLYGON_THRESHOLD &&
+                    this.validPolygon) {
+                    this._selectPolygonObjects();
+                    this.reset();
+                    redraw = true;
+                    deactivate = true;
+                }
+            }
+            else {
+                this._selectRectangleObjects();
+                this.reset();
+                redraw = true;
+                deactivate = true;
+            }
+        }
+        return { redraw, deactivate };
+    }
+    reset() {
+        this.landPoints = [];
+        this.mousePoints = [];
+    }
+    _makeStartPointHighlight(center) {
+        const buffer = turfBuffer(point(center), POLYGON_THRESHOLD / 4.0);
+        // @ts-expect-error revisit return type
+        return turfBboxPolygon(turfBbox(buffer)).geometry.coordinates;
+    }
+    render() {
+        const data = [];
+        const dataPick = [];
+        if (!this.usePolygon && this.landPoints.length === 2) {
+            // Use mouse points instead of land points so we get the right shape
+            // no matter what bearing is.
+            const [[x1, y1], [x2, y2]] = this.mousePoints;
+            const selPolygon = [
+                [x1, y1],
+                [x1, y2],
+                [x2, y2],
+                [x2, y1],
+                [x1, y1],
+            ].map((mousePos) => this.nebula.unprojectMousePosition(mousePos));
+            data.push({
+                polygon: selPolygon,
+                lineColor: POLYGON_LINE_COLOR,
+                fillColor: POLYGON_FILL_COLOR,
+            });
+        }
+        else if (this.usePolygon && this.landPoints.length) {
+            data.push({
+                polygon: this.landPoints,
+                lineColor: POLYGON_LINE_COLOR,
+                fillColor: POLYGON_FILL_COLOR,
+            });
+            // Hack: use a polygon to hide the outside, because pickObjects()
+            // does not support polygons
+            if (this.landPoints.length >= 3) {
+                const landPointsPoly = polygon([[...this.landPoints, this.landPoints[0]]]);
+                const bigBuffer = turfBuffer(point(this.landPoints[0]), EXPANSION_KM);
+                let bigPolygon;
+                try {
+                    // turfDifference throws an exception if the polygon
+                    // intersects with itself
+                    bigPolygon = turfDifference(bigBuffer, landPointsPoly);
+                    dataPick.push({
+                        polygon: bigPolygon.geometry.coordinates,
+                        fillColor: [0, 0, 0, 1],
+                    });
+                    this.validPolygon = true;
+                }
+                catch (e) {
+                    // invalid selection polygon
+                    this.validPolygon = false;
+                }
+            }
+        }
+        if (this.landPoints.length) {
+            // highlight start point
+            data.push({
+                polygon: this._makeStartPointHighlight(this.landPoints[0]),
+                lineColor: [0, 0, 0, 0],
+                fillColor: POLYGON_LINE_COLOR,
+            });
+        }
+        // Hack to make the PolygonLayer() stay active,
+        // otherwise it takes 3 seconds (!) to init!
+        // TODO: fix this
+        data.push({ polygon: [[0, 0]] });
+        dataPick.push({ polygon: [[0, 0]] });
+        return [
+            new PolygonLayer({
+                id: LAYER_ID_VIEW,
+                data,
+                fp64: false,
+                opacity: 1.0,
+                pickable: false,
+                lineWidthMinPixels: POLYGON_LINE_WIDTH,
+                lineWidthMaxPixels: POLYGON_LINE_WIDTH,
+                lineDashJustified: true,
+                // TODO(v9) Add extension
+                // getLineDashArray: (x) => POLYGON_DASHES,
+                getLineColor: (obj) => obj.lineColor || [0, 0, 0, 255],
+                getFillColor: (obj) => obj.fillColor || [0, 0, 0, 255],
+                getPolygon: (o) => o.polygon,
+            }),
+            new PolygonLayer({
+                id: LAYER_ID_PICK,
+                data: dataPick,
+                getLineColor: (obj) => obj.lineColor || [0, 0, 0, 255],
+                getFillColor: (obj) => obj.fillColor || [0, 0, 0, 255],
+                fp64: false,
+                opacity: 1.0,
+                stroked: false,
+                pickable: true,
+                getPolygon: (o) => o.polygon,
+            }),
+        ];
+    }
+}

package/dist/lib/feature.d.ts

@@ -0,0 +1,10 @@
+import { Feature as GeoJson } from '../geojson-types';
+import { Style } from '../types';
+export default class Feature {
+    geoJson: GeoJson;
+    style: Style;
+    original: any | null | undefined;
+    metadata: Record<string, any>;
+    constructor(geoJson: GeoJson, style: Style, original?: any | null | undefined, metadata?: Record<string, any>);
+    getCoords(): import("../geojson-types").Position | import("../geojson-types").LineStringCoordinates | import("../geojson-types").PolygonCoordinates | import("../geojson-types").MultiPointCoordinates | import("../geojson-types").MultiLineStringCoordinates | import("../geojson-types").MultiPolygonCoordinates;
+}

package/dist/lib/feature.js

@@ -0,0 +1,16 @@
+export default class Feature {
+    // geo json coordinates
+    geoJson;
+    style;
+    original;
+    metadata;
+    constructor(geoJson, style, original = null, metadata = {}) {
+        this.geoJson = geoJson;
+        this.style = style;
+        this.original = original;
+        this.metadata = metadata;
+    }
+    getCoords() {
+        return this.geoJson.geometry.coordinates;
+    }
+}

package/dist/lib/layer-mouse-event.d.ts

@@ -0,0 +1,11 @@
+import { Position } from '../geojson-types';
+export default class LayerMouseEvent {
+    canceled: boolean;
+    data: Record<string, any>;
+    metadata: Record<string, any>;
+    groundPoint: Position;
+    nativeEvent: MouseEvent;
+    nebula: Record<string, any>;
+    constructor(nativeEvent: MouseEvent, { data, groundPoint, nebula, metadata }: Record<string, any>);
+    stopPropagation(): void;
+}

package/dist/lib/layer-mouse-event.js

@@ -0,0 +1,24 @@
+export default class LayerMouseEvent {
+    canceled = false;
+    // original item that this event is related to
+    data;
+    // internal nebula info about the object
+    metadata;
+    // the mouse [lng,lat] raycasted onto the ground
+    groundPoint;
+    // browser event
+    nativeEvent;
+    // reference to nebula
+    nebula;
+    constructor(nativeEvent, { data, groundPoint, nebula, metadata }) {
+        this.nativeEvent = nativeEvent;
+        this.data = data;
+        this.groundPoint = groundPoint;
+        this.nebula = nebula;
+        this.metadata = metadata;
+    }
+    stopPropagation() {
+        this.nativeEvent.stopPropagation();
+        this.canceled = true;
+    }
+}

package/dist/lib/layers/junctions-layer.d.ts

@@ -0,0 +1,8 @@
+import NebulaLayer from '../nebula-layer';
+import DeckCache from '../deck-renderer/deck-cache';
+import JunctionScatterplotLayer from '../../editable-layers/junction-scatterplot-layer';
+export default class JunctionsLayer extends NebulaLayer {
+    deckCache: DeckCache<any, any>;
+    constructor(config: Record<string, any>);
+    render({ nebula }: Record<string, any>): JunctionScatterplotLayer;
+}

package/dist/lib/layers/junctions-layer.js

@@ -0,0 +1,33 @@
+import NebulaLayer from '../nebula-layer';
+import { toDeckColor } from '../../utils';
+import DeckCache from '../deck-renderer/deck-cache';
+import JunctionScatterplotLayer from '../../editable-layers/junction-scatterplot-layer';
+export default class JunctionsLayer extends NebulaLayer {
+    deckCache;
+    constructor(config) {
+        super(config);
+        this.deckCache = new DeckCache(config.getData, (data) => config.toNebulaFeature(data));
+        this.enablePicking = true;
+    }
+    render({ nebula }) {
+        const defaultColor = [0x0, 0x0, 0x0, 0xff];
+        const { objects, updateTrigger } = this.deckCache;
+        return new JunctionScatterplotLayer({
+            id: `junctions-${this.id}`,
+            data: objects,
+            opacity: 1,
+            pickable: true,
+            getPosition: (nf) => nf.geoJson.geometry.coordinates,
+            getFillColor: (nf) => toDeckColor(nf.style.fillColor) || defaultColor,
+            getStrokeColor: (nf) => toDeckColor(nf.style.outlineColor) || toDeckColor(nf.style.fillColor) || defaultColor,
+            getRadius: (nf) => nf.style.pointRadiusMeters + nf.style.outlineRadiusMeters || 1,
+            getInnerRadius: (nf) => nf.style.pointRadiusMeters || 0.5,
+            parameters: {
+                depthCompare: 'always'
+            },
+            updateTriggers: { all: updateTrigger },
+            // @ts-ignore
+            nebulaLayer: this,
+        });
+    }
+}

package/dist/lib/layers/segments-layer.d.ts

@@ -0,0 +1,18 @@
+import NebulaLayer from '../nebula-layer';
+import DeckCache from '../deck-renderer/deck-cache';
+import PathMarkerLayer from '../../editable-layers/path-marker-layer/path-marker-layer';
+export default class SegmentsLayer extends NebulaLayer {
+    deckCache: DeckCache<any, any>;
+    noBlend: boolean;
+    highlightColor: [number, number, number, number];
+    arrowSize: number;
+    jointRounded: boolean;
+    capRounded: boolean;
+    dashed: boolean;
+    markerLayerProps: Record<string, any> | null | undefined;
+    constructor(config: Record<string, any>);
+    getMouseOverSegment(): any;
+    _calcMarkerPercentages(nf: Record<string, any>): number[];
+    _getHighlightedObjectIndex({ nebula }: Record<string, any>): number;
+    render({ nebula }: Record<string, any>): PathMarkerLayer<any, Record<string, unknown>>;
+}