aur-openlayers 0.0.1

package/lib/map-framework/runtime/fit-layer.utils.d.ts

@@ -0,0 +1,3 @@
+import type { ViewFitOptions, ViewFitPadding } from '../public/types';
+export declare function toOlPadding(p?: ViewFitPadding, fallback?: [number, number, number, number] | undefined): [number, number, number, number] | undefined;
+export declare function toOlFitOptions(opts?: ViewFitOptions): any;

package/lib/map-framework/runtime/interaction-manager.d.ts

@@ -0,0 +1,110 @@
+import Feature from 'ol/Feature';
+import type Geometry from 'ol/geom/Geometry';
+import type MapBrowserEvent from 'ol/MapBrowserEvent';
+import type OlMap from 'ol/Map';
+import type VectorLayer from 'ol/layer/Vector';
+import type { HitItem, MapContext, MapSchema, VectorLayerApi, VectorLayerDescriptor } from '../public/types';
+export type HitTestArgs = {
+    layerId: string;
+    layer: VectorLayer;
+    api: VectorLayerApi<any, any>;
+    descriptor: VectorLayerDescriptor<any, any, any, any>;
+    event: MapBrowserEvent<UIEvent>;
+    hitTolerance: number;
+};
+export type ClusterHit = {
+    feature: Feature<Geometry>;
+    features: Array<Feature<Geometry>>;
+    size: number;
+};
+export type HitTestResult = {
+    items: Array<HitItem<any, any>>;
+    cluster?: ClusterHit;
+};
+export type HitTestFn = (args: HitTestArgs) => HitTestResult;
+export type InteractionManagerOptions<Layers extends readonly VectorLayerDescriptor<any, any, any, any>[]> = {
+    ctx: MapContext;
+    map: OlMap;
+    schema: MapSchema<Layers>;
+    layers: Record<string, VectorLayer>;
+    apis: Record<string, VectorLayerApi<any, any>>;
+    hitTest?: HitTestFn;
+};
+export declare class InteractionManager<Layers extends readonly VectorLayerDescriptor<any, any, any, any>[]> {
+    private readonly ctx;
+    private readonly map;
+    private readonly schema;
+    private readonly layers;
+    private readonly apis;
+    private readonly hitTest;
+    private readonly hoverItems;
+    private readonly selectedItems;
+    private readonly activeTranslates;
+    private readonly activeModifies;
+    private readonly nativeModifies;
+    private readonly popupStack;
+    private readonly listenerKeys;
+    private readonly enabledState;
+    private dragPanLocks;
+    private dragPanStates?;
+    private currentCursor?;
+    constructor(options: InteractionManagerOptions<Layers>);
+    refreshEnabled(): void;
+    handlePointerDown(event: MapBrowserEvent<UIEvent>): void;
+    handlePointerDrag(event: MapBrowserEvent<UIEvent>): void;
+    handlePointerUp(event: MapBrowserEvent<UIEvent>): void;
+    handlePointerMove(event: MapBrowserEvent<UIEvent>): void;
+    handleSingleClick(event: MapBrowserEvent<UIEvent>): void;
+    handleDoubleClick(event: MapBrowserEvent<UIEvent>): void;
+    private runInteractionMutation;
+    private syncListeners;
+    private syncNativeModify;
+    private teardownNativeModify;
+    private handleNativeModifyStart;
+    private handleNativeModifyEnd;
+    private resolveHitItemsFromFeatures;
+    private hasCursorInteraction;
+    private toggleListener;
+    private removeListener;
+    private isListening;
+    private applyDisabledCleanup;
+    private clearHoverState;
+    private clearSelectState;
+    private cancelTranslate;
+    private cancelModify;
+    private updateCursor;
+    private getActiveSessionCursor;
+    private getLayerCursor;
+    private getCursorHitTolerance;
+    private setCursor;
+    private getTargetElement;
+    private getLayerEntry;
+    private applyTranslateMove;
+    private applyModifyChange;
+    private finishTranslate;
+    private finishModify;
+    private resolveTarget;
+    private lockDragPan;
+    private unlockDragPan;
+    private createTranslateEvent;
+    private createModifyEvent;
+    private createDefaultHitTest;
+    private collectFeaturePopupItems;
+    private collectPopupItems;
+    private getClusterDedupKey;
+    private getOrderedLayers;
+    private getHitTolerance;
+    private isEnabled;
+    private processHover;
+    private processSelect;
+    private processClick;
+    private processDoubleClick;
+    private itemsToMap;
+    private applyState;
+    private isHandled;
+    private shouldStopPropagation;
+    private shouldContinuePropagation;
+    private handleClusterClick;
+    private expandCluster;
+    private shouldStopClusterPropagation;
+}

package/lib/map-framework/runtime/layer-manager.d.ts

