terra-draw 0.0.1-alpha.8 → 1.0.0-beta.0

package/dist/modes/select/select.mode.d.ts

@@ -1,78 +1,119 @@
-import { TerraDrawMouseEvent, TerraDrawKeyboardEvent, HexColor, TerraDrawAdapterStyling } from "../../common";
-import { TerraDrawBaseDrawMode } from "../base.mode";
-import { BehaviorConfig } from "../base.behavior";
-import { GeoJSONStoreFeatures } from "../../store/store";
-declare type TerraDrawSelectModeKeyEvents = {
-    deselect: KeyboardEvent["key"];
-    delete: KeyboardEvent["key"];
-    rotate: KeyboardEvent["key"];
-    scale: KeyboardEvent["key"];
-};
-declare type ModeFlags = {
-    feature?: {
-        draggable?: boolean;
-        rotateable?: boolean;
-        scaleable?: boolean;
-        coordinates?: {
-            midpoints?: boolean;
-            draggable?: boolean;
-            deletable?: boolean;
-        };
-    };
-};
-declare type SelectionStyling = {
-    selectedColor: HexColor;
-    selectedPointOutlineColor: HexColor;
-    selectPointOutlineWidth: number;
-    selectionPointWidth: number;
-    selectionPointColor: HexColor;
-    selectionPointOutlineColor: HexColor;
-    selectionPointOutlineWidth: number;
-    midPointColor: HexColor;
-    midPointOutlineColor: HexColor;
-    midPointWidth: number;
-    midPointOutlineWidth: number;
-};
-export declare class TerraDrawSelectMode extends TerraDrawBaseDrawMode<SelectionStyling> {
-    mode: string;
-    private dragEventThrottle;
-    private dragEventCount;
-    private selected;
-    private flags;
-    private keyEvents;
-    private selectionPoints;
-    private midPoints;
-    private featuresAtMouseEvent;
-    private pixelDistance;
-    private clickBoundingBox;
-    private dragFeature;
-    private dragCoordinate;
-    private rotateFeature;
-    private scaleFeature;
-    constructor(options?: {
-        styles?: Partial<SelectionStyling>;
-        pointerDistance?: number;
-        flags?: {
-            [mode: string]: ModeFlags;
-        };
-        keyEvents?: TerraDrawSelectModeKeyEvents;
-        dragEventThrottle?: number;
-    });
-    registerBehaviors(config: BehaviorConfig): void;
-    private deselect;
-    private deleteSelected;
-    private onRightClick;
-    private onLeftClick;
-    start(): void;
-    stop(): void;
-    onClick(event: TerraDrawMouseEvent): void;
-    onKeyDown(): void;
-    onKeyUp(event: TerraDrawKeyboardEvent): void;
-    cleanUp(): void;
-    onDragStart(event: TerraDrawMouseEvent, setMapDraggability: (enabled: boolean) => void): void;
-    onDrag(event: TerraDrawMouseEvent): void;
-    onDragEnd(_: TerraDrawMouseEvent, setMapDraggability: (enabled: boolean) => void): void;
-    onMouseMove(event: TerraDrawMouseEvent): void;
-    styleFeature(feature: GeoJSONStoreFeatures): TerraDrawAdapterStyling;
-}
-export {};
+import { TerraDrawMouseEvent, TerraDrawKeyboardEvent, TerraDrawAdapterStyling, HexColorStyling, NumericStyling, Cursor, Validation } from "../../common";
+import { BaseModeOptions, CustomStyling, TerraDrawBaseSelectMode } from "../base.mode";
+import { BehaviorConfig } from "../base.behavior";
+import { FeatureId, GeoJSONStoreFeatures } from "../../store/store";
+import { ResizeOptions } from "./behaviors/drag-coordinate-resize.behavior";
+type TerraDrawSelectModeKeyEvents = {
+    deselect: KeyboardEvent["key"] | null;
+    delete: KeyboardEvent["key"] | null;
+    rotate: KeyboardEvent["key"][] | null;
+    scale: KeyboardEvent["key"][] | null;
+};
+type ModeFlags = {
+    feature?: {
+        validation?: Validation;
+        draggable?: boolean;
+        rotateable?: boolean;
+        scaleable?: boolean;
+        selfIntersectable?: boolean;
+        coordinates?: {
+            midpoints?: boolean;
+            draggable?: boolean;
+            resizable?: ResizeOptions;
+            deletable?: boolean;
+        };
+    };
+};
+type SelectionStyling = {
+    selectedPointColor: HexColorStyling;
+    selectedPointWidth: NumericStyling;
+    selectedPointOutlineColor: HexColorStyling;
+    selectedPointOutlineWidth: NumericStyling;
+    selectedLineStringColor: HexColorStyling;
+    selectedLineStringWidth: NumericStyling;
+    selectedPolygonColor: HexColorStyling;
+    selectedPolygonFillOpacity: NumericStyling;
+    selectedPolygonOutlineColor: HexColorStyling;
+    selectedPolygonOutlineWidth: NumericStyling;
+    selectionPointWidth: NumericStyling;
+    selectionPointColor: HexColorStyling;
+    selectionPointOutlineColor: HexColorStyling;
+    selectionPointOutlineWidth: NumericStyling;
+    midPointColor: HexColorStyling;
+    midPointOutlineColor: HexColorStyling;
+    midPointWidth: NumericStyling;
+    midPointOutlineWidth: NumericStyling;
+};
+interface Cursors {
+    pointerOver?: Cursor;
+    dragStart?: Cursor;
+    dragEnd?: Cursor;
+    insertMidpoint?: Cursor;
+}
+interface TerraDrawSelectModeOptions<T extends CustomStyling> extends BaseModeOptions<T> {
+    pointerDistance?: number;
+    flags?: {
+        [mode: string]: ModeFlags;
+    };
+    keyEvents?: TerraDrawSelectModeKeyEvents | null;
+    dragEventThrottle?: number;
+    cursors?: Cursors;
+    allowManualDeselection?: boolean;
+}
+export declare class TerraDrawSelectMode extends TerraDrawBaseSelectMode<SelectionStyling> {
+    mode: string;
+    private allowManualDeselection;
+    private dragEventThrottle;
+    private dragEventCount;
+    private selected;
+    private flags;
+    private keyEvents;
+    private selectionPoints;
+    private midPoints;
+    private featuresAtMouseEvent;
+    private pixelDistance;
+    private clickBoundingBox;
+    private dragFeature;
+    private dragCoordinate;
+    private rotateFeature;
+    private scaleFeature;
+    private dragCoordinateResizeFeature;
+    private cursors;
+    private validations;
+    constructor(options?: TerraDrawSelectModeOptions<SelectionStyling>);
+    selectFeature(featureId: FeatureId): void;
+    setSelecting(): void;
+    registerBehaviors(config: BehaviorConfig): void;
+    deselectFeature(): void;
+    private deselect;
+    private deleteSelected;
+    private onRightClick;
+    private select;
+    private onLeftClick;
+    /** @internal */
+    start(): void;
+    /** @internal */
+    stop(): void;
+    /** @internal */
+    onClick(event: TerraDrawMouseEvent): void;
+    private canScale;
+    private canRotate;
+    private preventDefaultKeyEvent;
+    /** @internal */
+    onKeyDown(event: TerraDrawKeyboardEvent): void;
+    /** @internal */
+    onKeyUp(event: TerraDrawKeyboardEvent): void;
+    /** @internal */
+    cleanUp(): void;
+    /** @internal */
+    onDragStart(event: TerraDrawMouseEvent, setMapDraggability: (enabled: boolean) => void): void;
+    /** @internal */
+    onDrag(event: TerraDrawMouseEvent, setMapDraggability: (enabled: boolean) => void): void;
+    /** @internal */
+    onDragEnd(_: TerraDrawMouseEvent, setMapDraggability: (enabled: boolean) => void): void;
+    /** @internal */
+    onMouseMove(event: TerraDrawMouseEvent): void;
+    /** @internal */
+    styleFeature(feature: GeoJSONStoreFeatures): TerraDrawAdapterStyling;
+}
+export {};

