@open-pioneer/map 0.12.0-dev.20250725080856 → 1.0.0-dev.20251020091932

package/CHANGELOG.md

@@ -1,10 +1,52 @@
 # @open-pioneer/map
 
-## 0.12.0-dev.20250725080856
+## 1.0.0-dev.20251020091932
+
+### Major Changes
+
+- b3709f1: **Breaking:** Remove layer constructor types from public API (e.g. `SimpleLayerConstructor`).
+- 9e9bc6e: **Breaking**: Internal layers are no longer returned from getters such as `getItems()` or `getRecursiveLayers()` by default.
+
+    A new option `includeInternalLayers` has been implemented opt-in into internal layers.
+    By default, internal layers are not returned by functions like `getItems()` or `getRecursiveLayers()`.
+    If internal layer should be returned this must be specified explicitly with the `includeInternalLayers` option.
+
+    ```js
+    import { MapModel } from "@open-pioneer/map";
+
+    //internal layers are not included
+    const layers = myMapModel.layers.getItems();
+    //include internal layers
+    const allLayers = myMapModel.layers.getItems({ includeInternalLayers: true });
+    ```
+
+    Note that if internal layers are returned this includes system layers (e.g. for highlights or geolocation) that were not explicitly added to the map.
+    The described behavior is aligned for the functions `getItems()`, `getLayers()`, `getAllLayers()` and `getRecursiveLayers()` in `LayerCollection`, `WMSLayer` and `GroupLayer`.
+    The function `getRecursiveLayers()` does not return non-internal child layers of an internal layer.
+
+- b3709f1: **Breaking:** Remove old event API from layer types and the map model. These were only used for the `"destroy"` event.
+
+    The destroy event still exists, but is now based on the event system of the [reactivity API](https://github.com/conterra/reactivity/tree/main/packages/reactivity-events):
+
+    ```ts
+    import { on } from "@conterra/reactivity-events";
+
+    const layer = ...;
+    on(layer.destroyed, () => {
+        console.debug("layer was destroyed");
+    });
+
+    const mapModel = ...;
+    on(mapModel.destroyed, () => {
+        console.debug("layer was destroyed");
+    });
+    ```
 
 ### Minor Changes
 
-- 2702df4: Introduce `internal` property for all layer types (including sublayers). If `internal` is `true` (default: `false`) the layer is not considered by any UI widget (e.g. legend and Toc). The `internal` state of a layer is not to be confused with the layer's visibility on the map which is determined by the `visible` property.
+- 2702df4: Introduce `internal` property for all layer types (including sublayers).
+  If `internal` is `true` (default: `false`) the layer is not considered by any UI widget (e.g. legend and Toc).
+  The `internal` state of a layer is not to be confused with the layer's visibility on the map which is determined by the `visible` property.
 
     ```typescript
     //internal layer is visible on the map but hidden in UI elements like legend and Toc
@@ -17,10 +59,165 @@
     });
     ```
 
+- 5df900f: Add a new hook `useMapModelValue(props?)`.
+  The hook returns either the directly configured `map` (via props) or the default map from a parent `DefaultMapProvider`.
+  If neither is present, an error will be thrown.
+
+    This hook is used in all components that work with the map.
+    The typical usage works like this:
+
+    ```ts
+    import { MapModelProps, useMapModelValue } from "@open-pioneer/map";
+
+    // optional `map` property inherited from `MapModelProps`
+    export interface MyComponentProps extends MapModelProps {
+        // ... other properties
+    }
+
+    export function MyComponent(props) {
+        const map = useMapModelValue(props); // looks up the map
+    }
+    ```
+
+    You can also call this hook without any arguments:
+
+    ```ts
+    // Map model from DefaultMapProvider or an error.
+    const mapModel = useMapModelValue();
+    ```
+
+    This hook should replace _most_ usages `useMapModel`, which can't return the map model directly since it may not have finished construction yet.
+
+- 14c484e: Introduce the `LayerFactory` service (interface `"map.LayerFactory"`).
+
+    The layer factory should be used to construct new layer instances, instead of calling the layer constructor directly.
+    Calling the constructor directly (e.g. `new SimpleLayer`) is deprecated (but still fully supported).
+
+    For example:
+
+    ```ts
+    // OLD
+    new SimpleLayer({
+        title: "OSM",
+        isBaseLayer: true,
+        olLayer: new TileLayer({
+            source: new OSM()
+        })
+    });
+    ```
+
+    ```ts
+    // NEW
+    const layerFactory = ...; // injected
+    layerFactory.create({
+        type: SimpleLayer,
+        title: "OSM",
+        isBaseLayer: true,
+        olLayer: new TileLayer({
+            source: new OSM()
+        })
+    });
+    ```
+
+    This was done to support passing hidden dependencies from the layer factory to the layer instance (such as the `HttpService`),
+    without forcing the user to supply these dependencies manually.
+
+    The `MapConfigProvider` has been updated as well.
+    The `getMapConfig` method will now receive the layer factory as an option.
+    This makes it easy to migrate to the new API:
+
+    ```diff
+    # Example MapConfigProvider
+    export class MapConfigProviderImpl implements MapConfigProvider {
+        mapId = MAP_ID;
+
+    -   async getMapConfig(): Promise<MapConfig> {
+    +   async getMapConfig({ layerFactory }: MapConfigProviderOptions): Promise<MapConfig> {
+            return {
+                initialView: {
+                    kind: "position",
+                    center: { x: 404747, y: 5757920 },
+                    zoom: 14
+                },
+                layers: [
+    -               new SimpleLayer({
+    +               layerFactory.create({
+    +                   type: SimpleLayer,
+                        title: "OSM",
+                        isBaseLayer: true,
+                        olLayer: new TileLayer({
+                            source: new OSM()
+                        })
+                    })
+                ]
+            };
+        }
+    }
+    ```
+
+- aeb9000: Add new `"topmost"` option to add layers that are always displayed on the top (above all other layers).
+
+    A new layers can be added at `topmost` to ensure that this layer will always be displayed on top of the other layers.
+    This can be used, for example, to implement highlights or to draw graphics.
+    Layers added at `"topmost"` will always be shown above layers at `"top"`.
+
+    When using the `"above"` or `"below"` options with a `"topmost"` reference layer, that layer becomes `"topmost"` as well.
+
+    ```typescript
+    import { MapModel, SimpleLayer } from "@open-pioneer/map";
+
+    const highlightLayer = new SimpleLayer({
+        title: "highlights",
+        olLayer: myOlLayer
+    });
+    //always displayed at the top
+    myMapModel.layers.addLayer(highlightLayer, { at: "topmost" });
+    ```
+
+- 5df900f: Deprecate the parameter-less signature of `useMapModel()`:
+
+    ```ts
+    // Returns the DefaultMapProvider's map, but wrapped in a result value (loading/resolved/rejected)
+    const result = useMapModel();
+    ```
+
+    Use `useMapModelValue()` instead:
+
+    ```ts
+    // Returns the map model directly.
+    const mapModel = useMapModelValue();
+    ```
+
+    All other signatures of `useMapModel()` are still fully supported.
+
+- 773fa2d: The map now has an appropriate focus outline style by default, which respects the map view's padding.
+  For information on disabling this behavior, see the map package documentation.
+- 2abcaaf: Update to chakra-ui 3.27.1
+
 ### Patch Changes
 
+- c6180c6: Update eslint to version 9.
+- 29a10df: Support buffer for zoom geometries.
+
+    For example:
+
+    ```ts
+    const map: MapModel = ...;
+    const highlight = map.highlightAndZoom(someGeometries, {
+        // Grows extent by 10%
+        buffer: 0.1
+    });
+    ```
+
 - 10d2fe7: Update dependencies
+- 12561fe: The default value of the `role` prop on the `MapContainer` was changed to `application` to allow map keyboard navigation while using NVDA screen reader.
 - 8986b3b: Remove obsolete dependency @types/proj4
+- dfd7c7e: We use the already existing calculateBufferedExtent instead of the highlights buffer.
+  Use the `buffer` to specify the size increase. E.g. `1.1` for 10% size increase.
+- 138d85b: Update core packages to 4.1.0
+- 2c8b617: Introduce `MapRegistry.createMapModel` method to create a `MapModel` without a `MapConfigProvider`.
+  For more details, see [PR](https://github.com/open-pioneer/trails-openlayers-base-packages/pull/499) and [issue](https://github.com/open-pioneer/trails-openlayers-base-packages/issues/483).
+- b3709f1: Refactor map package internals.
 - f1f69f2: Update to OpenLayers 10.6.1
 - da6a410: Update dependencies
 

package/LayerFactory.d.ts

@@ -0,0 +1,54 @@
+import { HttpService } from "@open-pioneer/http";
+import { DECLARE_SERVICE_INTERFACE, ServiceOptions } from "@open-pioneer/runtime";
+import { LayerConfig } from "./layers/shared/LayerConfig";
+import { LayerConstructor } from "./layers/shared/internals";
+import { Layer } from "./layers/unions";
+interface References {
+    httpService: HttpService;
+}
+/**
+ * Options that can be passed to {@link LayerFactory.create}.
+ *
+ * The `type` option is mandatory and indicates the type of the layer (e.g. `WMSLayer`).
+ * The other options depend on the specific layer type.
+ *
+ * @group Services
+ */
+export type LayerCreateOptions<LayerType extends Layer, Config extends LayerConfig> = {
+    /** The layer type to construct. */
+    type: LayerConstructor<Config, LayerType>;
+} & Config;
+/**
+ * Creates instances of layer classes.
+ *
+ * Use the interface `"map.LayerFactory"` to obtain an instance of this service.
+ *
+ * @group Services
+ */
+export declare class LayerFactory {
+    #private;
+    [DECLARE_SERVICE_INTERFACE]: "map.LayerFactory";
+    constructor(options: ServiceOptions<References>);
+    /**
+     * Creates a new instance of the given layer type.
+     * The `"type"` option is mandatory and specifies which layer type to create.
+     *
+     * The other configuration options may be dependent on the specific layer type.
+     *
+     * Example:
+     *
+     * ```ts
+     * import { SimpleLayer } from "@open-pioneer/map";
+     *
+     * const layerFactory = ...; // injected
+     * const layer = layerFactory.create({
+     *     type: SimpleLayer,
+     *     title: "Layer title",
+     *     olLayer: new TileLayer({}),
+     *     // ... other options
+     * });
+     * ```
+     */
+    create<LayerType extends Layer, Config extends LayerConfig>(config: LayerCreateOptions<LayerType, Config>): LayerType;
+}
+export {};

package/LayerFactory.js

@@ -0,0 +1,45 @@
+import { AbstractLayer } from './layers/AbstractLayer.js';
+import { INTERNAL_CONSTRUCTOR_TAG } from './utils/InternalConstructorTag.js';
+
+class LayerFactory {
+  #httpService;
+  constructor(options) {
+    this.#httpService = options.references.httpService;
+  }
+  /**
+   * Creates a new instance of the given layer type.
+   * The `"type"` option is mandatory and specifies which layer type to create.
+   *
+   * The other configuration options may be dependent on the specific layer type.
+   *
+   * Example:
+   *
+   * ```ts
+   * import { SimpleLayer } from "@open-pioneer/map";
+   *
+   * const layerFactory = ...; // injected
+   * const layer = layerFactory.create({
+   *     type: SimpleLayer,
+   *     title: "Layer title",
+   *     olLayer: new TileLayer({}),
+   *     // ... other options
+   * });
+   * ```
+   */
+  create(config) {
+    const { type, ...rest } = config;
+    if (!type || !(type.prototype instanceof AbstractLayer)) {
+      throw new Error(
+        `Invalid layer type option. Use one of the layer classes exported by this package.`
+      );
+    }
+    return new type(
+      rest,
+      { httpService: this.#httpService },
+      INTERNAL_CONSTRUCTOR_TAG
+    );
+  }
+}
+
+export { LayerFactory };
+//# sourceMappingURL=LayerFactory.js.map

package/LayerFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LayerFactory.js","sources":["LayerFactory.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2023-2025 Open Pioneer project (https://github.com/open-pioneer)\n// SPDX-License-Identifier: Apache-2.0\nimport { HttpService } from \"@open-pioneer/http\";\nimport { DECLARE_SERVICE_INTERFACE, ServiceOptions } from \"@open-pioneer/runtime\";\nimport { AbstractLayer } from \"./layers/AbstractLayer\";\nimport { LayerConfig } from \"./layers/shared/LayerConfig\";\nimport { LayerConstructor } from \"./layers/shared/internals\";\nimport { INTERNAL_CONSTRUCTOR_TAG } from \"./utils/InternalConstructorTag\";\nimport { Layer } from \"./layers/unions\";\n\ninterface References {\n    httpService: HttpService;\n}\n\n/**\n * Options that can be passed to {@link LayerFactory.create}.\n *\n * The `type` option is mandatory and indicates the type of the layer (e.g. `WMSLayer`).\n * The other options depend on the specific layer type.\n *\n * @group Services\n */\nexport type LayerCreateOptions<LayerType extends Layer, Config extends LayerConfig> = {\n    /** The layer type to construct. */\n    type: LayerConstructor<Config, LayerType>;\n} & Config;\n\n/**\n * Creates instances of layer classes.\n *\n * Use the interface `\"map.LayerFactory\"` to obtain an instance of this service.\n *\n * @group Services\n */\nexport class LayerFactory {\n    declare [DECLARE_SERVICE_INTERFACE]: \"map.LayerFactory\";\n\n    #httpService: HttpService;\n\n    constructor(options: ServiceOptions<References>) {\n        this.#httpService = options.references.httpService;\n    }\n\n    /**\n     * Creates a new instance of the given layer type.\n     * The `\"type\"` option is mandatory and specifies which layer type to create.\n     *\n     * The other configuration options may be dependent on the specific layer type.\n     *\n     * Example:\n     *\n     * ```ts\n     * import { SimpleLayer } from \"@open-pioneer/map\";\n     *\n     * const layerFactory = ...; // injected\n     * const layer = layerFactory.create({\n     *     type: SimpleLayer,\n     *     title: \"Layer title\",\n     *     olLayer: new TileLayer({}),\n     *     // ... other options\n     * });\n     * ```\n     */\n    create<LayerType extends Layer, Config extends LayerConfig>(\n        config: LayerCreateOptions<LayerType, Config>\n    ): LayerType {\n        const { type, ...rest } = config;\n        if (!type || !(type.prototype instanceof AbstractLayer)) {\n            throw new Error(\n                `Invalid layer type option. Use one of the layer classes exported by this package.`\n            );\n        }\n        return new type(\n            rest as unknown as Config,\n            { httpService: this.#httpService },\n            INTERNAL_CONSTRUCTOR_TAG\n        );\n    }\n}\n"],"names":[],"mappings":";;;AAkCO,MAAM,YAAA,CAAa;AAAA,EAGtB,YAAA;AAAA,EAEA,YAAY,OAAA,EAAqC;AAC7C,IAAA,IAAA,CAAK,YAAA,GAAe,QAAQ,UAAA,CAAW,WAAA;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAsBA,OACI,MAAA,EACS;AACT,IAAA,MAAM,EAAE,IAAA,EAAM,GAAG,IAAA,EAAK,GAAI,MAAA;AAC1B,IAAA,IAAI,CAAC,IAAA,IAAQ,EAAE,IAAA,CAAK,qBAAqB,aAAA,CAAA,EAAgB;AACrD,MAAA,MAAM,IAAI,KAAA;AAAA,QACN,CAAA,iFAAA;AAAA,OACJ;AAAA,IACJ;AACA,IAAA,OAAO,IAAI,IAAA;AAAA,MACP,IAAA;AAAA,MACA,EAAE,WAAA,EAAa,IAAA,CAAK,YAAA,EAAa;AAAA,MACjC;AAAA,KACJ;AAAA,EACJ;AACJ;;;;"}

package/MapRegistry.d.ts

@@ -0,0 +1,81 @@
+import { HttpService } from "@open-pioneer/http";
+import { DECLARE_SERVICE_INTERFACE, Service, ServiceOptions } from "@open-pioneer/runtime";
+import OlMap from "ol/Map";
+import { LayerFactory } from "./LayerFactory";
+import { MapConfig } from "./model/MapConfig";
+import { MapModel } from "./model/MapModel";
+/**
+ * Options passed to the {@link MapConfigProvider.getMapConfig} method.
+ *
+ * @group Services
+ */
+export interface MapConfigProviderOptions {
+    /**
+     * A reference to the layer factory, for the construction of new layer instances.
+     */
+    layerFactory: LayerFactory;
+}
+/**
+ * Provides an OpenLayers map configuration with a given map id.
+ *
+ * The implementor must also provide the interface name `"map.MapConfigProvider"`.
+ *
+ * @group Services
+ */
+export interface MapConfigProvider {
+    /**
+     * Unique identifier of the map.
+     */
+    readonly mapId: string;
+    /**
+     * Returns the map configuration for this map.
+     *
+     * Called by the {@link MapRegistry} when the map is requested for the first time.
+     *
+     * See {@link MapConfig} for supported options during map creation.
+     * Use {@link MapConfigProviderOptions.layerFactory} to construct new layers.
+     */
+    getMapConfig(options: MapConfigProviderOptions): Promise<MapConfig>;
+}
+interface References {
+    providers: MapConfigProvider[];
+    httpService: HttpService;
+    layerFactory: LayerFactory;
+}
+/**
+ * Provides access to registered map instances.
+ *
+ * Maps are identified by a unique id.
+ *
+ * Inject an instance of this service by referencing the interface name `"map.MapRegistry"`.
+ *
+ * @group Services
+ */
+export declare class MapRegistry implements Service {
+    #private;
+    [DECLARE_SERVICE_INTERFACE]: "map.MapRegistry";
+    constructor({ references, intl }: ServiceOptions<References>);
+    destroy(): void;
+    /**
+     * Returns the map model associated with the given id.
+     * Returns undefined if there is no such model.
+     */
+    getMapModel(mapId: string): Promise<MapModel | undefined>;
+    /**
+     * Like {@link getMapModel}, but throws if no model exists for the given `mapId`.
+     */
+    expectMapModel(mapId: string): Promise<MapModel>;
+    /**
+     * Creates a MapModel without the need to provide a {@link MapConfigProvider}.
+     * Throws an error if a map with the given id already exists or if the map config is invalid.
+     */
+    createMapModel(mapId: string, options?: MapConfig): Promise<MapModel>;
+    /**
+     * Given a raw OpenLayers map instance, returns the associated {@link MapModel} - or undefined
+     * if the map is unknown to this registry.
+     *
+     * All OpenLayers maps created by this registry (e.g. via {@link MapConfigProvider} or {@link createMapModel}) have an associated map model.
+     */
+    getMapModelByRawInstance(olMap: OlMap): MapModel | undefined;
+}
+export {};

package/MapRegistry.js

@@ -0,0 +1,162 @@
+import { batch } from '@conterra/reactivity-core';
+import { onSync } from '@conterra/reactivity-events';
+import { createLogger } from '@open-pioneer/core';
+import { createMapModel } from './model/createMapModel.js';
+
+const LOG = createLogger("map:MapRegistry");
+class MapRegistry {
+  #intl;
+  #httpService;
+  #layerFactory;
+  #configProviders = /* @__PURE__ */ new Map();
+  #entries = /* @__PURE__ */ new Map();
+  #modelCreationJobs = /* @__PURE__ */ new Map();
+  #modelsByOlMap = /* @__PURE__ */ new WeakMap();
+  #destroyed = false;
+  constructor({ references, intl }) {
+    this.#intl = intl;
+    this.#httpService = references.httpService;
+    this.#layerFactory = references.layerFactory;
+    const providers = references.providers;
+    for (const provider of providers) {
+      this.#configProviders.set(provider.mapId, provider);
+    }
+  }
+  destroy() {
+    if (this.#destroyed) {
+      return;
+    }
+    batch(() => {
+      LOG.debug(`Destroy map registry and all maps`);
+      this.#destroyed = true;
+      this.#entries.forEach((entry) => {
+        if (entry.kind === "model") {
+          entry.listener.destroy();
+          entry.model.destroy();
+        }
+      });
+      this.#entries.clear();
+      this.#modelCreationJobs.clear();
+    });
+  }
+  /**
+   * Returns the map model associated with the given id.
+   * Returns undefined if there is no such model.
+   */
+  async getMapModel(mapId) {
+    if (this.#destroyed) {
+      throw new Error("MapRegistry has already been destroyed.");
+    }
+    const entry = this.#entries.get(mapId);
+    if (entry) {
+      return unbox(entry);
+    }
+    const creationJob = this.#modelCreationJobs.get(mapId);
+    if (creationJob) {
+      return await waitForResult(creationJob);
+    }
+    const provider = this.#configProviders.get(mapId);
+    if (!provider) {
+      LOG.debug(`Failed to find a config provider for map id '${mapId}'.`);
+      return void 0;
+    }
+    return await this.#createMapModel(
+      mapId,
+      () => provider.getMapConfig({
+        layerFactory: this.#layerFactory
+      })
+    );
+  }
+  /**
+   * Like {@link getMapModel}, but throws if no model exists for the given `mapId`.
+   */
+  async expectMapModel(mapId) {
+    const model = await this.getMapModel(mapId);
+    if (!model) {
+      throw new Error(`No configuration available for map with id '${mapId}'.`);
+    }
+    return model;
+  }
+  /**
+   * Creates a MapModel without the need to provide a {@link MapConfigProvider}.
+   * Throws an error if a map with the given id already exists or if the map config is invalid.
+   */
+  async createMapModel(mapId, options) {
+    if (this.#destroyed) {
+      throw new Error("MapRegistry has already been destroyed.");
+    }
+    if (this.#entries.has(mapId)) {
+      throw new Error(`Map id '${mapId}' is not unique.`);
+    }
+    if (this.#modelCreationJobs.has(mapId)) {
+      throw new Error(`A map with the id '${mapId}' is already under construction.`);
+    }
+    return await this.#createMapModel(mapId, () => Promise.resolve(options ?? {}));
+  }
+  /**
+   * Given a raw OpenLayers map instance, returns the associated {@link MapModel} - or undefined
+   * if the map is unknown to this registry.
+   *
+   * All OpenLayers maps created by this registry (e.g. via {@link MapConfigProvider} or {@link createMapModel}) have an associated map model.
+   */
+  getMapModelByRawInstance(olMap) {
+    return this.#modelsByOlMap.get(olMap);
+  }
+  // Wrapper method to ensure that in-progress construction of maps can be observed.
+  #createMapModel(mapId, configProvider) {
+    const creationJob = this.#modelCreationJobs.get(mapId);
+    if (creationJob) {
+      throw new Error("Internal error: a map model is already being created for this mapId");
+    }
+    const modelPromise = this.#createMapModelImpl(mapId, configProvider).then((mapModel) => {
+      if (this.#destroyed) {
+        mapModel.destroy();
+        throw new Error(`MapRegistry has been destroyed.`);
+      }
+      const listener = onSync(mapModel.destroyed, () => {
+        if (this.#isDynamic(mapId)) {
+          const currentEntry = this.#entries.get(mapId);
+          if (currentEntry === entry) {
+            this.#entries.delete(mapId);
+          }
+        }
+      });
+      const entry = { kind: "model", model: mapModel, listener };
+      this.#entries.set(mapId, entry);
+      this.#modelCreationJobs.delete(mapId);
+      this.#modelsByOlMap.set(mapModel.olMap, mapModel);
+      return entry;
+    }).catch((cause) => {
+      const error = new Error(`Failed to construct map '${mapId}'`, { cause });
+      const entry = { kind: "error", error };
+      this.#modelCreationJobs.delete(mapId);
+      if (!this.#isDynamic(mapId)) {
+        this.#entries.set(mapId, entry);
+      }
+      return entry;
+    });
+    this.#modelCreationJobs.set(mapId, modelPromise);
+    return waitForResult(modelPromise);
+  }
+  async #createMapModelImpl(mapId, configProvider) {
+    LOG.info(`Creating map with id '${mapId}'`);
+    const mapConfig = await configProvider();
+    const mapModel = await createMapModel(mapId, mapConfig, this.#intl, this.#httpService);
+    return mapModel;
+  }
+  #isDynamic(mapId) {
+    return !this.#configProviders.has(mapId);
+  }
+}
+async function waitForResult(job) {
+  return unbox(await job);
+}
+function unbox(entry) {
+  if (entry.kind === "error") {
+    throw entry.error;
+  }
+  return entry.model;
+}
+
+export { MapRegistry };
+//# sourceMappingURL=MapRegistry.js.map

