@florasync/leaflet-geokit 0.2.0 → 0.4.0

package/dist/types/e2e/component.spec.d.ts

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

package/dist/types/e2e/dummy.spec.d.ts

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

package/dist/types/src/components/LeafletDrawMapElement.d.ts

@@ -0,0 +1,94 @@
+import type { Feature, FeatureCollection } from "geojson";
+import type { LeafletDrawMapElementAPI, MeasurementSystem } from "@src/types/public";
+import { type LogLevel } from "@src/utils/logger";
+import type * as LeafletNS from "leaflet";
+export declare class LeafletDrawMapElement extends HTMLElement implements LeafletDrawMapElementAPI {
+    private _root;
+    private _container;
+    private _logger;
+    private _latitude;
+    private _longitude;
+    private _zoom;
+    private _minZoom?;
+    private _maxZoom?;
+    private _tileUrl;
+    private _tileAttribution?;
+    private _readOnly;
+    private _logLevel;
+    private _devOverlay;
+    private _polygonAllowIntersection;
+    private _preferCanvas;
+    private _themeUrl?;
+    private _themeCss;
+    private _themeLinkEl;
+    private _themeStyleEl;
+    private _controller;
+    private _useExternalLeaflet;
+    private _skipLeafletStyles;
+    private _leafletInstance;
+    constructor();
+    private _controlsFromAttributes;
+    private _mapConfig;
+    connectedCallback(): Promise<void>;
+    disconnectedCallback(): Promise<void>;
+    static get observedAttributes(): string[];
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    get latitude(): number;
+    set latitude(v: number);
+    get longitude(): number;
+    set longitude(v: number);
+    get zoom(): number;
+    set zoom(v: number);
+    get minZoom(): number | undefined;
+    set minZoom(v: number | undefined);
+    get maxZoom(): number | undefined;
+    set maxZoom(v: number | undefined);
+    get tileUrl(): string;
+    set tileUrl(v: string);
+    get tileAttribution(): string | undefined;
+    set tileAttribution(v: string | undefined);
+    get readOnly(): boolean;
+    set readOnly(v: boolean);
+    get logLevel(): LogLevel;
+    set logLevel(v: LogLevel);
+    get devOverlay(): boolean;
+    set devOverlay(v: boolean);
+    get preferCanvas(): boolean;
+    set preferCanvas(v: boolean);
+    get useExternalLeaflet(): boolean;
+    set useExternalLeaflet(v: boolean);
+    get skipLeafletStyles(): boolean;
+    set skipLeafletStyles(v: boolean);
+    get leafletInstance(): typeof LeafletNS | undefined;
+    set leafletInstance(v: typeof LeafletNS | undefined);
+    get themeCss(): string;
+    set themeCss(v: string);
+    getGeoJSON(): Promise<FeatureCollection>;
+    loadGeoJSON(fc: FeatureCollection): Promise<void>;
+    clearLayers(): Promise<void>;
+    addFeatures(fc: FeatureCollection): Promise<string[]>;
+    updateFeature(id: string, feature: Feature): Promise<void>;
+    removeFeature(id: string): Promise<void>;
+    fitBoundsToData(padding?: number): Promise<void>;
+    fitBounds(bounds: [[number, number], [number, number]], padding?: number): Promise<void>;
+    setView(lat: number, lng: number, zoom?: number): Promise<void>;
+    exportGeoJSON(): Promise<FeatureCollection>;
+    /**
+     * Merge all visible polygon layers into a single polygon.
+     * This removes the original polygon features and adds a new merged feature.
+     *
+     * @param options Optional configuration for the merge operation
+     * @returns Promise resolving to the ID of the newly created merged feature, or null if no polygons to merge
+     */
+    mergePolygons(options?: {
+        properties?: Record<string, any>;
+    }): Promise<string | null>;
+    setMeasurementUnits(system: MeasurementSystem): Promise<void>;
+    loadGeoJSONFromUrl(url: string): Promise<void>;
+    loadGeoJSONFromText(text: string): Promise<void>;
+    private _currentConfig;
+    private _applyThemeStyles;
+    private _reflect;
+    private _booleanReflect;
+    private _coerceNumber;
+}

package/dist/types/src/django/index.d.ts