@@ -0,0 +1,17 @@
+import VectorLayer from 'ol/layer/Vector';
+import type OlMap from 'ol/Map';
+import type { MapContext, MapSchema, VectorLayerApi, VectorLayerDescriptor } from '../public/types';
+export declare class LayerManager<Layers extends readonly VectorLayerDescriptor<any, any, any, any>[]> {
+    private readonly map;
+    private readonly layers;
+    private readonly apis;
+    private readonly interactions;
+    private readonly ctx;
+    private constructor();
+    static create<Layers extends readonly VectorLayerDescriptor<any, any, any, any>[]>(map: OlMap, schema: MapSchema<Layers>): LayerManager<Layers>;
+    getLayer(id: string): VectorLayer | undefined;
+    getApi(id: string): VectorLayerApi<any, any> | undefined;
+    getApis(): Record<string, VectorLayerApi<any, any>>;
+    getContext(): MapContext;
+    refreshEnabled(): void;
+}

package/lib/map-framework/runtime/map-context.d.ts

@@ -0,0 +1,4 @@
+import type OlMap from 'ol/Map';
+import type { MapContext, PopupHostApi, VectorLayerApi } from '../public/types';
+import { FlushScheduler } from './scheduler';
+export declare const createMapContext: (map: OlMap, layers: Record<string, VectorLayerApi<any, any>>, popupHost?: PopupHostApi, scheduler?: FlushScheduler) => MapContext;

package/lib/map-framework/runtime/plain-layer.d.ts

@@ -0,0 +1,6 @@
+import type Geometry from 'ol/geom/Geometry';
+import { VectorLayerBase, VectorLayerBaseOptions } from './vector-layer-base';
+export type PlainLayerOptions<M, G extends Geometry, OPTS extends object> = VectorLayerBaseOptions<M, G, OPTS>;
+export declare class PlainVectorLayer<M, G extends Geometry, OPTS extends object> extends VectorLayerBase<M, G, OPTS> {
+    constructor(options: PlainLayerOptions<M, G, OPTS>);
+}

package/lib/map-framework/runtime/popup-host.d.ts

@@ -0,0 +1,31 @@
+import type { Enabled, PopupHostApi, PopupItem } from '../public/types';
+export type PopupHostOptions = {
+    enabled?: Enabled;
+    maxItems?: number;
+    sort?: (a: PopupItem<any>, b: PopupItem<any>) => number;
+    mount?: HTMLElement | (() => HTMLElement);
+};
+export declare class PopupHost implements PopupHostApi {
+    private readonly options;
+    private items;
+    private container;
+    private target;
+    constructor(options?: PopupHostOptions);
+    push(items: PopupItem<any>[]): void;
+    set(items: PopupItem<any>[]): void;
+    clear(): void;
+    remove(key: string | number): void;
+    getItems(): PopupItem<any>[];
+    mount(target: HTMLElement | (() => HTMLElement)): void;
+    dispose(): void;
+    private ensureEnabled;
+    private isEnabled;
+    private unmount;
+    private prepareItems;
+    private dedup;
+    private applySort;
+    private applyLimit;
+    private getDedupKey;
+    private defaultSort;
+    private render;
+}

package/lib/map-framework/runtime/scheduler.d.ts

@@ -0,0 +1,21 @@
+import type { BatchOptions, FlushPolicy } from '../public/types';
+type TaskKey = unknown;
+export declare class FlushScheduler {
+    private readonly defaultPolicy;
+    private readonly queue;
+    private pendingPolicy;
+    private scheduledToken;
+    private rafId;
+    private batchDepth;
+    private readonly policyStack;
+    constructor(defaultPolicy?: FlushPolicy);
+    batch(fn: () => void, options?: BatchOptions): void;
+    schedule(key: TaskKey, task: () => void, policy?: FlushPolicy): void;
+    private requestFlush;
+    private scheduleFlush;
+    private flush;
+    private currentPolicy;
+    private combinePolicies;
+    private shouldUpgradePolicy;
+}
+export {};

package/lib/map-framework/runtime/style/feature-states.d.ts

@@ -0,0 +1,5 @@
+import type Feature from 'ol/Feature';
+import type Geometry from 'ol/geom/Geometry';
+export declare const getFeatureStates: (feature: Feature<Geometry>) => string[];
+export declare const setFeatureStates: (feature: Feature<Geometry>, states: string[]) => void;
+export declare const clearFeatureStates: (feature: Feature<Geometry>) => void;

package/lib/map-framework/runtime/style/style-cache.d.ts

@@ -0,0 +1,7 @@
+import type Style from 'ol/style/Style';
+export type StyleCacheKey = string;
+export declare class StyleCache {
+    private readonly stringCache;
+    get(key: StyleCacheKey): Style | Style[] | undefined;
+    set(key: StyleCacheKey, value: Style | Style[]): void;
+}

package/lib/map-framework/runtime/style/style-pipeline.d.ts

