leaflet-polydraw/dist/types/managers/event-manager.d.ts

Advanced Leaflet plugin for freehand polygon drawing, with smart merging and powerful editing tools. Compatible with both Leaflet v1.x and v2.x.

import { Feature, Polygon, MultiPolygon } from 'geojson';
import { DrawMode } from '../enums';
import { FeatureGroup, LatLngExpression } from 'leaflet';
export type PolydrawEventPayloads = {
    'polygon:add': {
        polygon: Feature<Polygon | MultiPolygon>;
    };
    'polydraw:subtract': {
        subtractPolygon: Feature<Polygon | MultiPolygon>;
    };
    drawCancelled: {
        mode?: DrawMode;
    };
    polygonDeleted: undefined;
    polygonSubtracted: {
        subtractedPolygon: Feature<Polygon | MultiPolygon>;
        affectedFeatureGroups: FeatureGroup[];
        resultFeatureGroups: FeatureGroup[];
    };
    polygonOperationComplete: {
        operation: string;
        polygon: Feature<Polygon | MultiPolygon>;
        featureGroup?: FeatureGroup;
        resultFeatureGroups?: FeatureGroup[];
    };
    polygonAdded: {
        polygon: Feature<Polygon | MultiPolygon>;
        featureGroup: FeatureGroup;
    };
    polygonsUnioned: {
        originalPolygons: Feature<Polygon | MultiPolygon>[];
        resultPolygon: Feature<Polygon | MultiPolygon>;
        featureGroups?: FeatureGroup[];
    };
    'polygon:intersect': {
        polygon1: Feature<Polygon | MultiPolygon>;
        polygon2: Feature<Polygon | MultiPolygon>;
        callback: (intersects: boolean) => void;
    };
    'freehand:complete': {
        polygon: Feature<Polygon | MultiPolygon>;
    };
    'polydraw:polygon:created': {
        polygon: Feature<Polygon | MultiPolygon>;
        isPointToPoint?: boolean;
        mode?: DrawMode;
    };
    'polydraw:polygon:updated': {
        polygon: Feature<Polygon | MultiPolygon>;
        operation?: string;
        allowMerge?: boolean;
        optimizationLevel?: number;
        originalOptimizationLevel?: number;
        featureId?: string;
        featureMetadata?: Record<string, unknown>;
        sourceFeatureIds?: string[];
        featureInteractionOverride?: 'editable' | 'readonly' | 'static';
        featureStyleOverrides?: {
            color?: string;
            fillColor?: string;
            fillOpacity?: number;
            weight?: number;
        };
        featureCreatedAt?: string;
        featureLastModified?: string;
    };
    'polydraw:polygon:deleted': undefined;
    'polydraw:mode:change': {
        mode: DrawMode;
    };
    'polydraw:draw:cancel': {
        mode?: DrawMode;
    };
    'polydraw:menu:action': {
        action: string;
        menuActionId?: string;
        latLngs?: LatLngExpression[];
        featureGroup?: FeatureGroup;
    };
    'polydraw:check:intersection': {
        polygon1: Feature<Polygon | MultiPolygon>;
        polygon2: Feature<Polygon | MultiPolygon>;
        callback: (intersects: boolean) => void;
    };
    'polydraw:history:undo': {
        canUndo: boolean;
        canRedo: boolean;
        action?: string;
    };
    'polydraw:history:redo': {
        canUndo: boolean;
        canRedo: boolean;
        action?: string;
    };
    'polydraw:history:changed': {
        canUndo: boolean;
        canRedo: boolean;
    };
    'polydraw:layer:created': {
        layerId: string;
        color: string;
    };
    'polydraw:layer:deleted': {
        layerId: string;
        removedFeatureGroups: FeatureGroup[];
    };
    'polydraw:layer:activated': {
        layerId: string;
        previousLayerId: string;
    };
    'polydraw:layer:visibility': {
        layerId: string;
        visible: boolean;
    };
    'polydraw:layer:colorChanged': {
        layerId: string;
        color: string;
    };
    'polydraw:layer:delete-requested': {
        layerId: string;
    };
    'polydraw:layer:reorder-requested': {
        layerId: string;
        targetLayerId: string;
    };
    'polydraw:layer:reordered': {
        layerId: string;
        targetLayerId: string;
        orderedLayerIds: string[];
    };
};
export type PolydrawEvent = keyof PolydrawEventPayloads;
export type PolydrawEventCallback<T extends PolydrawEvent = PolydrawEvent> = (data: PolydrawEventPayloads[T]) => void;
export declare class EventManager {
    private eventListeners;
    /**
     * Register an event listener.
     * @param event - The event to listen for.
     * @param callback - The callback to execute when the event is emitted.
     */
    on<T extends PolydrawEvent>(event: T, callback: PolydrawEventCallback<T>): void;
    /**
     * Unregister an event listener.
     * @param event - The event to stop listening for.
     * @param callback - The specific callback to remove.
     */
    off<T extends PolydrawEvent>(event: T, callback: PolydrawEventCallback<T>): void;
    /**
     * Emit an event.
     * @param event - The event to emit.
     * @param data - The data to pass to the event listeners.
     */
    emit<T extends PolydrawEvent>(event: T, data: PolydrawEventPayloads[T]): void;
}
//# sourceMappingURL=event-manager.d.ts.map