@besovideo/bvmap-leaflet 0.0.10 → 0.0.13

package/dist/types/basemap/config.d.ts

@@ -1,9 +1,11 @@
+import { IRenderMarkerCluster } from './markerCluster/index';
 import { MapType, TileType } from './tmsProviders';
 
 declare const glbConfig: {
     mapType: MapType;
     tileType: TileType;
     mapInfoShow: string;
+    clusterType: IRenderMarkerCluster<any>["clusterType"];
 };
 type ConfigType = typeof glbConfig;
 export declare function setGlobalConfig(config: Partial<ConfigType>): void;
@@ -11,6 +13,7 @@ export declare function getGlobalConfig(): {
     mapType: MapType;
     tileType: TileType;
     mapInfoShow: string;
+    clusterType: IRenderMarkerCluster<any>["clusterType"];
 };
 export declare function watchConfigChange<T extends keyof ConfigType>(configItemType: T, handle: (val: ConfigType[T], config: ConfigType, configItemType: T) => void, runNow?: boolean): () => void;
 export declare function getConfigItem<T extends keyof ConfigType>(configItemType: T): [ConfigType[T], ConfigType];

package/dist/types/basemap/customControls/circle.d.ts

@@ -0,0 +1,29 @@
+import { IShapeExtraInfo } from './index';
+import { ICustomControls } from './utils';
+
+export interface ICustomControlsCircleInit extends IShapeExtraInfo {
+    circleInfo?: {
+        center: L.LatLngTuple;
+        radius: number;
+    };
+    title: string;
+    color: string;
+    opacity: number;
+    polygonStrokeWidth: number;
+    onDrawingEnd?: () => void;
+}
+export declare class CustomControlsCircle implements ICustomControls<ICustomControlsCircleInit, "circleInfo"> {
+    private map;
+    private circle;
+    private infoCircle;
+    private titleMarker;
+    private radiusMarker;
+    constructor(map: L.Map, infoCircle: ICustomControlsCircleInit);
+    private update;
+    enableEdit(): void;
+    disableEdit(): void;
+    getInfo(): ICustomControlsCircleInit;
+    setInfo(params: Partial<ICustomControlsCircleInit>): void;
+    onClick(handle: () => void): void;
+    remove(): void;
+}

package/dist/types/basemap/customControls/distanceTools.d.ts

@@ -0,0 +1,17 @@
+export interface DistanceToolsTexts {
+    start: string;
+    end: string;
+    total: string;
+    kiloMeter: string;
+    drawingEnd?: () => void;
+    onMove?: () => void;
+}
+export declare class DistanceTools {
+    path: L.Polyline;
+    map: L.Map;
+    params: DistanceToolsTexts;
+    constructor(map: L.Map, params: DistanceToolsTexts);
+    private titleArray;
+    private update;
+    remove(): void;
+}

package/dist/types/basemap/customControls/distanceToolsMarkerTitle.d.ts

@@ -0,0 +1,16 @@
+import { MakerTitle } from './titleMarker';
+
+export type TitleType = "START" | "NORMAL" | "END" | "CENTER";
+export declare class DistanceToolsMarkerTitle {
+    titleMarker: MakerTitle;
+    titleType: TitleType;
+    setTitle: (title: string) => void;
+    private updateTitle;
+    constructor(map: L.Map, onClose: () => void, onDelete: () => void);
+    SetLatlng(latlng?: L.LatLngExpression): void;
+    remove(): void;
+    SetTitleType(titleType: TitleType): void;
+    private kiloMeter;
+    setUserData(kiloMeter: number): void;
+    getUserData(): number;
+}

package/dist/types/basemap/customControls/geojson.d.ts

@@ -0,0 +1,12 @@
+export interface IGeoProperties {
+    name: string;
+    stroke?: string;
+    "stroke-opacity"?: number;
+    "stroke-width"?: number;
+    description?: string;
+}
+export declare function ParseGeoJsonToPathInfo(geoJson: GeoJSON.FeatureCollection<GeoJSON.Geometry, IGeoProperties>): {
+    position: L.LatLngTuple | Array<L.LatLngTuple>;
+    props: IGeoProperties;
+    type: "Point" | "LineString";
+}[];

package/dist/types/basemap/customControls/index.d.ts