@@ -0,0 +1,35 @@
+import "@src/index";
+import type { LeafletDrawMapElement } from "@src/components/LeafletDrawMapElement";
+export type DjangoShimPhase = "mount" | "parse" | "sync";
+export interface DjangoShimErrorContext {
+    phase: DjangoShimPhase;
+    textarea: HTMLTextAreaElement;
+    element?: LeafletDrawMapElement;
+}
+export interface DjangoShimHandle {
+    textarea: HTMLTextAreaElement;
+    element: LeafletDrawMapElement;
+    container: HTMLDivElement;
+    sync: () => Promise<void>;
+    destroy: () => void;
+}
+export interface DjangoShimOptions {
+    selector?: string;
+    height?: number | string;
+    attributePrefix?: string;
+    onError?: (error: Error, context: DjangoShimErrorContext) => void;
+    onInit?: (handle: DjangoShimHandle) => void;
+    /**
+     * Programmatic attributes to apply to the <leaflet-geokit> element.
+     * These take precedence over textarea data attributes.
+     */
+    elementAttributes?: Record<string, string | number | boolean>;
+}
+export declare function initDjangoGeokit(selectorOrOptions?: string | DjangoShimOptions, maybeOptions?: DjangoShimOptions): DjangoShimHandle[];
+declare global {
+    interface Window {
+        GeoKitDjango?: {
+            init: typeof initDjangoGeokit;
+        };
+    }
+}

package/dist/types/src/external.d.ts

@@ -0,0 +1,4 @@
+import { LeafletDrawMapElement } from "@src/components/LeafletDrawMapElement";
+export { LeafletDrawMapElement };
+export * from "@src/types/public";
+export * from "@src/types/events";

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

@@ -0,0 +1,4 @@
+import { LeafletDrawMapElement } from "@src/components/LeafletDrawMapElement";
+export { LeafletDrawMapElement };
+export * from "@src/types/public";
+export * from "@src/types/events";

package/dist/types/src/lib/FeatureStore.d.ts

@@ -0,0 +1,48 @@
+import type { Feature, FeatureCollection } from "geojson";
+import { type BoundsPair } from "@src/utils/geojson";
+import { type Logger } from "@src/utils/logger";
+/**
+ * FeatureStore
+ * - Maintains a stable, id-centric in-memory FeatureCollection
+ * - IDs are sourced from feature.id, feature.properties.id, or generated (uuid v4)
+ * - Provides CRUD and export helpers
+ *
+ * Note: Leaflet layer bindings will be handled by the controller; this store is map-agnostic.
+ */
+export declare class FeatureStore {
+    private log;
+    private features;
+    constructor(logger?: Logger);
+    size(): number;
+    has(id: string): boolean;
+    get(id: string): Feature | undefined;
+    /**
+     * Add features to the store; returns the assigned/normalized ids in order.
+     */
+    add(fc: FeatureCollection): string[];
+    /**
+     * Update a feature by id. If the feature does not exist, this is a no-op.
+     * The provided feature will overwrite the stored one with the given id.
+     */
+    update(id: string, feature: Feature): void;
+    /**
+     * Remove a feature by id. No-op if missing.
+     */
+    remove(id: string): void;
+    /**
+     * Clear all features.
+     */
+    clear(): void;
+    /**
+     * Export snapshot as FeatureCollection.
+     */
+    toFeatureCollection(): FeatureCollection;
+    /**
+     * Compute bounds for current data as [[south, west], [north, east]] or null if empty.
+     */
+    bounds(): BoundsPair | null;
+    /**
+     * Ensure the feature has an id; returns the resolved id.
+     */
+    private ensureId;
+}

package/dist/types/src/lib/MapController.d.ts

