@vcmap/core 5.0.0-rc.32 → 5.0.0-rc.34

package/dist/src/layer/layer.d.ts

@@ -0,0 +1,221 @@
+import VcsObject, { VcsObjectOptions } from '../vcsObject.js';
+import Extent, { type ExtentOptions } from '../util/extent.js';
+import LayerState from './layerState.js';
+import VcsEvent from '../vcsEvent.js';
+import GlobalHider from './globalHider.js';
+import VcsMap from '../map/vcsMap.js';
+import LayerImplementation from './layerImplementation.js';
+import AbstractFeatureProvider from '../featureProvider/abstractFeatureProvider.js';
+export type CopyrightOptions = {
+    provider?: string;
+    url?: string;
+    year?: string;
+};
+export type LayerOptions = VcsObjectOptions & {
+    /**
+     * if true the layer will be activated on initialization
+     */
+    activeOnStartup?: boolean;
+    /**
+     * whether to allow picking on this layer
+     */
+    allowPicking?: boolean;
+    /**
+     * zIndex of this layer
+     */
+    zIndex?: number;
+    /**
+     * metadata on the data extent of the layer.
+     */
+    extent?: ExtentOptions;
+    exclusiveGroups?: (string | symbol)[];
+    /**
+     * the map names on which this layer is shown, all if empty or undefined
+     */
+    mapNames?: string[];
+    url?: string | Record<string, string>;
+    /**
+     * an array of building ids which should be hidden if this layer is active
+     */
+    hiddenObjectIds?: string[];
+    copyright?: CopyrightOptions;
+};
+export type LayerImplementationOptions = {
+    name: string;
+    url: string;
+};
+/**
+ * Abstract base class for Layers.
+ * To create a layer Implementation the function `createImplementationsForMap` has to be implemented.
+ * To receive implementation options, implement `geImplementationOptions`
+ */
+declare class Layer<I extends LayerImplementation<VcsMap> = LayerImplementation<VcsMap>> extends VcsObject {
+    static get className(): string;
+    /**
+     * Symbol to declare a layers name on its visualizations, e.g. ol.layer.Layer, Cesium.Cesium3DTileset
+     * @deprecated
+     */
+    static get vcsLayerNameSymbol(): symbol;
+    static getDefaultOptions(): LayerOptions;
+    extent: Extent | null;
+    activeOnStartup: boolean;
+    private _allowPicking;
+    private _state;
+    private _loadingPromise;
+    private _initialized;
+    mapNames: string[];
+    /**
+     * The class names of the supported maps.
+     */
+    protected _supportedMaps: string[];
+    protected _url: string | Record<string, string> | undefined;
+    private _zIndex;
+    /**
+     * Called when the zIndex of this layer is changed. Is passed the new zIndex as its only argument.
+     */
+    zIndexChanged: VcsEvent<number>;
+    /**
+     * array of object Ids which should be hidden within the context of the layers layerCollection, if this layer is active
+     */
+    private _hiddenObjectIds;
+    private _globalHider;
+    private _exclusiveGroups;
+    /**
+     * event raised if the exclusives group of the layer changes. is passed the array of exclusive groups as its only argument
+     */
+    exclusiveGroupsChanged: VcsEvent<(string | symbol)[]>;
+    copyright: CopyrightOptions | undefined;
+    private _implementations;
+    private _activeMaps;
+    /**
+     * Event raised, if the layers state changes. Is passed the LayerState as its only parameter
+     */
+    stateChanged: VcsEvent<LayerState>;
+    /**
+     * An optional feature provider to provider features based on click events.
+     */
+    featureProvider: AbstractFeatureProvider | undefined;
+    private _locale;
+    constructor(options: LayerOptions);
+    /**
+     * True if this layer has been initialized, typically after its first activation.
+     */
+    get initialized(): boolean;
+    get active(): boolean;
+    get loading(): boolean;
+    get state(): LayerState;
+    get allowPicking(): boolean;
+    set allowPicking(allowPicking: boolean);
+    /**
+     * A layers url, should on be configured, else an empty string
+     */
+    get url(): string;
+    set url(url: string | Record<string, string>);
+    get hiddenObjectIds(): string[];
+    set hiddenObjectIds(hiddenObjectIds: string[]);
+    get globalHider(): GlobalHider | undefined;
+    setGlobalHider(globalHider?: GlobalHider): void;
+    /**
+     * Indicates, that this layer is part of an exclusiveGroup
+     */
+    get exclusive(): boolean;
+    /**
+     * An array of arbitrary exclusive groups
+     */
+    get exclusiveGroups(): (string | symbol)[];
+    set exclusiveGroups(groups: (string | symbol)[]);
+    get zIndex(): number;
+    set zIndex(index: number);
+    /**
+     * returns the currently set locale. Can be used to provide locale specific URLs.
+     */
+    get locale(): string;
+    /**
+     * sets the locale and reloads the layer the if the URL is a locale aware Object.
+     */
+    set locale(value: string);
+    /**
+     * creates an array of layer implementations for the given map.
+     * @param  _map Map
+     * @returns return the specific implementation
+     */
+    createImplementationsForMap(_map: VcsMap): I[];
+    /**
+     * creates or returns a cached array of layer implementations for the given map.
+     * @param  map initialized Map
+     * @returns  return the specific implementation
+     */
+    getImplementationsForMap<T extends VcsMap>(map: T): I[];
+    /**
+     * Returns all implementation of this layer for all maps
+     */
+    getImplementations(): I[];
+    getImplementationOptions(): LayerImplementationOptions;
+    /**
+     * Reloads all the data loaded and forces a redraw
+     */
+    reload(): Promise<void>;
+    /**
+     * destroys all current implementations and recreates the ones which have an active map.
+     * called for instance when the URL for a layer changes
+     */
+    forceRedraw(): Promise<void>;
+    /**
+     * returns the Extent of this layer
+     */
+    getExtent(): Extent | null;
+    /**
+     * returns the Extent of this layer or null, if the layers extent was not defined or cannot be established
+     */
+    getZoomToExtent(): Extent | null;
+    /**
+     * initializes the layer, can be used to defer loading
+     */
+    initialize(): Promise<void>;
+    /**
+     * is called from the map when the map is activated, and this layer is in the layerCollection of the map.
+     * Will create an implementation if it does not exits and will forward the activation call to the implementation.
+     * @param  map
+  @link   */
+    mapActivated(map: VcsMap): Promise<void>;
+    /**
+     * is called from the map when the map is deactivated, and this layer is in the layerCollection of the map.
+     * will forward deactivation call to the map specific implementation
+     * @param  map
+     */
+    mapDeactivated(map: VcsMap): void;
+    /**
+     * is called when a layer is removed from the layer collection of a map or said map is destroyed.
+     * destroys the associated implementation.
+     * @param  map
+     */
+    removedFromMap(map: VcsMap): void;
+    /**
+     * checks if the currently active map supports this layer
+     * @param  map
+     */
+    isSupported(map: VcsMap): boolean;
+    private _activateImplsForMap;
+    private _activate;
+    /**
+     * Activates this layer object, i.e. changes its internal view state
+     * and updates the map. The returned promise resolves, once the layer & any _implementations are initialized
+     * and all data is loaded.
+     * Once the promise resolves, the layer can still be inactive, if deactivate was called while initializing the layer.
+     */
+    activate(): Promise<void>;
+    /**
+     * Deactivates a layer, changing the internal view state
+     */
+    deactivate(): void;
+    toJSON(): LayerOptions;
+    /**
+     * disposes of this layer, removes instances from the current maps and the framework
+     */
+    destroy(): void;
+}
+export interface SplitLayer {
+    splitDirection: import('@vcmap-cesium/engine').SplitDirection;
+    splitDirectionChanged: VcsEvent<import('@vcmap-cesium/engine').SplitDirection>;
+}
+export default Layer;