package/dist/modes/snapping.behavior.d.ts

@@ -1,13 +1,16 @@
-import { BehaviorConfig, TerraDrawModeBehavior } from "./base.behavior";
-import { TerraDrawMouseEvent } from "../common";
-import { Position } from "geojson";
-import { ClickBoundingBoxBehavior } from "./click-bounding-box.behavior";
-import { PixelDistanceBehavior } from "./pixel-distance.behavior";
-export declare class SnappingBehavior extends TerraDrawModeBehavior {
-    readonly config: BehaviorConfig;
-    private readonly pixelDistance;
-    private readonly clickBoundingBox;
-    constructor(config: BehaviorConfig, pixelDistance: PixelDistanceBehavior, clickBoundingBox: ClickBoundingBoxBehavior);
-    getSnappableCoordinate: (event: TerraDrawMouseEvent, currentFeatureId: string) => Position | undefined;
-    private getSnappable;
-}
+import { BehaviorConfig, TerraDrawModeBehavior } from "./base.behavior";
+import { TerraDrawMouseEvent } from "../common";
+import { Position } from "geojson";
+import { ClickBoundingBoxBehavior } from "./click-bounding-box.behavior";
+import { FeatureId } from "../store/store";
+import { PixelDistanceBehavior } from "./pixel-distance.behavior";
+export declare class SnappingBehavior extends TerraDrawModeBehavior {
+    readonly config: BehaviorConfig;
+    private readonly pixelDistance;
+    private readonly clickBoundingBox;
+    constructor(config: BehaviorConfig, pixelDistance: PixelDistanceBehavior, clickBoundingBox: ClickBoundingBoxBehavior);
+    /** Returns the nearest snappable coordinate - on first click there is no currentId so no need to provide */
+    getSnappableCoordinateFirstClick: (event: TerraDrawMouseEvent) => Position | undefined;
+    getSnappableCoordinate: (event: TerraDrawMouseEvent, currentFeatureId: FeatureId) => Position | undefined;
+    private getSnappable;
+}