@@ -0,0 +1,116 @@
+import * as BundledL from "leaflet";
+import "leaflet-draw";
+import "leaflet-ruler";
+import type { Feature, FeatureCollection } from "geojson";
+import type { DrawControlsConfig, MapConfig, MeasurementSystem } from "@src/types/public";
+import { type Logger } from "@src/utils/logger";
+export interface MapControllerCallbacks {
+    onReady?: (detail: {
+        bounds?: [[number, number], [number, number]];
+    }) => void;
+    onCreated?: (detail: {
+        id: string;
+        layerType: "polygon" | "polyline" | "rectangle" | "circle" | "marker";
+        geoJSON: Feature;
+    }) => void;
+    onEdited?: (detail: {
+        ids: string[];
+        geoJSON: FeatureCollection;
+    }) => void;
+    onDeleted?: (detail: {
+        ids: string[];
+        geoJSON: FeatureCollection;
+    }) => void;
+    onError?: (detail: {
+        message: string;
+        cause?: unknown;
+    }) => void;
+}
+export interface MapControllerOptions {
+    container: HTMLElement;
+    map: MapConfig;
+    controls: DrawControlsConfig;
+    readOnly?: boolean;
+    logger?: Logger;
+    callbacks?: MapControllerCallbacks;
+    /** Optional injected Leaflet namespace to use instead of bundled import. */
+    leaflet?: typeof BundledL;
+    /** Prefer external Leaflet if available (falls back to bundled if missing/invalid). */
+    useExternalLeaflet?: boolean;
+}
+/**
+ * MapController: initializes Leaflet map + Draw, bridges events, and manages data via FeatureStore.
+ */
+export declare class MapController {
+    private container;
+    private logger;
+    private options;
+    private L;
+    private store;
+    private map;
+    private drawnItems;
+    private drawControl;
+    private rulerControl;
+    private measurementControl;
+    private measurementSystem;
+    private measurementModalOverlay;
+    private measurementModalDialog;
+    private measurementModalRadios;
+    private measurementModalKeydownHandler;
+    private detachPolygonFinishPatch;
+    private vertexMenuEl;
+    private vertexMenuCleanup;
+    private activeCakeSession;
+    constructor(opts: MapControllerOptions);
+    private resolveLeaflet;
+    init(): Promise<void>;
+    destroy(): Promise<void>;
+    getGeoJSON(): Promise<FeatureCollection>;
+    loadGeoJSON(fc: FeatureCollection, fitToData?: boolean): Promise<void>;
+    clearLayers(): Promise<void>;
+    addFeatures(fc: FeatureCollection): Promise<string[]>;
+    updateFeature(id: string, feature: Feature): Promise<void>;
+    removeFeature(id: string): Promise<void>;
+    fitBoundsToData(paddingRatio?: number): Promise<void>;
+    fitBounds(boundsTuple: [[number, number], [number, number]], paddingRatio?: number): Promise<void>;
+    setView(lat: number, lng: number, zoom?: number): Promise<void>;
+    /**
+     * Merge all visible polygon features into a single polygon feature.
+     * This removes the original features and adds a new feature with the merged geometry.
+     *
+     * @param options Optional configuration for the merge operation
+     * @returns The ID of the newly created merged feature, or null if no polygons to merge
+     */
+    mergeVisiblePolygons(options?: {
+        /** Properties to apply to the merged feature (defaults to properties from first polygon) */
+        properties?: Record<string, any>;
+    }): Promise<string | null>;
+    setRulerUnits(system: MeasurementSystem): void;
+    private buildDrawOptions;
+    private applyLayerCakeToolbarIcon;
+    private addRulerControl;
+    private installRulerPrecisionPatch;
+    private rebuildRulerControl;
+    private installMeasurementSettingsControl;
+    private ensureMeasurementModal;
+    private toggleMeasurementModal;
+    private syncMeasurementModalState;
+    private removeMeasurementModal;
+    private attachMeasurementModalKeydown;
+    private detachMeasurementModalKeydown;
+    /**
+     * Workaround: In some environments (notably within Shadow DOM), clicking the first vertex
+     * to close a polygon can be unreliable due to event retargeting/hit testing.
+     * This patch listens for map clicks while the polygon draw handler is enabled and,
+     * if the click is within a small pixel radius of the first vertex, it triggers finishShape().
+     */
+    private installPolygonFinishPatch;
+    private patchLeafletDrawBugs;
+    private bindDrawEvents;
+    private _error;
+    private installVertexContextMenu;
+    private openVertexMenu;
+    private showVertexMenu;
+    private findNearestVertex;
+    private deleteVertex;
+}

package/dist/types/src/lib/draw/L.Draw.Cake.d.ts