@@ -0,0 +1,41 @@
+import { ITitileLineInfoInit, LeafletTitleLine } from './titleLine';
+import { CustomControlsMarker, ICustomControlsMarkerInit } from './maker';
+import { CustomControlsPolygon, ICustomControlsPolygon } from './polygon';
+import { CustomControlsCircle, ICustomControlsCircleInit } from './circle';
+import { CustomControlsRectangle, ICustomControlsRectangleInit } from './rectangle';
+import { DistanceTools, DistanceToolsTexts } from './distanceTools';
+import { IAreaToolsInit, PolygonAreaTools } from './polygonAreaTools';
+
+export type TShapeType = keyof ShapeTypeMap;
+export interface ShapeTypeMap {
+    MARKER: ReturnType<LeafletCustomControlsMgr["addMarker"]>;
+    POLYLINE: ReturnType<LeafletCustomControlsMgr["addLine"]>;
+    POLYGON: ReturnType<LeafletCustomControlsMgr["addPolygon"]>;
+    RECTANGLE: ReturnType<LeafletCustomControlsMgr["addRectangle"]>;
+    CIRCLE: ReturnType<LeafletCustomControlsMgr["addCircle"]>;
+}
+export interface IShapeExtraInfo {
+    id?: string;
+    isSave?: boolean;
+    decription?: string;
+}
+export declare function ParseShapeType<T extends TShapeType>(shapeType: T, obj: any): ShapeTypeMap[T];
+export interface IShapeTypeAppend {
+    shapeType: TShapeType;
+}
+export declare class LeafletCustomControlsMgr {
+    private map;
+    constructor(map: L.Map);
+    addLine(info: ITitileLineInfoInit): LeafletTitleLine & IShapeTypeAppend;
+    addMarker(info: ICustomControlsMarkerInit): CustomControlsMarker & IShapeTypeAppend;
+    addPolygon(info: ICustomControlsPolygon): CustomControlsPolygon & IShapeTypeAppend;
+    addCircle(info: ICustomControlsCircleInit): CustomControlsCircle & IShapeTypeAppend;
+    addRectangle(info: ICustomControlsRectangleInit): CustomControlsRectangle & IShapeTypeAppend;
+    addDistanceRule(params: DistanceToolsTexts): DistanceTools;
+    addPolygonAreaRule(params: IAreaToolsInit): PolygonAreaTools;
+    parseGeoJson(geoJson: GeoJSON.FeatureCollection): {
+        position: L.LatLngTuple | Array<L.LatLngTuple>;
+        props: import('./geojson').IGeoProperties;
+        type: "Point" | "LineString";
+    }[];
+}

package/dist/types/basemap/customControls/maker.d.ts

@@ -0,0 +1,39 @@
+import { IShapeExtraInfo } from './index';
+import { ICustomControls } from './utils';
+
+export interface ICustomControlsMarker {
+    latlng: L.LatLngTuple;
+}
+export interface ICustomControlsMarkerInit extends IShapeExtraInfo {
+    title: string;
+    color: string;
+    size: number;
+    showName: boolean;
+    latlng?: L.LatLngTuple;
+    onDrawingEnd?: () => void;
+}
+export type ICustomControlsMarkerInitStyle = Omit<ICustomControlsMarkerInit, "latlng">;
+export declare class CustomControlsMarker implements ICustomControls<ICustomControlsMarkerInit, "latlng"> {
+    map: L.Map;
+    marker: L.Marker;
+    html: HTMLDivElement;
+    markerInfo: ICustomControlsMarkerInit;
+    constructor(map: L.Map, markerInitInfo: ICustomControlsMarkerInit);
+    enableEdit(): void;
+    disableEdit(): void;
+    setInfo(params: Partial<Omit<ICustomControlsMarkerInit, "latlng">>): void;
+    private SetStyle;
+    onClick(handleClick: () => void): void;
+    getInfo(): {
+        latlng: L.LatLngTuple;
+        title: string;
+        color: string;
+        size: number;
+        showName: boolean;
+        onDrawingEnd?: () => void;
+        id?: string;
+        isSave?: boolean;
+        decription?: string;
+    };
+    remove(): void;
+}

package/dist/types/basemap/customControls/polygon.d.ts