package/dist/modes/static/static.mode.d.ts

@@ -1,30 +1,32 @@
-import { TerraDrawAdapterStyling } from "../../common";
-import { TerraDrawBaseDrawMode } from "../base.mode";
-declare type StaticModeStylingExt<T extends TerraDrawAdapterStyling> = {};
-declare type StaticModeStyling = StaticModeStylingExt<TerraDrawAdapterStyling>;
-export declare class TerraDrawStaticMode extends TerraDrawBaseDrawMode<StaticModeStyling> {
-    mode: string;
-    start(): void;
-    stop(): void;
-    onKeyUp(): void;
-    onKeyDown(): void;
-    onClick(): void;
-    onDragStart(): void;
-    onDrag(): void;
-    onDragEnd(): void;
-    onMouseMove(): void;
-    styleFeature(): {
-        pointColor: `#${string}`;
-        pointWidth: number;
-        pointOutlineColor: `#${string}`;
-        pointOutlineWidth: number;
-        polygonFillColor: `#${string}`;
-        polygonFillOpacity: number;
-        polygonOutlineColor: `#${string}`;
-        polygonOutlineWidth: number;
-        lineStringWidth: number;
-        lineStringColor: `#${string}`;
-        zIndex: number;
-    };
-}
-export {};
+import { TerraDrawAdapterStyling } from "../../common";
+import { ModeTypes, TerraDrawBaseDrawMode } from "../base.mode";
+type StaticModeStylingExt<T extends TerraDrawAdapterStyling> = {};
+type StaticModeStyling = StaticModeStylingExt<TerraDrawAdapterStyling>;
+export declare class TerraDrawStaticMode extends TerraDrawBaseDrawMode<StaticModeStyling> {
+    type: ModeTypes;
+    mode: string;
+    start(): void;
+    stop(): void;
+    onKeyUp(): void;
+    onKeyDown(): void;
+    onClick(): void;
+    onDragStart(): void;
+    onDrag(): void;
+    onDragEnd(): void;
+    onMouseMove(): void;
+    cleanUp(): void;
+    styleFeature(): {
+        pointColor: import("../../common").HexColor;
+        pointWidth: number;
+        pointOutlineColor: import("../../common").HexColor;
+        pointOutlineWidth: number;
+        polygonFillColor: import("../../common").HexColor;
+        polygonFillOpacity: number;
+        polygonOutlineColor: import("../../common").HexColor;
+        polygonOutlineWidth: number;
+        lineStringWidth: number;
+        lineStringColor: import("../../common").HexColor;
+        zIndex: number;
+    };
+}
+export {};

package/dist/store/spatial-index/quickselect.d.ts

@@ -1,2 +1,2 @@
-export declare type CompareFunction<T> = (a: T, b: T) => number;
-export declare function quickselect<T>(arr: T[], k: number, left: number, right: number, compare: CompareFunction<T>): void;
+export type CompareFunction<T> = (a: T, b: T) => number;
+export declare function quickselect<T>(arr: T[], k: number, left: number, right: number, compare: CompareFunction<T>): void;

package/dist/store/spatial-index/rbush.d.ts

