@smart-factor/gem-ui-map-component 0.0.1

package/dist/providers/GemUIMapComponentProvider.d.ts

@@ -0,0 +1,4 @@
+declare const GemUIMapComponentProvider: ({ children, }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export default GemUIMapComponentProvider;

package/dist/services/EventEmitter.d.ts

@@ -0,0 +1,7 @@
+export declare class TypedEventEmitter<Events extends Record<string, unknown>> {
+    private emitter;
+    constructor();
+    emit<Key extends keyof Events>(event: Key, ...args: Events[Key] extends void ? [] : [Events[Key]?]): boolean;
+    on<Key extends keyof Events>(event: Key, listener: (arg: Events[Key]) => void): this;
+    off<Key extends keyof Events>(event: Key, listener?: (arg: Events[Key]) => void): this;
+}

package/dist/services/Layers/LayersService.d.ts

@@ -0,0 +1,34 @@
+import { GEMLayer, GEMLayerTreeItem, LayersEvents, ProcessedGEMLayer, WMSLayerDetailed } from '../../components/Map/types';
+import { TypedEventEmitter } from '../EventEmitter';
+declare class LayersService {
+    private selectedLayers;
+    private selectedLayersSymbols;
+    layersEventEmitters: TypedEventEmitter<LayersEvents>;
+    queryGEMLayers(): Promise<import('axios').AxiosResponse<{
+        response: {
+            data: GEMLayer[];
+        };
+    }, any>>;
+    querySelectedLayers(symbol: string): Promise<import('axios').AxiosResponse<any, any>>;
+    saveLayersConfig(value: string, symbol: string): Promise<import('axios').AxiosResponse<any, any>>;
+    setSelectedLayers(layers: (GEMLayer | WMSLayerDetailed)[]): void;
+    addLayersToSelected(layers: (GEMLayer | WMSLayerDetailed)[]): void;
+    removeLayersFromSelected(layers: (GEMLayer | WMSLayerDetailed)[]): void;
+    getSelectedLayersSymbols(): string[];
+    queryLayersByKeys(unprocessedLayers: GEMLayer[], checkedLayersKeys: string[]): GEMLayer[];
+    processLayersStructure(layers: GEMLayer[], selectedLayerIds: string[]): {
+        id: string;
+        parent: string;
+        label: string;
+        config: import('../Map/types').GEMLayerConfig;
+        checked: boolean;
+    }[];
+    createTreeItems(flatLayers: ProcessedGEMLayer[]): GEMLayerTreeItem[];
+    onNodeCheck(nodeId: string, checked: boolean, treeItems: GEMLayerTreeItem[]): GEMLayerTreeItem[];
+    getCheckedLayers(treeItems: GEMLayerTreeItem[], unprocessedLayers: GEMLayer[]): GEMLayer[];
+    getCheckedLayerIds(treeItems: GEMLayerTreeItem[]): string[];
+    filterTree(nodes: GEMLayerTreeItem[], searchTerm: string): GEMLayerTreeItem[];
+    private filterNode;
+}
+declare const _default: LayersService;
+export default _default;

package/dist/services/Map/MapService.d.ts

@@ -0,0 +1,70 @@
+import { Map } from 'ol';
+import { Coordinate } from 'ol/coordinate';
+import { default as Feature } from 'ol/Feature';
+import { Geometry as GeometryOl } from 'ol/geom';
+import { Type } from 'ol/geom/Geometry';
+import { default as VectorLayer } from 'ol/layer/Vector';
+import { default as VectorSource } from 'ol/source/Vector';
+import { Style } from 'ol/style';
+import { Geometry as GeometryApi } from '../../api/services/generated/api';
+import { GEMRoadNetDetails, GeometryEvents, ItemPositionResponse, MapEvents, SnapEvents, VectorLayerType } from '../../components/Map/types';
+import { TypedEventEmitter } from '../EventEmitter';
+import { GEMFeature, GEMLayerConfig, GEMVectorLayer, GroupedWMSLayer, QueryMapItemsPayload, StyleDefinition, WMSLayer, WMSLayerConfig } from './types';
+declare class MapService {
+    projectionConst: {
+        EPSG_2180: string;
+        EPSG_3857: string;
+    };
+    private imageScale;
+    private mapItemsCache;
+    private abortController;
+    private debounceTimeout;
+    mapEventEmitter: TypedEventEmitter<MapEvents>;
+    geometryEventEmitter: TypedEventEmitter<GeometryEvents>;
+    snapEventEmitter: TypedEventEmitter<SnapEvents>;
+    constructor();
+    queryConfig(symbol: string): Promise<import('axios').AxiosResponse<any, any>>;
+    queryMapItemsDebounced(payload: QueryMapItemsPayload, options?: {
+        signal?: AbortSignal;
+    }, debounceTime?: number): Promise<GEMVectorLayer[]>;
+    clearCache(key?: string): void;
+    getMapExtent(map: Map): {
+        type: string;
+        coordinates: Coordinate[][];
+        crs: {
+            type: string;
+            properties: {
+                name: string;
+            };
+        };
+    };
+    createFeatures(featureList: GEMFeature[], style: StyleDefinition, image: GEMVectorLayer['image']): Feature<GeometryOl>[];
+    createFeature(feature: GEMFeature, style: StyleDefinition, image: GEMVectorLayer['image'], imageScale?: number | null): Feature<GeometryOl>;
+    createLayer(style?: StyleDefinition): VectorLayer<VectorSource<Feature<GeometryOl>>, Feature<GeometryOl>>;
+    createEmptyVectorLayer(layer_symbol: string): VectorLayer<VectorSource<Feature<GeometryOl>>, Feature<GeometryOl>>;
+    createVectorLayer(layer: GEMVectorLayer, type: string, imageScale: number, config?: GEMLayerConfig | WMSLayerConfig): VectorLayer<VectorSource<Feature<GeometryOl>>, Feature<GeometryOl>>;
+    groupWMSServices(layers: WMSLayer[]): GroupedWMSLayer[];
+    processStyle(styleDefinition: StyleDefinition, imageSrc: string | null): Style;
+    queryNetsByRoadId(roadId: number): Promise<import('axios').AxiosResponse<{
+        response: GEMRoadNetDetails[];
+    }, any>>;
+    queryPointIconPositionFromCoords(coords: Coordinate): Promise<{
+        response: ItemPositionResponse;
+    }>;
+    createPurposeGeometry(caseObjectId: number, geometry: Partial<GeometryApi>, layerId: number): Promise<import('axios').AxiosResponse<any, any>>;
+    updatePurposeGeometry(id: number, mapRepresentationId: number, geometry: Partial<GeometryApi>, layerId: number): Promise<import('axios').AxiosResponse<any, any>>;
+    deletePurposeGeometry(id: number, mapRepresentationId: number): Promise<import('axios').AxiosResponse<any, any>>;
+    getPurposeGeometry(caseObjectId: number): Promise<import('axios').AxiosResponse<import('../../api/services/generated/api').QueryMapRepresentationsByCaseObjectIdData, any>>;
+    validatePurposeGeometry(geometry: Partial<GeometryApi>): Promise<{
+        response: boolean;
+    }>;
+    getDefaultStyle(feature?: Feature<GeometryOl>, isNonEditable?: boolean): any;
+    getSelectStyle(feature: Feature<GeometryOl>): any[] | Style;
+    queryHoverStyles(): Record<Type, Style>;
+    getHoverStyle(feature: Feature<GeometryOl>): any[] | Style | undefined;
+    removeHoverStyle(feature: Feature<GeometryOl>): any;
+    filterLayersByFeatureId(id: string, layers: VectorLayerType[]): VectorLayerType[];
+    findLayerByFeatureId(id: string, layers: VectorLayerType[]): VectorLayerType | undefined;
+}
+declare const _default: MapService;
+export default _default;

package/dist/services/Map/types.d.ts

@@ -0,0 +1,96 @@
+import { Coordinate } from 'ol/coordinate';
+import { Geometry } from 'ol/geom';
+export interface WMSLayer {
+    id: string;
+    name: string;
+    projection: string;
+    type: string;
+    url: string;
+    use_cors: boolean;
+    version: string;
+    zIndex: number;
+}
+export type WMSLayerConfig = {
+    type: 'WMS';
+    symbol: string;
+    url: string;
+    use_cors: boolean;
+    read_only: boolean;
+    creatable_por: string;
+    min_zoom: number;
+    max_zoom: number;
+    declutter: boolean;
+    format: string;
+    projection: string;
+    version: string;
+    layerOrder: number;
+    geomType: string;
+    mlv_id: number;
+    visible_for_rlo: boolean;
+};
+export interface GroupedWMSLayer extends Omit<WMSLayer, 'name'> {
+    layers: string[];
+}
+export type GEMLayerConfig = {
+    creatable_por: boolean;
+    declutter: boolean;
+    format: string | null;
+    geomType: 'POINT' | 'LINESTRING' | 'POLYGON';
+    layerOrder: number;
+    max_zoom: number;
+    min_zoom: number;
+    mlv_id: number;
+    projection: string | null;
+    read_only: boolean;
+    symbol: string;
+    type: 'GEM' | 'WMS' | 'VECTOR' | 'RASTR';
+    url: string | null;
+    use_cors: boolean;
+    version: string | null;
+    visible_for_rlo: boolean;
+};
+export type GEMVectorLayer = {
+    image: string | null;
+    items: GEMFeature[];
+    layer_style: StyleDefinition;
+    layer_symbol: string;
+};
+export type StyleDefinition = {
+    fill: string;
+    radius: string;
+    rotateWithView?: boolean;
+    rotation?: number;
+    styleDefinition?: boolean;
+    stroke: {
+        color: string;
+        width?: string;
+        lineDash?: number[];
+        lineCap?: CanvasLineCap;
+    };
+};
+export type GEMFeature = {
+    id: number;
+    road_id: number;
+    item_style: StyleDefinition | null;
+    image: string | null;
+    text: string | null;
+    ref_id: number | null;
+    parent_id: number | null;
+    geometry: Geometry;
+};
+type Bbox = {
+    coordinates: Coordinate[][];
+    crs: {
+        properties: {
+            name: string;
+        };
+        type: string;
+    };
+    type: string;
+};
+export type QueryMapItemsPayload = {
+    layerList: string[];
+    bbox: Bbox;
+    zoom: number;
+};
+export {};

package/dist/services/Navigation/NavigationService.d.ts

@@ -0,0 +1,12 @@
+import { GEMRoad, GEMRoadNetResponse, NavigationEvents } from '../../components/Map/types';
+import { TypedEventEmitter } from '../EventEmitter';
+declare class NavigationService {
+    navigationEventEmitter: TypedEventEmitter<NavigationEvents>;
+    constructor();
+    queryRoadsInformation(): Promise<import('axios').AxiosResponse<{
+        response: GEMRoad[];
+    }, any>>;
+    queryRoadNets(roadId: number): Promise<import('axios').AxiosResponse<GEMRoadNetResponse, any>>;
+}
+declare const _default: NavigationService;
+export default _default;

package/dist/snap/helpers.d.ts

@@ -0,0 +1,7 @@
+import { Collection, Feature } from 'ol';
+import { Coordinate } from 'ol/coordinate';
+import { FindInteractionProps, QuerySnapProps, RemoveInteractionProps } from './types';
+export declare const removeInteraction: ({ type, map }: RemoveInteractionProps) => void;
+export declare const findInteraction: ({ type, interactions, }: FindInteractionProps) => import('ol/interaction/Interaction').default | undefined;
+export declare const createAngleFeatures: (points: Coordinate[]) => Collection<Feature<import('ol/geom').Geometry>>;
+export declare const querySnapPoints: ({ interactLayers, type }: QuerySnapProps) => Collection<Feature<import('ol/geom').Geometry>>;

package/dist/snap/snap.d.ts

@@ -0,0 +1,12 @@
+import { Collection, Feature } from 'ol';
+import { default as Select } from 'ol/interaction/Select';
+import { default as Snap } from 'ol/interaction/Snap';
+import { default as VectorLayer } from 'ol/layer/Vector';
+import { Vector } from 'ol/source';
+import { AddAdditionalSnapProps, AddAngleSnapProps, CreateHoverSnapLayer, RemoveHoverSnapLayerProps } from './types';
+export declare const initializeSnapInteraction: (features: Collection<Feature>) => Snap;
+export declare const addAdditionalSnapInteraction: ({ interactLayers, map, pixelTolerance, type, }: AddAdditionalSnapProps) => void;
+export declare const addAngleSnapInteraction: ({ map, points, pixelTolerance, type, }: AddAngleSnapProps) => void;
+export declare const createHoverSnapLayer: ({ features, type, }: CreateHoverSnapLayer) => VectorLayer<Vector<Feature<import('ol/geom').Geometry>>, Feature<import('ol/geom').Geometry>>;
+export declare const removeHoverSnapLayer: ({ interactSnapLayers, type, map, }: RemoveHoverSnapLayerProps) => void;
+export declare const initializeHoverSnapInteraction: (layers: VectorLayer[], pixelTolerance: number) => Select;

package/dist/snap/types.d.ts

@@ -0,0 +1,49 @@
+import { Collection, Feature, Map } from 'ol';
+import { Coordinate } from 'ol/coordinate';
+import { default as Interaction } from 'ol/interaction/Interaction';
+import { default as VectorLayer } from 'ol/layer/Vector';
+export interface AddAdditionalSnapProps {
+    interactLayers: VectorLayer[];
+    map: Map;
+    pixelTolerance: number;
+    type: string;
+}
+export interface AddAngleSnapProps {
+    map: Map;
+    points: Coordinate[];
+    pixelTolerance: number;
+    type: string;
+}
+export interface CreateHoverSnapLayer {
+    features: Collection<Feature>;
+    type: string;
+}
+export interface RemoveInteractionProps {
+    type: string;
+    map: Map;
+}
+export interface FindInteractionProps {
+    type: string;
+    interactions: Interaction[];
+}
+export interface QuerySnapProps {
+    interactLayers: VectorLayer[];
+    type: string;
+}
+export interface InitializeAdditionalSnapProps {
+    features: Collection<Feature>;
+    map: Map;
+    pixelTolerance: number;
+    type: string;
+}
+export interface InitializeAngleSnapProps {
+    features: Collection<Feature>;
+    map: Map;
+    pixelTolerance: number;
+    type: string;
+}
+export interface RemoveHoverSnapLayerProps {
+    interactSnapLayers: VectorLayer[];
+    type: string;
+    map: Map;
+}

package/package.json

@@ -0,0 +1,107 @@
+{
+  "name": "@smart-factor/gem-ui-map-component",
+  "version": "0.0.1",
+  "private": false,
+  "description": "Gem UI Map Component",
+  "type": "module",
+  "module": "./dist/main.js",
+  "exports": "./dist/main.js",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "types": "./dist/main.d.ts",
+  "scripts": {
+    "build": "tsc && vite build",
+    "watch": "vite build --watch",
+    "lint": "eslint 'src/**/*.{js,jsx,ts,tsx}' --report-unused-disable-directives --max-warnings 0",
+    "lint:fix": "eslint 'src/**/*.{js,jsx,ts,tsx}' --fix",
+    "format": "prettier --write 'src/**/*.{js,jsx,ts,tsx,css,md}' --ignore-unknown",
+    "storybook": "storybook dev -p 6006",
+    "build-storybook": "storybook build",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest run --coverage",
+    "prepare": "husky",
+    "knip": "knip"
+  },
+  "peerDependencies": {
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "@chromatic-com/storybook": "^1.6.1",
+    "@storybook/addon-essentials": "^8.2.4",
+    "@storybook/addon-interactions": "^8.2.4",
+    "@storybook/addon-links": "^8.2.4",
+    "@storybook/blocks": "^8.2.4",
+    "@storybook/react": "^8.2.4",
+    "@storybook/react-vite": "^8.2.4",
+    "@storybook/test": "^8.2.4",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.0.0",
+    "@testing-library/user-event": "^14.5.2",
+    "@types/node": "^20.14.9",
+    "@types/proj4": "^2.5.6",
+    "@types/qs": "^6.9.18",
+    "@types/react": "^18.3.3",
+    "@types/react-dom": "^18.3.0",
+    "@typescript-eslint/eslint-plugin": "^7.16.1",
+    "@typescript-eslint/parser": "^7.16.1",
+    "@vitejs/plugin-react": "^4.3.1",
+    "@vitest/coverage-v8": "^2.0.5",
+    "@vitest/ui": "^2.0.5",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-react": "^7.34.2",
+    "eslint-plugin-react-hooks": "^4.6.2",
+    "eslint-plugin-react-refresh": "^0.4.7",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "eslint-plugin-storybook": "^0.8.0",
+    "glob": "10.3.12",
+    "jsdom": "^24.1.0",
+    "knip": "^5.43.6",
+    "prettier": "^3.4.2",
+    "storybook": "^8.2.4",
+    "typescript": "5.4.5",
+    "vite": "^5.3.1",
+    "vite-plugin-dts": "^4.0.0-beta.2",
+    "vite-plugin-lib-inject-css": "2.0.1",
+    "vitest": "^2.0.3"
+  },
+  "dependencies": {
+    "@emotion/react": "^11.13.0",
+    "@emotion/styled": "^11.13.0",
+    "@hookform/resolvers": "^3.9.0",
+    "@mui/icons-material": "^5.15.21",
+    "@mui/material": "^5.16.7",
+    "@mui/system": "^5.16.7",
+    "@smart-factor/gem-ui-components": "^0.0.51",
+    "@tanstack/react-query": "^5.49.2",
+    "@turf/bearing": "^7.1.0",
+    "@turf/center": "^7.1.0",
+    "@turf/destination": "^7.1.0",
+    "@turf/distance": "^7.1.0",
+    "@turf/helpers": "^7.1.0",
+    "axios": "^1.7.9",
+    "eventemitter3": "^5.0.1",
+    "husky": "^9.1.4",
+    "lint-staged": "^15.2.8",
+    "lodash-es": "^4.17.21",
+    "ol": "^10.2.1",
+    "proj4": "^2.12.0",
+    "qs": "^6.14.0",
+    "react-hook-form": "^7.53.0",
+    "react-router-dom": "^6.26.0",
+    "zod": "^3.23.8"
+  },
+  "lint-staged": {
+    "src/**/*.{js,jsx,ts,tsx}": [
+      "npm run lint:fix",
+      "npm run format"
+    ]
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}