@@ -0,0 +1,9 @@
+import * as L from "leaflet";
+declare const DrawCake_base: any;
+export declare class DrawCake extends DrawCake_base {
+    static TYPE: string;
+    constructor(map: L.Map, options?: L.DrawOptions.CircleOptions);
+    addHooks(): void;
+}
+export declare function ensureDrawCakeRegistered(Lns: typeof L): void;
+export {};

package/dist/types/src/lib/draw/toolbar-patch.d.ts

@@ -0,0 +1,2 @@
+import * as L from "leaflet";
+export declare function registerLayerCakeTool(Lns?: typeof L): void;

package/dist/types/src/lib/layer-cake/CakeBaker.d.ts

@@ -0,0 +1,12 @@
+export interface CircleLike {
+    getLatLng(): {
+        lat: number;
+        lng: number;
+    };
+    getRadius(): number;
+}
+export interface CakeLayerOptions {
+    circles: CircleLike[];
+    steps?: number;
+}
+export declare function bakeLayerCake(options: CakeLayerOptions): GeoJSON.FeatureCollection;

package/dist/types/src/lib/layer-cake/LayerCakeManager.d.ts

@@ -0,0 +1,29 @@
+import * as L from "leaflet";
+import type { MeasurementSystem } from "@src/types/public";
+export declare class LayerCakeManager {
+    private map;
+    private layers;
+    private controlsGroup;
+    private onSave;
+    private sessionId;
+    private baseCircleOptions;
+    private detachMapListeners;
+    private renderScheduled;
+    private measurementSystem;
+    constructor(map: L.Map, initialCircle: L.Circle, onSave: (geojson: GeoJSON.FeatureCollection) => void, measurementSystem?: MeasurementSystem);
+    private installEditEventBridges;
+    private requestRenderControls;
+    private addLayer;
+    addRing(): void;
+    save(): void;
+    private getLargestCircle;
+    private syncCenters;
+    /**
+     * Update the label for the active circle being resized.
+     * Shows both total radius and delta (ring width) from the next smaller circle.
+     * Positions the tooltip on the left side to avoid toolbar interference.
+     */
+    private updateLabels;
+    private renderControls;
+    destroy(): void;
+}

package/dist/types/src/lib/layer-cake/bindCakeControls.d.ts

@@ -0,0 +1,8 @@
+export interface BindCakeControlsOptions {
+    root: ParentNode;
+    addButtonId: string;
+    saveButtonId: string;
+    onAddRing: () => void;
+    onSave: () => void;
+}
+export declare function bindCakeControls(options: BindCakeControlsOptions): void;

package/dist/types/src/lib/layer-cake/ensureCircleEditable.d.ts

@@ -0,0 +1,2 @@
+import type * as L from "leaflet";
+export declare function ensureCircleEditable(circle: L.Circle): void;

package/dist/types/src/lib/leaflet-assets.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Inject Leaflet and Leaflet.draw CSS into the given ShadowRoot.
+ * Idempotent: does nothing if already injected for this root.
+ */
+export declare function injectLeafletStyles(root: ShadowRoot): void;
+/**
+ * Inject only project-specific style overrides that must exist even when
+ * consumers provide external Leaflet CSS.
+ * Idempotent: does nothing if already injected for this root.
+ */
+export declare function injectLeafletCustomStyles(root: ShadowRoot): void;
+/**
+ * Ensure Leaflet default marker icons resolve via the bundler.
+ * Safe to call multiple times.
+ */
+export declare function configureLeafletDefaultIcons(): void;
+/**
+ * Conditional helper: apply styles and icon wiring only if not skipped.
+ */
+export declare function applyLeafletStylingIfNeeded(options: {
+    root: ShadowRoot;
+    skipStyles?: boolean;
+}): void;

package/dist/types/src/preact/core.d.ts