package/dist/src/layer/layer.js

@@ -0,0 +1,491 @@
+import { check, checkMaybe } from '@vcsuite/check';
+import { parseBoolean, parseInteger } from '@vcsuite/parsers';
+import VcsObject from '../vcsObject.js';
+import Extent from '../util/extent.js';
+import { vcsLayerName } from './layerSymbols.js';
+import LayerState from './layerState.js';
+import VcsEvent from '../vcsEvent.js';
+import { layerClassRegistry } from '../classRegistry.js';
+import GlobalHider from './globalHider.js';
+/**
+ * Abstract base class for Layers.
+ * To create a layer Implementation the function `createImplementationsForMap` has to be implemented.
+ * To receive implementation options, implement `geImplementationOptions`
+ */
+class Layer extends VcsObject {
+    static get className() {
+        return 'Layer';
+    }
+    /**
+     * Symbol to declare a layers name on its visualizations, e.g. ol.layer.Layer, Cesium.Cesium3DTileset
+     * @deprecated
+     */
+    static get vcsLayerNameSymbol() {
+        return vcsLayerName;
+    }
+    static getDefaultOptions() {
+        return {
+            name: undefined,
+            extent: undefined,
+            activeOnStartup: false,
+            allowPicking: true,
+            exclusiveGroups: [],
+            mapNames: [],
+            url: undefined,
+            hiddenObjectIds: [],
+            copyright: undefined,
+        };
+    }
+    extent;
+    activeOnStartup;
+    _allowPicking;
+    _state;
+    _loadingPromise;
+    _initialized;
+    mapNames;
+    /**
+     * The class names of the supported maps.
+     */
+    _supportedMaps;
+    _url;
+    _zIndex;
+    /**
+     * Called when the zIndex of this layer is changed. Is passed the new zIndex as its only argument.
+     */
+    zIndexChanged;
+    /**
+     * array of object Ids which should be hidden within the context of the layers layerCollection, if this layer is active
+     */
+    _hiddenObjectIds;
+    _globalHider;
+    _exclusiveGroups;
+    /**
+     * event raised if the exclusives group of the layer changes. is passed the array of exclusive groups as its only argument
+     */
+    exclusiveGroupsChanged;
+    copyright;
+    _implementations;
+    _activeMaps;
+    /**
+     * Event raised, if the layers state changes. Is passed the LayerState as its only parameter
+     */
+    stateChanged;
+    /**
+     * An optional feature provider to provider features based on click events.
+     */
+    featureProvider;
+    _locale;
+    constructor(options) {
+        super(options);
+        const defaultOptions = Layer.getDefaultOptions();
+        this.extent = options.extent ? new Extent(options.extent) : null;
+        this.activeOnStartup = parseBoolean(options.activeOnStartup, defaultOptions.activeOnStartup);
+        this._allowPicking = parseBoolean(options.allowPicking, defaultOptions.allowPicking);
+        this._state = LayerState.INACTIVE;
+        this._loadingPromise = null;
+        this._initialized = false;
+        this.mapNames = options.mapNames ?? defaultOptions.mapNames;
+        this._supportedMaps = [];
+        this._url = options.url;
+        this._zIndex = parseInteger(options.zIndex, 0);
+        this.zIndexChanged = new VcsEvent();
+        this._hiddenObjectIds = Array.isArray(options.hiddenObjectIds)
+            ? options.hiddenObjectIds
+            : defaultOptions.hiddenObjectIds;
+        this._globalHider = undefined;
+        this._exclusiveGroups = Array.isArray(options.exclusiveGroups)
+            ? options.exclusiveGroups.slice()
+            : defaultOptions.exclusiveGroups;
+        this.exclusiveGroupsChanged = new VcsEvent();
+        this.copyright = options.copyright || defaultOptions.copyright;
+        this._implementations = new Map();
+        this._activeMaps = new Set();
+        this.stateChanged = new VcsEvent();
+        this.featureProvider = undefined;
+        this._locale = 'en';
+    }
+    /**
+     * True if this layer has been initialized, typically after its first activation.
+     */
+    get initialized() {
+        return this._initialized;
+    }
+    get active() {
+        return this._state === LayerState.ACTIVE;
+    }
+    get loading() {
+        return !!(this._state & LayerState.LOADING);
+    }
+    get state() {
+        return this._state;
+    }
+    get allowPicking() {
+        return this._allowPicking;
+    }
+    set allowPicking(allowPicking) {
+        this._allowPicking = allowPicking;
+    }
+    /**
+     * A layers url, should on be configured, else an empty string
+     */
+    get url() {
+        if (this._url) {
+            if (typeof this._url === 'string') {
+                return this._url;
+            }
+            if (this._url[this._locale]) {
+                return this._url[this._locale];
+            }
+            return Object.values(this._url)[0];
+        }
+        return '';
+    }
+    set url(url) {
+        check(url, [String, Object]);
+        if (this._url !== url) {
+            const currentValue = this._url;
+            this._url = url;
+            this.reload().catch((err) => {
+                this.getLogger().error('failed to reload after URL setting');
+                this.getLogger().error(String(err));
+                this._url = currentValue;
+            });
+        }
+    }
+    get hiddenObjectIds() {
+        return this._hiddenObjectIds;
+    }
+    set hiddenObjectIds(hiddenObjectIds) {
+        check(hiddenObjectIds, [String]);
+        if (this._globalHider && this.active) {
+            this._globalHider.hideObjects(hiddenObjectIds);
+        }
+        this._hiddenObjectIds = hiddenObjectIds;
+    }
+    get globalHider() {
+        return this._globalHider;
+    }
+    setGlobalHider(globalHider) {
+        checkMaybe(globalHider, GlobalHider);
+        if (globalHider && this.active) {
+            globalHider.hideObjects(this.hiddenObjectIds);
+        }
+        this._globalHider = globalHider;
+    }
+    /**
+     * Indicates, that this layer is part of an exclusiveGroup
+     */
+    get exclusive() {
+        return this._exclusiveGroups.length > 0;
+    }
+    /**
+     * An array of arbitrary exclusive groups
+     */
+    get exclusiveGroups() {
+        return this._exclusiveGroups.slice();
+    }
+    set exclusiveGroups(groups) {
+        check(groups, [[String, Symbol]]);
+        if (groups.length !== this._exclusiveGroups.length ||
+            !groups.every((g) => this._exclusiveGroups.includes(g))) {
+            this._exclusiveGroups = groups.slice();
+            this.exclusiveGroupsChanged.raiseEvent(groups);
+        }
+    }
+    get zIndex() {
+        return this._zIndex;
+    }
+    set zIndex(index) {
+        check(index, Number);
+        if (this._zIndex !== index) {
+            this._zIndex = index;
+            this.zIndexChanged.raiseEvent(index);
+        }
+    }
+    /**
+     * returns the currently set locale. Can be used to provide locale specific URLs.
+     */
+    get locale() {
+        return this._locale;
+    }
+    /**
+     * sets the locale and reloads the layer the if the URL is a locale aware Object.
+     */
+    set locale(value) {
+        check(value, String);
+        if (this._locale !== value) {
+            this._locale = value;
+            if (this._url &&
+                typeof this._url === 'object' &&
+                this._url[this._locale]) {
+                this.reload().catch((err) => {
+                    this.getLogger().error('failed to reload after setting locale');
+                    this.getLogger().error(String(err));
+                });
+            }
+        }
+    }
+    /**
+     * creates an array of layer implementations for the given map.
+     * @param  _map Map
+     * @returns return the specific implementation
+     */
+    // eslint-disable-next-line class-methods-use-this,no-unused-vars
+    createImplementationsForMap(_map) {
+        return [];
+    }
+    /**
+     * creates or returns a cached array of layer implementations for the given map.
+     * @param  map initialized Map
+     * @returns  return the specific implementation
+     */
+    getImplementationsForMap(map) {
+        if (!this._implementations.has(map)) {
+            if (this.isSupported(map)) {
+                this._implementations.set(map, this.createImplementationsForMap(map));
+            }
+            else {
+                this._implementations.set(map, []);
+            }
+        }
+        return this._implementations.get(map);
+    }
+    /**
+     * Returns all implementation of this layer for all maps
+     */
+    getImplementations() {
+        return [...this._implementations.values()].flat();
+    }
+    getImplementationOptions() {
+        return {
+            name: this.name,
+            url: this.url,
+        };
+    }
+    /**
+     * Reloads all the data loaded and forces a redraw
+     */
+    reload() {
+        return this.forceRedraw();
+    }
+    /**
+     * destroys all current implementations and recreates the ones which have an active map.
+     * called for instance when the URL for a layer changes
+     */
+    async forceRedraw() {
+        const maps = [...this._implementations.keys()];
+        const promises = maps.map((map) => {
+            this.removedFromMap(map);
+            if (map.active) {
+                return this.mapActivated(map);
+            }
+            return Promise.resolve();
+        });
+        await Promise.all(promises);
+    }
+    /**
+     * returns the Extent of this layer
+     */
+    getExtent() {
+        return this.extent;
+    }
+    /**
+     * returns the Extent of this layer or null, if the layers extent was not defined or cannot be established
+     */
+    getZoomToExtent() {
+        if (this.extent && this.extent.isValid()) {
+            return this.extent;
+        }
+        return null;
+    }
+    /**
+     * initializes the layer, can be used to defer loading
+     */
+    initialize() {
+        this._initialized = true;
+        return Promise.resolve();
+    }
+    /**
+     * is called from the map when the map is activated, and this layer is in the layerCollection of the map.
+     * Will create an implementation if it does not exits and will forward the activation call to the implementation.
+     * @param  map
+  @link   */
+    async mapActivated(map) {
+        this.getLogger().debug(`Layer: ${this.name} mapActivated is called from Map: ${map.name}`);
+        this._activeMaps.add(map);
+        if (this.active || (this.loading && this.initialized)) {
+            await this._activateImplsForMap(map);
+        }
+    }
+    /**
+     * is called from the map when the map is deactivated, and this layer is in the layerCollection of the map.
+     * will forward deactivation call to the map specific implementation
+     * @param  map
+     */
+    mapDeactivated(map) {
+        this.getLogger().debug(`Layer: ${this.name} mapDeactivated is called from Map: ${map.name}`);
+        this._activeMaps.delete(map);
+        if (this.active || this.loading) {
+            this.getImplementationsForMap(map).forEach((impl) => {
+                impl.deactivate();
+            });
+        }
+    }
+    /**
+     * is called when a layer is removed from the layer collection of a map or said map is destroyed.
+     * destroys the associated implementation.
+     * @param  map
+     */
+    removedFromMap(map) {
+        this._activeMaps.delete(map);
+        this.getImplementationsForMap(map).forEach((impl) => {
+            impl.destroy();
+        });
+        this._implementations.delete(map);
+    }
+    /**
+     * checks if the currently active map supports this layer
+     * @param  map
+     */
+    isSupported(map) {
+        return (map &&
+            this._supportedMaps.includes(map.className) &&
+            (this.mapNames.length === 0 || this.mapNames.indexOf(map.name) >= 0));
+    }
+    async _activateImplsForMap(map) {
+        const impls = this.getImplementationsForMap(map);
+        try {
+            await Promise.all(impls.map((i) => i.activate()));
+        }
+        catch (err) {
+            this.getLogger().error(`Layer ${this.name} could not activate impl for map ${map.name}`);
+            this.getLogger().error(String(err));
+            this._implementations.set(map, []);
+            impls.forEach((i) => {
+                i.destroy();
+            });
+        }
+    }
+    async _activate() {
+        this._state = LayerState.LOADING;
+        try {
+            this.stateChanged.raiseEvent(LayerState.LOADING);
+        }
+        catch (e) {
+            this.getLogger().debug(`Error on raising LayerState.LOADING event for layer ${this.name} : ${e.message}`);
+        }
+        await this.initialize();
+        if (this._state !== LayerState.LOADING) {
+            return;
+        }
+        await Promise.all([...this._activeMaps].map((m) => this._activateImplsForMap(m)));
+        if (this._state !== LayerState.LOADING) {
+            return;
+        }
+        if (this._globalHider) {
+            this._globalHider.hideObjects(this.hiddenObjectIds);
+        }
+        this._state = LayerState.ACTIVE;
+        try {
+            this.stateChanged.raiseEvent(LayerState.ACTIVE);
+        }
+        catch (e) {
+            this.getLogger().debug(`Error on raising LayerState.ACTIVE event for layer ${this.name} : ${e.message}`);
+        }
+        this._loadingPromise = null;
+    }
+    /**
+     * Activates this layer object, i.e. changes its internal view state
+     * and updates the map. The returned promise resolves, once the layer & any _implementations are initialized
+     * and all data is loaded.
+     * Once the promise resolves, the layer can still be inactive, if deactivate was called while initializing the layer.
+     */
+    activate() {
+        if (this._loadingPromise) {
+            return this._loadingPromise;
+        }
+        if (this._state === LayerState.INACTIVE) {
+            this._loadingPromise = this._activate().catch((err) => {
+                this._state = LayerState.INACTIVE;
+                return Promise.reject(err);
+            });
+            return this._loadingPromise;
+        }
+        return Promise.resolve();
+    }
+    /**
+     * Deactivates a layer, changing the internal view state
+     */
+    deactivate() {
+        if (this._loadingPromise) {
+            this._loadingPromise = null;
+        }
+        if (this._state !== LayerState.INACTIVE) {
+            this.getImplementations().forEach((impl) => {
+                if (impl.loading || impl.active) {
+                    impl.deactivate();
+                }
+            });
+            if (this._globalHider) {
+                this._globalHider.showObjects(this.hiddenObjectIds);
+            }
+            this._state = LayerState.INACTIVE;
+            try {
+                this.stateChanged.raiseEvent(LayerState.INACTIVE);
+            }
+            catch (e) {
+                this.getLogger().debug(`Error on raising LayerState.INACTIVE event for layer ${this.name} : ${e.message}`);
+            }
+        }
+    }
+    toJSON() {
+        const config = super.toJSON();
+        const defaultOptions = Layer.getDefaultOptions();
+        if (this.activeOnStartup !== defaultOptions.activeOnStartup) {
+            config.activeOnStartup = this.activeOnStartup;
+        }
+        if (this.allowPicking !== defaultOptions.allowPicking) {
+            config.allowPicking = this.allowPicking;
+        }
+        if (this.mapNames.length > 0) {
+            config.mapNames = this.mapNames.slice();
+        }
+        if (this.hiddenObjectIds.length > 0) {
+            config.hiddenObjectIds = this.hiddenObjectIds.slice();
+        }
+        if (this._url) {
+            config.url = this._url;
+        }
+        if (this.extent && this.extent.isValid()) {
+            config.extent = this.extent.toJSON();
+        }
+        if (this._exclusiveGroups.length > 0) {
+            config.exclusiveGroups = this._exclusiveGroups.slice();
+        }
+        if (this.copyright !== defaultOptions.copyright) {
+            config.copyright = { ...this.copyright };
+        }
+        return config;
+    }
+    /**
+     * disposes of this layer, removes instances from the current maps and the framework
+     */
+    destroy() {
+        super.destroy();
+        if (this.featureProvider) {
+            this.featureProvider.destroy();
+        }
+        this._activeMaps.clear();
+        this.getImplementations().forEach((impl) => {
+            impl.destroy();
+        });
+        this._initialized = false;
+        this._implementations.clear();
+        this.stateChanged.destroy();
+        this.zIndexChanged.destroy();
+        this.exclusiveGroupsChanged.destroy();
+    }
+}
+layerClassRegistry.registerClass(Layer.className, Layer);
+export default Layer;
+//# sourceMappingURL=layer.js.map