@igo2/geo 18.0.1-next.2 → 18.0.2

package/esm2022/lib/geometry/shared/controls/modify.mjs

@@ -0,0 +1,538 @@
+import OlFeature from 'ol/Feature';
+import { unByKey } from 'ol/Observable';
+import OlLinearRing from 'ol/geom/LinearRing';
+import OlPolygon from 'ol/geom/Polygon';
+import OlDragBoxInteraction from 'ol/interaction/DragBox';
+import OlDraw from 'ol/interaction/Draw';
+import OlModify from 'ol/interaction/Modify';
+import OlTranslate from 'ol/interaction/Translate';
+import OlVectorLayer from 'ol/layer/Vector';
+import OlVectorSource from 'ol/source/Vector';
+import { Subject, fromEvent } from 'rxjs';
+import { addLinearRingToOlPolygon, createDrawHoleInteractionStyle, getMousePositionFromOlGeometryEvent } from '../geometry.utils';
+/**
+ * Control to modify geometries
+ */
+export class ModifyControl {
+    options;
+    /**
+     * Modify start observable
+     */
+    start$ = new Subject();
+    /**
+     * Modify end observable
+     */
+    end$ = new Subject();
+    /**
+     * Geometry changes observable
+     */
+    changes$ = new Subject();
+    olMap;
+    olOverlayLayer;
+    olModifyInteraction;
+    onModifyStartKey;
+    onModifyEndKey;
+    onModifyKey;
+    olModifyInteractionIsActive = false;
+    olTranslateInteraction;
+    onTranslateStartKey;
+    onTranslateEndKey;
+    onTranslateKey;
+    olTranslateInteractionIsActive = false;
+    olDrawInteraction;
+    onDrawStartKey;
+    onDrawEndKey;
+    onDrawKey;
+    olDrawInteractionIsActive = false;
+    mousePosition;
+    keyDown$$;
+    drawKeyUp$$;
+    drawKeyDown$$;
+    removedOlInteractions = [];
+    olLinearRingsLayer;
+    // This is the geometry to test against when drawing holes
+    olOuterGeometry;
+    /**
+     * Wheter the control is active
+     */
+    get active() {
+        return this.olMap !== undefined;
+    }
+    /**
+     * OL overlay source
+     * @internal
+     */
+    get olOverlaySource() {
+        return this.olOverlayLayer.getSource();
+    }
+    /**
+     * OL linear rings source
+     * @internal
+     */
+    get olLinearRingsSource() {
+        return this.olLinearRingsLayer.getSource();
+    }
+    /**
+     * Whether a modify control should be available
+     */
+    modify = true;
+    /**
+     * Whether a translate control should be available
+     */
+    translate = true;
+    constructor(options) {
+        this.options = options;
+        if (options.modify !== undefined) {
+            this.modify = options.modify;
+        }
+        if (options.translate !== undefined) {
+            this.translate = options.translate;
+        }
+        if (options.layer !== undefined) {
+            this.olOverlayLayer = options.layer;
+        }
+        else {
+            this.olOverlayLayer = this.createOlInnerOverlayLayer();
+        }
+        this.olLinearRingsLayer = this.createOlLinearRingsLayer();
+    }
+    /**
+     * Add or remove this control to/from a map.
+     * @param map OL Map
+     */
+    setOlMap(olMap) {
+        if (olMap === undefined) {
+            this.clearOlInnerOverlaySource();
+            this.removeOlInnerOverlayLayer();
+            this.removeOlModifyInteraction();
+            this.removeOlTranslateInteraction();
+            this.removeOlDrawInteraction();
+            this.olMap = olMap;
+            return;
+        }
+        this.olMap = olMap;
+        this.addOlInnerOverlayLayer();
+        // The order in which these interactions
+        // are added is important
+        if (this.modify === true) {
+            this.addOlDrawInteraction();
+        }
+        if (this.translate === true) {
+            this.addOlTranslateInteraction();
+            this.activateTranslateInteraction();
+        }
+        if (this.modify === true) {
+            this.addOlModifyInteraction();
+            this.activateModifyInteraction();
+        }
+    }
+    /**
+     * Return the overlay source
+     */
+    getSource() {
+        return this.olOverlaySource;
+    }
+    /**
+     * Add an OL geometry to the overlay and start modifying it
+     * @param olGeometry Ol Geometry
+     */
+    setOlGeometry(olGeometry) {
+        const olFeature = new OlFeature({ geometry: olGeometry });
+        this.olOverlaySource.clear();
+        this.olOverlaySource.addFeature(olFeature);
+    }
+    /**
+     * Create an overlay source if none is defined in the options
+     */
+    createOlInnerOverlayLayer() {
+        return new OlVectorLayer({
+            source: this.options.source ? this.options.source : new OlVectorSource(),
+            style: this.options.layerStyle,
+            zIndex: 500
+        });
+    }
+    /**
+     * Add the overlay layer if it wasn't defined in the options
+     */
+    addOlInnerOverlayLayer() {
+        if (this.options.layer === undefined) {
+            this.olMap.addLayer(this.olOverlayLayer);
+        }
+    }
+    /**
+     * Clear the overlay layer if it wasn't defined in the options
+     */
+    removeOlInnerOverlayLayer() {
+        if (this.options.layer === undefined && this.olMap !== undefined) {
+            this.olMap.removeLayer(this.olOverlayLayer);
+        }
+    }
+    /**
+     * Clear the overlay source if it wasn't defined in the options
+     */
+    clearOlInnerOverlaySource() {
+        if (this.options.layer === undefined && this.options.source === undefined) {
+            this.olOverlaySource.clear(true);
+        }
+    }
+    createOlLinearRingsLayer() {
+        return new OlVectorLayer({
+            source: new OlVectorSource(),
+            style: createDrawHoleInteractionStyle(),
+            zIndex: 500
+        });
+    }
+    /**
+     * Add the linear rings layer
+     */
+    addOlLinearRingsLayer() {
+        this.olMap.addLayer(this.olLinearRingsLayer);
+    }
+    /**
+     * Clear the linear rings layer
+     */
+    removeOlLinearRingsLayer() {
+        this.olMap.removeLayer(this.olLinearRingsLayer);
+    }
+    /**
+     * Clear the linear rings source
+     */
+    clearOlLinearRingsSource() {
+        this.olLinearRingsSource.clear(true);
+    }
+    /**
+     * Add a modify interaction to the map an set up some listeners
+     */
+    addOlModifyInteraction() {
+        const olModifyInteraction = new OlModify({
+            source: this.olOverlaySource,
+            style: this.options.drawStyle
+        });
+        this.olModifyInteraction = olModifyInteraction;
+    }
+    /**
+     * Remove the modify interaction
+     */
+    removeOlModifyInteraction() {
+        if (this.olModifyInteraction === undefined) {
+            return;
+        }
+        this.deactivateModifyInteraction();
+        this.olModifyInteraction = undefined;
+    }
+    activateModifyInteraction() {
+        if (this.olModifyInteractionIsActive === true) {
+            return;
+        }
+        this.olModifyInteractionIsActive = true;
+        this.onModifyStartKey = this.olModifyInteraction.on('modifystart', (event) => this.onModifyStart(event));
+        this.onModifyEndKey = this.olModifyInteraction.on('modifyend', (event) => this.onModifyEnd(event));
+        this.olMap.addInteraction(this.olModifyInteraction);
+    }
+    deactivateModifyInteraction() {
+        if (this.olModifyInteractionIsActive === false) {
+            return;
+        }
+        this.olModifyInteractionIsActive = false;
+        unByKey([this.onModifyStartKey, this.onModifyEndKey, this.onModifyKey]);
+        if (this.olMap !== undefined) {
+            this.olMap.removeInteraction(this.olModifyInteraction);
+        }
+    }
+    /**
+     * When modifying starts, clear the overlay and start watching for changes
+     * @param event Modify start event
+     */
+    onModifyStart(event) {
+        const olGeometry = event.features.item(0).getGeometry();
+        this.start$.next(olGeometry);
+        this.onModifyKey = olGeometry.on('change', (olGeometryEvent) => {
+            this.mousePosition =
+                getMousePositionFromOlGeometryEvent(olGeometryEvent);
+            this.changes$.next(olGeometryEvent.target);
+        });
+        this.subscribeToKeyDown();
+    }
+    /**
+     * When modifying ends, update the geometry observable and stop watching for changes
+     * @param event Modify end event
+     */
+    onModifyEnd(event) {
+        unByKey(this.onModifyKey);
+        this.end$.next(event.features.item(0).getGeometry());
+        this.unsubscribeToKeyDown();
+    }
+    /**
+     * Subscribe to space key down to pan the map
+     */
+    subscribeToKeyDown() {
+        this.keyDown$$ = fromEvent(document, 'keydown').subscribe((event) => {
+            if (event.key === ' ') {
+                // On space bar, pan to the current mouse position
+                this.olMap.getView().animate({
+                    center: this.mousePosition,
+                    duration: 0
+                });
+                return;
+            }
+        });
+    }
+    /**
+     * Unsubscribe to key down
+     */
+    unsubscribeToKeyDown() {
+        if (this.keyDown$$ !== undefined) {
+            this.keyDown$$.unsubscribe();
+        }
+    }
+    /**
+     * Add a translate interaction to the map an set up some listeners
+     */
+    addOlTranslateInteraction() {
+        const olTranslateInteraction = new OlTranslate({
+            layers: [this.olOverlayLayer]
+        });
+        this.olTranslateInteraction = olTranslateInteraction;
+    }
+    /**
+     * Remove the translate interaction
+     */
+    removeOlTranslateInteraction() {
+        if (this.olTranslateInteraction === undefined) {
+            return;
+        }
+        this.deactivateTranslateInteraction();
+        this.olTranslateInteraction = undefined;
+    }
+    activateTranslateInteraction() {
+        if (this.olTranslateInteractionIsActive === true) {
+            return;
+        }
+        this.olTranslateInteractionIsActive = true;
+        this.onTranslateStartKey = this.olTranslateInteraction.on('translatestart', (event) => this.onTranslateStart(event));
+        this.onTranslateEndKey = this.olTranslateInteraction.on('translateend', (event) => this.onTranslateEnd(event));
+        this.olMap.addInteraction(this.olTranslateInteraction);
+    }
+    deactivateTranslateInteraction() {
+        if (this.olTranslateInteractionIsActive === false) {
+            return;
+        }
+        this.olTranslateInteractionIsActive = false;
+        unByKey([
+            this.onTranslateStartKey,
+            this.onTranslateEndKey,
+            this.onTranslateKey
+        ]);
+        if (this.olMap !== undefined) {
+            this.olMap.removeInteraction(this.olTranslateInteraction);
+        }
+    }
+    /**
+     * When translation starts, clear the overlay and start watching for changes
+     * @param event Translate start event
+     */
+    onTranslateStart(event) {
+        const olGeometry = event.features.item(0).getGeometry();
+        this.start$.next(olGeometry);
+    }
+    /**
+     * When translation ends, update the geometry observable and stop watchign for changes
+     * @param event Translate end event
+     */
+    onTranslateEnd(event) {
+        unByKey(this.onTranslateKey);
+        this.end$.next(event.features.item(0).getGeometry());
+    }
+    /**
+     * Add a draw interaction to the map an set up some listeners
+     */
+    addOlDrawInteraction() {
+        const olDrawInteraction = new OlDraw({
+            type: 'Polygon',
+            source: this.olLinearRingsSource,
+            stopClick: true,
+            style: createDrawHoleInteractionStyle(),
+            condition: (event) => {
+                const olOuterGeometry = this.olOuterGeometry || this.getOlGeometry();
+                const intersects = olOuterGeometry.intersectsCoordinate(event.coordinate);
+                return intersects;
+            }
+        });
+        this.olDrawInteraction = olDrawInteraction;
+        this.subscribeToDrawKeyDown();
+    }
+    /**
+     * Subscribe to CTRL key down to activate the draw control
+     */
+    subscribeToDrawKeyDown() {
+        this.drawKeyDown$$ = fromEvent(document, 'keydown').subscribe((event) => {
+            if (event.key !== 'Control') {
+                return;
+            }
+            this.unsubscribeToDrawKeyDown();
+            const olGeometry = this.getOlGeometry();
+            if (!olGeometry || !(olGeometry instanceof OlPolygon)) {
+                return;
+            }
+            this.subscribeToDrawKeyUp();
+            this.deactivateModifyInteraction();
+            this.deactivateTranslateInteraction();
+            this.activateDrawInteraction();
+        });
+    }
+    /**
+     * Subscribe to CTRL key up to deactivate the draw control
+     */
+    subscribeToDrawKeyUp() {
+        this.drawKeyUp$$ = fromEvent(document, 'keyup').subscribe((event) => {
+            if (event.key !== 'Control') {
+                return;
+            }
+            this.unsubscribeToDrawKeyUp();
+            this.unsubscribeToKeyDown();
+            this.deactivateDrawInteraction();
+            this.activateModifyInteraction();
+            if (this.translate === true) {
+                this.activateTranslateInteraction();
+            }
+            this.subscribeToDrawKeyDown();
+            this.olOuterGeometry = undefined;
+            this.clearOlLinearRingsSource();
+            this.end$.next(this.getOlGeometry());
+        });
+    }
+    /**
+     * Unsubscribe to draw key down
+     */
+    unsubscribeToDrawKeyDown() {
+        if (this.drawKeyDown$$ !== undefined) {
+            this.drawKeyDown$$.unsubscribe();
+        }
+    }
+    /**
+     * Unsubscribe to key up
+     */
+    unsubscribeToDrawKeyUp() {
+        if (this.drawKeyUp$$ !== undefined) {
+            this.drawKeyUp$$.unsubscribe();
+        }
+    }
+    /**
+     * Remove the draw interaction
+     */
+    removeOlDrawInteraction() {
+        if (this.olDrawInteraction === undefined) {
+            return;
+        }
+        this.unsubscribeToKeyDown();
+        this.unsubscribeToDrawKeyUp();
+        this.unsubscribeToDrawKeyDown();
+        this.deactivateDrawInteraction();
+        this.clearOlLinearRingsSource();
+        this.olDrawInteraction = undefined;
+    }
+    /**
+     * Activate the draw interaction
+     */
+    activateDrawInteraction() {
+        if (this.olDrawInteractionIsActive === true) {
+            return;
+        }
+        this.clearOlLinearRingsSource();
+        this.addOlLinearRingsLayer();
+        this.olMap.getInteractions().forEach((olInteraction) => {
+            if (olInteraction instanceof OlDragBoxInteraction) {
+                this.olMap.removeInteraction(olInteraction);
+                this.removedOlInteractions.push(olInteraction);
+            }
+        });
+        this.olDrawInteractionIsActive = true;
+        this.onDrawStartKey = this.olDrawInteraction.on('drawstart', (event) => this.onDrawStart(event));
+        this.onDrawEndKey = this.olDrawInteraction.on('drawend', (event) => this.onDrawEnd(event));
+        this.olMap.addInteraction(this.olDrawInteraction);
+    }
+    /**
+     * Deactivate the draw interaction
+     */
+    deactivateDrawInteraction() {
+        if (this.olDrawInteractionIsActive === false) {
+            return;
+        }
+        this.removeOlLinearRingsLayer();
+        this.removedOlInteractions.forEach((olInteraction) => {
+            this.olMap.addInteraction(olInteraction);
+        });
+        this.removedOlInteractions = [];
+        this.olDrawInteractionIsActive = false;
+        unByKey([this.onDrawStartKey, this.onDrawEndKey, this.onDrawKey]);
+        if (this.olMap !== undefined) {
+            this.olMap.removeInteraction(this.olDrawInteraction);
+        }
+    }
+    /**
+     * When draw start, add a new linerar ring to the geometry and start watching for changes
+     * @param event Draw start event
+     */
+    onDrawStart(event) {
+        const olGeometry = event.feature.getGeometry();
+        this.olOuterGeometry = this.getOlGeometry().clone();
+        const linearRingCoordinates = olGeometry.getLinearRing().getCoordinates();
+        this.addLinearRingToOlGeometry(linearRingCoordinates);
+        this.start$.next(this.getOlGeometry());
+        this.onDrawKey = olGeometry.on('change', (olGeometryEvent) => {
+            this.mousePosition = getMousePositionFromOlGeometryEvent(olGeometryEvent);
+            const olGeometryTarget = olGeometryEvent.target;
+            const _linearRingCoordinates = olGeometryTarget
+                .getLinearRing(0)
+                .getCoordinates();
+            this.updateLinearRingOfOlGeometry(_linearRingCoordinates);
+            this.changes$.next(this.getOlGeometry());
+        });
+        this.subscribeToKeyDown();
+    }
+    /**
+     * When translation ends, update the geometry observable and stop watchign for changes
+     * @param event Draw end event
+     */
+    onDrawEnd(event) {
+        unByKey(this.onDrawKey);
+        this.olOuterGeometry = undefined;
+        const linearRingCoordinates = event.feature.getGeometry().getLinearRing().getCoordinates();
+        this.updateLinearRingOfOlGeometry(linearRingCoordinates);
+        this.clearOlLinearRingsSource();
+        this.end$.next(this.getOlGeometry());
+        this.unsubscribeToKeyDown();
+    }
+    /**
+     * Add a linear ring to the geometry being modified
+     * @param coordinates Linear ring coordinates
+     */
+    addLinearRingToOlGeometry(coordinates) {
+        const olGeometry = this.getOlGeometry();
+        const olLinearRing = new OlLinearRing(coordinates);
+        addLinearRingToOlPolygon(olGeometry, olLinearRing);
+    }
+    /**
+     * Update the last linear ring of the geometry being modified
+     * @param coordinates Linear ring coordinates
+     */
+    updateLinearRingOfOlGeometry(coordinates) {
+        const olGeometry = this.getOlGeometry();
+        // Remove the last linear ring (the one we are updating)
+        const olLinearRings = olGeometry.getLinearRings().slice(0, -1);
+        const newCoordinates = olLinearRings.map((olLinearRing) => {
+            return olLinearRing.getCoordinates();
+        });
+        newCoordinates.push(coordinates);
+        olGeometry.setCoordinates(newCoordinates);
+    }
+    /**
+     * Get the geometry being modified
+     * @returns OL Geometry
+     */
+    getOlGeometry() {
+        const olFeatures = this.olOverlaySource.getFeatures();
+        return olFeatures.length > 0 ? olFeatures[0].getGeometry() : undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modify.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/geometry/shared/controls/modify.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,YAAY,CAAC;AAGnC,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAKxC,OAAO,YAAY,MAAM,oBAAoB,CAAC;AAC9C,OAAO,SAAS,MAAM,iBAAiB,CAAC;AACxC,OAAO,oBAAoB,MAAM,wBAAwB,CAAC;AAC1D,OAAO,MAAM,MAAM,qBAAqB,CAAC;AAGzC,OAAO,QAAQ,MAAM,uBAAuB,CAAC;AAE7C,OAAO,WAAW,MAAM,0BAA0B,CAAC;AAEnD,OAAO,aAAa,MAAM,iBAAiB,CAAC;AAC5C,OAAO,cAAc,MAAM,kBAAkB,CAAC;AAI9C,OAAO,EAAE,OAAO,EAAgB,SAAS,EAAE,MAAM,MAAM,CAAC;AAExD,OAAO,EACL,wBAAwB,EACxB,8BAA8B,EAC9B,mCAAmC,EACpC,MAAM,mBAAmB,CAAC;AAW3B;;GAEG;AACH,MAAM,OAAO,aAAa;IA+EJ;IA9EpB;;OAEG;IACI,MAAM,GAAG,IAAI,OAAO,EAAc,CAAC;IAE1C;;OAEG;IACI,IAAI,GAAG,IAAI,OAAO,EAAc,CAAC;IAExC;;OAEG;IACI,QAAQ,GAAG,IAAI,OAAO,EAAc,CAAC;IAEpC,KAAK,CAAQ;IACb,cAAc,CAAqB;IACpC,mBAAmB,CAAW;IAC7B,gBAAgB,CAAM;IACtB,cAAc,CAAM;IACpB,WAAW,CAAM;IACjB,2BAA2B,GAAG,KAAK,CAAC;IACpC,sBAAsB,CAAc;IACpC,mBAAmB,CAAM;IACzB,iBAAiB,CAAM;IACvB,cAAc,CAAM;IACpB,8BAA8B,GAAG,KAAK,CAAC;IACvC,iBAAiB,CAAS;IAC1B,cAAc,CAAM;IACpB,YAAY,CAAM;IAClB,SAAS,CAAM;IACf,yBAAyB,GAAG,KAAK,CAAC;IAElC,aAAa,CAAmB;IAEhC,SAAS,CAAe;IACxB,WAAW,CAAe;IAC1B,aAAa,CAAe;IAE5B,qBAAqB,GAAoB,EAAE,CAAC;IAC5C,kBAAkB,CAAqB;IAE/C,0DAA0D;IAClD,eAAe,CAAa;IAEpC;;OAEG;IACH,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,KAAK,KAAK,SAAS,CAAC;IAClC,CAAC;IAED;;;OAGG;IACH,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,CAAC;IACzC,CAAC;IAED;;;OAGG;IACH,IAAI,mBAAmB;QACrB,OAAO,IAAI,CAAC,kBAAkB,CAAC,SAAS,EAAE,CAAC;IAC7C,CAAC;IAED;;OAEG;IACK,MAAM,GAAG,IAAI,CAAC;IAEtB;;OAEG;IACK,SAAS,GAAG,IAAI,CAAC;IAEzB,YAAoB,OAA6B;QAA7B,YAAO,GAAP,OAAO,CAAsB;QAC/C,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YACjC,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;QAC/B,CAAC;QACD,IAAI,OAAO,CAAC,SAAS,KAAK,SAAS,EAAE,CAAC;YACpC,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;QACrC,CAAC;QAED,IAAI,OAAO,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YAChC,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,KAAK,CAAC;QACtC,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,yBAAyB,EAAE,CAAC;QACzD,CAAC;QACD,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,wBAAwB,EAAE,CAAC;IAC5D,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,KAAwB;QAC/B,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,IAAI,CAAC,yBAAyB,EAAE,CAAC;YACjC,IAAI,CAAC,yBAAyB,EAAE,CAAC;YACjC,IAAI,CAAC,yBAAyB,EAAE,CAAC;YACjC,IAAI,CAAC,4BAA4B,EAAE,CAAC;YACpC,IAAI,CAAC,uBAAuB,EAAE,CAAC;YAC/B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;YACnB,OAAO;QACT,CAAC;QAED,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAE9B,wCAAwC;QACxC,yBAAyB;QACzB,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,EAAE,CAAC;YACzB,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC9B,CAAC;QAED,IAAI,IAAI,CAAC,SAAS,KAAK,IAAI,EAAE,CAAC;YAC5B,IAAI,CAAC,yBAAyB,EAAE,CAAC;YACjC,IAAI,CAAC,4BAA4B,EAAE,CAAC;QACtC,CAAC;QAED,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,EAAE,CAAC;YACzB,IAAI,CAAC,sBAAsB,EAAE,CAAC;YAC9B,IAAI,CAAC,yBAAyB,EAAE,CAAC;QACnC,CAAC;IACH,CAAC;IAED;;OAEG;IACH,SAAS;QACP,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IAED;;;OAGG;IACH,aAAa,CAAC,UAAsB;QAClC,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC,CAAC;QAC1D,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC;QAC7B,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;IAC7C,CAAC;IAED;;OAEG;IACK,yBAAyB;QAC/B,OAAO,IAAI,aAAa,CAAC;YACvB,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,cAAc,EAAE;YACxE,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU;YAC9B,MAAM,EAAE,GAAG;SACZ,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,sBAAsB;QAC5B,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YACrC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAC3C,CAAC;IACH,CAAC;IAED;;OAEG;IACK,yBAAyB;QAC/B,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,KAAK,SAAS,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YACjE,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAC9C,CAAC;IACH,CAAC;IAED;;OAEG;IACK,yBAAyB;QAC/B,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,KAAK,SAAS,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YAC1E,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACnC,CAAC;IACH,CAAC;IAEO,wBAAwB;QAC9B,OAAO,IAAI,aAAa,CAAC;YACvB,MAAM,EAAE,IAAI,cAAc,EAAE;YAC5B,KAAK,EAAE,8BAA8B,EAAE;YACvC,MAAM,EAAE,GAAG;SACZ,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,qBAAqB;QAC3B,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;IAC/C,CAAC;IAED;;OAEG;IACK,wBAAwB;QAC9B,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;IAClD,CAAC;IAED;;OAEG;IACK,wBAAwB;QAC9B,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACvC,CAAC;IAED;;OAEG;IACK,sBAAsB;QAC5B,MAAM,mBAAmB,GAAG,IAAI,QAAQ,CAAC;YACvC,MAAM,EAAE,IAAI,CAAC,eAAe;YAC5B,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,SAA0B;SAC/C,CAAC,CAAC;QACH,IAAI,CAAC,mBAAmB,GAAG,mBAAmB,CAAC;IACjD,CAAC;IAED;;OAEG;IACK,yBAAyB;QAC/B,IAAI,IAAI,CAAC,mBAAmB,KAAK,SAAS,EAAE,CAAC;YAC3C,OAAO;QACT,CAAC;QAED,IAAI,CAAC,2BAA2B,EAAE,CAAC;QACnC,IAAI,CAAC,mBAAmB,GAAG,SAAS,CAAC;IACvC,CAAC;IAEO,yBAAyB;QAC/B,IAAI,IAAI,CAAC,2BAA2B,KAAK,IAAI,EAAE,CAAC;YAC9C,OAAO;QACT,CAAC;QAED,IAAI,CAAC,2BAA2B,GAAG,IAAI,CAAC;QACxC,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,mBAAmB,CAAC,EAAE,CACjD,aAAa,EACb,CAAC,KAAoB,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CACpD,CAAC;QACF,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,mBAAmB,CAAC,EAAE,CAC/C,WAAW,EACX,CAAC,KAAoB,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAClD,CAAC;QACF,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;IACtD,CAAC;IAEO,2BAA2B;QACjC,IAAI,IAAI,CAAC,2BAA2B,KAAK,KAAK,EAAE,CAAC;YAC/C,OAAO;QACT,CAAC;QAED,IAAI,CAAC,2BAA2B,GAAG,KAAK,CAAC;QAEzC,OAAO,CAAC,CAAC,IAAI,CAAC,gBAAgB,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;QACxE,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YAC7B,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QACzD,CAAC;IACH,CAAC;IAED;;;OAGG;IACK,aAAa,CAAC,KAAoB;QACxC,MAAM,UAAU,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,EAAgB,CAAC;QACtE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAC7B,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC,EAAE,CAC9B,QAAQ,EACR,CAAC,eAA2B,EAAE,EAAE;YAC9B,IAAI,CAAC,aAAa;gBAChB,mCAAmC,CAAC,eAAe,CAAC,CAAC;YACvD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAChB,eAAe,CAAC,MAA6C,CAC9D,CAAC;QACJ,CAAC,CACF,CAAC;QACF,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,CAAC;IAED;;;OAGG;IACK,WAAW,CAAC,KAAoB;QACtC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC1B,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,EAAgB,CAAC,CAAC;QACnE,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC9B,CAAC;IAED;;OAEG;IACK,kBAAkB;QACxB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,SAAS,CACvD,CAAC,KAAoB,EAAE,EAAE;YACvB,IAAI,KAAK,CAAC,GAAG,KAAK,GAAG,EAAE,CAAC;gBACtB,kDAAkD;gBAClD,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC;oBAC3B,MAAM,EAAE,IAAI,CAAC,aAAa;oBAC1B,QAAQ,EAAE,CAAC;iBACZ,CAAC,CAAC;gBACH,OAAO;YACT,CAAC;QACH,CAAC,CACF,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,oBAAoB;QAC1B,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS,EAAE,CAAC;YACjC,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC;QAC/B,CAAC;IACH,CAAC;IAED;;OAEG;IACK,yBAAyB;QAC/B,MAAM,sBAAsB,GAAG,IAAI,WAAW,CAAC;YAC7C,MAAM,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC;SAC9B,CAAC,CAAC;QACH,IAAI,CAAC,sBAAsB,GAAG,sBAAsB,CAAC;IACvD,CAAC;IAED;;OAEG;IACK,4BAA4B;QAClC,IAAI,IAAI,CAAC,sBAAsB,KAAK,SAAS,EAAE,CAAC;YAC9C,OAAO;QACT,CAAC;QAED,IAAI,CAAC,8BAA8B,EAAE,CAAC;QACtC,IAAI,CAAC,sBAAsB,GAAG,SAAS,CAAC;IAC1C,CAAC;IAEO,4BAA4B;QAClC,IAAI,IAAI,CAAC,8BAA8B,KAAK,IAAI,EAAE,CAAC;YACjD,OAAO;QACT,CAAC;QAED,IAAI,CAAC,8BAA8B,GAAG,IAAI,CAAC;QAC3C,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,sBAAsB,CAAC,EAAE,CACvD,gBAAgB,EAChB,CAAC,KAAuB,EAAE,EAAE,CAAC,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAC1D,CAAC;QACF,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,sBAAsB,CAAC,EAAE,CACrD,cAAc,EACd,CAAC,KAAuB,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CACxD,CAAC;QACF,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;IACzD,CAAC;IAEO,8BAA8B;QACpC,IAAI,IAAI,CAAC,8BAA8B,KAAK,KAAK,EAAE,CAAC;YAClD,OAAO;QACT,CAAC;QAED,IAAI,CAAC,8BAA8B,GAAG,KAAK,CAAC;QAC5C,OAAO,CAAC;YACN,IAAI,CAAC,mBAAmB;YACxB,IAAI,CAAC,iBAAiB;YACtB,IAAI,CAAC,cAAc;SACpB,CAAC,CAAC;QACH,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YAC7B,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;QAC5D,CAAC;IACH,CAAC;IAED;;;OAGG;IACK,gBAAgB,CAAC,KAAuB;QAC9C,MAAM,UAAU,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,EAAgB,CAAC;QACtE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC/B,CAAC;IAED;;;OAGG;IACK,cAAc,CAAC,KAAuB;QAC5C,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAC7B,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,EAAgB,CAAC,CAAC;IACrE,CAAC;IAED;;OAEG;IACK,oBAAoB;QAC1B,MAAM,iBAAiB,GAAG,IAAI,MAAM,CAAC;YACnC,IAAI,EAAE,SAAS;YACf,MAAM,EAAE,IAAI,CAAC,mBAAmB;YAChC,SAAS,EAAE,IAAI;YACf,KAAK,EAAE,8BAA8B,EAAE;YACvC,SAAS,EAAE,CAAC,KAA2B,EAAE,EAAE;gBACzC,MAAM,eAAe,GAAG,IAAI,CAAC,eAAe,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;gBACrE,MAAM,UAAU,GAAG,eAAe,CAAC,oBAAoB,CACrD,KAAK,CAAC,UAAU,CACjB,CAAC;gBACF,OAAO,UAAU,CAAC;YACpB,CAAC;SACF,CAAC,CAAC;QAEH,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAC;QAC3C,IAAI,CAAC,sBAAsB,EAAE,CAAC;IAChC,CAAC;IAED;;OAEG;IACK,sBAAsB;QAC5B,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,SAAS,CAC3D,CAAC,KAAoB,EAAE,EAAE;YACvB,IAAI,KAAK,CAAC,GAAG,KAAK,SAAS,EAAE,CAAC;gBAC5B,OAAO;YACT,CAAC;YAED,IAAI,CAAC,wBAAwB,EAAE,CAAC;YAEhC,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;YACxC,IAAI,CAAC,UAAU,IAAI,CAAC,CAAC,UAAU,YAAY,SAAS,CAAC,EAAE,CAAC;gBACtD,OAAO;YACT,CAAC;YAED,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAE5B,IAAI,CAAC,2BAA2B,EAAE,CAAC;YACnC,IAAI,CAAC,8BAA8B,EAAE,CAAC;YACtC,IAAI,CAAC,uBAAuB,EAAE,CAAC;QACjC,CAAC,CACF,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,oBAAoB;QAC1B,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,SAAS,CACvD,CAAC,KAAoB,EAAE,EAAE;YACvB,IAAI,KAAK,CAAC,GAAG,KAAK,SAAS,EAAE,CAAC;gBAC5B,OAAO;YACT,CAAC;YAED,IAAI,CAAC,sBAAsB,EAAE,CAAC;YAC9B,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC5B,IAAI,CAAC,yBAAyB,EAAE,CAAC;YAEjC,IAAI,CAAC,yBAAyB,EAAE,CAAC;YACjC,IAAI,IAAI,CAAC,SAAS,KAAK,IAAI,EAAE,CAAC;gBAC5B,IAAI,CAAC,4BAA4B,EAAE,CAAC;YACtC,CAAC;YACD,IAAI,CAAC,sBAAsB,EAAE,CAAC;YAE9B,IAAI,CAAC,eAAe,GAAG,SAAS,CAAC;YACjC,IAAI,CAAC,wBAAwB,EAAE,CAAC;YAChC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;QACvC,CAAC,CACF,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,wBAAwB;QAC9B,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,EAAE,CAAC;YACrC,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC;QACnC,CAAC;IACH,CAAC;IAED;;OAEG;IACK,sBAAsB;QAC5B,IAAI,IAAI,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;YACnC,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;QACjC,CAAC;IACH,CAAC;IAED;;OAEG;IACK,uBAAuB;QAC7B,IAAI,IAAI,CAAC,iBAAiB,KAAK,SAAS,EAAE,CAAC;YACzC,OAAO;QACT,CAAC;QAED,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC5B,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAC9B,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAChC,IAAI,CAAC,yBAAyB,EAAE,CAAC;QACjC,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAChC,IAAI,CAAC,iBAAiB,GAAG,SAAS,CAAC;IACrC,CAAC;IAED;;OAEG;IACK,uBAAuB;QAC7B,IAAI,IAAI,CAAC,yBAAyB,KAAK,IAAI,EAAE,CAAC;YAC5C,OAAO;QACT,CAAC;QAED,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAChC,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAE7B,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,CAAC,OAAO,CAAC,CAAC,aAA4B,EAAE,EAAE;YACpE,IAAI,aAAa,YAAY,oBAAoB,EAAE,CAAC;gBAClD,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,aAAa,CAAC,CAAC;gBAC5C,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YACjD,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,yBAAyB,GAAG,IAAI,CAAC;QACtC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAC7C,WAAW,EACX,CAAC,KAAkB,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAChD,CAAC;QACF,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAC3C,SAAS,EACT,CAAC,KAAkB,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAC9C,CAAC;QACF,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;IACpD,CAAC;IAED;;OAEG;IACK,yBAAyB;QAC/B,IAAI,IAAI,CAAC,yBAAyB,KAAK,KAAK,EAAE,CAAC;YAC7C,OAAO;QACT,CAAC;QAED,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAEhC,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC,aAA4B,EAAE,EAAE;YAClE,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,qBAAqB,GAAG,EAAE,CAAC;QAEhC,IAAI,CAAC,yBAAyB,GAAG,KAAK,CAAC;QACvC,OAAO,CAAC,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;QAClE,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YAC7B,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;QACvD,CAAC;IACH,CAAC;IAED;;;OAGG;IACK,WAAW,CAAC,KAAkB;QACpC,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC;QAC/C,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,KAAK,EAAE,CAAC;QAEpD,MAAM,qBAAqB,GACxB,UAAkB,CAAC,aAAa,EAClC,CAAC,cAAc,EAAE,CAAC;QACnB,IAAI,CAAC,yBAAyB,CAAC,qBAAqB,CAAC,CAAC;QACtD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;QAEvC,IAAI,CAAC,SAAS,GAAG,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,eAA2B,EAAE,EAAE;YACvE,IAAI,CAAC,aAAa,GAAG,mCAAmC,CAAC,eAAe,CAAC,CAAC;YAC1E,MAAM,gBAAgB,GAAG,eAAe,CAAC,MAAmB,CAAC;YAC7D,MAAM,sBAAsB,GAAG,gBAAgB;iBAC5C,aAAa,CAAC,CAAC,CAAC;iBAChB,cAAc,EAAE,CAAC;YACpB,IAAI,CAAC,4BAA4B,CAAC,sBAAsB,CAAC,CAAC;YAC1D,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,CAAC;IAED;;;OAGG;IACK,SAAS,CAAC,KAAkB;QAClC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACxB,IAAI,CAAC,eAAe,GAAG,SAAS,CAAC;QAEjC,MAAM,qBAAqB,GACxB,KAAK,CAAC,OAAO,CAAC,WAAW,EAAU,CAAC,aAAa,EACnD,CAAC,cAAc,EAAE,CAAC;QACnB,IAAI,CAAC,4BAA4B,CAAC,qBAAqB,CAAC,CAAC;QACzD,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAChC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;QACrC,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC9B,CAAC;IAED;;;OAGG;IACK,yBAAyB,CAAC,WAAqB;QACrD,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,EAAe,CAAC;QACrD,MAAM,YAAY,GAAG,IAAI,YAAY,CAAC,WAAW,CAAC,CAAC;QACnD,wBAAwB,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;IACrD,CAAC;IAED;;;OAGG;IACK,4BAA4B,CAAC,WAAuB;QAC1D,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,EAAe,CAAC;QACrD,wDAAwD;QACxD,MAAM,aAAa,GAAG,UAAU,CAAC,cAAc,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAC/D,MAAM,cAAc,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,YAA0B,EAAE,EAAE;YACtE,OAAO,YAAY,CAAC,cAAc,EAAE,CAAC;QACvC,CAAC,CAAC,CAAC;QACH,cAAc,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACjC,UAAU,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;IAC5C,CAAC;IAED;;;OAGG;IACK,aAAa;QACnB,MAAM,UAAU,GAAG,IAAI,CAAC,eAAe,CAAC,WAAW,EAAE,CAAC;QACtD,OAAO,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;IACzE,CAAC;CACF","sourcesContent":["import OlFeature from 'ol/Feature';\nimport OlMap from 'ol/Map';\nimport MapBrowserEvent from 'ol/MapBrowserEvent';\nimport { unByKey } from 'ol/Observable';\nimport BasicEvent from 'ol/events/Event';\nimport OlCircle from 'ol/geom/Circle';\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\nimport OlLineString from 'ol/geom/LineString';\nimport OlLinearRing from 'ol/geom/LinearRing';\nimport OlPolygon from 'ol/geom/Polygon';\nimport OlDragBoxInteraction from 'ol/interaction/DragBox';\nimport OlDraw from 'ol/interaction/Draw';\nimport { DrawEvent as OlDrawEvent } from 'ol/interaction/Draw';\nimport OlInteraction from 'ol/interaction/Interaction';\nimport OlModify from 'ol/interaction/Modify';\nimport { ModifyEvent as OlModifyEvent } from 'ol/interaction/Modify';\nimport OlTranslate from 'ol/interaction/Translate';\nimport { TranslateEvent as OlTranslateEvent } from 'ol/interaction/Translate';\nimport OlVectorLayer from 'ol/layer/Vector';\nimport OlVectorSource from 'ol/source/Vector';\nimport * as OlStyle from 'ol/style';\nimport { StyleLike as OlStyleLike } from 'ol/style/Style';\n\nimport { Subject, Subscription, fromEvent } from 'rxjs';\n\nimport {\n  addLinearRingToOlPolygon,\n  createDrawHoleInteractionStyle,\n  getMousePositionFromOlGeometryEvent\n} from '../geometry.utils';\n\nexport interface ModifyControlOptions {\n  source?: OlVectorSource<any>;\n  layer?: OlVectorLayer<any>;\n  layerStyle?: OlStyleLike;\n  drawStyle?: OlStyleLike;\n  modify?: boolean;\n  translate?: boolean;\n}\n\n/**\n * Control to modify geometries\n */\nexport class ModifyControl {\n  /**\n   * Modify start observable\n   */\n  public start$ = new Subject<OlGeometry>();\n\n  /**\n   * Modify end observable\n   */\n  public end$ = new Subject<OlGeometry>();\n\n  /**\n   * Geometry changes observable\n   */\n  public changes$ = new Subject<OlGeometry>();\n\n  private olMap: OlMap;\n  private olOverlayLayer: OlVectorLayer<any>;\n  public olModifyInteraction: OlModify;\n  private onModifyStartKey: any;\n  private onModifyEndKey: any;\n  private onModifyKey: any;\n  private olModifyInteractionIsActive = false;\n  private olTranslateInteraction: OlTranslate;\n  private onTranslateStartKey: any;\n  private onTranslateEndKey: any;\n  private onTranslateKey: any;\n  private olTranslateInteractionIsActive = false;\n  private olDrawInteraction: OlDraw;\n  private onDrawStartKey: any;\n  private onDrawEndKey: any;\n  private onDrawKey: any;\n  private olDrawInteractionIsActive = false;\n\n  private mousePosition: [number, number];\n\n  private keyDown$$: Subscription;\n  private drawKeyUp$$: Subscription;\n  private drawKeyDown$$: Subscription;\n\n  private removedOlInteractions: OlInteraction[] = [];\n  private olLinearRingsLayer: OlVectorLayer<any>;\n\n  // This is the geometry to test against when drawing holes\n  private olOuterGeometry: OlGeometry;\n\n  /**\n   * Wheter the control is active\n   */\n  get active(): boolean {\n    return this.olMap !== undefined;\n  }\n\n  /**\n   * OL overlay source\n   * @internal\n   */\n  get olOverlaySource(): OlVectorSource<any> {\n    return this.olOverlayLayer.getSource();\n  }\n\n  /**\n   * OL linear rings source\n   * @internal\n   */\n  get olLinearRingsSource(): OlVectorSource<any> {\n    return this.olLinearRingsLayer.getSource();\n  }\n\n  /**\n   * Whether a modify control should be available\n   */\n  private modify = true;\n\n  /**\n   * Whether a translate control should be available\n   */\n  private translate = true;\n\n  constructor(private options: ModifyControlOptions) {\n    if (options.modify !== undefined) {\n      this.modify = options.modify;\n    }\n    if (options.translate !== undefined) {\n      this.translate = options.translate;\n    }\n\n    if (options.layer !== undefined) {\n      this.olOverlayLayer = options.layer;\n    } else {\n      this.olOverlayLayer = this.createOlInnerOverlayLayer();\n    }\n    this.olLinearRingsLayer = this.createOlLinearRingsLayer();\n  }\n\n  /**\n   * Add or remove this control to/from a map.\n   * @param map OL Map\n   */\n  setOlMap(olMap: OlMap | undefined) {\n    if (olMap === undefined) {\n      this.clearOlInnerOverlaySource();\n      this.removeOlInnerOverlayLayer();\n      this.removeOlModifyInteraction();\n      this.removeOlTranslateInteraction();\n      this.removeOlDrawInteraction();\n      this.olMap = olMap;\n      return;\n    }\n\n    this.olMap = olMap;\n    this.addOlInnerOverlayLayer();\n\n    // The order in which these interactions\n    // are added is important\n    if (this.modify === true) {\n      this.addOlDrawInteraction();\n    }\n\n    if (this.translate === true) {\n      this.addOlTranslateInteraction();\n      this.activateTranslateInteraction();\n    }\n\n    if (this.modify === true) {\n      this.addOlModifyInteraction();\n      this.activateModifyInteraction();\n    }\n  }\n\n  /**\n   * Return the overlay source\n   */\n  getSource(): OlVectorSource<any> {\n    return this.olOverlaySource;\n  }\n\n  /**\n   * Add an OL geometry to the overlay and start modifying it\n   * @param olGeometry Ol Geometry\n   */\n  setOlGeometry(olGeometry: OlGeometry) {\n    const olFeature = new OlFeature({ geometry: olGeometry });\n    this.olOverlaySource.clear();\n    this.olOverlaySource.addFeature(olFeature);\n  }\n\n  /**\n   * Create an overlay source if none is defined in the options\n   */\n  private createOlInnerOverlayLayer(): OlVectorLayer<any> {\n    return new OlVectorLayer({\n      source: this.options.source ? this.options.source : new OlVectorSource(),\n      style: this.options.layerStyle,\n      zIndex: 500\n    });\n  }\n\n  /**\n   * Add the overlay layer if it wasn't defined in the options\n   */\n  private addOlInnerOverlayLayer() {\n    if (this.options.layer === undefined) {\n      this.olMap.addLayer(this.olOverlayLayer);\n    }\n  }\n\n  /**\n   * Clear the overlay layer if it wasn't defined in the options\n   */\n  private removeOlInnerOverlayLayer() {\n    if (this.options.layer === undefined && this.olMap !== undefined) {\n      this.olMap.removeLayer(this.olOverlayLayer);\n    }\n  }\n\n  /**\n   * Clear the overlay source if it wasn't defined in the options\n   */\n  private clearOlInnerOverlaySource() {\n    if (this.options.layer === undefined && this.options.source === undefined) {\n      this.olOverlaySource.clear(true);\n    }\n  }\n\n  private createOlLinearRingsLayer(): OlVectorLayer<any> {\n    return new OlVectorLayer({\n      source: new OlVectorSource(),\n      style: createDrawHoleInteractionStyle(),\n      zIndex: 500\n    });\n  }\n\n  /**\n   * Add the linear rings layer\n   */\n  private addOlLinearRingsLayer() {\n    this.olMap.addLayer(this.olLinearRingsLayer);\n  }\n\n  /**\n   * Clear the linear rings layer\n   */\n  private removeOlLinearRingsLayer() {\n    this.olMap.removeLayer(this.olLinearRingsLayer);\n  }\n\n  /**\n   * Clear the linear rings source\n   */\n  private clearOlLinearRingsSource() {\n    this.olLinearRingsSource.clear(true);\n  }\n\n  /**\n   * Add a modify interaction to the map an set up some listeners\n   */\n  private addOlModifyInteraction() {\n    const olModifyInteraction = new OlModify({\n      source: this.olOverlaySource,\n      style: this.options.drawStyle as OlStyle.Style\n    });\n    this.olModifyInteraction = olModifyInteraction;\n  }\n\n  /**\n   * Remove the modify interaction\n   */\n  private removeOlModifyInteraction() {\n    if (this.olModifyInteraction === undefined) {\n      return;\n    }\n\n    this.deactivateModifyInteraction();\n    this.olModifyInteraction = undefined;\n  }\n\n  private activateModifyInteraction() {\n    if (this.olModifyInteractionIsActive === true) {\n      return;\n    }\n\n    this.olModifyInteractionIsActive = true;\n    this.onModifyStartKey = this.olModifyInteraction.on(\n      'modifystart',\n      (event: OlModifyEvent) => this.onModifyStart(event)\n    );\n    this.onModifyEndKey = this.olModifyInteraction.on(\n      'modifyend',\n      (event: OlModifyEvent) => this.onModifyEnd(event)\n    );\n    this.olMap.addInteraction(this.olModifyInteraction);\n  }\n\n  private deactivateModifyInteraction() {\n    if (this.olModifyInteractionIsActive === false) {\n      return;\n    }\n\n    this.olModifyInteractionIsActive = false;\n\n    unByKey([this.onModifyStartKey, this.onModifyEndKey, this.onModifyKey]);\n    if (this.olMap !== undefined) {\n      this.olMap.removeInteraction(this.olModifyInteraction);\n    }\n  }\n\n  /**\n   * When modifying starts, clear the overlay and start watching for changes\n   * @param event Modify start event\n   */\n  private onModifyStart(event: OlModifyEvent) {\n    const olGeometry = event.features.item(0).getGeometry() as OlGeometry;\n    this.start$.next(olGeometry);\n    this.onModifyKey = olGeometry.on(\n      'change',\n      (olGeometryEvent: BasicEvent) => {\n        this.mousePosition =\n          getMousePositionFromOlGeometryEvent(olGeometryEvent);\n        this.changes$.next(\n          olGeometryEvent.target as OlLineString | OlCircle | OlPolygon\n        );\n      }\n    );\n    this.subscribeToKeyDown();\n  }\n\n  /**\n   * When modifying ends, update the geometry observable and stop watching for changes\n   * @param event Modify end event\n   */\n  private onModifyEnd(event: OlModifyEvent) {\n    unByKey(this.onModifyKey);\n    this.end$.next(event.features.item(0).getGeometry() as OlGeometry);\n    this.unsubscribeToKeyDown();\n  }\n\n  /**\n   * Subscribe to space key down to pan the map\n   */\n  private subscribeToKeyDown() {\n    this.keyDown$$ = fromEvent(document, 'keydown').subscribe(\n      (event: KeyboardEvent) => {\n        if (event.key === ' ') {\n          // On space bar, pan to the current mouse position\n          this.olMap.getView().animate({\n            center: this.mousePosition,\n            duration: 0\n          });\n          return;\n        }\n      }\n    );\n  }\n\n  /**\n   * Unsubscribe to key down\n   */\n  private unsubscribeToKeyDown() {\n    if (this.keyDown$$ !== undefined) {\n      this.keyDown$$.unsubscribe();\n    }\n  }\n\n  /**\n   * Add a translate interaction to the map an set up some listeners\n   */\n  private addOlTranslateInteraction() {\n    const olTranslateInteraction = new OlTranslate({\n      layers: [this.olOverlayLayer]\n    });\n    this.olTranslateInteraction = olTranslateInteraction;\n  }\n\n  /**\n   * Remove the translate interaction\n   */\n  private removeOlTranslateInteraction() {\n    if (this.olTranslateInteraction === undefined) {\n      return;\n    }\n\n    this.deactivateTranslateInteraction();\n    this.olTranslateInteraction = undefined;\n  }\n\n  private activateTranslateInteraction() {\n    if (this.olTranslateInteractionIsActive === true) {\n      return;\n    }\n\n    this.olTranslateInteractionIsActive = true;\n    this.onTranslateStartKey = this.olTranslateInteraction.on(\n      'translatestart',\n      (event: OlTranslateEvent) => this.onTranslateStart(event)\n    );\n    this.onTranslateEndKey = this.olTranslateInteraction.on(\n      'translateend',\n      (event: OlTranslateEvent) => this.onTranslateEnd(event)\n    );\n    this.olMap.addInteraction(this.olTranslateInteraction);\n  }\n\n  private deactivateTranslateInteraction() {\n    if (this.olTranslateInteractionIsActive === false) {\n      return;\n    }\n\n    this.olTranslateInteractionIsActive = false;\n    unByKey([\n      this.onTranslateStartKey,\n      this.onTranslateEndKey,\n      this.onTranslateKey\n    ]);\n    if (this.olMap !== undefined) {\n      this.olMap.removeInteraction(this.olTranslateInteraction);\n    }\n  }\n\n  /**\n   * When translation starts, clear the overlay and start watching for changes\n   * @param event Translate start event\n   */\n  private onTranslateStart(event: OlTranslateEvent) {\n    const olGeometry = event.features.item(0).getGeometry() as OlGeometry;\n    this.start$.next(olGeometry);\n  }\n\n  /**\n   * When translation ends, update the geometry observable and stop watchign for changes\n   * @param event Translate end event\n   */\n  private onTranslateEnd(event: OlTranslateEvent) {\n    unByKey(this.onTranslateKey);\n    this.end$.next(event.features.item(0).getGeometry() as OlGeometry);\n  }\n\n  /**\n   * Add a draw interaction to the map an set up some listeners\n   */\n  private addOlDrawInteraction() {\n    const olDrawInteraction = new OlDraw({\n      type: 'Polygon',\n      source: this.olLinearRingsSource,\n      stopClick: true,\n      style: createDrawHoleInteractionStyle(),\n      condition: (event: MapBrowserEvent<any>) => {\n        const olOuterGeometry = this.olOuterGeometry || this.getOlGeometry();\n        const intersects = olOuterGeometry.intersectsCoordinate(\n          event.coordinate\n        );\n        return intersects;\n      }\n    });\n\n    this.olDrawInteraction = olDrawInteraction;\n    this.subscribeToDrawKeyDown();\n  }\n\n  /**\n   * Subscribe to CTRL key down to activate the draw control\n   */\n  private subscribeToDrawKeyDown() {\n    this.drawKeyDown$$ = fromEvent(document, 'keydown').subscribe(\n      (event: KeyboardEvent) => {\n        if (event.key !== 'Control') {\n          return;\n        }\n\n        this.unsubscribeToDrawKeyDown();\n\n        const olGeometry = this.getOlGeometry();\n        if (!olGeometry || !(olGeometry instanceof OlPolygon)) {\n          return;\n        }\n\n        this.subscribeToDrawKeyUp();\n\n        this.deactivateModifyInteraction();\n        this.deactivateTranslateInteraction();\n        this.activateDrawInteraction();\n      }\n    );\n  }\n\n  /**\n   * Subscribe to CTRL key up to deactivate the draw control\n   */\n  private subscribeToDrawKeyUp() {\n    this.drawKeyUp$$ = fromEvent(document, 'keyup').subscribe(\n      (event: KeyboardEvent) => {\n        if (event.key !== 'Control') {\n          return;\n        }\n\n        this.unsubscribeToDrawKeyUp();\n        this.unsubscribeToKeyDown();\n        this.deactivateDrawInteraction();\n\n        this.activateModifyInteraction();\n        if (this.translate === true) {\n          this.activateTranslateInteraction();\n        }\n        this.subscribeToDrawKeyDown();\n\n        this.olOuterGeometry = undefined;\n        this.clearOlLinearRingsSource();\n        this.end$.next(this.getOlGeometry());\n      }\n    );\n  }\n\n  /**\n   * Unsubscribe to draw key down\n   */\n  private unsubscribeToDrawKeyDown() {\n    if (this.drawKeyDown$$ !== undefined) {\n      this.drawKeyDown$$.unsubscribe();\n    }\n  }\n\n  /**\n   * Unsubscribe to key up\n   */\n  private unsubscribeToDrawKeyUp() {\n    if (this.drawKeyUp$$ !== undefined) {\n      this.drawKeyUp$$.unsubscribe();\n    }\n  }\n\n  /**\n   * Remove the draw interaction\n   */\n  private removeOlDrawInteraction() {\n    if (this.olDrawInteraction === undefined) {\n      return;\n    }\n\n    this.unsubscribeToKeyDown();\n    this.unsubscribeToDrawKeyUp();\n    this.unsubscribeToDrawKeyDown();\n    this.deactivateDrawInteraction();\n    this.clearOlLinearRingsSource();\n    this.olDrawInteraction = undefined;\n  }\n\n  /**\n   * Activate the draw interaction\n   */\n  private activateDrawInteraction() {\n    if (this.olDrawInteractionIsActive === true) {\n      return;\n    }\n\n    this.clearOlLinearRingsSource();\n    this.addOlLinearRingsLayer();\n\n    this.olMap.getInteractions().forEach((olInteraction: OlInteraction) => {\n      if (olInteraction instanceof OlDragBoxInteraction) {\n        this.olMap.removeInteraction(olInteraction);\n        this.removedOlInteractions.push(olInteraction);\n      }\n    });\n\n    this.olDrawInteractionIsActive = true;\n    this.onDrawStartKey = this.olDrawInteraction.on(\n      'drawstart',\n      (event: OlDrawEvent) => this.onDrawStart(event)\n    );\n    this.onDrawEndKey = this.olDrawInteraction.on(\n      'drawend',\n      (event: OlDrawEvent) => this.onDrawEnd(event)\n    );\n    this.olMap.addInteraction(this.olDrawInteraction);\n  }\n\n  /**\n   * Deactivate the draw interaction\n   */\n  private deactivateDrawInteraction() {\n    if (this.olDrawInteractionIsActive === false) {\n      return;\n    }\n\n    this.removeOlLinearRingsLayer();\n\n    this.removedOlInteractions.forEach((olInteraction: OlInteraction) => {\n      this.olMap.addInteraction(olInteraction);\n    });\n    this.removedOlInteractions = [];\n\n    this.olDrawInteractionIsActive = false;\n    unByKey([this.onDrawStartKey, this.onDrawEndKey, this.onDrawKey]);\n    if (this.olMap !== undefined) {\n      this.olMap.removeInteraction(this.olDrawInteraction);\n    }\n  }\n\n  /**\n   * When draw start, add a new linerar ring to the geometry and start watching for changes\n   * @param event Draw start event\n   */\n  private onDrawStart(event: OlDrawEvent) {\n    const olGeometry = event.feature.getGeometry();\n    this.olOuterGeometry = this.getOlGeometry().clone();\n\n    const linearRingCoordinates = (\n      (olGeometry as any).getLinearRing() as any\n    ).getCoordinates();\n    this.addLinearRingToOlGeometry(linearRingCoordinates);\n    this.start$.next(this.getOlGeometry());\n\n    this.onDrawKey = olGeometry.on('change', (olGeometryEvent: BasicEvent) => {\n      this.mousePosition = getMousePositionFromOlGeometryEvent(olGeometryEvent);\n      const olGeometryTarget = olGeometryEvent.target as OlPolygon;\n      const _linearRingCoordinates = olGeometryTarget\n        .getLinearRing(0)\n        .getCoordinates();\n      this.updateLinearRingOfOlGeometry(_linearRingCoordinates);\n      this.changes$.next(this.getOlGeometry());\n    });\n    this.subscribeToKeyDown();\n  }\n\n  /**\n   * When translation ends, update the geometry observable and stop watchign for changes\n   * @param event Draw end event\n   */\n  private onDrawEnd(event: OlDrawEvent) {\n    unByKey(this.onDrawKey);\n    this.olOuterGeometry = undefined;\n\n    const linearRingCoordinates = (\n      (event.feature.getGeometry() as any).getLinearRing() as any\n    ).getCoordinates();\n    this.updateLinearRingOfOlGeometry(linearRingCoordinates);\n    this.clearOlLinearRingsSource();\n    this.end$.next(this.getOlGeometry());\n    this.unsubscribeToKeyDown();\n  }\n\n  /**\n   * Add a linear ring to the geometry being modified\n   * @param coordinates Linear ring coordinates\n   */\n  private addLinearRingToOlGeometry(coordinates: number[]) {\n    const olGeometry = this.getOlGeometry() as OlPolygon;\n    const olLinearRing = new OlLinearRing(coordinates);\n    addLinearRingToOlPolygon(olGeometry, olLinearRing);\n  }\n\n  /**\n   * Update the last linear ring of the geometry being modified\n   * @param coordinates Linear ring coordinates\n   */\n  private updateLinearRingOfOlGeometry(coordinates: number[][]) {\n    const olGeometry = this.getOlGeometry() as OlPolygon;\n    // Remove the last linear ring (the one we are updating)\n    const olLinearRings = olGeometry.getLinearRings().slice(0, -1);\n    const newCoordinates = olLinearRings.map((olLinearRing: OlLinearRing) => {\n      return olLinearRing.getCoordinates();\n    });\n    newCoordinates.push(coordinates);\n    olGeometry.setCoordinates(newCoordinates);\n  }\n\n  /**\n   * Get the geometry being modified\n   * @returns OL Geometry\n   */\n  private getOlGeometry(): OlGeometry {\n    const olFeatures = this.olOverlaySource.getFeatures();\n    return olFeatures.length > 0 ? olFeatures[0].getGeometry() : undefined;\n  }\n}\n"]}