@@ -0,0 +1,36 @@
+import type { LeafletDrawMapElement } from "@src/components/LeafletDrawMapElement";
+type Primitive = string | number | boolean | null | undefined;
+type LeafletMode = "external" | "bundled";
+export interface PreactLeafletGeoKitProps {
+    className?: string;
+    style?: string | Record<string, string | number>;
+    /**
+     * HTML attributes to apply to <leaflet-geokit>.
+     * Boolean true => present attribute, false => removed.
+     */
+    attributes?: Record<string, Primitive>;
+    /**
+     * Override the default entrypoint mode:
+     * - /preact defaults to external
+     * - /preact-bundled defaults to bundled
+     */
+    externalLeaflet?: boolean;
+    /** Optional explicit Leaflet namespace (window.L equivalent). */
+    leafletInstance?: any;
+    /** Initial GeoJSON text to load once on ready. */
+    initialGeoJSONText?: string;
+    /** Called whenever draw/edit/delete/merge occurs, with latest serialized FeatureCollection. */
+    onChangeText?: (text: string) => void;
+    /** Called with parsed FeatureCollection after sync, if parsing is desired by host. */
+    onChangeGeoJSON?: (geoJSON: unknown) => void;
+    /** Called if sync/load operations fail. */
+    onError?: (error: Error) => void;
+    /** Access underlying custom element instance. */
+    onReady?: (element: LeafletDrawMapElement) => void;
+}
+export declare function createPreactLeafletGeoKit(defaultMode: LeafletMode): (props: PreactLeafletGeoKitProps) => import("preact").VNode<import("preact").Attributes & {
+    ref: import("preact/hooks").MutableRef<LeafletDrawMapElement | null>;
+    className: string | undefined;
+    style: string;
+}>;
+export {};

package/dist/types/src/preact/index.d.ts

@@ -0,0 +1,8 @@
+import { type PreactLeafletGeoKitProps } from "@src/preact/core";
+export type { PreactLeafletGeoKitProps };
+export declare const PreactLeafletGeoKit: (props: PreactLeafletGeoKitProps) => import("preact").VNode<import("preact").Attributes & {
+    ref: import("preact/hooks").MutableRef<import("..").LeafletDrawMapElement | null>;
+    className: string | undefined;
+    style: string;
+}>;
+export default PreactLeafletGeoKit;

package/dist/types/src/preact-bundled/index.d.ts

@@ -0,0 +1,9 @@
+import "@src/index";
+import { type PreactLeafletGeoKitProps } from "@src/preact/core";
+export type { PreactLeafletGeoKitProps };
+export declare const PreactLeafletGeoKit: (props: PreactLeafletGeoKitProps) => import("preact").VNode<import("preact").Attributes & {
+    ref: import("preact/hooks").MutableRef<import("@src/index").LeafletDrawMapElement | null>;
+    className: string | undefined;
+    style: string;
+}>;
+export default PreactLeafletGeoKit;

package/dist/types/src/react/core.d.ts

@@ -0,0 +1,36 @@
+import React from "react";
+import type { LeafletDrawMapElement } from "@src/components/LeafletDrawMapElement";
+type Primitive = string | number | boolean | null | undefined;
+type LeafletMode = "external" | "bundled";
+export interface ReactLeafletGeoKitProps {
+    className?: string;
+    style?: string | Record<string, string | number>;
+    /**
+     * HTML attributes to apply to <leaflet-geokit>.
+     * Boolean true => present attribute, false => removed.
+     */
+    attributes?: Record<string, Primitive>;
+    /**
+     * Override the default entrypoint mode:
+     * - /react defaults to external
+     * - /react-bundled defaults to bundled
+     */
+    externalLeaflet?: boolean;
+    /** Optional explicit Leaflet namespace (window.L equivalent). */
+    leafletInstance?: any;
+    /** Initial GeoJSON text to load once on ready. */
+    initialGeoJSONText?: string;
+    /** Called whenever draw/edit/delete/merge occurs, with latest serialized FeatureCollection. */
+    onChangeText?: (text: string) => void;
+    /** Called with parsed FeatureCollection after sync, if parsing is desired by host. */
+    onChangeGeoJSON?: (geoJSON: unknown) => void;
+    /** Called if sync/load operations fail. */
+    onError?: (error: Error) => void;
+    /** Access underlying custom element instance. */
+    onReady?: (element: LeafletDrawMapElement) => void;
+}
+export declare function createReactLeafletGeoKit(defaultMode: LeafletMode): (props: ReactLeafletGeoKitProps) => React.ReactElement<{
+    ref: React.MutableRefObject<LeafletDrawMapElement | null>;
+    className: string | undefined;
+}, string | React.JSXElementConstructor<any>>;
+export {};

package/dist/types/src/react/index.d.ts