@@ -0,0 +1,35 @@
+import { IShapeExtraInfo } from './index';
+import { ICustomControls } from './utils';
+
+export interface ICustomControlsPolygon extends IShapeExtraInfo {
+    color: string;
+    latlngs?: Array<L.LatLngTuple>;
+    opacity: number;
+    title: string;
+    polygonStrokeWidth: number;
+    onDrawingEnd?: () => void;
+}
+export declare class CustomControlsPolygon implements ICustomControls<ICustomControlsPolygon, "latlngs"> {
+    private polygonInfo;
+    private polygon;
+    private markerTitle;
+    constructor(map: L.Map, polygonInfo: ICustomControlsPolygon);
+    setInfo(params: Partial<Omit<ICustomControlsPolygon, "latlngs">>): void;
+    onClick(handle: () => void): void;
+    private SetStyle;
+    enableEdit(): void;
+    disableEdit(): void;
+    getInfo(): {
+        latlngs: import('leaflet').LatLngTuple[];
+        color: string;
+        opacity: number;
+        title: string;
+        polygonStrokeWidth: number;
+        onDrawingEnd?: () => void;
+        id?: string;
+        isSave?: boolean;
+        decription?: string;
+    };
+    OnClick(handleClick: () => void): void;
+    remove(): void;
+}

package/dist/types/basemap/customControls/polygonAreaTools.d.ts

@@ -0,0 +1,16 @@
+export interface IAreaToolsInit {
+    kiloMeterSquare: string;
+    MeterSquare: string;
+    color: string;
+    onRemove?(): void;
+    onDrawingEnd?(): void;
+}
+export declare class PolygonAreaTools {
+    private map;
+    private titleMarker;
+    private polygon;
+    private params;
+    constructor(map: L.Map, params: IAreaToolsInit);
+    private update;
+    remove(): void;
+}

package/dist/types/basemap/customControls/rectangle.d.ts

@@ -0,0 +1,27 @@
+import { IShapeExtraInfo } from './index';
+import { ICustomControls } from './utils';
+
+export interface ICustomControlsRectangleInit extends IShapeExtraInfo {
+    reacInfo?: {
+        latlngBounds: L.LatLngBoundsLiteral;
+    };
+    color: string;
+    polygonStrokeWidth: number;
+    opacity: number;
+    title: string;
+    onDrawingEnd?: () => void;
+}
+export declare class CustomControlsRectangle implements ICustomControls<ICustomControlsRectangleInit, "reacInfo"> {
+    private map;
+    private rectangle;
+    private rectangleInfo;
+    private titleMarker;
+    constructor(map: L.Map, init: ICustomControlsRectangleInit);
+    enableEdit(): void;
+    disableEdit(): void;
+    getInfo(): ICustomControlsRectangleInit;
+    setInfo(params: Partial<Omit<ICustomControlsRectangleInit, "reacInfo">>): void;
+    private update;
+    onClick(handle: () => void): void;
+    remove(): void;
+}

package/dist/types/basemap/customControls/titleLine.d.ts

@@ -0,0 +1,49 @@
+import { IShapeExtraInfo } from './index';
+import { ICustomControls } from './utils';
+
+export interface ITitileLineInfo extends IShapeExtraInfo {
+    latlngs: Array<L.LatLngExpression>;
+    title: string;
+    color: string;
+    lineStyle: "dashed" | "solid";
+    polygonStrokeWidth: number;
+    onDrawingEnd?: () => void;
+}
+export type ITitileLineInfoInit = Omit<ITitileLineInfo, "latlngs"> & {
+    latlngs?: Array<L.LatLngExpression>;
+};
+export declare class LeafletTitleLine implements ICustomControls<ITitileLineInfo, "latlngs"> {
+    private map;
+    private polyline;
+    private marker;
+    private html;
+    private titleLatlng;
+    private onRemove;
+    private lineInfo;
+    constructor(map: L.Map, lineInfo: ITitileLineInfo, onRemove: () => void);
+    enableEdit(): void;
+    disableEdit(): void;
+    setInfo(params: Partial<Omit<ITitileLineInfo, "latlngs">>): void;
+    private setLineStyle;
+    private load;
+    getInfo(): {
+        latlngs: import('leaflet').LatLngTuple[];
+        title: string;
+        color: string;
+        lineStyle: "dashed" | "solid";
+        polygonStrokeWidth: number;
+        onDrawingEnd?: () => void;
+        id?: string;
+        isSave?: boolean;
+        decription?: string;
+    };
+    disableEditable(): void;
+    private tryInitLatlng;
+    private setPathStyle;
+    enableEditable(): void;
+    private title;
+    private updateTitle;
+    remove(): void;
+    setTitle(title: string): void;
+    onClick(onHandle: (line: LeafletTitleLine) => void): void;
+}

package/dist/types/basemap/customControls/titleMarker.d.ts

