@igo2/geo 17.0.1-next.2 → 18.0.0-next.10

package/esm2022/lib/layer/shared/layer-controller.mjs

@@ -0,0 +1,316 @@
+import { TREE_SEPERATOR, Tree } from '@igo2/utils';
+import { BehaviorSubject, combineLatest, debounceTime, map } from 'rxjs';
+import { isBaseLayer, isLayerGroup, isLayerItem } from '../utils/layer.utils';
+import { LayerSelectionModel } from './layer-selection';
+import { isLayerLinked } from './layers/linked/linked-layer.utils';
+// Below 10 is reserved for BaseLayer
+const ZINDEX_MIN = 10;
+/**
+ * We got four kind of layers
+ * TreeLayer: all layers to show in the layer manager
+ * Baselayer: Layer dedicated for the basemap
+ * SystemLayer: Every layer dedicated to good function of the map (Selection, hovering)
+ * OtherLayer: all remaining layer that is linked to another layer or simply not a systemLayer that need to be cleaned on map reset
+ */
+export class LayerController extends LayerSelectionModel {
+    _map;
+    tree;
+    /** Selection, Hovering, every internalLayer not in the tree is here */
+    _systemLayers = [];
+    /** LinkedLayer and other layer that are not in the previous category and not visible in tree */
+    _otherLayers = [];
+    layersFlattened = [];
+    _layers$ = new BehaviorSubject(undefined);
+    layers$ = this._layers$.asObservable();
+    layersFlattened$ = this._layers$
+        .asObservable()
+        .pipe(map(() => this.layersFlattened));
+    _baseLayers = [];
+    _baseLayers$ = new BehaviorSubject(undefined);
+    baseLayers$ = this._baseLayers$.asObservable();
+    baseLayerSelection;
+    /** All layers with the tree flattened */
+    all$;
+    constructor(_map, layers) {
+        super();
+        this._map = _map;
+        this.all$ = combineLatest([this.layersFlattened$, this.baseLayers$]).pipe(debounceTime(10), map(() => this.all));
+        this.tree = new Tree(layers, {
+            getChildren: (node) => isLayerGroup(node) && node.children,
+            getId: (node) => node.id,
+            getLevel: (node) => node.zIndex,
+            reverse: true
+        });
+    }
+    get all() {
+        return [
+            ...this.baseLayers,
+            ...this.layersFlattened,
+            ...this._systemLayers,
+            ...this._otherLayers
+        ];
+    }
+    get baseLayers() {
+        return this._baseLayers;
+    }
+    get baseLayer() {
+        return this.baseLayers.find((layer) => layer.visible);
+    }
+    get treeLayers() {
+        return this.tree.data;
+    }
+    add(...layers) {
+        const offset = 0;
+        const addedLayers = layers
+            .map((layer) => this.handleAdd(layer, offset))
+            .filter(Boolean);
+        if (!addedLayers.length) {
+            this.notify();
+            return;
+        }
+        this.tree.add(...addedLayers);
+        // Notify the layers change before the iteration on the addedLayer
+        // Because the Layer may have have LinkedLayer who need to find the parent.
+        this.layersFlattened = [...this.tree.flattened];
+        addedLayers.forEach((layer) => layer.add());
+        this.recalculateZindex();
+        this.notify();
+    }
+    selectBaseLayer(layer) {
+        if (!isBaseLayer(layer)) {
+            return;
+        }
+        if (this.baseLayerSelection) {
+            this.baseLayerSelection.visible = false;
+        }
+        layer.visible = true;
+        this.baseLayerSelection = layer;
+        this._map.viewController.olView.setMinZoom(layer.dataSource.options.minZoom || (this._map.options.view || {}).minZoom);
+        this._map.viewController.olView.setMaxZoom(layer.dataSource.options.maxZoom || (this._map.options.view || {}).maxZoom);
+    }
+    remove(...layers) {
+        const list = layers.reduce((list, layer) => {
+            if (this.isSelected(layer)) {
+                this.deselect(layer);
+            }
+            const result = this._remove(layer);
+            Array.isArray(result) ? list.push(...result) : list.push(result);
+            return list;
+        }, []);
+        this.tree.remove(...list);
+        this.notify();
+    }
+    /**
+     * Move a layer into the tree
+     * @param layer Layer to move
+     * @param beforeTo The index position to move inside a tree
+     */
+    moveTo(beforeTo, ...layers) {
+        const movedLayers = this.tree.moveTo(beforeTo, ...layers);
+        if (!movedLayers?.length) {
+            return;
+        }
+        return movedLayers;
+    }
+    moveBelow(layerRef, ...layers) {
+        const position = this.getPosition(layerRef, 'below');
+        const movedLayers = this.moveTo(position, ...layers);
+        this.handleMove(movedLayers, layerRef.parent);
+    }
+    moveAbove(layerRef, ...layers) {
+        const position = this.getPosition(layerRef);
+        const movedLayers = this.moveTo(position, ...layers);
+        this.handleMove(movedLayers, layerRef.parent);
+    }
+    moveInside(layerRef, ...layers) {
+        const position = this.getPosition(layerRef);
+        const movedLayers = this.moveTo(position.concat(0), ...layers);
+        this.handleMove(movedLayers, layerRef);
+    }
+    raise(...layers) {
+        const position = this.getPosition(layers[0]);
+        const nextPosition = this.findLowestVisiblePostion(position, -1);
+        this.moveTo(nextPosition, ...layers);
+        this.handleMove(layers, null, true);
+    }
+    lower(...layers) {
+        const position = this.getPosition(layers[layers.length - 1]);
+        const nextPosition = this.findLowestVisiblePostion(position, 2); // +2 because we use moveBefore
+        this.moveTo(nextPosition, ...layers);
+        this.handleMove(layers, null, true);
+    }
+    /** Reset all except SystemLayer */
+    reset() {
+        this.clearBaselayers();
+        this.clearTree();
+        this.clearOther();
+        this.clearSelection();
+        this.notify();
+    }
+    getById(id) {
+        return this.all.find((layer) => layer.id && layer.id === id);
+    }
+    getBySourceId(id) {
+        return this.all.find((layer) => layer.dataSource?.id && layer.dataSource.id === id);
+    }
+    getPosition(layer, type = 'above') {
+        const position = this.tree.getPosition(layer);
+        if (type === 'below') {
+            let index = position.pop();
+            return position.concat(++index);
+        }
+        return position;
+    }
+    getLayerRecipient(layer) {
+        return layer.parent
+            ? this.tree.getChildren(layer.parent)
+            : [...this.treeLayers];
+    }
+    /**
+     * We got non visible layer in the tree like LinkedLayer. We want the next visible layer in tree
+     */
+    findLowestVisiblePostion(position, increment) {
+        const index = position.pop();
+        const nextPosition = position.concat(index + increment);
+        const layer = this.tree.getNodeByPosition(nextPosition);
+        if (layer && !layer.showInLayerList) {
+            const nextIndex = increment > 1 ? 1 : increment;
+            return this.findLowestVisiblePostion(nextPosition, nextIndex);
+        }
+        return nextPosition;
+    }
+    handleMove(layers, parent, keepCurrentParent) {
+        if (!layers?.length) {
+            return;
+        }
+        layers.forEach((layer) => {
+            layer.moveTo(keepCurrentParent ? layer.parent : parent);
+        });
+        this._internalMove();
+    }
+    _internalMove() {
+        this.recalculateZindex();
+        this.notify();
+    }
+    getBefore(layer) {
+        return this.treeLayers.find((layerTree) => layerTree.zIndex <= layer.zIndex);
+    }
+    /** Recursive */
+    recalculateZindex(minIndex = this.baseLayers.length, layers = this.treeLayers) {
+        return [...layers].reverse().reduce((previousZindex, layer) => {
+            let zIndex = ++previousZindex;
+            layer.zIndex = zIndex;
+            if (isLayerGroup(layer)) {
+                zIndex = this.recalculateZindex(zIndex, layer.children);
+            }
+            return zIndex;
+        }, minIndex);
+    }
+    handleAdd(layer, offset) {
+        const existingLayer = this.getById(layer.id);
+        if (existingLayer !== undefined) {
+            existingLayer.visible = true;
+            return;
+        }
+        const zIndex = this.getZindexOffset(layer, offset);
+        this.setZindex(layer, zIndex);
+        layer.init(this._map);
+        if (isBaseLayer(layer)) {
+            if (layer.visible) {
+                this.selectBaseLayer(layer);
+            }
+            this._baseLayers.push(layer);
+        }
+        else if (this.isOtherLayer(layer)) {
+            this._otherLayers.push(layer);
+        }
+        else if (this.isSystemLayer(layer) && !layer.showInLayerList) {
+            this._systemLayers.push(layer);
+        }
+        else if (layer.showInLayerList) {
+            return layer;
+        }
+        else {
+            this._otherLayers.push(layer);
+        }
+        const parent = layer.parentId
+            ? this.getById(layer.parentId.split(TREE_SEPERATOR).pop())
+            : undefined;
+        layer.add(parent);
+        return;
+    }
+    _remove(layer) {
+        if (isBaseLayer(layer)) {
+            this.removeBaselayer(layer);
+        }
+        else if (this.isOtherLayer(layer)) {
+            this.removeOtherLayer(layer);
+        }
+        else if (this.isSystemLayer(layer)) {
+            this.removeSystemLayer(layer);
+        }
+        layer.remove();
+        return layer;
+    }
+    removeBaselayer(layer) {
+        this.removeIn(layer, this._baseLayers);
+    }
+    removeSystemLayer(layer) {
+        this.removeIn(layer, this._systemLayers);
+    }
+    removeOtherLayer(layer) {
+        this.removeIn(layer, this._otherLayers);
+    }
+    removeIn(layer, store) {
+        const index = store.findIndex((sysLayer) => sysLayer.id === layer.id);
+        if (index === -1) {
+            return;
+        }
+        store.splice(index, 1);
+    }
+    isSystemLayer(layer) {
+        return isLayerItem(layer) && layer.isIgoInternalLayer;
+    }
+    isOtherLayer(layer) {
+        return isLayerLinked(layer) && !layer.showInLayerList;
+    }
+    clearBaselayers() {
+        this.baseLayers.forEach((layer) => this._remove(layer));
+        this._baseLayers = [];
+    }
+    clearTree() {
+        this.treeLayers.forEach((layer) => this._remove(layer));
+        this.tree.clear();
+    }
+    clearSystems() {
+        this._systemLayers.forEach((layer) => this._remove(layer));
+        this._systemLayers = [];
+    }
+    clearOther() {
+        this._otherLayers.forEach((layer) => this._remove(layer));
+        this._otherLayers = [];
+    }
+    getZindexOffset(layer, previousOffset = 0) {
+        return layer.zIndex ? 0 : previousOffset++;
+    }
+    setZindex(layer, offset) {
+        if (isBaseLayer(layer)) {
+            return this.handleBaselayerZIndex(layer, offset);
+        }
+        if (layer.zIndex === undefined || layer.zIndex === 0) {
+            const maxZIndex = Math.max(ZINDEX_MIN, ...this.treeLayers.map((l) => l.zIndex));
+            layer.zIndex = maxZIndex + 1 + (offset ?? 0);
+        }
+    }
+    handleBaselayerZIndex(layer, offset) {
+        const maxZIndex = Math.max(0, ...this.baseLayers.map((l) => l.zIndex));
+        const zIndex = maxZIndex + 1 + (offset ?? 0);
+        layer.zIndex = zIndex > ZINDEX_MIN ? ZINDEX_MIN : zIndex;
+    }
+    notify() {
+        this.layersFlattened = [...this.tree.flattened];
+        this._layers$.next([...this.treeLayers]);
+        this._baseLayers$.next([...this.baseLayers]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"layer-controller.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/layer/shared/layer-controller.ts"],"names":[],"mappings":"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","sourcesContent":["import { TREE_SEPERATOR, Tree } from '@igo2/utils';\n\nimport {\n  BehaviorSubject,\n  Observable,\n  combineLatest,\n  debounceTime,\n  map\n} from 'rxjs';\n\nimport { type MapBase } from '../../map/shared/map.abstract';\nimport { isBaseLayer, isLayerGroup, isLayerItem } from '../utils/layer.utils';\nimport { LayerSelectionModel } from './layer-selection';\nimport type { AnyLayer } from './layers/any-layer';\nimport type { Layer } from './layers/layer';\nimport type { LayerGroup } from './layers/layer-group';\nimport { isLayerLinked } from './layers/linked/linked-layer.utils';\n\n// Below 10 is reserved for BaseLayer\nconst ZINDEX_MIN = 10;\n\n/**\n * We got four kind of layers\n * TreeLayer: all layers to show in the layer manager\n * Baselayer: Layer dedicated for the basemap\n * SystemLayer: Every layer dedicated to good function of the map (Selection, hovering)\n * OtherLayer: all remaining layer that is linked to another layer or simply not a systemLayer that need to be cleaned on map reset\n */\nexport class LayerController extends LayerSelectionModel {\n  private tree: Tree<AnyLayer>;\n\n  /** Selection, Hovering, every internalLayer not in the tree is here */\n  private _systemLayers: AnyLayer[] = [];\n\n  /** LinkedLayer and other layer that are not in the previous category and not visible in tree */\n  private _otherLayers: AnyLayer[] = [];\n\n  layersFlattened: AnyLayer[] = [];\n\n  private _layers$ = new BehaviorSubject<AnyLayer[] | undefined>(undefined);\n  layers$ = this._layers$.asObservable();\n\n  layersFlattened$ = this._layers$\n    .asObservable()\n    .pipe(map(() => this.layersFlattened));\n\n  private _baseLayers: Layer[] = [];\n  private _baseLayers$ = new BehaviorSubject<Layer[] | undefined>(undefined);\n  baseLayers$ = this._baseLayers$.asObservable();\n\n  baseLayerSelection: Layer;\n\n  /** All layers with the tree flattened */\n  all$: Observable<AnyLayer[]>;\n\n  constructor(\n    private _map: MapBase,\n    layers: AnyLayer[]\n  ) {\n    super();\n\n    this.all$ = combineLatest([this.layersFlattened$, this.baseLayers$]).pipe(\n      debounceTime(10),\n      map(() => this.all)\n    );\n\n    this.tree = new Tree(layers, {\n      getChildren: (node) => isLayerGroup(node) && node.children,\n      getId: (node) => node.id,\n      getLevel: (node) => node.zIndex,\n      reverse: true\n    });\n  }\n\n  get all(): AnyLayer[] {\n    return [\n      ...this.baseLayers,\n      ...this.layersFlattened,\n      ...this._systemLayers,\n      ...this._otherLayers\n    ];\n  }\n\n  get baseLayers(): readonly Layer[] {\n    return this._baseLayers;\n  }\n\n  get baseLayer(): Layer {\n    return this.baseLayers.find((layer) => layer.visible);\n  }\n\n  get treeLayers(): readonly AnyLayer[] {\n    return this.tree.data;\n  }\n\n  add(...layers: AnyLayer[]): void {\n    const offset = 0;\n\n    const addedLayers = layers\n      .map((layer) => this.handleAdd(layer, offset))\n      .filter(Boolean);\n\n    if (!addedLayers.length) {\n      this.notify();\n      return;\n    }\n\n    this.tree.add(...addedLayers);\n\n    // Notify the layers change before the iteration on the addedLayer\n    // Because the Layer may have have LinkedLayer who need to find the parent.\n    this.layersFlattened = [...this.tree.flattened];\n    addedLayers.forEach((layer) => layer.add());\n\n    this.recalculateZindex();\n    this.notify();\n  }\n\n  selectBaseLayer(layer: Layer): void {\n    if (!isBaseLayer(layer)) {\n      return;\n    }\n\n    if (this.baseLayerSelection) {\n      this.baseLayerSelection.visible = false;\n    }\n\n    layer.visible = true;\n    this.baseLayerSelection = layer;\n\n    this._map.viewController.olView.setMinZoom(\n      layer.dataSource.options.minZoom || (this._map.options.view || {}).minZoom\n    );\n    this._map.viewController.olView.setMaxZoom(\n      layer.dataSource.options.maxZoom || (this._map.options.view || {}).maxZoom\n    );\n  }\n\n  remove(...layers: AnyLayer[]): void {\n    const list = layers.reduce((list, layer) => {\n      if (this.isSelected(layer)) {\n        this.deselect(layer);\n      }\n      const result = this._remove(layer);\n      Array.isArray(result) ? list.push(...result) : list.push(result);\n      return list;\n    }, []);\n    this.tree.remove(...list);\n\n    this.notify();\n  }\n\n  /**\n   * Move a layer into the tree\n   * @param layer Layer to move\n   * @param beforeTo The index position to move inside a tree\n   */\n  moveTo(beforeTo: number[], ...layers: AnyLayer[]): AnyLayer[] {\n    const movedLayers = this.tree.moveTo(beforeTo, ...layers);\n    if (!movedLayers?.length) {\n      return;\n    }\n\n    return movedLayers;\n  }\n\n  moveBelow(layerRef: AnyLayer | undefined, ...layers: AnyLayer[]): void {\n    const position = this.getPosition(layerRef, 'below');\n\n    const movedLayers = this.moveTo(position, ...layers);\n    this.handleMove(movedLayers, layerRef.parent);\n  }\n\n  moveAbove(layerRef: AnyLayer | undefined, ...layers: AnyLayer[]): void {\n    const position = this.getPosition(layerRef);\n\n    const movedLayers = this.moveTo(position, ...layers);\n    this.handleMove(movedLayers, layerRef.parent);\n  }\n\n  moveInside(layerRef: LayerGroup, ...layers: AnyLayer[]): void {\n    const position = this.getPosition(layerRef);\n\n    const movedLayers = this.moveTo(position.concat(0), ...layers);\n    this.handleMove(movedLayers, layerRef);\n  }\n\n  raise(...layers: AnyLayer[]): void {\n    const position = this.getPosition(layers[0]);\n    const nextPosition = this.findLowestVisiblePostion(position, -1);\n    this.moveTo(nextPosition, ...layers);\n    this.handleMove(layers, null, true);\n  }\n\n  lower(...layers: AnyLayer[]): void {\n    const position = this.getPosition(layers[layers.length - 1]);\n    const nextPosition = this.findLowestVisiblePostion(position, 2); // +2 because we use moveBefore\n    this.moveTo(nextPosition, ...layers);\n    this.handleMove(layers, null, true);\n  }\n\n  /** Reset all except SystemLayer */\n  reset(): void {\n    this.clearBaselayers();\n    this.clearTree();\n    this.clearOther();\n    this.clearSelection();\n\n    this.notify();\n  }\n\n  getById(id: string): AnyLayer {\n    return this.all.find((layer) => layer.id && layer.id === id);\n  }\n\n  getBySourceId(id: string): AnyLayer {\n    return this.all.find(\n      (layer) => layer.dataSource?.id && layer.dataSource.id === id\n    );\n  }\n\n  getPosition(layer: AnyLayer, type: 'below' | 'above' = 'above'): number[] {\n    const position = this.tree.getPosition(layer);\n\n    if (type === 'below') {\n      let index = position.pop();\n      return position.concat(++index);\n    }\n\n    return position;\n  }\n\n  getLayerRecipient(layer: AnyLayer): AnyLayer[] {\n    return layer.parent\n      ? this.tree.getChildren(layer.parent)\n      : [...this.treeLayers];\n  }\n\n  /**\n   * We got non visible layer in the tree like LinkedLayer. We want the next visible layer in tree\n   */\n  private findLowestVisiblePostion(\n    position: number[],\n    increment: number\n  ): number[] {\n    const index = position.pop();\n    const nextPosition = position.concat(index + increment);\n    const layer = this.tree.getNodeByPosition(nextPosition);\n    if (layer && !layer.showInLayerList) {\n      const nextIndex = increment > 1 ? 1 : increment;\n      return this.findLowestVisiblePostion(nextPosition, nextIndex);\n    }\n    return nextPosition;\n  }\n\n  private handleMove(\n    layers: AnyLayer[],\n    parent?: LayerGroup,\n    keepCurrentParent?: boolean\n  ): void {\n    if (!layers?.length) {\n      return;\n    }\n\n    layers.forEach((layer) => {\n      layer.moveTo(keepCurrentParent ? layer.parent : parent);\n    });\n    this._internalMove();\n  }\n\n  private _internalMove() {\n    this.recalculateZindex();\n    this.notify();\n  }\n\n  private getBefore(layer: AnyLayer): AnyLayer {\n    return this.treeLayers.find(\n      (layerTree) => layerTree.zIndex <= layer.zIndex\n    );\n  }\n\n  /** Recursive */\n  private recalculateZindex(\n    minIndex = this.baseLayers.length,\n    layers = this.treeLayers\n  ) {\n    return [...layers].reverse().reduce((previousZindex, layer) => {\n      let zIndex = ++previousZindex;\n      layer.zIndex = zIndex;\n      if (isLayerGroup(layer)) {\n        zIndex = this.recalculateZindex(zIndex, layer.children);\n      }\n\n      return zIndex;\n    }, minIndex);\n  }\n\n  private handleAdd(layer: AnyLayer, offset?: number): AnyLayer {\n    const existingLayer = this.getById(layer.id);\n    if (existingLayer !== undefined) {\n      existingLayer.visible = true;\n      return;\n    }\n\n    const zIndex = this.getZindexOffset(layer, offset);\n    this.setZindex(layer, zIndex);\n\n    layer.init(this._map);\n\n    if (isBaseLayer(layer)) {\n      if (layer.visible) {\n        this.selectBaseLayer(layer);\n      }\n      this._baseLayers.push(layer);\n    } else if (this.isOtherLayer(layer)) {\n      this._otherLayers.push(layer);\n    } else if (this.isSystemLayer(layer) && !layer.showInLayerList) {\n      this._systemLayers.push(layer);\n    } else if (layer.showInLayerList) {\n      return layer;\n    } else {\n      this._otherLayers.push(layer);\n    }\n\n    const parent: LayerGroup | undefined = layer.parentId\n      ? (this.getById(layer.parentId.split(TREE_SEPERATOR).pop()) as LayerGroup)\n      : undefined;\n    layer.add(parent);\n\n    return;\n  }\n\n  private _remove(layer: AnyLayer): AnyLayer | AnyLayer[] {\n    if (isBaseLayer(layer)) {\n      this.removeBaselayer(layer);\n    } else if (this.isOtherLayer(layer)) {\n      this.removeOtherLayer(layer);\n    } else if (this.isSystemLayer(layer)) {\n      this.removeSystemLayer(layer);\n    }\n\n    layer.remove();\n    return layer;\n  }\n\n  private removeBaselayer(layer: AnyLayer) {\n    this.removeIn(layer, this._baseLayers);\n  }\n\n  private removeSystemLayer(layer: AnyLayer) {\n    this.removeIn(layer, this._systemLayers);\n  }\n\n  private removeOtherLayer(layer: AnyLayer) {\n    this.removeIn(layer, this._otherLayers);\n  }\n\n  private removeIn(layer: AnyLayer, store: AnyLayer[]) {\n    const index = store.findIndex((sysLayer) => sysLayer.id === layer.id);\n    if (index === -1) {\n      return;\n    }\n    store.splice(index, 1);\n  }\n\n  private isSystemLayer(layer: AnyLayer): boolean {\n    return isLayerItem(layer) && layer.isIgoInternalLayer;\n  }\n\n  private isOtherLayer(layer: AnyLayer): boolean {\n    return isLayerLinked(layer) && !layer.showInLayerList;\n  }\n\n  private clearBaselayers(): void {\n    this.baseLayers.forEach((layer) => this._remove(layer));\n    this._baseLayers = [];\n  }\n\n  private clearTree(): void {\n    this.treeLayers.forEach((layer) => this._remove(layer));\n    this.tree.clear();\n  }\n\n  private clearSystems(): void {\n    this._systemLayers.forEach((layer) => this._remove(layer));\n    this._systemLayers = [];\n  }\n\n  private clearOther(): void {\n    this._otherLayers.forEach((layer) => this._remove(layer));\n    this._otherLayers = [];\n  }\n\n  private getZindexOffset(layer: AnyLayer, previousOffset = 0): number {\n    return layer.zIndex ? 0 : previousOffset++;\n  }\n\n  private setZindex(layer: AnyLayer, offset?: number): void {\n    if (isBaseLayer(layer)) {\n      return this.handleBaselayerZIndex(layer, offset);\n    }\n    if (layer.zIndex === undefined || layer.zIndex === 0) {\n      const maxZIndex = Math.max(\n        ZINDEX_MIN,\n        ...this.treeLayers.map((l) => l.zIndex)\n      );\n      layer.zIndex = maxZIndex + 1 + (offset ?? 0);\n    }\n  }\n\n  private handleBaselayerZIndex(layer: Layer, offset?: number) {\n    const maxZIndex = Math.max(0, ...this.baseLayers.map((l) => l.zIndex));\n\n    const zIndex = maxZIndex + 1 + (offset ?? 0);\n    layer.zIndex = zIndex > ZINDEX_MIN ? ZINDEX_MIN : zIndex;\n  }\n\n  private notify(): void {\n    this.layersFlattened = [...this.tree.flattened];\n    this._layers$.next([...this.treeLayers]);\n    this._baseLayers$.next([...this.baseLayers]);\n  }\n}\n"]}

package/esm2022/lib/layer/shared/layer-selection.mjs

@@ -0,0 +1,38 @@
+import { SelectionModel } from '@angular/cdk/collections';
+import { isLayerGroup } from '../utils/layer.utils';
+export class LayerSelectionModel {
+    selection = new SelectionModel(true);
+    descendantSelection = new SelectionModel(true);
+    get selected() {
+        return this.selection.selected;
+    }
+    get hasSelection() {
+        return this.selection.hasValue();
+    }
+    get isSelectionEmpty() {
+        return this.selection.isEmpty();
+    }
+    clearSelection() {
+        this.selection.clear();
+        this.descendantSelection.clear();
+    }
+    select(...layers) {
+        this.selection.select(...layers);
+        this.descendantSelection.select(...this.getDescendants(...layers));
+    }
+    deselect(...layers) {
+        this.selection.deselect(...layers);
+        this.descendantSelection.deselect(...this.getDescendants(...layers));
+    }
+    isSelected = (layer) => this.selection.isSelected(layer);
+    isDescendantSelection = (layer) => this.descendantSelection.isSelected(layer);
+    getDescendants(...layers) {
+        return layers.reduce((descendants, layer) => {
+            if (isLayerGroup(layer)) {
+                return descendants.concat(layer.descendants);
+            }
+            return descendants;
+        }, []);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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