@@ -1,35 +1,35 @@
-export declare type Node = {
-    children: Node[];
-    height: number;
-    leaf: boolean;
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-};
-export declare class RBush {
-    private _maxEntries;
-    private _minEntries;
-    private data;
-    constructor(maxEntries: number);
-    search(bbox: Node): Node[];
-    collides(bbox: Node): boolean;
-    load(data: Node[]): void;
-    insert(item: Node): void;
-    clear(): void;
-    remove(item: Node): void;
-    private toBBox;
-    private compareMinX;
-    private compareMinY;
-    private _all;
-    private _build;
-    private _chooseSubtree;
-    private _insert;
-    private _split;
-    private _splitRoot;
-    private _chooseSplitIndex;
-    private _chooseSplitAxis;
-    private _allDistMargin;
-    private _adjustParentBBoxes;
-    private _condense;
-}
+export type Node = {
+    children: Node[];
+    height: number;
+    leaf: boolean;
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+};
+export declare class RBush {
+    private _maxEntries;
+    private _minEntries;
+    private data;
+    constructor(maxEntries: number);
+    search(bbox: Node): Node[];
+    collides(bbox: Node): boolean;
+    load(data: Node[]): void;
+    insert(item: Node): void;
+    clear(): void;
+    remove(item: Node): void;
+    private toBBox;
+    private compareMinX;
+    private compareMinY;
+    private _all;
+    private _build;
+    private _chooseSubtree;
+    private _insert;
+    private _split;
+    private _splitRoot;
+    private _chooseSplitIndex;
+    private _chooseSplitAxis;
+    private _allDistMargin;
+    private _adjustParentBBoxes;
+    private _condense;
+}

package/dist/store/spatial-index/spatial-index.d.ts

@@ -1,18 +1,18 @@
-import { GeoJSONStoreFeatures } from "../store";
-export declare class SpatialIndex {
-    private tree;
-    private idToNode;
-    private nodeToId;
-    constructor(options?: {
-        maxEntries: number;
-    });
-    private setMaps;
-    private toBBox;
-    insert(feature: GeoJSONStoreFeatures): void;
-    load(features: GeoJSONStoreFeatures[]): void;
-    update(feature: GeoJSONStoreFeatures): void;
-    remove(featureId: string): void;
-    clear(): void;
-    search(feature: GeoJSONStoreFeatures): string[];
-    collides(feature: GeoJSONStoreFeatures): boolean;
-}
+import { FeatureId, GeoJSONStoreFeatures } from "../store";
+export declare class SpatialIndex {
+    private tree;
+    private idToNode;
+    private nodeToId;
+    constructor(options?: {
+        maxEntries: number;
+    });
+    private setMaps;
+    private toBBox;
+    insert(feature: GeoJSONStoreFeatures): void;
+    load(features: GeoJSONStoreFeatures[]): void;
+    update(feature: GeoJSONStoreFeatures): void;
+    remove(featureId: FeatureId): void;
+    clear(): void;
+    search(feature: GeoJSONStoreFeatures): FeatureId[];
+    collides(feature: GeoJSONStoreFeatures): boolean;
+}

package/dist/store/store-feature-validation.d.ts

@@ -0,0 +1,16 @@
+import { FeatureId, GeoJSONStoreFeatures, IdStrategy } from "./store";
+export declare const StoreValidationErrors: {
+    readonly FeatureHasNoId: "Feature has no id";
+    readonly FeatureIsNotObject: "Feature is not object";
+    readonly InvalidTrackedProperties: "updatedAt and createdAt are not valid timestamps";
+    readonly FeatureHasNoMode: "Feature does not have a set mode";
+    readonly FeatureIdIsNotValidGeoJSON: "Feature must be string or number as per GeoJSON spec";
+    readonly FeatureIdIsNotValid: "Feature must match the id strategy (default is UUID4)";
+    readonly FeatureHasNoGeometry: "Feature has no geometry";
+    readonly FeatureHasNoProperties: "Feature has no properties";
+    readonly FeatureGeometryNotSupported: "Feature is not Point, LineString or Polygon";
+    readonly FeatureCoordinatesNotAnArray: "Feature coordinates is not an array";
+    readonly InvalidModeProperty: "Feature does not have a valid mode property";
+};
+export declare function isValidTimestamp(timestamp: unknown): boolean;
+export declare function isValidStoreFeature(feature: unknown, isValidId: IdStrategy<FeatureId>["isValidId"]): feature is GeoJSONStoreFeatures;

package/dist/store/store.d.ts