@@ -0,0 +1,15 @@
+export declare class MakerTitle {
+    private html;
+    private marker;
+    private map;
+    private icon;
+    constructor(map: L.Map);
+    private latlngTitle;
+    setLatlng(latlng?: L.LatLngExpression): void;
+    private updata;
+    private title;
+    private titleHtml;
+    setTitle(title: string): void;
+    setTitleHtml(titleHtml?: HTMLDivElement): void;
+    remove(): void;
+}

package/dist/types/basemap/customControls/utils.d.ts

@@ -0,0 +1,8 @@
+export interface ICustomControls<TInit, M extends keyof TInit> {
+    enableEdit(): void;
+    disableEdit(): void;
+    getInfo(): TInit;
+    setInfo(params: Partial<Omit<TInit, M>>): void;
+    onClick(handle: () => void): void;
+    remove(): void;
+}

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

@@ -3,8 +3,10 @@ import { MapType, ICustomMapInfo, TileType } from './tmsProviders';
 import { IAddMarkerParams, ILeafletCustomMarker, IRenderMarkerCluster, LeafletMarkerHandle } from './markerCluster/index';
 import { LeafletTrackPlayback } from './trackPlayback/index';
 import { LeafletEditableHandle } from './leafletEditable/index';
-import { LeafletTitleLineMgr } from './titleLine/index';
+import { LeafletCustomControlsMgr } from './customControls/index';
 
+export { ParseShapeType as ParseShapeType } from './customControls/index';
+export type { TShapeType, ShapeTypeMap, IShapeTypeAppend, IShapeExtraInfo } from './customControls/index';
 export { PolygonHandle as LeaflePolygonEditHandle, ClrcleHandle as LeafletCicleEditHandle, } from './leafletEditable/index';
 export type { ILeafletCustomMarker } from './markerCluster/index';
 export type { LeafletInfoWindow } from './infoWindow/index';
@@ -15,6 +17,7 @@ export declare function SwichTileType(params: {
     custom?: ICustomMapInfo;
 }): void;
 export declare function SetMapBottomLeftShow(info: string): void;
+export declare function SetMapClusterType(clusterType: IRenderMarkerCluster<any>["clusterType"]): void;
 export type ICustomLeafletMap = ReturnType<typeof CreateMap>;
 export type { IRenderMarkerCluster } from './markerCluster/index';
 export type { LeafletTrackPlaybackPoint } from './trackPlayback/index';
