@regionerne/gis-komponent 0.0.21 → 0.0.28

package/lib/services/conflictAnalysisSearch.service.d.ts

@@ -0,0 +1,19 @@
+import { Geometry } from 'ol/geom';
+import { SearchProviderBase } from './infoSearch.service';
+import { FeatureCollection } from 'geojson';
+import Filter from 'ol/format/filter/Filter';
+import { ILayer } from '../models/ILayer';
+import * as i0 from "@angular/core";
+interface IConflictAnalysisResult {
+    layerName: string;
+    conflict: boolean;
+}
+export declare class ConflictAnalysisSearchProvider extends SearchProviderBase<IConflictAnalysisResult, Geometry> {
+    private _current;
+    getSearchableLayers(): ILayer[];
+    getFilter(searchValue: Geometry, layer: ILayer): Filter;
+    map(l: ILayer, f: FeatureCollection): IConflictAnalysisResult;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConflictAnalysisSearchProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConflictAnalysisSearchProvider>;
+}
+export {};

package/lib/services/currentItems.service.d.ts

@@ -1,13 +1,16 @@
 import { Map } from 'ol';
 import { IProfileDetailed } from '../models/IProfile';
+import { GisKomponentSettings } from '../models/GisKomponentSettings';
 import * as i0 from "@angular/core";
 export declare class CurrentItemsService {
+    constructor();
     private _map;
     get map(): Map | undefined;
     set map(value: Map);
     profile: IProfileDetailed | undefined;
     private _mapSubject;
     map$: import("rxjs").Observable<Map>;
+    gisKomponentSettings: GisKomponentSettings;
     static ɵfac: i0.ɵɵFactoryDeclaration<CurrentItemsService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CurrentItemsService>;
 }

package/lib/services/drawLayerSource.service.d.ts

@@ -6,14 +6,18 @@ export declare class DrawLayerSourceService {
     private _current;
     private _features;
     features$: import("rxjs").Observable<Feature<import("ol/geom").Geometry>[]>;
+    private _selectedForHighlight;
+    selectedForHighlight$: import("rxjs").Observable<Feature<import("ol/geom").Geometry>[]>;
     source: VectorSource;
     layer: VectorLayer<VectorSource<Feature<import("ol/geom").Geometry>>, Feature<import("ol/geom").Geometry>>;
     private _disabled;
     constructor();
     private _initListener;
     get allFeatures(): Feature[];
+    get allCleanedFeatures(): Feature[];
     remove(id: string | number): void;
     setFeatures(features: Feature[]): void;
+    setFeaturesSelectedForHighlight(features: Feature | Feature[]): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DrawLayerSourceService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DrawLayerSourceService>;
 }

package/lib/services/featureHelper.service.d.ts

