@arcgis/core 5.2.0-next.95 → 5.2.0-next.97

package/geometry/operators/minimumBoundingCircleOperator.d.ts

@@ -14,7 +14,7 @@
 import type Polygon from "../Polygon.js";
 import type { GeometryUnion } from "../types.js";
 
-export interface Options {
+export interface MinimumBoundingCircleOptions {
   /**
    * If `true`, the input geometries will be merged into a single geometry before
    * calculating the minimum bounding circle.
@@ -24,6 +24,9 @@ export interface Options {
   merge?: boolean;
 }
 
+/** @deprecated since 5.2 use [MinimumBoundingCircleOptions](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/minimumBoundingCircleOperator/#MinimumBoundingCircleOptions) */
+export type Options = MinimumBoundingCircleOptions;
+
 /**
  * Performs the minimum bounding circle operation on the geometry.
  *
@@ -31,7 +34,19 @@ export interface Options {
  * @returns Returns the minimum bounding circle polygon with [curves](https://developers.arcgis.com/javascript/latest/references/core/geometry/Polygon/#curveRings).
  * @example
  * // Perform the minimum bounding circle operation
- * const minimumBoundingCircle = minimumBoundingCircleOperator.execute(polygon);
+ * const minimumBoundingCircle = minimumBoundingCircleExecute(polygon);
+ */
+export function minimumBoundingCircleExecute(geometry: GeometryUnion): Polygon;
+
+/**
+ * Performs the minimum bounding circle operation on the geometry.
+ *
+ * @deprecated since 5.2 use [minimumBoundingCircleExecute()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/minimumBoundingCircleOperator/#minimumBoundingCircleExecute)
+ * @param geometry - The input geometry.
+ * @returns Returns the minimum bounding circle polygon with [curves](https://developers.arcgis.com/javascript/latest/references/core/geometry/Polygon/#curveRings).
+ * @example
+ * // Perform the minimum bounding circle operation
+ * const minimumBoundingCircle = minimumBoundingCircleExecute(polygon);
  */
 export function execute(geometry: GeometryUnion): Polygon;
 
@@ -43,10 +58,29 @@ export function execute(geometry: GeometryUnion): Polygon;
  * @param options - Additional options.
  * @returns Returns the minimum bounding circle polygons with [curves](https://developers.arcgis.com/javascript/latest/references/core/geometry/Polygon/#curveRings).
  */
-export function executeMany(geometries: GeometryUnion[], options?: Options): Polygon[];
+export function minimumBoundingCircleExecuteMany(geometries: GeometryUnion[], options?: MinimumBoundingCircleOptions): Polygon[];
+
+/**
+ * Performs the minimum bounding circle operation on the geometry set.
+ *
+ * @deprecated since 5.2 use [minimumBoundingCircleExecuteMany()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/minimumBoundingCircleOperator/#minimumBoundingCircleExecuteMany)
+ * @param geometries - The set of input geometries.
+ * All the geometries must have the same spatial reference.
+ * @param options - Additional options.
+ * @returns Returns the minimum bounding circle polygons with [curves](https://developers.arcgis.com/javascript/latest/references/core/geometry/Polygon/#curveRings).
+ */
+export function executeMany(geometries: GeometryUnion[], options?: MinimumBoundingCircleOptions): Polygon[];
 
 /**
  * Indicates if the operator supports input geometries that contain curves.
  * The value will always be `false`.
  */
-export const supportsCurves: boolean;
+export const minimumBoundingCircleSupportsCurves: boolean;
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `false`.
+ *
+ * @deprecated since 5.2 use [minimumBoundingCircleSupportsCurves](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/minimumBoundingCircleOperator/#minimumBoundingCircleSupportsCurves)
+ */
+export const supportsCurves: ReturnType<typeof Boolean>;

package/geometry/operators/minimumBoundingCircleOperator.js

@@ -1,2 +1,2 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{isSome as r}from"../../core/arrayUtils.js";import{supportsCurves as o,executeMany as t}from"./gx/operatorMinimumBoundingCircle.js";import{fromGeometry as e,getSpatialReference as n,toPolygon as i}from"./support/apiConverter.js";function p(r){return s([r])[0]}function s(o,p={}){const{merge:s=!1}=p,m=o.map(e),u=n(o);return t(m,s).map(r=>i(r,u)).filter(r)}const m=o();export{p as execute,s as executeMany,m as supportsCurves};
+import{isSome as e}from"../../core/arrayUtils.js";import{deprecatedFunction as r}from"../../core/deprecate.js";import n from"../../core/Logger.js";import{supportsCurves as i,executeMany as o}from"./gx/operatorMinimumBoundingCircle.js";import{fromGeometry as t,getSpatialReference as m,toPolygon as u}from"./support/apiConverter.js";function c(e){return s([e])[0]}function a(e){return r(n.getLogger("esri.geometry.operators.minimumBoundingCircleOperator"),"execute is deprecated. Use minimumBoundingCircleExecute instead.",{replacement:"minimumBoundingCircleExecute",warnOnce:!0}),c(e)}function s(r,n={}){const{merge:i=!1}=n,c=r.map(t),a=m(r);return o(c,i).map(e=>u(e,a)).filter(e)}function p(e,i={}){return r(n.getLogger("esri.geometry.operators.minimumBoundingCircleOperator"),"executeMany is deprecated. Use minimumBoundingCircleExecuteMany instead.",{replacement:"minimumBoundingCircleExecuteMany",warnOnce:!0}),s(e,i)}const g=i(),d=Boolean(g);export{a as execute,p as executeMany,c as minimumBoundingCircleExecute,s as minimumBoundingCircleExecuteMany,g as minimumBoundingCircleSupportsCurves,d as supportsCurves};

package/geometry/operators/multiPartToSinglePartOperator.d.ts

@@ -7,7 +7,7 @@
  */
 import type { GeometryUnion, GeometryWithoutMeshUnion } from "../types.js";
 
-export interface Options {
+export interface MultiPartToSinglePartOptions {
   /**
    * When this parameter is set to false, the input polygons will not be simplified before converting them to single part geometries. Make sure the input polygons are topologically simple.
    * Otherwise, the operation may assume incorrect ring orientation or order of rings.
@@ -17,11 +17,32 @@ export interface Options {
   simplifyPolygons?: boolean;
 }
 
+/** @deprecated since 5.2 use [MultiPartToSinglePartOptions](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/multiPartToSinglePartOperator/#MultiPartToSinglePartOptions) */
+export type Options = MultiPartToSinglePartOptions;
+
+/**
+ * Performs the multipart to single part operation on the input geometries.
+ * Single part geometries will not be affected (i.e. they just get passed along) with the exception of multipoints, which always become points.
+ * By default, polygons will be simplified before producing single parts.
+ *
+ * @param geometries - The input geometries to be converted to single part geometries.
+ * All the geometries must have the same spatial reference.
+ * @param options - Additional options.
+ * @returns Returns the single part geometries.
+ * For non-simple polygons, the output of the method is not guaranteed to be correct if the `simplifyPolgons` option is set to `false`.
+ * In that case, the method may either throw an error, or produce some output which is not guaranteed to be correct.
+ * @example
+ * // Convert multipart geometries to single part geometries
+ * const singlePartGeometries = multiPartToSinglePartExecuteMany(multiPartGeometries);
+ */
+export function multiPartToSinglePartExecuteMany(geometries: GeometryUnion[], options?: MultiPartToSinglePartOptions): GeometryWithoutMeshUnion[];
+
 /**
  * Performs the multipart to single part operation on the input geometries.
  * Single part geometries will not be affected (i.e. they just get passed along) with the exception of multipoints, which always become points.
  * By default, polygons will be simplified before producing single parts.
  *
+ * @deprecated since 5.2 use [multiPartToSinglePartExecuteMany()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/multiPartToSinglePartOperator/#multiPartToSinglePartExecuteMany)
  * @param geometries - The input geometries to be converted to single part geometries.
  * All the geometries must have the same spatial reference.
  * @param options - Additional options.
@@ -30,12 +51,20 @@ export interface Options {
  * In that case, the method may either throw an error, or produce some output which is not guaranteed to be correct.
  * @example
  * // Convert multipart geometries to single part geometries
- * const singlePartGeometries = multiPartToSinglePartOperator.executeMany(multiPartGeometries);
+ * const singlePartGeometries = multiPartToSinglePartExecuteMany(multiPartGeometries);
  */
-export function executeMany(geometries: GeometryUnion[], options?: Options): GeometryWithoutMeshUnion[];
+export function executeMany(geometries: GeometryUnion[], options?: MultiPartToSinglePartOptions): GeometryWithoutMeshUnion[];
 
 /**
  * Indicates if the operator supports input geometries that contain curves.
  * The value will always be `true`.
  */
-export const supportsCurves: boolean;
+export const multiPartToSinglePartSupportsCurves: boolean;
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ *
+ * @deprecated since 5.2 use [multiPartToSinglePartSupportsCurves](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/multiPartToSinglePartOperator/#multiPartToSinglePartSupportsCurves)
+ */
+export const supportsCurves: ReturnType<typeof Boolean>;

package/geometry/operators/multiPartToSinglePartOperator.js

@@ -1,2 +1,2 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{isSome as r}from"../../core/arrayUtils.js";import{supportsCurves as o,executeMany as t}from"./gx/operatorMultiPartToSinglePart.js";import{fromGeometry as s,getSpatialReference as p,fromSpatialReference as e,toGeometry as a}from"./support/apiConverter.js";function i(o,i={}){const{simplifyPolygons:m=!0}=i,n=m?1:2,u=o.map(s),f=p(o);return t(u,e(f),n).map(r=>a(r,f)).filter(r)}const m=o();export{i as executeMany,m as supportsCurves};
+import{isSome as r}from"../../core/arrayUtils.js";import{deprecatedFunction as e}from"../../core/deprecate.js";import t from"../../core/Logger.js";import{supportsCurves as o,executeMany as a}from"./gx/operatorMultiPartToSinglePart.js";import{fromGeometry as i,getSpatialReference as n,fromSpatialReference as s,toGeometry as p}from"./support/apiConverter.js";function m(e,t={}){const{simplifyPolygons:o=!0}=t,m=o?1:2,c=e.map(i),u=n(e);return a(c,s(u),m).map(r=>p(r,u)).filter(r)}function c(r,o={}){return e(t.getLogger("esri.geometry.operators.multiPartToSinglePartOperator"),"executeMany is deprecated. Use multiPartToSinglePartExecuteMany instead.",{replacement:"multiPartToSinglePartExecuteMany",warnOnce:!0}),m(r,o)}const u=o(),l=Boolean(u);export{c as executeMany,m as multiPartToSinglePartExecuteMany,u as multiPartToSinglePartSupportsCurves,l as supportsCurves};

package/geometry/operators/offsetOperator.d.ts

@@ -45,7 +45,7 @@
 import type { LengthUnit } from "../../core/units.js";
 import type { GeometryUnion, GeometryWithoutMeshUnion } from "../types.js";
 
-export interface Options {
+export interface OffsetOptions {
   /**
    * The maximum distance of the resulting segments compared to the true circular arc (used only when joins is round).
    * The algorithm never produces more than around 180 vertices for each round join.
@@ -80,10 +80,32 @@ export interface Options {
   unit?: LengthUnit;
 }
 
+/** @deprecated since 5.2 use [OffsetOptions](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/offsetOperator/#OffsetOptions) */
+export type Options = OffsetOptions;
+
+/**
+ * Creates an offset version of the input geometry.
+ * This is not applicable to point geometries.
+ *
+ * @param geometry - The input geometry.
+ * Can be an extent, polyline, or polygon.
+ * Point and multipoint geometries are not supported.
+ * @param distance - The distance to offset the input geometry.
+ * Unless the `unit` option is set, the default is the geometry's spatial reference unit.
+ * @param options - Additional options.
+ * @returns Returns the offset geometry or null.
+ * Very acute angles can return null when an offset geometry segment cannot be created with the given parameters.
+ * @example
+ * // Create an offset polygon.
+ * const offsetPolygon = offsetExecute(polygon, 100);
+ */
+export function offsetExecute(geometry: GeometryUnion, distance: number, options?: OffsetOptions): GeometryWithoutMeshUnion | null | undefined;
+
 /**
  * Creates an offset version of the input geometry.
  * This is not applicable to point geometries.
  *
+ * @deprecated since 5.2 use [offsetExecute()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/offsetOperator/#offsetExecute)
  * @param geometry - The input geometry.
  * Can be an extent, polyline, or polygon.
  * Point and multipoint geometries are not supported.
@@ -94,13 +116,28 @@ export interface Options {
  * Very acute angles can return null when an offset geometry segment cannot be created with the given parameters.
  * @example
  * // Create an offset polygon.
- * const offsetPolygon = offsetOperator.execute(polygon, 100);
+ * const offsetPolygon = offsetExecute(polygon, 100);
+ */
+export function execute(geometry: GeometryUnion, distance: number, options?: OffsetOptions): GeometryWithoutMeshUnion | null | undefined;
+
+/**
+ * Creates offset versions of the input geometries.
+ *
+ * @param geometries - The set of input geometries.
+ * Can be extents, polylines, or polygons.
+ * Point and multipoint geometries are not supported.
+ * All the geometries must have the same spatial reference.
+ * @param distance - The distance to offset the input geometries.
+ * Unless the `unit` option is set, the default is the geometries spatial reference unit.
+ * @param options - Additional options.
+ * @returns Returns the offset geometry results or null. Very acute angles can return null when an offset geometry segment cannot be created with the given parameters.
  */
-export function execute(geometry: GeometryUnion, distance: number, options?: Options): GeometryWithoutMeshUnion | null | undefined;
+export function offsetExecuteMany(geometries: GeometryUnion[], distance: number, options?: OffsetOptions): (GeometryWithoutMeshUnion | null | undefined)[];
 
 /**
  * Creates offset versions of the input geometries.
  *
+ * @deprecated since 5.2 use [offsetExecuteMany()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/offsetOperator/#offsetExecuteMany)
  * @param geometries - The set of input geometries.
  * Can be extents, polylines, or polygons.
  * Point and multipoint geometries are not supported.
@@ -110,10 +147,18 @@ export function execute(geometry: GeometryUnion, distance: number, options?: Opt
  * @param options - Additional options.
  * @returns Returns the offset geometry results or null. Very acute angles can return null when an offset geometry segment cannot be created with the given parameters.
  */
-export function executeMany(geometries: GeometryUnion[], distance: number, options?: Options): (GeometryWithoutMeshUnion | null | undefined)[];
+export function executeMany(geometries: GeometryUnion[], distance: number, options?: OffsetOptions): (GeometryWithoutMeshUnion | null | undefined)[];
 
 /**
  * Indicates if the operator supports input geometries that contain curves.
  * The value will always be `true`. This will produce densified output geometries.
  */
-export const supportsCurves: boolean;
+export const offsetSupportsCurves: boolean;
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`. This will produce densified output geometries.
+ *
+ * @deprecated since 5.2 use [offsetSupportsCurves](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/offsetOperator/#offsetSupportsCurves)
+ */
+export const supportsCurves: ReturnType<typeof Boolean>;

package/geometry/operators/offsetOperator.js

@@ -1,2 +1,2 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{convertToSpatialReferenceUnit as r}from"../../core/units.js";import{supportsCurves as t,execute as o,executeMany as e}from"./gx/operatorOffset.js";import{getSpatialReference as n,toGeometry as s,fromSpatialReference as i,fromGeometry as u}from"./support/apiConverter.js";const m={round:0,bevel:1,miter:2,square:3};function p(t,e,p={}){const{miterLimit:a=10,flattenError:c=0,joins:f="round",unit:j}=p,x=n(t);return j&&(e=r(e,j,x)),s(o(u(t),i(x),e,m[f],a,c),x)}function a(t,o,p={}){const{miterLimit:a=10,flattenError:c=0,joins:f="round",unit:j}=p,x=n(t);j&&(o=r(o,j,x));const d=t.map(u);return e(d,i(x),o,m[f],a,c).map(r=>s(r,x))}const c=t();export{p as execute,a as executeMany,c as supportsCurves};
+import{deprecatedFunction as e}from"../../core/deprecate.js";import t from"../../core/Logger.js";import{convertToSpatialReferenceUnit as r}from"../../core/units.js";import{supportsCurves as o,execute as n,executeMany as s}from"./gx/operatorOffset.js";import{getSpatialReference as a,toGeometry as i,fromSpatialReference as c,fromGeometry as u}from"./support/apiConverter.js";const f={round:0,bevel:1,miter:2,square:3};function p(e,t,o={}){const{miterLimit:s=10,flattenError:p=0,joins:m="round",unit:g}=o,d=a(e);return g&&(t=r(t,g,d)),i(n(u(e),c(d),t,f[m],s,p),d)}function m(r,o,n={}){return e(t.getLogger("esri.geometry.operators.offsetOperator"),"execute is deprecated. Use offsetExecute instead.",{replacement:"offsetExecute",warnOnce:!0}),p(r,o,n)}function g(e,t,o={}){const{miterLimit:n=10,flattenError:p=0,joins:m="round",unit:g}=o,d=a(e);g&&(t=r(t,g,d));const x=e.map(u);return s(x,c(d),t,f[m],n,p).map(e=>i(e,d))}function d(r,o,n={}){return e(t.getLogger("esri.geometry.operators.offsetOperator"),"executeMany is deprecated. Use offsetExecuteMany instead.",{replacement:"offsetExecuteMany",warnOnce:!0}),g(r,o,n)}const x=o(),j=Boolean(x);export{m as execute,d as executeMany,p as offsetExecute,g as offsetExecuteMany,x as offsetSupportsCurves,j as supportsCurves};

package/geometry/operators/overlapsOperator.d.ts

@@ -13,6 +13,15 @@ import type { GeometryUnion } from "../types.js";
  * @param geometry - The geometry to accelerate.
  * @returns Returns `true` if the geometry was successfully accelerated.
  */
+export function overlapsAccelerateGeometry(geometry: GeometryUnion): boolean;
+
+/**
+ * Accelerate a geometry. This method prepares the geometry for faster overlaps operations when the same geometry is tested multiple times (e.g. in a loop with hundreds of iterations). See the [Acceleration](https://developers.arcgis.com/javascript/latest/spatial-analysis/intro-geometry-operators/#acceleration) guide topic for more information.
+ *
+ * @deprecated since 5.2 use [overlapsAccelerateGeometry()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/overlapsOperator/#overlapsAccelerateGeometry)
+ * @param geometry - The geometry to accelerate.
+ * @returns Returns `true` if the geometry was successfully accelerated.
+ */
 export function accelerateGeometry(geometry: GeometryUnion): boolean;
 
 /**
@@ -24,7 +33,21 @@ export function accelerateGeometry(geometry: GeometryUnion): boolean;
  * @example
  * // Returns true if one geometry overlaps another,
  * // but is not contained or disjointed
- * const isOverlapping = overlapsOperator.execute(polygon1, polygon2);
+ * const isOverlapping = overlapsExecute(polygon1, polygon2);
+ */
+export function overlapsExecute(geometry1: GeometryUnion, geometry2: GeometryUnion): boolean;
+
+/**
+ * Perform the overlaps operation on two geometries.
+ *
+ * @deprecated since 5.2 use [overlapsExecute()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/overlapsOperator/#overlapsExecute)
+ * @param geometry1 - The base geometry that is tested for the "overlaps" relationship with `geometry2`.
+ * @param geometry2 - The comparison geometry that is tested for the "overlaps" relationship with `geometry1`.
+ * @returns Returns `true` if the intersection set results in a geometry different from both of the input geometries, but of the same dimension. For example, if `geometry1` and `geometry2` are both polygons, then they must return a polygon in order to overlap. If two polygons cross each other at exactly one point then no overlap has occurred because points have a dimension of 0 and polygons have a dimension of 2. See the [Working with spatial relationship operators](https://developers.arcgis.com/javascript/latest/spatial-analysis/intro-geometry-operators/#dimensionality) guide topic on dimensionality for more details.
+ * @example
+ * // Returns true if one geometry overlaps another,
+ * // but is not contained or disjointed
+ * const isOverlapping = overlapsExecute(polygon1, polygon2);
  */
 export function execute(geometry1: GeometryUnion, geometry2: GeometryUnion): boolean;
 
@@ -32,4 +55,12 @@ export function execute(geometry1: GeometryUnion, geometry2: GeometryUnion): boo
  * Indicates if the operator supports input geometries that contain curves.
  * The value will always be `true`.
  */
-export const supportsCurves: boolean;
+export const overlapsSupportsCurves: boolean;
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ *
+ * @deprecated since 5.2 use [overlapsSupportsCurves](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/overlapsOperator/#overlapsSupportsCurves)
+ */
+export const supportsCurves: ReturnType<typeof Boolean>;

package/geometry/operators/overlapsOperator.js

@@ -1,2 +1,2 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{OperatorOverlaps as e}from"../../chunks/OperatorOverlaps.js";import{getSpatialReference as r,fromGeometry as t,fromSpatialReference as o}from"./support/apiConverter.js";const n=new e;function s(e){const s=r(e);return n.accelerateGeometry(t(e),o(s),1)}function p(e,r){return n.execute(t(e),t(r),o(e.spatialReference),null)}const c=n.supportsCurves();export{s as accelerateGeometry,p as execute,c as supportsCurves};
+import{OperatorOverlaps as e}from"../../chunks/OperatorOverlaps.js";import{deprecatedFunction as r}from"../../core/deprecate.js";import t from"../../core/Logger.js";import{getSpatialReference as o,fromGeometry as a,fromSpatialReference as c}from"./support/apiConverter.js";const s=new e;function n(e){const r=o(e);return s.accelerateGeometry(a(e),c(r),1)}function p(e){return r(t.getLogger("esri.geometry.operators.overlapsOperator"),"accelerateGeometry is deprecated. Use overlapsAccelerateGeometry instead.",{replacement:"overlapsAccelerateGeometry",warnOnce:!0}),n(e)}function l(e,r){return s.execute(a(e),a(r),c(e.spatialReference),null)}function u(e,o){return r(t.getLogger("esri.geometry.operators.overlapsOperator"),"execute is deprecated. Use overlapsExecute instead.",{replacement:"overlapsExecute",warnOnce:!0}),l(e,o)}const i=s.supportsCurves(),m=Boolean(i);export{p as accelerateGeometry,u as execute,n as overlapsAccelerateGeometry,l as overlapsExecute,i as overlapsSupportsCurves,m as supportsCurves};

package/geometry/operators/polygonOverlayOperator.d.ts

@@ -6,7 +6,7 @@
  */
 import type Polygon from "../Polygon.js";
 
-export interface Options {
+export interface PolygonOverlayOptions {
   /**
    * Output overlapping areas of polygons.
    *
@@ -39,7 +39,10 @@ export interface Options {
   multiPart?: boolean;
 }
 
-/** Object returned by the [executeMany()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/polygonOverlayOperator/#executeMany) method. */
+/** @deprecated since 5.2 use [PolygonOverlayOptions](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/polygonOverlayOperator/#PolygonOverlayOptions) */
+export type Options = PolygonOverlayOptions;
+
+/** Object returned by the [polygonOverlayExecuteMany()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/polygonOverlayOperator/#polygonOverlayExecuteMany) method. */
 export interface ExecuteManyResult {
   /** The array of polygons returned by the operator. */
   results: Polygon[];
@@ -57,12 +60,35 @@ export interface ExecuteManyResult {
  * Overlaps have two or more ids, no-overlaps have one id, and gaps have no ids.
  * @example
  * // Overlay a set of polygons
- * const result = polygonOverlayOperator.executeMany(polygons);
+ * const result = polygonOverlayExecuteMany(polygons);
  */
-export function executeMany(polygons: Polygon[], options?: Options): ExecuteManyResult;
+export function polygonOverlayExecuteMany(polygons: Polygon[], options?: PolygonOverlayOptions): ExecuteManyResult;
+
+/**
+ * Performs the topological overlay of the geometry set in the XY plane.
+ *
+ * @deprecated since 5.2 use [polygonOverlayExecuteMany()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/polygonOverlayOperator/#polygonOverlayExecuteMany)
+ * @param polygons - The set of polygons to overlay.
+ * All the polygons must have the same spatial reference.
+ * @param options - Additional options.
+ * @returns Returns the result polygons and ids.
+ * Overlaps have two or more ids, no-overlaps have one id, and gaps have no ids.
+ * @example
+ * // Overlay a set of polygons
+ * const result = polygonOverlayExecuteMany(polygons);
+ */
+export function executeMany(polygons: Polygon[], options?: PolygonOverlayOptions): ExecuteManyResult;
 
 /**
  * Indicates if the operator supports input polygons that contain curves.
  * The value will always be `true`.
  */
-export const supportsCurves: boolean;
+export const polygonOverlaySupportsCurves: boolean;
+
+/**
+ * Indicates if the operator supports input polygons that contain curves.
+ * The value will always be `true`.
+ *
+ * @deprecated since 5.2 use [polygonOverlaySupportsCurves](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/polygonOverlayOperator/#polygonOverlaySupportsCurves)
+ */
+export const supportsCurves: ReturnType<typeof Boolean>;

package/geometry/operators/polygonOverlayOperator.js

@@ -1,2 +1,2 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{supportsCurves as o,executeMany as r}from"./gx/operatorPolygonOverlay.js";import{getSpatialReference as s,fromSpatialReference as t,fromPolygon as e,toPolygon as p}from"./support/apiConverter.js";function a(o,a){const{overlaps:n=!0,noOverlaps:u=!0,gaps:l,holes:m,multiPart:i}=a??{};let c=0;n&&(c|=1),u&&(c|=2),l&&(c|=4),m&&(c|=8),i&&(c|=16);const v=s(o),f=r(o.map(e),t(v),c),g=[],x=[];let y;for(;y=f.next();)g.push(p(y,v)),x.push(f.getGeometryIDs());return{results:g,ids:x}}const n=o();export{a as executeMany,n as supportsCurves};
+import{deprecatedFunction as e}from"../../core/deprecate.js";import r from"../../core/Logger.js";import{supportsCurves as o,executeMany as t}from"./gx/operatorPolygonOverlay.js";import{getSpatialReference as s,fromSpatialReference as a,fromPolygon as n,toPolygon as p}from"./support/apiConverter.js";function l(e,r){const{overlaps:o=!0,noOverlaps:l=!0,gaps:c,holes:u,multiPart:y}=r??{};let g=0;o&&(g|=1),l&&(g|=2),c&&(g|=4),u&&(g|=8),y&&(g|=16);const m=s(e),i=t(e.map(n),a(m),g),v=[],f=[];let x;for(;x=i.next();)v.push(p(x,m)),f.push(i.getGeometryIDs());return{results:v,ids:f}}function c(o,t){return e(r.getLogger("esri.geometry.operators.polygonOverlayOperator"),"executeMany is deprecated. Use polygonOverlayExecuteMany instead.",{replacement:"polygonOverlayExecuteMany",warnOnce:!0}),l(o,t)}const u=o(),y=Boolean(u);export{c as executeMany,l as polygonOverlayExecuteMany,u as polygonOverlaySupportsCurves,y as supportsCurves};

package/geometry/operators/polygonSlicerOperator.d.ts

@@ -7,7 +7,7 @@ import type Polygon from "../Polygon.js";
 import type Transformation from "./support/Transformation.js";
 import type { AreaUnit } from "../../core/units.js";
 
-export interface Options {
+export interface PolygonSlicerOptions {
   /**
    * The affine transformation to apply to the polygon before slicing. When applying the transformation, the slicing starts from the bottom and proceeds to the top. The default is the identity transformation.
    * For horizontal slices, use [Transformation.setIdentity()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/support/Transformation/#setIdentity). To slice vertically, apply [Transformation.setSwapCoordinates()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/support/Transformation/#setSwapCoordinates) that swaps x and y coordinate values, and for an arbitrary angle, use [Transformation.rotate()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/support/Transformation/#rotate).
@@ -15,7 +15,10 @@ export interface Options {
   transform?: Transformation;
 }
 
-export interface FindSlicesByAreaOptions extends Options {
+/** @deprecated since 5.2 use [PolygonSlicerOptions](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/polygonSlicerOperator/#PolygonSlicerOptions) */
+export type Options = PolygonSlicerOptions;
+
+export interface PolygonSlicerFindSlicesByAreaOptions extends PolygonSlicerOptions {
   /**
    * The area unit of the remaining area.
    * The default is the input geometry's spatial reference unit.
@@ -24,24 +27,60 @@ export interface FindSlicesByAreaOptions extends Options {
   unit?: AreaUnit;
 }
 
+/** @deprecated since 5.2 use [PolygonSlicerFindSlicesByAreaOptions](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/polygonSlicerOperator/#PolygonSlicerFindSlicesByAreaOptions) */
+export type FindSlicesByAreaOptions = PolygonSlicerFindSlicesByAreaOptions;
+
+/**
+ * Finds positions of the sliced strips for a given polygon given the number of equal area parts to slice the polygon into.
+ *
+ * @param polygon - The input polygon.
+ * @param partCount - The number of parts to slice into.
+ * @param remainingArea - The size of the remaining piece of the uncut polygon. Pass zero, if you want to slice the whole polygon.
+ * Unless the `unit` option is set, the default is the spatial reference unit of `polygon`.
+ * @param options - Additional options.
+ * @returns Returns the y-coordinate set for the slice positions sorted in increasing y-order. The set can be used as input to the
+ * [polygonSlicerSliceIntoStrips()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/polygonSlicerOperator/#polygonSlicerSliceIntoStrips) method.
+ * @example
+ * // Find the slice positions for a polygon
+ * const slicePositions = polygonSlicerFindSlicesByArea(polygon, 3, 0);
+ */
+export function polygonSlicerFindSlicesByArea(polygon: Polygon, partCount: number, remainingArea: number, options?: PolygonSlicerFindSlicesByAreaOptions): number[];
+
 /**
  * Finds positions of the sliced strips for a given polygon given the number of equal area parts to slice the polygon into.
  *
+ * @deprecated since 5.2 use [polygonSlicerFindSlicesByArea()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/polygonSlicerOperator/#polygonSlicerFindSlicesByArea)
  * @param polygon - The input polygon.
  * @param partCount - The number of parts to slice into.
  * @param remainingArea - The size of the remaining piece of the uncut polygon. Pass zero, if you want to slice the whole polygon.
  * Unless the `unit` option is set, the default is the spatial reference unit of `polygon`.
  * @param options - Additional options.
- * @returns Returns the y-coordinate set for the slice positions sorted in increasing y-order. The set can be used as input to the [sliceIntoStrips()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/polygonSlicerOperator/#sliceIntoStrips) method.
+ * @returns Returns the y-coordinate set for the slice positions sorted in increasing y-order. The set can be used as input to the
+ * [polygonSlicerSliceIntoStrips()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/polygonSlicerOperator/#polygonSlicerSliceIntoStrips) method.
  * @example
  * // Find the slice positions for a polygon
- * const slicePositions = polygonSlicerOperator.findSlicesByArea(polygon, 3, 0);
+ * const slicePositions = polygonSlicerFindSlicesByArea(polygon, 3, 0);
+ */
+export function findSlicesByArea(polygon: Polygon, partCount: number, remainingArea: number, options?: PolygonSlicerFindSlicesByAreaOptions): number[];
+
+/**
+ * Slices the given polygon into equal area parts, not necessarily strips. The slicing is done recursively, each time slicing the polygon into two parts along the larger dimension (height or width).
+ *
+ * @param polygon - The input polygon to slice.
+ * @param partCount - The number of equal area parts to slice the polygon into.
+ * @param options - Additional options.
+ * @returns Returns the array of polygons that are the result of the slicing.
+ * The number of output polygons will not necessarily match the number of requested slices. For example, if some of the slices became degenerate, they may not be output. The method uses topological operations that rely on the tolerance value in the input spatial reference. These operations may shift vertices in a way that affects result areas.
+ * @example
+ * // Slice a polygon into equal area parts
+ * const slicedPolygons = polygonSlicerRecursiveSliceEqualArea(polygon, 3);
  */
-export function findSlicesByArea(polygon: Polygon, partCount: number, remainingArea: number, options?: FindSlicesByAreaOptions): number[];
+export function polygonSlicerRecursiveSliceEqualArea(polygon: Polygon, partCount: number, options?: PolygonSlicerOptions): Polygon[];
 
 /**
  * Slices the given polygon into equal area parts, not necessarily strips. The slicing is done recursively, each time slicing the polygon into two parts along the larger dimension (height or width).
  *
+ * @deprecated since 5.2 use [polygonSlicerRecursiveSliceEqualArea()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/polygonSlicerOperator/#polygonSlicerRecursiveSliceEqualArea)
  * @param polygon - The input polygon to slice.
  * @param partCount - The number of equal area parts to slice the polygon into.
  * @param options - Additional options.
@@ -49,13 +88,28 @@ export function findSlicesByArea(polygon: Polygon, partCount: number, remainingA
  * The number of output polygons will not necessarily match the number of requested slices. For example, if some of the slices became degenerate, they may not be output. The method uses topological operations that rely on the tolerance value in the input spatial reference. These operations may shift vertices in a way that affects result areas.
  * @example
  * // Slice a polygon into equal area parts
- * const slicedPolygons = polygonSlicerOperator.recursiveSliceEqualArea(polygon, 3);
+ * const slicedPolygons = polygonSlicerRecursiveSliceEqualArea(polygon, 3);
+ */
+export function recursiveSliceEqualArea(polygon: Polygon, partCount: number, options?: PolygonSlicerOptions): Polygon[];
+
+/**
+ * Slices the given polygon into strips.
+ *
+ * @param polygon - The input polygon to slice.
+ * @param ySlices - The array of y coordinates, sorted in ascending order. The polygon will be transformed with the transform, and then it will be sliced horizontally at each y coordinate. That is, the `ySlices` are given in the coordinates after transform is applied to the polygon.
+ * @param options - Additional options.
+ * @returns Returns the array of polygons that are the result of the slicing.
+ * The number of output polygons will not necessarily match the number of requested slices. For example, if some of the slices became degenerate, they may not be output. The method uses topological operations that rely on the tolerance value in the input spatial reference. These operations may shift vertices in a way that affects result areas.
+ * @example
+ * // Slice a polygon into strips
+ * const slicedPolygons = polygonSlicerSliceIntoStrips(polygon, [100, 200, 300]);
  */
-export function recursiveSliceEqualArea(polygon: Polygon, partCount: number, options?: Options): Polygon[];
+export function polygonSlicerSliceIntoStrips(polygon: Polygon, ySlices: number[], options?: PolygonSlicerOptions): Polygon[];
 
 /**
  * Slices the given polygon into strips.
  *
+ * @deprecated since 5.2 use [polygonSlicerSliceIntoStrips()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/polygonSlicerOperator/#polygonSlicerSliceIntoStrips)
  * @param polygon - The input polygon to slice.
  * @param ySlices - The array of y coordinates, sorted in ascending order. The polygon will be transformed with the transform, and then it will be sliced horizontally at each y coordinate. That is, the `ySlices` are given in the coordinates after transform is applied to the polygon.
  * @param options - Additional options.
@@ -63,12 +117,20 @@ export function recursiveSliceEqualArea(polygon: Polygon, partCount: number, opt
  * The number of output polygons will not necessarily match the number of requested slices. For example, if some of the slices became degenerate, they may not be output. The method uses topological operations that rely on the tolerance value in the input spatial reference. These operations may shift vertices in a way that affects result areas.
  * @example
  * // Slice a polygon into strips
- * const slicedPolygons = polygonSlicerOperator.sliceIntoStrips(polygon, [100, 200, 300]);
+ * const slicedPolygons = polygonSlicerSliceIntoStrips(polygon, [100, 200, 300]);
  */
-export function sliceIntoStrips(polygon: Polygon, ySlices: number[], options?: Options): Polygon[];
+export function sliceIntoStrips(polygon: Polygon, ySlices: number[], options?: PolygonSlicerOptions): Polygon[];
 
 /**
  * Indicates if the operator supports input geometries that contain curves.
  * The value will always be `true`.
  */
-export const supportsCurves: boolean;
+export const polygonSlicerSupportsCurves: boolean;
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ *
+ * @deprecated since 5.2 use [polygonSlicerSupportsCurves](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/polygonSlicerOperator/#polygonSlicerSupportsCurves)
+ */
+export const supportsCurves: ReturnType<typeof Boolean>;

package/geometry/operators/polygonSlicerOperator.js

@@ -1,2 +1,2 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{areaUnitFromSpatialReference as r,convertUnit as t,getMetersPerUnitForSR as n}from"../../core/units.js";import{supportsCurves as o,findSlicesByArea as s,recursiveSliceEqualArea as a,sliceIntoStrips as e}from"./gx/operatorPolygonSlicer.js";import{getSpatialReference as i,fromSpatialReference as u,fromPolygon as c,toPolygon as f}from"./support/apiConverter.js";function m(o,a,e,f={}){const{transform:m,unit:l}=f,p=i(o);if(e&&l){if(p.isGeographic)throw new Error("Unable to convert from an angular area unit to a linear area unit.");const o=r(p);o!==l&&(o?e=t(e,l,o):(e=t(e,l,"square-meters"),e=Math.sqrt(e),e/=n(p),e**=2))}return s(c(o),u(p),a,e,m?.transform??null)}function l(r,t,n={}){const{transform:o}=n,s=i(r);return a(c(r),u(s),t,o?.transform??null).map(r=>f(r,s))}function p(r,t,n={}){const{transform:o}=n,s=i(r);return e(c(r),u(s),t,o?.transform??null).map(r=>f(r,s))}const g=o();export{m as findSlicesByArea,l as recursiveSliceEqualArea,p as sliceIntoStrips,g as supportsCurves};
+import{deprecatedFunction as r}from"../../core/deprecate.js";import e from"../../core/Logger.js";import{areaUnitFromSpatialReference as o,convertUnit as n,getMetersPerUnitForSR as t}from"../../core/units.js";import{supportsCurves as i,findSlicesByArea as a,recursiveSliceEqualArea as s,sliceIntoStrips as c}from"./gx/operatorPolygonSlicer.js";import{getSpatialReference as l,fromSpatialReference as p,fromPolygon as u,toPolygon as g}from"./support/apiConverter.js";function m(r,e,i,s={}){const{transform:c,unit:g}=s,m=l(r);if(i&&g){if(m.isGeographic)throw new Error("Unable to convert from an angular area unit to a linear area unit.");const r=o(m);r!==g&&(r?i=n(i,g,r):(i=n(i,g,"square-meters"),i=Math.sqrt(i),i/=t(m),i**=2))}return a(u(r),p(m),e,i,c?.transform??null)}function S(o,n,t,i={}){return r(e.getLogger("esri.geometry.operators.polygonSlicerOperator"),"findSlicesByArea is deprecated. Use polygonSlicerFindSlicesByArea instead.",{replacement:"polygonSlicerFindSlicesByArea",warnOnce:!0}),m(o,n,t,i)}function f(r,e,o={}){const{transform:n}=o,t=l(r);return s(u(r),p(t),e,n?.transform??null).map(r=>g(r,t))}function y(o,n,t={}){return r(e.getLogger("esri.geometry.operators.polygonSlicerOperator"),"recursiveSliceEqualArea is deprecated. Use polygonSlicerRecursiveSliceEqualArea instead.",{replacement:"polygonSlicerRecursiveSliceEqualArea",warnOnce:!0}),f(o,n,t)}function d(r,e,o={}){const{transform:n}=o,t=l(r);return c(u(r),p(t),e,n?.transform??null).map(r=>g(r,t))}function A(o,n,t={}){return r(e.getLogger("esri.geometry.operators.polygonSlicerOperator"),"sliceIntoStrips is deprecated. Use polygonSlicerSliceIntoStrips instead.",{replacement:"polygonSlicerSliceIntoStrips",warnOnce:!0}),d(o,n,t)}const v=i(),q=Boolean(v);export{S as findSlicesByArea,m as polygonSlicerFindSlicesByArea,f as polygonSlicerRecursiveSliceEqualArea,d as polygonSlicerSliceIntoStrips,v as polygonSlicerSupportsCurves,y as recursiveSliceEqualArea,A as sliceIntoStrips,q as supportsCurves};