@@ -143,11 +146,14 @@ export declare function CreateMap<T>(params: {
         getContainer(): HTMLElement;
         updateContainer(): void;
         removeAllMarkers(): void;
+        setCursor(): {
+            resume(): void;
+        };
     };
     playback: LeafletTrackPlayback;
     fenceHandle: LeafletEditableHandle;
     components: {
-        titleLineMgr: LeafletTitleLineMgr;
+        titleLineMgr: LeafletCustomControlsMgr;
     };
     conversion: {
         containerPointToLatLng(point: [x: number, y: number]): L.LatLng;

package/dist/types/basemap/leafletEditable/index.d.ts

@@ -15,6 +15,9 @@ export declare class LeafletMutilsEditableHandle {
     addPolygonHandle(): PolygonHandle;
     clear(): void;
 }
+export declare function setMapEditCursor(map: L.Map, cursor?: string): {
+    resume(): void;
+};
 export declare class PolygonHandle {
     private polygon;
     private map;

package/dist/types/basemap/markerCluster/index.d.ts

@@ -5,6 +5,7 @@ import { createMarkerCustomFromMarker } from './marker';
 export interface IRenderMarkerCluster<T> {
     rendeCluster?: (userDatas: Array<T>, map: L.Map, cluster: ReturnType<LeafletMarkerHandle<any>["getCurrentZoomCluster"]>) => L.DivIcon;
     onClusterClick?: (userDatas: Array<T>, cluster: L.MarkerCluster, map: L.Map) => void;
+    clusterType?: "NORMAL" | "NO_CLUSTER";
 }
 export type ILeafletCustomMarker = ReturnType<typeof createMarkerCustomFromMarker>;
 export interface IAddMarkerParams<T> {
@@ -18,7 +19,7 @@ export interface IAddMarkerParams<T> {
     options?: L.MarkerOptions;
 }
 export declare class IntervalTick {
-    constructor(cluster: L.MarkerClusterGroup);
+    constructor();
     private tasks;
     push(task: () => void): Promise<void>;
 }
@@ -32,11 +33,13 @@ export declare class LeafletMarkerHandle<T = any> {
     private freshCurrentZoomCluster;
     getCurrentZoomCluster(cluster: L.MarkerCluster): {
         utils: {
+            getPos: () => L.Point;
             freshIcons: () => void;
         };
         currentId: string;
     };
     private gRealtimeTrack;
+    private radius;
     constructor(map: L.Map, renderOptions: IRenderMarkerCluster<T>);
     private clusterClickHandle;
     on(eventType: "clusterclick", handle: (userDatas: T[], utils: {
@@ -45,6 +48,10 @@ export declare class LeafletMarkerHandle<T = any> {
     }) => void): void;
     off(eventType: "clusterclick", handle: Parameters<LeafletMarkerHandle["on"]>[1]): void;
     private iconCreateFunction;
+    setMaxClusterRadius(radius: number): void;
+    private szMarkers;
+    private addMarkerWrapper;
+    proxyRemove(marker: L.Marker): void;
     addMarkers(markerInfos: Array<IAddMarkerParams<T>>): {
         getUserData(): T;
         emitsClick(): void;

package/dist/types/basemap/markerCluster/marker.d.ts

@@ -6,7 +6,9 @@ import { CreateMarker } from './utils';
 export declare function createMarkerCustomFromMarker<T>(markerCreated: ReturnType<typeof CreateMarker>, addParams: IAddMarkerParams<T>, addition: {
     infoWindow: LeafletInfoWindow;
     map: L.Map;
-    cluster: L.MarkerClusterGroup;
+    cluster: {
+        proxyRemove(marker: L.Marker): void;
+    };
     intervalTick: IntervalTick;
     realtimeTrackMgr: RealtimeTrackMgr;
 }): {

package/dist/types/basemap/realtimeTrack/polylineTrack.d.ts

@@ -6,8 +6,9 @@ interface Icustom {
     onTooltipUpdata?: IRealtimeTrackEvents["onTooltipUpdate"];
 }
 export declare class PolylineTrack extends L.Polyline {
+    private cicleColorMy?;
     constructor(latlngs: L.LatLngExpression[] | L.LatLngExpression[][], options?: L.PolylineOptions & {
-        custom: Icustom;
+        custom?: Icustom;
     });
     private customData;
     private myCircleBorder;
@@ -21,5 +22,6 @@ export declare class PolylineTrack extends L.Polyline {
         title: string;
         value: string;
     }>): this;
+    private filterCircleMarkers;
 }
 export {};

package/dist/types/basemap/realtimeTrackMgr/index.d.ts

@@ -4,6 +4,7 @@ export declare class RealtimeTrackMgr {
     private tooltipContentDiv;
     private tooltip;
     private mapTrajektoria;
+    private getColor;
     private getTrajektoria;
     startTrajektoria(marker: L.Marker): void;
     stopTrajektoria(marker: L.Marker): void;

package/dist/types/basemap/realtimeTrackMgr/trajektoriaAndTrack.d.ts

@@ -3,7 +3,7 @@ export declare class TrajektoriaAndTrack {
     private marker;
     private map;
     private currentMarker;
-    constructor(map: L.Map, marker: L.Marker);
+    constructor(map: L.Map, marker: L.Marker, lineOptions: L.PolylineOptions);
     private onMarker;
     private bTrajektoriaing;
     private bTracking;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@besovideo/bvmap-leaflet",
-  "version": "0.0.10",
+  "version": "0.0.13",
   "description": "",
   "main": "./dist/main.js",
   "types": "./dist/types/main.d.ts",
@@ -16,6 +16,9 @@
     "@types/leaflet-editable": "^1.2.6",
     "@types/leaflet-rotate": "^0.1.4",
     "@types/leaflet.markercluster": "^1.5.4",
+    "@types/node": "^22.9.0",
+    "kml": "^0.0.1",
+    "togeojson": "^0.16.0",
     "typescript": "^5.5.4",
     "vite": "^5.3.4",
     "vite-plugin-dts": "4.0.0-beta.2"

package/dist/types/basemap/titleLine/index.d.ts

@@ -1,12 +0,0 @@
-export declare class LeafletTitleLineMgr {
-    private map;
-    constructor(map: L.Map);
-    private lines;
-    addLine(latlngs: Array<L.LatLngTuple>, title: string): LeafletTitleLine;
-}
-declare class LeafletTitleLine {
-    private map;
-    private polyline;
-    constructor(map: L.Map, latlngs: Array<L.LatLngTuple>, title: string);
-}
-export {};