@@ -1,48 +1,59 @@
-import { Feature, Point, Polygon, LineString } from "geojson";
-declare type JSON = string | number | boolean | null | JSONArray | JSONObject;
-export interface JSONObject {
-    [member: string]: JSON;
-}
-declare type JSONArray = Array<JSON>;
-declare type DefinedProperties = Record<string, JSON>;
-export declare type GeoJSONStoreGeometries = Polygon | LineString | Point;
-export declare type BBoxPolygon = Feature<Polygon, DefinedProperties>;
-export declare type GeoJSONStoreFeatures = Feature<GeoJSONStoreGeometries, DefinedProperties>;
-export declare type StoreChangeEvents = "delete" | "create" | "update";
-export declare type StoreChangeHandler = (ids: string[], change: StoreChangeEvents) => void;
-export declare type GeoJSONStoreConfig = {
-    data?: GeoJSONStoreFeatures[];
-    tracked?: boolean;
-    validateFeature?: (feature: unknown, tracked?: boolean) => void;
-};
-export declare class GeoJSONStore {
-    constructor(config?: GeoJSONStoreConfig);
-    private tracked;
-    private spatialIndex;
-    private store;
-    private _onChange;
-    private getId;
-    private clone;
-    has(id: string): boolean;
-    load(data: GeoJSONStoreFeatures[], featureValidation?: (feature: unknown, tracked?: boolean) => void): void;
-    search(bbox: BBoxPolygon, filter?: (feature: GeoJSONStoreFeatures) => boolean): GeoJSONStoreFeatures[];
-    registerOnChange(onChange: StoreChangeHandler): void;
-    getGeometryCopy<T extends GeoJSONStoreGeometries>(id: string): T;
-    getPropertiesCopy(id: string): DefinedProperties;
-    updateProperty(propertiesToUpdate: {
-        id: string;
-        property: string;
-        value: JSON;
-    }[]): void;
-    updateGeometry(geometriesToUpdate: {
-        id: string;
-        geometry: GeoJSONStoreGeometries;
-    }[]): void;
-    create(features: {
-        geometry: GeoJSONStoreGeometries;
-        properties?: JSONObject;
-    }[]): string[];
-    delete(ids: string[]): void;
-    copyAll(): GeoJSONStoreFeatures[];
-}
-export {};
+import { Feature, Point, Polygon, LineString } from "geojson";
+type JSON = string | number | boolean | null | JSONArray | JSONObject;
+export interface JSONObject {
+    [member: string]: JSON;
+}
+type JSONArray = Array<JSON>;
+type DefinedProperties = Record<string, JSON>;
+export type GeoJSONStoreGeometries = Polygon | LineString | Point;
+export type BBoxPolygon = Feature<Polygon, DefinedProperties>;
+export type GeoJSONStoreFeatures = Feature<GeoJSONStoreGeometries, DefinedProperties>;
+export type StoreChangeEvents = "delete" | "create" | "update" | "styling";
+export type StoreChangeHandler = (ids: FeatureId[], change: StoreChangeEvents) => void;
+export type FeatureId = string | number;
+export type IdStrategy<Id extends FeatureId> = {
+    isValidId: (id: Id) => boolean;
+    getId: () => Id;
+};
+export type GeoJSONStoreConfig<Id extends FeatureId> = {
+    idStrategy?: IdStrategy<Id>;
+    tracked?: boolean;
+};
+export declare const defaultIdStrategy: {
+    getId: <FeatureId>() => FeatureId;
+    isValidId: (id: FeatureId) => boolean;
+};
+export declare class GeoJSONStore<Id extends FeatureId = FeatureId> {
+    constructor(config?: GeoJSONStoreConfig<Id>);
+    idStrategy: IdStrategy<Id>;
+    private tracked;
+    private spatialIndex;
+    private store;
+    private _onChange;
+    private clone;
+    getId(): FeatureId;
+    has(id: FeatureId): boolean;
+    load(data: GeoJSONStoreFeatures[], featureValidation?: (feature: unknown, tracked?: boolean) => boolean): void;
+    search(bbox: BBoxPolygon, filter?: (feature: GeoJSONStoreFeatures) => boolean): GeoJSONStoreFeatures[];
+    registerOnChange(onChange: StoreChangeHandler): void;
+    getGeometryCopy<T extends GeoJSONStoreGeometries>(id: FeatureId): T;
+    getPropertiesCopy(id: FeatureId): DefinedProperties;
+    updateProperty(propertiesToUpdate: {
+        id: FeatureId;
+        property: string;
+        value: JSON;
+    }[]): void;
+    updateGeometry(geometriesToUpdate: {
+        id: FeatureId;
+        geometry: GeoJSONStoreGeometries;
+    }[]): void;
+    create<Id extends FeatureId>(features: {
+        geometry: GeoJSONStoreGeometries;
+        properties?: JSONObject;
+    }[]): Id[];
+    delete(ids: FeatureId[]): void;
+    copyAll(): GeoJSONStoreFeatures[];
+    clear(): void;
+    size(): number;
+}
+export {};