package/MapRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapRegistry.js","sources":["MapRegistry.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2023-2025 Open Pioneer project (https://github.com/open-pioneer)\n// SPDX-License-Identifier: Apache-2.0\nimport { batch } from \"@conterra/reactivity-core\";\nimport { onSync } from \"@conterra/reactivity-events\";\nimport { createLogger, Resource } from \"@open-pioneer/core\";\nimport { HttpService } from \"@open-pioneer/http\";\nimport {\n    DECLARE_SERVICE_INTERFACE,\n    PackageIntl,\n    Service,\n    ServiceOptions\n} from \"@open-pioneer/runtime\";\nimport OlMap from \"ol/Map\";\nimport { LayerFactory } from \"./LayerFactory\";\nimport { createMapModel } from \"./model/createMapModel\";\nimport { MapConfig } from \"./model/MapConfig\";\nimport { MapModel } from \"./model/MapModel\";\n\nconst LOG = createLogger(\"map:MapRegistry\");\n\n/**\n * Options passed to the {@link MapConfigProvider.getMapConfig} method.\n *\n * @group Services\n */\nexport interface MapConfigProviderOptions {\n    /**\n     * A reference to the layer factory, for the construction of new layer instances.\n     */\n    layerFactory: LayerFactory;\n}\n\n/**\n * Provides an OpenLayers map configuration with a given map id.\n *\n * The implementor must also provide the interface name `\"map.MapConfigProvider\"`.\n *\n * @group Services\n */\nexport interface MapConfigProvider {\n    /**\n     * Unique identifier of the map.\n     */\n    readonly mapId: string;\n\n    /**\n     * Returns the map configuration for this map.\n     *\n     * Called by the {@link MapRegistry} when the map is requested for the first time.\n     *\n     * See {@link MapConfig} for supported options during map creation.\n     * Use {@link MapConfigProviderOptions.layerFactory} to construct new layers.\n     */\n    getMapConfig(options: MapConfigProviderOptions): Promise<MapConfig>;\n}\n\ninterface References {\n    providers: MapConfigProvider[];\n    httpService: HttpService;\n    layerFactory: LayerFactory;\n}\n\ntype ModelJobResult =\n    | { kind: \"model\"; model: MapModel; listener: Resource }\n    | { kind: \"error\"; error: Error };\n\n/**\n * Provides access to registered map instances.\n *\n * Maps are identified by a unique id.\n *\n * Inject an instance of this service by referencing the interface name `\"map.MapRegistry\"`.\n *\n * @group Services\n */\nexport class MapRegistry implements Service {\n    declare [DECLARE_SERVICE_INTERFACE]: \"map.MapRegistry\";\n\n    #intl: PackageIntl;\n    #httpService: HttpService;\n    #layerFactory: LayerFactory;\n\n    #configProviders = new Map<string, MapConfigProvider>();\n    #entries = new Map<string, ModelJobResult>();\n    #modelCreationJobs = new Map<string, Promise<ModelJobResult>>();\n    #modelsByOlMap = new WeakMap<OlMap, MapModel>();\n    #destroyed = false;\n\n    constructor({ references, intl }: ServiceOptions<References>) {\n        this.#intl = intl;\n        this.#httpService = references.httpService;\n        this.#layerFactory = references.layerFactory;\n\n        const providers = references.providers;\n        for (const provider of providers) {\n            this.#configProviders.set(provider.mapId, provider);\n        }\n    }\n\n    destroy(): void {\n        if (this.#destroyed) {\n            return;\n        }\n\n        batch(() => {\n            LOG.debug(`Destroy map registry and all maps`);\n            this.#destroyed = true;\n            this.#entries.forEach((entry) => {\n                if (entry.kind === \"model\") {\n                    entry.listener.destroy();\n                    entry.model.destroy();\n                }\n            });\n            this.#entries.clear();\n            this.#modelCreationJobs.clear();\n        });\n    }\n\n    /**\n     * Returns the map model associated with the given id.\n     * Returns undefined if there is no such model.\n     */\n    async getMapModel(mapId: string): Promise<MapModel | undefined> {\n        if (this.#destroyed) {\n            throw new Error(\"MapRegistry has already been destroyed.\");\n        }\n\n        const entry = this.#entries.get(mapId);\n        if (entry) {\n            return unbox(entry);\n        }\n\n        const creationJob = this.#modelCreationJobs.get(mapId);\n        if (creationJob) {\n            return await waitForResult(creationJob);\n        }\n\n        const provider = this.#configProviders.get(mapId);\n        if (!provider) {\n            LOG.debug(`Failed to find a config provider for map id '${mapId}'.`);\n            return undefined;\n        }\n\n        return await this.#createMapModel(mapId, () =>\n            provider.getMapConfig({\n                layerFactory: this.#layerFactory\n            })\n        );\n    }\n\n    /**\n     * Like {@link getMapModel}, but throws if no model exists for the given `mapId`.\n     */\n    async expectMapModel(mapId: string): Promise<MapModel> {\n        const model = await this.getMapModel(mapId);\n        if (!model) {\n            throw new Error(`No configuration available for map with id '${mapId}'.`);\n        }\n        return model;\n    }\n\n    /**\n     * Creates a MapModel without the need to provide a {@link MapConfigProvider}.\n     * Throws an error if a map with the given id already exists or if the map config is invalid.\n     */\n    async createMapModel(mapId: string, options?: MapConfig): Promise<MapModel> {\n        if (this.#destroyed) {\n            throw new Error(\"MapRegistry has already been destroyed.\");\n        }\n        if (this.#entries.has(mapId)) {\n            throw new Error(`Map id '${mapId}' is not unique.`);\n        }\n        if (this.#modelCreationJobs.has(mapId)) {\n            throw new Error(`A map with the id '${mapId}' is already under construction.`);\n        }\n        return await this.#createMapModel(mapId, () => Promise.resolve(options ?? {}));\n    }\n\n    /**\n     * Given a raw OpenLayers map instance, returns the associated {@link MapModel} - or undefined\n     * if the map is unknown to this registry.\n     *\n     * All OpenLayers maps created by this registry (e.g. via {@link MapConfigProvider} or {@link createMapModel}) have an associated map model.\n     */\n    getMapModelByRawInstance(olMap: OlMap): MapModel | undefined {\n        return this.#modelsByOlMap.get(olMap);\n    }\n\n    // Wrapper method to ensure that in-progress construction of maps can be observed.\n    #createMapModel(mapId: string, configProvider: () => Promise<MapConfig>): Promise<MapModel> {\n        const creationJob = this.#modelCreationJobs.get(mapId);\n        if (creationJob) {\n            throw new Error(\"Internal error: a map model is already being created for this mapId\");\n        }\n\n        const modelPromise = this.#createMapModelImpl(mapId, configProvider)\n            .then((mapModel) => {\n                if (this.#destroyed) {\n                    mapModel.destroy();\n                    throw new Error(`MapRegistry has been destroyed.`);\n                }\n\n                const listener = onSync(mapModel.destroyed, () => {\n                    // Allow id reuse for dynamically created maps\n                    if (this.#isDynamic(mapId)) {\n                        const currentEntry = this.#entries.get(mapId);\n                        if (currentEntry === entry) {\n                            this.#entries.delete(mapId);\n                        }\n                    }\n                });\n\n                const entry: ModelJobResult = { kind: \"model\", model: mapModel, listener };\n                this.#entries.set(mapId, entry);\n                this.#modelCreationJobs.delete(mapId);\n                this.#modelsByOlMap.set(mapModel.olMap, mapModel);\n                return entry;\n            })\n            .catch((cause) => {\n                const error = new Error(`Failed to construct map '${mapId}'`, { cause });\n                const entry: ModelJobResult = { kind: \"error\", error };\n                this.#modelCreationJobs.delete(mapId);\n                if (!this.#isDynamic(mapId)) {\n                    // Don't store errors for dynamically created maps (the caller already got the error via promise).\n                    this.#entries.set(mapId, entry);\n                }\n                return entry;\n            });\n        this.#modelCreationJobs.set(mapId, modelPromise);\n        return waitForResult(modelPromise);\n    }\n\n    async #createMapModelImpl(\n        mapId: string,\n        configProvider: () => Promise<MapConfig>\n    ): Promise<MapModel> {\n        LOG.info(`Creating map with id '${mapId}'`);\n        const mapConfig = await configProvider();\n        const mapModel = await createMapModel(mapId, mapConfig, this.#intl, this.#httpService);\n        return mapModel;\n    }\n\n    #isDynamic(mapId: string): boolean {\n        return !this.#configProviders.has(mapId);\n    }\n}\n\nasync function waitForResult(job: Promise<ModelJobResult>): Promise<MapModel> {\n    return unbox(await job);\n}\n\nfunction unbox(entry: ModelJobResult): MapModel {\n    if (entry.kind === \"error\") {\n        throw entry.error;\n    }\n    return entry.model;\n}\n"],"names":[],"mappings":"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"}