@@ -0,0 +1,20 @@
+import Feature from 'ol/Feature';
+import type Geometry from 'ol/geom/Geometry';
+import type OlMap from 'ol/Map';
+import type { StyleFunction } from 'ol/style/Style';
+import type { FeatureDescriptor, LayerClustering, MapContext } from '../../public/types';
+export type StylePipelineOptions<M, G extends Geometry, OPTS extends object> = {
+    descriptor: FeatureDescriptor<M, G, OPTS>;
+    ctx: MapContext;
+    registryGetModel: (feature: Feature<Geometry>) => M | undefined;
+    map?: OlMap;
+};
+export declare const createStyleFunction: <M, G extends Geometry, OPTS extends object>(options: StylePipelineOptions<M, G, OPTS>) => StyleFunction;
+export type ClusterStylePipelineOptions<M, G extends Geometry, OPTS extends object> = {
+    descriptor: FeatureDescriptor<M, G, OPTS>;
+    clustering: LayerClustering<M>;
+    ctx: MapContext;
+    registryGetModel: (feature: Feature<Geometry>) => M | undefined;
+    map?: OlMap;
+};
+export declare const createClusterStyleFunction: <M, G extends Geometry, OPTS extends object>(options: ClusterStylePipelineOptions<M, G, OPTS>) => StyleFunction;

package/lib/map-framework/runtime/vector-layer-base.d.ts

@@ -0,0 +1,53 @@
+import Feature from 'ol/Feature';
+import type Geometry from 'ol/geom/Geometry';
+import type VectorLayer from 'ol/layer/Vector';
+import type VectorSource from 'ol/source/Vector';
+import type { FeatureDescriptor, MapContext, ModelChange, VectorLayerApi, VectorLayerDescriptor, ViewFitOptions } from '../public/types';
+import { FeatureRegistry } from './feature-registry';
+export type VectorLayerBaseOptions<M, G extends Geometry, OPTS extends object> = {
+    descriptor: VectorLayerDescriptor<M, G, OPTS>;
+    layer: VectorLayer;
+    source: VectorSource<G>;
+    ctx: MapContext;
+    scheduleInvalidate: () => void;
+};
+export declare abstract class VectorLayerBase<M, G extends Geometry, OPTS extends object> implements VectorLayerApi<M, G> {
+    protected readonly descriptor: FeatureDescriptor<M, G, OPTS>;
+    protected readonly layer: VectorLayer;
+    protected readonly source: VectorSource<G>;
+    protected readonly registry: FeatureRegistry<M, G>;
+    protected readonly scheduleInvalidate: () => void;
+    protected readonly ctx: MapContext;
+    private readonly changeHandlers;
+    constructor(options: VectorLayerBaseOptions<M, G, OPTS>);
+    setModels(models: readonly M[]): void;
+    invalidate(): void;
+    syncFeatureFromModel(model: M): void;
+    getModelByFeature(feature: Feature<G>): M | undefined;
+    mutate(id: string | number, update: (prev: M) => M, reason?: ModelChange<M>['reason']): void;
+    mutateMany(ids: Array<string | number>, update: (prev: M) => M, reason?: ModelChange<M>['reason']): void;
+    onModelsChanged(cb: (changes: ModelChange<M>[]) => void): () => void;
+    /** Fit view to all features on the layer. No-op if extent is empty. */
+    centerOnAllModels(opts?: ViewFitOptions): void;
+    /** Fit view to a single feature by id. No-op if feature/geometry is missing. */
+    centerOnModel(id: string | number, opts?: ViewFitOptions): void;
+    /**
+     * Fit view to a subset of features by ids (combined extent).
+     * Missing ids are ignored. No-op if none found.
+     */
+    centerOnModels(ids: ReadonlyArray<string | number>, opts?: ViewFitOptions): void;
+    setVisible(visible: boolean): void;
+    isVisible(): boolean;
+    setOpacity(opacity: number): void;
+    getOpacity(): number;
+    getZIndex(): number | undefined;
+    setZIndex(z: number): void;
+    getModelById(id: string | number): M | undefined;
+    hasModel(id: string | number): boolean;
+    getAllModels(): readonly M[];
+    getAllModelIds(): Array<string | number>;
+    setFeatureStates(ids: string | number | ReadonlyArray<string | number>, states?: string | string[]): void;
+    protected setModelsInternal(models: readonly M[]): void;
+    protected getCenterOnAllModelsSource(): VectorSource<G> | null;
+    private emitModelChanges;
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "aur-openlayers",
+  "version": "0.0.1",
+  "peerDependencies": {
+    "@angular/common": "^19.2.0",
+    "@angular/core": "^19.2.0",
+    "ol": "^6.5.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/aur-openlayers.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/aur-openlayers.mjs"
+    }
+  }
+}

package/public-api.d.ts

@@ -0,0 +1,3 @@
+export * from './lib/lib.service';
+export * from './lib/lib.component';
+export * from './lib/map-framework';