@igo2/geo 18.0.1-next.2 → 18.0.2

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

@@ -0,0 +1,190 @@
+import OlFeature from 'ol/Feature';
+import OlVectorLayer from 'ol/layer/Vector';
+import OlVectorSource from 'ol/source/Vector';
+import { Subject } from 'rxjs';
+import { GeometrySliceError } from '../geometry.errors';
+import { sliceOlGeometry } from '../geometry.utils';
+import { DrawControl } from './draw';
+/**
+ * Control to modify geometries
+ */
+export class SliceControl {
+    options;
+    /**
+     * Slice end observable
+     */
+    end$ = new Subject();
+    /**
+     * Slice error, if any
+     */
+    error$ = new Subject();
+    olMap;
+    olOverlayLayer;
+    /**
+     * Draw line control
+     */
+    drawLineControl;
+    /**
+     * Subscription to draw start
+     */
+    drawLineStart$$;
+    /**
+     * Subscription to draw end
+     */
+    drawLineEnd$$;
+    /**
+     * Wheter the control is active
+     */
+    get active() {
+        return this.olMap !== undefined;
+    }
+    /**
+     * OL overlay source
+     * @internal
+     */
+    get olOverlaySource() {
+        return this.olOverlayLayer.getSource();
+    }
+    constructor(options) {
+        this.options = options;
+        if (options.layer !== undefined) {
+            this.olOverlayLayer = options.layer;
+        }
+        else {
+            this.olOverlayLayer = this.createOlInnerOverlayLayer();
+        }
+    }
+    /**
+     * Add or remove this control to/from a map.
+     * @param map OL Map
+     */
+    setOlMap(olMap) {
+        if (olMap === undefined) {
+            this.clearOlInnerOverlaySource();
+            this.removeOlInnerOverlayLayer();
+            this.removeDrawLineControl();
+            this.olMap = olMap;
+            return;
+        }
+        this.olMap = olMap;
+        this.addOlInnerOverlayLayer();
+        this.addDrawLineControl();
+    }
+    /**
+     * Return the overlay source
+     */
+    getSource() {
+        return this.olOverlaySource;
+    }
+    /**
+     * Add an OL geometry to the overlay for slicing
+     * @param olGeometry Ol Geometry
+     */
+    setOlGeometry(olGeometry) {
+        const olFeature = new OlFeature({ geometry: olGeometry });
+        this.olOverlaySource.clear(true);
+        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
+        });
+    }
+    /**
+     * 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);
+        }
+    }
+    /**
+     * 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 source if it wasn't defined in the options
+     */
+    clearOlInnerOverlaySource() {
+        if (this.options.layer === undefined && this.options.source === undefined) {
+            this.olOverlaySource.clear(true);
+        }
+    }
+    /**
+     * Create a draw line control and add it to the map
+     */
+    addDrawLineControl() {
+        this.drawLineControl = new DrawControl({
+            geometryType: 'LineString',
+            interactionStyle: this.options.drawStyle,
+            maxPoints: 2
+        });
+        this.drawLineStart$$ = this.drawLineControl.start$.subscribe(() => this.onDrawLineStart());
+        this.drawLineEnd$$ = this.drawLineControl.end$.subscribe((olLine) => this.onDrawLineEnd(olLine));
+        this.drawLineControl.setOlMap(this.olMap);
+    }
+    /**
+     * Remove draw line control
+     */
+    removeDrawLineControl() {
+        if (this.drawLineControl === undefined) {
+            return;
+        }
+        this.drawLineStart$$.unsubscribe();
+        this.drawLineEnd$$.unsubscribe();
+        this.drawLineControl.getSource().clear(true);
+        this.drawLineControl.setOlMap(undefined);
+    }
+    /**
+     * Clear the draw source and track the geometry being draw
+     * @param olLine Ol linestring or polygon
+     */
+    onDrawLineStart() {
+        this.drawLineControl.getSource().clear(true);
+    }
+    /**
+     * Slice the first geometry encountered with the drawn line
+     * @param olLine Ol linestring
+     */
+    onDrawLineEnd(olLine) {
+        const olSlicedGeometries = [];
+        const lineExtent = olLine.getExtent();
+        const olFeaturesToRemove = [];
+        try {
+            this.olOverlaySource.forEachFeatureInExtent(lineExtent, (olFeature) => {
+                const olGeometry = olFeature.getGeometry();
+                const olParts = sliceOlGeometry(olGeometry, olLine);
+                if (olParts.length > 0) {
+                    olSlicedGeometries.push(...olParts);
+                    olFeaturesToRemove.push(olFeature);
+                }
+            });
+        }
+        catch (e) {
+            if (e instanceof GeometrySliceError) {
+                this.error$.next(e);
+                return;
+            }
+            else {
+                throw e;
+            }
+        }
+        this.drawLineControl.getSource().clear(true);
+        this.olOverlaySource.addFeatures(olSlicedGeometries.map((olGeometry) => new OlFeature(olGeometry)));
+        olFeaturesToRemove.forEach((olFeature) => {
+            this.olOverlaySource.removeFeature(olFeature);
+        });
+        this.error$.next(undefined);
+        this.end$.next(olSlicedGeometries);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slice.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/geometry/shared/controls/slice.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,YAAY,CAAC;AAInC,OAAO,aAAa,MAAM,iBAAiB,CAAC;AAC5C,OAAO,cAAc,MAAM,kBAAkB,CAAC;AAG9C,OAAO,EAAE,OAAO,EAAgB,MAAM,MAAM,CAAC;AAE7C,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AASrC;;GAEG;AACH,MAAM,OAAO,YAAY;IA4CH;IA3CpB;;OAEG;IACI,IAAI,GAAG,IAAI,OAAO,EAAgB,CAAC;IAE1C;;OAEG;IACI,MAAM,GAAG,IAAI,OAAO,EAAsB,CAAC;IAE1C,KAAK,CAAQ;IACb,cAAc,CAAgC;IAEtD;;OAEG;IACK,eAAe,CAAc;IAErC;;OAEG;IACK,eAAe,CAAe;IAEtC;;OAEG;IACK,aAAa,CAAe;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,YAAoB,OAA4B;QAA5B,YAAO,GAAP,OAAO,CAAqB;QAC9C,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;IACH,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,qBAAqB,EAAE,CAAC;YAC7B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;YACnB,OAAO;QACT,CAAC;QAED,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAC9B,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,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,CAAC,IAAI,CAAC,CAAC;QACjC,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,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,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,OAAO,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YAC1E,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACnC,CAAC;IACH,CAAC;IAED;;OAEG;IACK,kBAAkB;QACxB,IAAI,CAAC,eAAe,GAAG,IAAI,WAAW,CAAC;YACrC,YAAY,EAAE,YAAY;YAC1B,gBAAgB,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS;YACxC,SAAS,EAAE,CAAC;SACb,CAAC,CAAC;QACH,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,CAChE,IAAI,CAAC,eAAe,EAAE,CACvB,CAAC;QACF,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,SAAS,CACtD,CAAC,MAAoB,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CACrD,CAAC;QACF,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC5C,CAAC;IAED;;OAEG;IACK,qBAAqB;QAC3B,IAAI,IAAI,CAAC,eAAe,KAAK,SAAS,EAAE,CAAC;YACvC,OAAO;QACT,CAAC;QAED,IAAI,CAAC,eAAe,CAAC,WAAW,EAAE,CAAC;QACnC,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC;QACjC,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC7C,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC3C,CAAC;IAED;;;OAGG;IACK,eAAe;QACrB,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC/C,CAAC;IAED;;;OAGG;IACK,aAAa,CAAC,MAAoB;QACxC,MAAM,kBAAkB,GAAG,EAAE,CAAC;QAC9B,MAAM,UAAU,GAAG,MAAM,CAAC,SAAS,EAAE,CAAC;QAEtC,MAAM,kBAAkB,GAAG,EAAE,CAAC;QAC9B,IAAI,CAAC;YACH,IAAI,CAAC,eAAe,CAAC,sBAAsB,CACzC,UAAU,EACV,CAAC,SAAgC,EAAE,EAAE;gBACnC,MAAM,UAAU,GAAG,SAAS,CAAC,WAAW,EAAS,CAAC;gBAClD,MAAM,OAAO,GAAG,eAAe,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;gBACpD,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACvB,kBAAkB,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC;oBACpC,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;gBACrC,CAAC;YACH,CAAC,CACF,CAAC;QACJ,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,IAAI,CAAC,YAAY,kBAAkB,EAAE,CAAC;gBACpC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBACpB,OAAO;YACT,CAAC;iBAAM,CAAC;gBACN,MAAM,CAAC,CAAC;YACV,CAAC;QACH,CAAC;QAED,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAE7C,IAAI,CAAC,eAAe,CAAC,WAAW,CAC9B,kBAAkB,CAAC,GAAG,CACpB,CAAC,UAAsB,EAAE,EAAE,CAAC,IAAI,SAAS,CAAC,UAAU,CAAC,CACtD,CACF,CAAC;QACF,kBAAkB,CAAC,OAAO,CAAC,CAAC,SAAgC,EAAE,EAAE;YAC9D,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;QAChD,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC5B,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;IACrC,CAAC;CACF","sourcesContent":["import OlFeature from 'ol/Feature';\nimport OlMap from 'ol/Map';\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\nimport OlLineString from 'ol/geom/LineString';\nimport OlVectorLayer from 'ol/layer/Vector';\nimport OlVectorSource from 'ol/source/Vector';\nimport { StyleLike as OlStyleLike } from 'ol/style/Style';\n\nimport { Subject, Subscription } from 'rxjs';\n\nimport { GeometrySliceError } from '../geometry.errors';\nimport { sliceOlGeometry } from '../geometry.utils';\nimport { DrawControl } from './draw';\n\nexport interface SliceControlOptions {\n  source?: OlVectorSource;\n  layer?: OlVectorLayer<OlVectorSource>;\n  layerStyle?: OlStyleLike;\n  drawStyle?: OlStyleLike;\n}\n\n/**\n * Control to modify geometries\n */\nexport class SliceControl {\n  /**\n   * Slice end observable\n   */\n  public end$ = new Subject<OlGeometry[]>();\n\n  /**\n   * Slice error, if any\n   */\n  public error$ = new Subject<GeometrySliceError>();\n\n  private olMap: OlMap;\n  private olOverlayLayer: OlVectorLayer<OlVectorSource>;\n\n  /**\n   * Draw line control\n   */\n  private drawLineControl: DrawControl;\n\n  /**\n   * Subscription to draw start\n   */\n  private drawLineStart$$: Subscription;\n\n  /**\n   * Subscription to draw end\n   */\n  private drawLineEnd$$: Subscription;\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 {\n    return this.olOverlayLayer.getSource();\n  }\n\n  constructor(private options: SliceControlOptions) {\n    if (options.layer !== undefined) {\n      this.olOverlayLayer = options.layer;\n    } else {\n      this.olOverlayLayer = this.createOlInnerOverlayLayer();\n    }\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.removeDrawLineControl();\n      this.olMap = olMap;\n      return;\n    }\n\n    this.olMap = olMap;\n    this.addOlInnerOverlayLayer();\n    this.addDrawLineControl();\n  }\n\n  /**\n   * Return the overlay source\n   */\n  getSource(): OlVectorSource {\n    return this.olOverlaySource;\n  }\n\n  /**\n   * Add an OL geometry to the overlay for slicing\n   * @param olGeometry Ol Geometry\n   */\n  setOlGeometry(olGeometry: OlGeometry) {\n    const olFeature = new OlFeature({ geometry: olGeometry });\n    this.olOverlaySource.clear(true);\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<OlVectorSource> {\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   * 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   * 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 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  /**\n   * Create a draw line control and add it to the map\n   */\n  private addDrawLineControl() {\n    this.drawLineControl = new DrawControl({\n      geometryType: 'LineString',\n      interactionStyle: this.options.drawStyle,\n      maxPoints: 2\n    });\n    this.drawLineStart$$ = this.drawLineControl.start$.subscribe(() =>\n      this.onDrawLineStart()\n    );\n    this.drawLineEnd$$ = this.drawLineControl.end$.subscribe(\n      (olLine: OlLineString) => this.onDrawLineEnd(olLine)\n    );\n    this.drawLineControl.setOlMap(this.olMap);\n  }\n\n  /**\n   * Remove draw line control\n   */\n  private removeDrawLineControl() {\n    if (this.drawLineControl === undefined) {\n      return;\n    }\n\n    this.drawLineStart$$.unsubscribe();\n    this.drawLineEnd$$.unsubscribe();\n    this.drawLineControl.getSource().clear(true);\n    this.drawLineControl.setOlMap(undefined);\n  }\n\n  /**\n   * Clear the draw source and track the geometry being draw\n   * @param olLine Ol linestring or polygon\n   */\n  private onDrawLineStart() {\n    this.drawLineControl.getSource().clear(true);\n  }\n\n  /**\n   * Slice the first geometry encountered with the drawn line\n   * @param olLine Ol linestring\n   */\n  private onDrawLineEnd(olLine: OlLineString) {\n    const olSlicedGeometries = [];\n    const lineExtent = olLine.getExtent();\n\n    const olFeaturesToRemove = [];\n    try {\n      this.olOverlaySource.forEachFeatureInExtent(\n        lineExtent,\n        (olFeature: OlFeature<OlGeometry>) => {\n          const olGeometry = olFeature.getGeometry() as any;\n          const olParts = sliceOlGeometry(olGeometry, olLine);\n          if (olParts.length > 0) {\n            olSlicedGeometries.push(...olParts);\n            olFeaturesToRemove.push(olFeature);\n          }\n        }\n      );\n    } catch (e) {\n      if (e instanceof GeometrySliceError) {\n        this.error$.next(e);\n        return;\n      } else {\n        throw e;\n      }\n    }\n\n    this.drawLineControl.getSource().clear(true);\n\n    this.olOverlaySource.addFeatures(\n      olSlicedGeometries.map(\n        (olGeometry: OlGeometry) => new OlFeature(olGeometry)\n      )\n    );\n    olFeaturesToRemove.forEach((olFeature: OlFeature<OlGeometry>) => {\n      this.olOverlaySource.removeFeature(olFeature);\n    });\n\n    this.error$.next(undefined);\n    this.end$.next(olSlicedGeometries);\n  }\n}\n"]}

package/esm2022/lib/geometry/shared/geometry.errors.mjs

@@ -0,0 +1,24 @@
+// See this issue: https://github.com/Microsoft/TypeScript/issues/13965
+// And the solution: https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work
+// for an explanation as to why the prototype is set manually
+export class GeometrySliceError extends Error {
+}
+export class GeometrySliceMultiPolygonError extends GeometrySliceError {
+    constructor() {
+        super("Can't slice a MultiPolygon.");
+        Object.setPrototypeOf(this, GeometrySliceMultiPolygonError.prototype);
+    }
+}
+export class GeometrySliceLineStringError extends GeometrySliceError {
+    constructor() {
+        super("Can't slice with a line that has more than 2 points.");
+        Object.setPrototypeOf(this, GeometrySliceLineStringError.prototype);
+    }
+}
+export class GeometrySliceTooManyIntersectionError extends GeometrySliceError {
+    constructor() {
+        super('More than 2 intersections found between the target polygon and the slicing line.');
+        Object.setPrototypeOf(this, GeometrySliceTooManyIntersectionError.prototype);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/geometry/shared/geometry.interfaces.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VvbWV0cnkuaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2dlby9zcmMvbGliL2dlb21ldHJ5L3NoYXJlZC9nZW9tZXRyeS5pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGb3JtRmllbGRJbnB1dHMgfSBmcm9tICdAaWdvMi9jb21tb24vZm9ybSc7XG5cbmltcG9ydCB0eXBlIHsgVHlwZSB9IGZyb20gJ29sL2dlb20vR2VvbWV0cnknO1xuXG5pbXBvcnQgeyBHZW9Kc29uR2VvbWV0cnlUeXBlcyB9IGZyb20gJ2dlb2pzb24nO1xuXG5pbXBvcnQgeyBJZ29NYXAgfSBmcm9tICcuLi8uLi9tYXAvc2hhcmVkL21hcCc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgR2VvbWV0cnlGb3JtRmllbGRJbnB1dHMgZXh0ZW5kcyBGb3JtRmllbGRJbnB1dHMge1xuICBtYXA6IElnb01hcDtcbiAgZ2VvbWV0cnlUeXBlOiBUeXBlO1xuICB0b29sdGlwPzogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEdlb0pTT05HZW9tZXRyeSB7XG4gIHR5cGU6IEdlb0pzb25HZW9tZXRyeVR5cGVzO1xuICBjb29yZGluYXRlczogYW55O1xufVxuIl19

package/esm2022/lib/geometry/shared/geometry.utils.mjs

@@ -0,0 +1,113 @@
+import OlGeoJSON from 'ol/format/GeoJSON';
+import OlLineString from 'ol/geom/LineString';
+import OlPolygon from 'ol/geom/Polygon';
+import * as olstyle from 'ol/style';
+import { lineString } from '@turf/helpers';
+import lineIntersect from '@turf/line-intersect';
+import { GeometrySliceLineStringError, GeometrySliceMultiPolygonError, GeometrySliceTooManyIntersectionError } from './geometry.errors';
+/**
+ * Create a default style for draw and modify interactions
+ * @param color Style color (R, G, B)
+ * @returns OL style
+ */
+export function createDrawInteractionStyle(color) {
+    color = color || [0, 153, 255];
+    return new olstyle.Circle({
+        stroke: new olstyle.Stroke({
+            color: color.concat([1]),
+            width: 2
+        }),
+        fill: new olstyle.Fill({
+            color: color.concat([0.2])
+        }),
+        radius: 8
+    });
+}
+/**
+ * Create a default style for drawing a hole
+ * @returns OL style
+ */
+export function createDrawHoleInteractionStyle() {
+    return new olstyle.Style({
+        stroke: new olstyle.Stroke({
+            color: [0, 153, 255, 1],
+            width: 2
+        })
+    });
+}
+/**
+ * Slice geometry into two parts
+ * @param olGeometry OL geometry
+ * @param olSlicer Slicing line
+ * @returns New OL geometries
+ */
+export function sliceOlGeometry(olGeometry, olSlicer) {
+    if (olGeometry instanceof OlPolygon) {
+        return sliceOlPolygon(olGeometry, olSlicer);
+    }
+    else if (olGeometry instanceof OlLineString) {
+        return [];
+    }
+    return [];
+}
+/**
+ * Slice OL Polygon into one or more polygons
+ * @param olPolygon OL polygon
+ * @param olSlicer Slicing line
+ * @returns New OL polygons
+ */
+export function sliceOlPolygon(olPolygon, olSlicer) {
+    if (olPolygon.getLinearRingCount() > 1) {
+        throw new GeometrySliceMultiPolygonError();
+    }
+    if (olSlicer.getCoordinates().length > 2) {
+        throw new GeometrySliceLineStringError();
+    }
+    const olGeoJSON = new OlGeoJSON();
+    const slicer = olGeoJSON.writeGeometryObject(olSlicer);
+    const outerCoordinates = olPolygon.getLinearRing(0).getCoordinates();
+    const parts = [[], []];
+    let totalIntersectionCount = 0;
+    for (let i = 0, ii = outerCoordinates.length - 1; i < ii; i++) {
+        const segmentCoordinates = [outerCoordinates[i], outerCoordinates[i + 1]];
+        const segment = lineString(segmentCoordinates);
+        const intersections = lineIntersect(segment, slicer).features;
+        const intersectionCount = intersections.length;
+        totalIntersectionCount += intersectionCount;
+        if (intersectionCount > 1 || totalIntersectionCount > 2) {
+            throw new GeometrySliceTooManyIntersectionError();
+        }
+        parts[0].push(segmentCoordinates[0]);
+        if (intersectionCount === 1) {
+            const intersection = intersections[0].geometry.coordinates;
+            parts[0].push(intersection);
+            parts[1].push(intersection);
+            parts.reverse();
+        }
+    }
+    if (totalIntersectionCount <= 1) {
+        return [];
+    }
+    parts[0].push(parts[0][0]);
+    parts[1].push(parts[1][0]);
+    return [new OlPolygon([parts[0]]), new OlPolygon([parts[1]])];
+}
+/**
+ * Splice geometry into two parts
+ * @param olGeometry OL geometry
+ * @param olSlicer Slicing line
+ * @returns New OL geometries
+ */
+export function addLinearRingToOlPolygon(olPolygon, olLinearRing) {
+    // TODO: make some validation and support updating an existing linear ring
+    olPolygon.appendLinearRing(olLinearRing);
+}
+export function getMousePositionFromOlGeometryEvent(olEvent) {
+    const olGeometry = olEvent.target;
+    if (olGeometry instanceof OlPolygon) {
+        return olGeometry.getFlatCoordinates().slice(-4, -2);
+    }
+    const olGeometryCast = olGeometry;
+    return olGeometryCast.getFlatCoordinates().slice(-2);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"geometry.utils.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/geometry/shared/geometry.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import BasicEvent from 'ol/events/Event';\nimport OlGeoJSON from 'ol/format/GeoJSON';\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 OlPoint from 'ol/geom/Point';\nimport OlPolygon from 'ol/geom/Polygon';\nimport * as olstyle from 'ol/style';\n\nimport { lineString } from '@turf/helpers';\nimport lineIntersect from '@turf/line-intersect';\n\nimport {\n  GeometrySliceLineStringError,\n  GeometrySliceMultiPolygonError,\n  GeometrySliceTooManyIntersectionError\n} from './geometry.errors';\n\n/**\n * Create a default style for draw and modify interactions\n * @param color Style color (R, G, B)\n * @returns OL style\n */\nexport function createDrawInteractionStyle(\n  color?: [number, number, number]\n): olstyle.Circle {\n  color = color || [0, 153, 255];\n  return new olstyle.Circle({\n    stroke: new olstyle.Stroke({\n      color: color.concat([1]),\n      width: 2\n    }),\n    fill: new olstyle.Fill({\n      color: color.concat([0.2])\n    }),\n    radius: 8\n  });\n}\n\n/**\n * Create a default style for drawing a hole\n * @returns OL style\n */\nexport function createDrawHoleInteractionStyle(): olstyle.Style {\n  return new olstyle.Style({\n    stroke: new olstyle.Stroke({\n      color: [0, 153, 255, 1],\n      width: 2\n    })\n  });\n}\n\n/**\n * Slice geometry into two parts\n * @param olGeometry OL geometry\n * @param olSlicer Slicing line\n * @returns New OL geometries\n */\nexport function sliceOlGeometry(\n  olGeometry: OlLineString | OlPolygon,\n  olSlicer: OlLineString\n): (OlLineString | OlPolygon)[] {\n  if (olGeometry instanceof OlPolygon) {\n    return sliceOlPolygon(olGeometry, olSlicer);\n  } else if (olGeometry instanceof OlLineString) {\n    return [];\n  }\n  return [];\n}\n\n/**\n * Slice OL Polygon into one or more polygons\n * @param olPolygon OL polygon\n * @param olSlicer Slicing line\n * @returns New OL polygons\n */\nexport function sliceOlPolygon(\n  olPolygon: OlPolygon,\n  olSlicer: OlLineString\n): OlPolygon[] {\n  if (olPolygon.getLinearRingCount() > 1) {\n    throw new GeometrySliceMultiPolygonError();\n  }\n\n  if (olSlicer.getCoordinates().length > 2) {\n    throw new GeometrySliceLineStringError();\n  }\n\n  const olGeoJSON = new OlGeoJSON();\n  const slicer = olGeoJSON.writeGeometryObject(olSlicer) as any;\n  const outerCoordinates = olPolygon.getLinearRing(0).getCoordinates();\n\n  const parts = [[], []];\n  let totalIntersectionCount = 0;\n  for (let i = 0, ii = outerCoordinates.length - 1; i < ii; i++) {\n    const segmentCoordinates = [outerCoordinates[i], outerCoordinates[i + 1]];\n    const segment = lineString(segmentCoordinates);\n    const intersections = lineIntersect(segment, slicer).features;\n\n    const intersectionCount = intersections.length;\n    totalIntersectionCount += intersectionCount;\n    if (intersectionCount > 1 || totalIntersectionCount > 2) {\n      throw new GeometrySliceTooManyIntersectionError();\n    }\n\n    parts[0].push(segmentCoordinates[0]);\n    if (intersectionCount === 1) {\n      const intersection = intersections[0].geometry.coordinates;\n      parts[0].push(intersection);\n      parts[1].push(intersection);\n      parts.reverse();\n    }\n  }\n\n  if (totalIntersectionCount <= 1) {\n    return [];\n  }\n\n  parts[0].push(parts[0][0]);\n  parts[1].push(parts[1][0]);\n\n  return [new OlPolygon([parts[0]]), new OlPolygon([parts[1]])];\n}\n\n/**\n * Splice geometry into two parts\n * @param olGeometry OL geometry\n * @param olSlicer Slicing line\n * @returns New OL geometries\n */\nexport function addLinearRingToOlPolygon(\n  olPolygon: OlPolygon,\n  olLinearRing: OlLinearRing\n) {\n  // TODO: make some validation and support updating an existing linear ring\n  olPolygon.appendLinearRing(olLinearRing);\n}\n\nexport function getMousePositionFromOlGeometryEvent(olEvent: BasicEvent) {\n  const olGeometry = olEvent.target as OlGeometry;\n  if (olGeometry instanceof OlPolygon) {\n    return olGeometry.getFlatCoordinates().slice(-4, -2) as [number, number];\n  }\n  const olGeometryCast = olGeometry as OlPoint | OlLineString | OlCircle;\n  return olGeometryCast.getFlatCoordinates().slice(-2) as [number, number];\n}\n"]}

package/esm2022/lib/geometry/shared/index.mjs

@@ -0,0 +1,5 @@
+export * from './geometry.interfaces';
+export * from './geometry.errors';
+export * from './geometry.utils';
+export * from './controls';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9nZW9tZXRyeS9zaGFyZWQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxZQUFZLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2dlb21ldHJ5LmludGVyZmFjZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9nZW9tZXRyeS5lcnJvcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9nZW9tZXRyeS51dGlscyc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnRyb2xzJztcbiJdfQ==

package/esm2022/lib/import-export/export-button/export-button.component.mjs

@@ -0,0 +1,49 @@
+import { NgIf } from '@angular/common';
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { MatButtonModule } from '@angular/material/button';
+import { MatIconModule } from '@angular/material/icon';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { IgoLanguageModule } from '@igo2/core/language';
+import { Layer, VectorLayer } from '../../layer/shared';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/button";
+import * as i2 from "@angular/material/tooltip";
+import * as i3 from "@angular/material/icon";
+import * as i4 from "@ngx-translate/core";
+export class ExportButtonComponent {
+    layer;
+    color = 'primary';
+    get options() {
+        if (!this.layer) {
+            return;
+        }
+        return this.layer.dataSource.options;
+    }
+    layerIsExportable() {
+        if ((this.layer instanceof VectorLayer && this.layer.exportable === true) ||
+            (this.layer.dataSource.options.download &&
+                this.layer.dataSource.options.download.url) ||
+            (this.layer.options.workspace?.enabled &&
+                this.layer.options.workspace?.workspaceId !== this.layer.id)) {
+            return true;
+        }
+        return false;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ExportButtonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: ExportButtonComponent, isStandalone: true, selector: "igo-export-button", inputs: { layer: "layer", color: "color" }, ngImport: i0, template: "<button\n  *ngIf=\"layerIsExportable()\"\n  mat-icon-button\n  tooltip-position=\"below\"\n  matTooltipShowDelay=\"500\"\n  [matTooltip]=\"'igo.geo.download.action' | translate\"\n  [color]=\"color\"\n>\n  <mat-icon>file_save</mat-icon>\n</button>\n", styles: [""], dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i1.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i2.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i3.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: IgoLanguageModule }, { kind: "pipe", type: i4.TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ExportButtonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'igo-export-button', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [
+                        NgIf,
+                        MatButtonModule,
+                        MatTooltipModule,
+                        MatIconModule,
+                        IgoLanguageModule
+                    ], template: "<button\n  *ngIf=\"layerIsExportable()\"\n  mat-icon-button\n  tooltip-position=\"below\"\n  matTooltipShowDelay=\"500\"\n  [matTooltip]=\"'igo.geo.download.action' | translate\"\n  [color]=\"color\"\n>\n  <mat-icon>file_save</mat-icon>\n</button>\n" }]
+        }], propDecorators: { layer: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/import-export/export-button/index.mjs

@@ -0,0 +1,2 @@
+export * from './export-button.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9pbXBvcnQtZXhwb3J0L2V4cG9ydC1idXR0b24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZXhwb3J0LWJ1dHRvbi5jb21wb25lbnQnO1xuIl19