@@ -0,0 +1,7 @@
+import { type ReactLeafletGeoKitProps } from "@src/react/core";
+export type { ReactLeafletGeoKitProps };
+export declare const ReactLeafletGeoKit: (props: ReactLeafletGeoKitProps) => import("react").ReactElement<{
+    ref: import("react").MutableRefObject<import("..").LeafletDrawMapElement | null>;
+    className: string | undefined;
+}, string | import("react").JSXElementConstructor<any>>;
+export default ReactLeafletGeoKit;

package/dist/types/src/react-bundled/index.d.ts

@@ -0,0 +1,8 @@
+import "@src/index";
+import { type ReactLeafletGeoKitProps } from "@src/react/core";
+export type { ReactLeafletGeoKitProps };
+export declare const ReactLeafletGeoKit: (props: ReactLeafletGeoKitProps) => import("react").ReactElement<{
+    ref: import("react").MutableRefObject<import("@src/index").LeafletDrawMapElement | null>;
+    className: string | undefined;
+}, string | import("react").JSXElementConstructor<any>>;
+export default ReactLeafletGeoKit;

package/dist/types/src/shims/ensure-element.d.ts

@@ -0,0 +1,2 @@
+export declare function isLeafletGeoKitRegistered(): boolean;
+export declare function ensureLeafletGeoKitRegistered(): Promise<void>;

package/dist/types/src/state/types.d.ts

@@ -0,0 +1,7 @@
+export type MapState = "uninitialized" | "initializing" | "ready" | "loadingData" | "drawing" | "editing" | "error";
+export interface StatusSnapshot {
+    state: MapState;
+    featureCount: number;
+    lastEvent?: string;
+    logLevel?: string;
+}

package/dist/types/src/types/events.d.ts

@@ -0,0 +1,71 @@
+import type { Feature, FeatureCollection } from "geojson";
+/**
+ * Details for the 'leaflet-draw:ready' event.
+ * bounds: optional southwest/northeast LatLng pairs.
+ */
+export interface ReadyEventDetail {
+    bounds?: [[number, number], [number, number]];
+}
+/**
+ * Details for the 'leaflet-draw:created' event.
+ * id: the stable feature id assigned by the FeatureStore.
+ */
+export interface CreatedEventDetail {
+    id: string;
+    layerType: "polygon" | "polyline" | "rectangle" | "circle" | "marker";
+    geoJSON: Feature;
+}
+/**
+ * Details for the 'leaflet-draw:edited' event.
+ * ids: array of feature ids that were edited.
+ */
+export interface EditedEventDetail {
+    ids: string[];
+    geoJSON: FeatureCollection;
+}
+/**
+ * Details for the 'leaflet-draw:deleted' event.
+ * ids: array of feature ids that were deleted.
+ */
+export interface DeletedEventDetail {
+    ids: string[];
+    geoJSON: FeatureCollection;
+}
+/**
+ * Details for error events emitted as 'leaflet-draw:error'.
+ */
+export interface ErrorEventDetail {
+    message: string;
+    cause?: unknown;
+}
+/**
+ * Details for 'leaflet-draw:ingest' event. Fired before data is added to the map.
+ * Listeners may mutate detail.fc to transform incoming data (e.g., flatten MultiPolygon).
+ */
+export interface IngestEventDetail {
+    fc: FeatureCollection;
+    mode: "load" | "add";
+}
+/**
+ * Details for 'leaflet-draw:export' event.
+ */
+export interface ExportEventDetail {
+    geoJSON: FeatureCollection;
+    featureCount: number;
+}
+/**
+ * Event name constants for convenience (non-enforced).
+ */
+export declare const DrawEvent: {
+    readonly Ready: "leaflet-draw:ready";
+    readonly Created: "leaflet-draw:created";
+    readonly Edited: "leaflet-draw:edited";
+    readonly Deleted: "leaflet-draw:deleted";
+    readonly Error: "leaflet-draw:error";
+    readonly Ingest: "leaflet-draw:ingest";
+    readonly Export: "leaflet-draw:export";
+    readonly DrawStart: "leaflet-draw:drawstart";
+    readonly DrawStop: "leaflet-draw:drawstop";
+    readonly EditStart: "leaflet-draw:editstart";
+    readonly EditStop: "leaflet-draw:editstop";
+};