@@ -6,7 +6,6 @@ export declare class FeatureHelperService {
     private _idCounter;
     isLocked: (feature: Feature) => boolean;
     lock(feature: Feature): void;
-    constructor();
     setTypeId(feature: Feature, typeId: string): void;
     typeId: (feature: Feature) => string;
     setId(feature: Feature): void;

package/lib/services/geometry.service.d.ts

@@ -0,0 +1,27 @@
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class GeometryService {
+    private config;
+    private _baseUrl;
+    private _http;
+    validate(wkt: string): Observable<ValidationResult>;
+    dmpValidate(wkt: string): Observable<DMPValidationResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GeometryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GeometryService>;
+}
+export interface ValidationResult {
+    wasCorrected: boolean;
+    correctedGeometries?: string[];
+}
+export interface DMPValidationResult {
+    isValid: boolean;
+    wasCorrected: boolean;
+    correctionAttempts: number;
+    error: DMPValidationErrorDto;
+    correctedGeometry?: string;
+}
+export interface DMPValidationErrorDto {
+    code: number;
+    message: string;
+    ruleName: string;
+}

package/lib/services/highlight.service.d.ts

@@ -1,15 +1,18 @@
 import { Feature } from 'ol';
-import VectorLayer from 'ol/layer/Vector';
-import { Vector } from 'ol/source';
 import * as i0 from "@angular/core";
-export declare class highlightService {
-    constructor();
+export declare class HighlightService {
+    private _wktFormat;
     private _zoomService;
-    private _style;
+    private _current;
+    private readonly fadeStart;
+    private readonly fadeEnd;
     private _highlightSource;
-    highlightLayer: VectorLayer<Vector<Feature<import("ol/geom").Geometry>>, Feature<import("ol/geom").Geometry>>;
+    private _highlightLayer;
+    constructor();
     clear(): void;
-    highlight(feature: Feature | Feature[], zoomToFeatures?: boolean): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<highlightService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<highlightService>;
+    highlight(feature: Feature | Feature[] | string, zoomToFeatures?: boolean): void;
+    private _ensureFeature;
+    private _getFadedStyle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HighlightService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HighlightService>;
 }

package/lib/services/hoverInfoSearch.service.d.ts

@@ -0,0 +1,24 @@
+import { Coordinate } from 'ol/coordinate';
+import { SearchProviderBase } from './infoSearch.service';
+import { FeatureCollection } from 'geojson';
+import Filter from 'ol/format/filter/Filter';
+import { ILayer } from '../models/ILayer';
+import Point from 'ol/geom/Point';
+import * as i0 from "@angular/core";
+interface IHoverResult {
+    values: {
+        center: Point;
+        showValue: string;
+    }[];
+}
+export declare class HoverInfoSearchService extends SearchProviderBase<IHoverResult, Coordinate> {
+    private _current;
+    private geojsonFormat;
+    getSearchableLayers(): ILayer[];
+    getFilter(searchValue: Coordinate, layer: ILayer): Filter;
+    map(l: ILayer, f: FeatureCollection): IHoverResult;
+    private _getCenterPoint;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HoverInfoSearchService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HoverInfoSearchService>;
+}
+export {};

package/lib/services/infoSearch.service.d.ts

@@ -0,0 +1,36 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { ILayer } from '../models/ILayer';
+import Filter from 'ol/format/filter/Filter';
+import { FeatureCollection } from 'geojson';
+import { Coordinate } from 'ol/coordinate';
+import * as i0 from "@angular/core";
+export declare abstract class SearchProviderBase<TResponse, TFilter> {
+    protected _http: HttpClient;
+    private wfsFormat;
+    private _serializer;
+    search(searchValue: TFilter, maxCount: number): Observable<TResponse[]>;
+    abstract getSearchableLayers(): ILayer[];
+    abstract getFilter(searchValue: TFilter, layer: ILayer): Filter;
+    abstract map(l: ILayer, f: FeatureCollection): TResponse;
+}
+export type ValueKind = 'data' | 'url' | 'img';
+export interface IValue {
+    kind: ValueKind;
+    name: string;
+    data: string;
+}
+export interface IInfoSearchResult {
+    layerName: string;
+    values: Record<string, IValue>[];
+}
+export declare class InfoSearchProvider extends SearchProviderBase<IInfoSearchResult, Coordinate> {
+    private _current;
+    getSearchableLayers(): ILayer[];
+    getFilter(searchValue: Coordinate, layer: ILayer): Filter;
+    map(layer: ILayer, f: FeatureCollection): IInfoSearchResult;
+    private _mapFeature;
+    private _getValueKind;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InfoSearchProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InfoSearchProvider>;
+}

package/lib/services/layerError.service.d.ts

@@ -8,6 +8,7 @@ export interface LayerStatus {
 }
 export declare class LayerErrorService {
     layerStatusChanged: Subject<number>;
+    layerErrored: Subject<number>;
     private layerStatuses;
     private listeners;
     private _errorService;

package/lib/services/layerHelper.service.d.ts

@@ -1,20 +1,23 @@
 import BaseLayer from 'ol/layer/Base';
 import Map from 'ol/Map';
 import { ILayer } from '../models/ILayer';
-import { BehaviorSubject } from 'rxjs';
+import { BehaviorSubject, Subject } from 'rxjs';
 import * as i0 from "@angular/core";
 export declare class LayerHelperService {
     activeLayersChanged: BehaviorSubject<boolean>;
     private readonly _layerDbIdKey;
     private readonly _layerGroupDbIdKey;
-    private readonly _layerIdsToDisplayInMapKeyName;
+    private readonly _mapFilteredLayerGroupsKeyName;
+    private _layerErrorService;
+    layerActivatedByBackgroundGroup: Subject<number>;
     setDbId(layer: BaseLayer, id: number): void;
     getDbId(layer: BaseLayer): number;
     setLayerGroupDbId(layer: BaseLayer, id: number): void;
     getLayerGroupDbId(layer: BaseLayer): number;
     applyCachedLayersToDisplayInMap(map: Map, profileId: number): void;
+    startFailoverForBackgroundGroup(aMap: Map, groupId: number): void;
     updateLayerOpacityInMap(map: Map, layer: ILayer): void;
-    toggleLayerInMap(map: Map, layer: ILayer): void;
+    toggleLayerInMap(map: Map, layerId: number): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<LayerHelperService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<LayerHelperService>;
 }

package/lib/services/layoutService.d.ts

@@ -0,0 +1,12 @@
+import Map from 'ol/Map';
+import * as i0 from "@angular/core";
+export declare class LayoutService {
+    loadInitialPositionFromProfile(widgetName: string, initialPosition: string): {
+        x: number;
+        y: number;
+    };
+    bringElementIntoViewIfNeeded(elementClass: string, offsetValue: number, collapsed: boolean, map: Map): void;
+    private _savePosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LayoutService>;
+}

package/lib/services/overlap.service.d.ts

@@ -0,0 +1,21 @@
+import { Feature as olFeature } from 'ol';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class OverlapService {
+    private _drawLayerService;
+    private _featureHelper;
+    private _snackbar;
+    private _confirmService;
+    private _geoJsonFormat;
+    private readonly EPSILON;
+    handleOverlaps(features: olFeature[]): Observable<olFeature[]>;
+    private _handleUnlockedFeaturesOverlapping;
+    handleOverlap(feature: olFeature): Observable<olFeature>;
+    private _handleLockedFeaturesOverlapping;
+    splitByFeature(cutterFeature: olFeature, remove?: boolean): Observable<olFeature[]>;
+    private _addTurfToResult;
+    private _olToGeoJSON;
+    private _geoJSONToOl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlapService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OverlapService>;
+}

package/lib/services/printDrawLayerSource.service.d.ts

@@ -1,11 +1,10 @@
-import Feature from 'ol/Feature';
 import VectorSource from 'ol/source/Vector';
 import VectorLayer from 'ol/layer/Vector';
 import * as i0 from "@angular/core";
 export declare class PrintDrawLayerSourceService {
     private _current;
     source: VectorSource;
-    layer: VectorLayer<VectorSource<Feature<import("ol/geom").Geometry>>, Feature<import("ol/geom").Geometry>>;
+    layer: VectorLayer<VectorSource<import("ol").Feature<import("ol/geom").Geometry>>, import("ol").Feature<import("ol/geom").Geometry>>;
     constructor();
     private _initListener;
     static ɵfac: i0.ɵɵFactoryDeclaration<PrintDrawLayerSourceService, never>;

package/lib/services/printHelper.service.d.ts

@@ -0,0 +1,9 @@
+import { Map } from 'ol';
+import * as i0 from "@angular/core";
+export declare class PrintHelperService {
+    setVisibiltyOnDOMElements(baseElement: HTMLElement, visible: boolean): void;
+    getImgData(map: Map, printFormat: 'image/png' | 'image/jpg', printDimensions?: [number, number]): Promise<string>;
+    private _setVisibiltyOnDOMElements;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrintHelperService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PrintHelperService>;
+}

package/lib/services/searchProvider.service.d.ts

@@ -0,0 +1,29 @@
+import { Geometry } from 'ol/geom';
+import { Observable } from 'rxjs';
+import { IValue } from './infoSearch.service';
+import * as i0 from "@angular/core";
+export declare class SearchProviderService {
+    private _cancelSearch;
+    maxSearchResults: number;
+    searchProviders: SearchProvider[];
+    search(searchString?: string, geometry?: Geometry): Observable<SearchResponse[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchProviderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SearchProviderService>;
+}
+export interface SearchProvider {
+    name: string;
+    search(searchValue?: string, geometry?: Geometry, maxCount?: number): Observable<SearchResponse[]>;
+    onSelect(searchResult: SearchResponse, targetSrs?: string): void;
+    onClear(): void;
+}
+export interface SearchResponseItem {
+    wkt: string;
+    header: string;
+    showMetadata: boolean;
+    metadata?: Record<string, IValue>[];
+}
+export interface SearchResponse {
+    total: number;
+    title: string;
+    items: SearchResponseItem[];
+}

package/lib/services/showInfo.service.d.ts

@@ -0,0 +1,15 @@
+import { IInfoSearchResult } from './infoSearch.service';
+import * as i0 from "@angular/core";
+export declare class ShowInfoService {
+    private _current;
+    private _listenKey;
+    private _active;
+    private _infoSearchProvider;
+    private _features;
+    features$: import("rxjs").Observable<IInfoSearchResult[] | null>;
+    stopShowInfo(): void;
+    startShowInfo(): void;
+    disable(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShowInfoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ShowInfoService>;
+}

package/lib/services/showInfoHover.service.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+export declare class ShowInfoHoverService {
+    private _current;
+    private _search;
+    private source;
+    private _layer;
+    init(): void;
+    private _getStyle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShowInfoHoverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ShowInfoHoverService>;
+}

package/lib/services/wfsSearch.service.d.ts

@@ -0,0 +1,39 @@
+import { FeatureCollection } from 'geojson';
+import { Observable } from 'rxjs';
+import { SearchProvider, SearchResponse } from './searchProvider.service';
+import { Geometry } from 'ol/geom';
+import * as i0 from "@angular/core";
+export interface WfsFeatureCollection extends FeatureCollection {
+    numberMatched?: number;
+    numberReturned?: number;
+    timeStamp?: string;
+    next?: string;
+    previous?: string;
+}
+export interface SearchableLayer {
+    featureType: string;
+    baseUrl: string;
+    searchField: string;
+    headerField: string;
+    geometryField: string;
+    name: string;
+    fieldsToExcludeFromInfoFromInfo: string;
+}
+export declare class WFSSearchService implements SearchProvider {
+    name: string;
+    private _http;
+    private wfsFormat;
+    private wktFormat;
+    private _searcheableLayers;
+    private geoJsonFormat;
+    private _serializer;
+    search(searchValue?: string, geometry?: Geometry, maxCount?: number): Observable<SearchResponse[]>;
+    onSelect(searchResult: SearchResponse, targetSrs?: string): void;
+    onClear(): void;
+    setSearcheableLayers(layers: SearchableLayer[]): void;
+    private _formatWKT;
+    private _mapFeatureMetadata;
+    private _getValueKind;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WFSSearchService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WFSSearchService>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@regionerne/gis-komponent",
-  "version": "0.0.21",
+  "version": "0.0.28",
   "peerDependencies": {
     "@angular/common": ">=19.2.0",
     "@angular/core": ">=19.2.0",