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

package/geometry/operators/geodeticDistanceOperator.d.ts

@@ -16,7 +16,7 @@
 import type { LengthUnit } from "../../core/units.js";
 import type { GeometryUnion, GeodeticCurveType } from "../types.js";
 
-export interface Options {
+export interface GeodeticDistanceOptions {
   /**
    * The type of geodetic curve used to determine the distance.
    *
@@ -31,16 +31,36 @@ export interface Options {
   unit?: LengthUnit;
 }
 
+/** @deprecated since 5.2 use [GeodeticDistanceOptions](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/geodeticDistanceOperator/#GeodeticDistanceOptions) */
+export type Options = GeodeticDistanceOptions;
+
+/**
+ * Indicates if all dependencies of this module have been loaded.
+ *
+ * @returns Returns `true` if this module's dependencies have been loaded.
+ */
+export function geodeticDistanceIsLoaded(): boolean;
+
 /**
  * Indicates if all dependencies of this module have been loaded.
  *
+ * @deprecated since 5.2 use [geodeticDistanceIsLoaded()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/geodeticDistanceOperator/#geodeticDistanceIsLoaded)
  * @returns Returns `true` if this module's dependencies have been loaded.
  */
 export function isLoaded(): boolean;
 
+/**
+ * Loads this module's dependencies. This method must be called first if `geodeticDistanceIsLoaded` returns `false`.
+ *
+ * @returns Resolves when the dependencies have been loaded.
+ * @see [geodeticDistanceIsLoaded()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/geodeticDistanceOperator/#geodeticDistanceIsLoaded)
+ */
+export function geodeticDistanceLoad(): Promise<void>;
+
 /**
  * Loads this module's dependencies. This method must be called first if `isLoaded` returns `false`.
  *
+ * @deprecated since 5.2 use [geodeticDistanceLoad()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/geodeticDistanceOperator/#geodeticDistanceLoad)
  * @returns Resolves when the dependencies have been loaded.
  * @see [isLoaded()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/geodeticDistanceOperator/#isLoaded)
  */
@@ -55,17 +75,44 @@ export function load(): Promise<void>;
  * @param options - Additional options.
  * @returns Returns the distance between the two geometries. Can return NaN for empty geometries.
  * @example
- * if (!geodeticDistanceOperator.isLoaded()) {
- *   await geodeticDistanceOperator.load();
+ * if (!geodeticDistanceIsLoaded()) {
+ *   await geodeticDistanceLoad();
+ * }
+ *
+ * // Calculate the geodetic distance between two geometries
+ * const distance = geodeticDistanceExecute(polyline1, polyline2);
+ */
+export function geodeticDistanceExecute(geometry1: GeometryUnion, geometry2: GeometryUnion, options?: GeodeticDistanceOptions): number;
+
+/**
+ * Calculates the shortest geodetic distance between two geometries.
+ * Unless the `unit` option is set, the default is meters.
+ *
+ * @deprecated since 5.2 use [geodeticDistanceExecute()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/geodeticDistanceOperator/#geodeticDistanceExecute)
+ * @param geometry1 - The first input geometry.
+ * @param geometry2 - The second input geometry.
+ * @param options - Additional options.
+ * @returns Returns the distance between the two geometries. Can return NaN for empty geometries.
+ * @example
+ * if (!geodeticDistanceIsLoaded()) {
+ *   await geodeticDistanceLoad();
  * }
  *
  * // Calculate the geodetic distance between two geometries
- * const distance = geodeticDistanceOperator.execute(polyline1, polyline2);
+ * const distance = geodeticDistanceExecute(polyline1, polyline2);
+ */
+export function execute(geometry1: GeometryUnion, geometry2: GeometryUnion, options?: GeodeticDistanceOptions): number;
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value is `null` or `undefined` until the operator is loaded, then it will always be `true`.
  */
-export function execute(geometry1: GeometryUnion, geometry2: GeometryUnion, options?: Options): number;
+export const geodeticDistanceSupportsCurves: boolean | null | undefined;
 
 /**
  * Indicates if the operator supports input geometries that contain curves.
  * The value is `null` or `undefined` until the operator is loaded, then it will always be `true`.
+ *
+ * @deprecated since 5.2 use [geodeticDistanceSupportsCurves](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/geodeticDistanceOperator/#geodeticDistanceSupportsCurves)
  */
 export const supportsCurves: boolean | null | undefined;

package/geometry/operators/geodeticDistanceOperator.js

@@ -1,2 +1,2 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{convertUnit as e}from"../../core/units.js";import{execute as t,load as r,supportsCurves as o,isLoaded as s}from"./gx/operatorGeodeticDistance.js";import{geodeticCurveType as i}from"./support/geodeticCurveType.js";let a,n,p,c;function u(){return!!a&&s()}async function m(){if(!u()){const[e]=await Promise.all([import("./support/apiConverter.js"),r()]);a=e.fromGeometry,n=e.fromSpatialReference,p=e.getSpatialReference,c=o()}}function f(r,o,s={}){const{curveType:c="geodesic",unit:u}=s,m=p(r);let f=t(a(r),a(o),n(m),i[c]);return f&&u&&(f=e(f,"meters",u)),f}export{f as execute,u as isLoaded,m as load,c as supportsCurves};
+import{deprecatedFunction as e}from"../../core/deprecate.js";import t from"../../core/Logger.js";import{convertUnit as r}from"../../core/units.js";import{execute as o,load as i,supportsCurves as a,isLoaded as c}from"./gx/operatorGeodeticDistance.js";import{geodeticCurveType as s}from"./support/geodeticCurveType.js";let n,d,p,g,u;function m(){return!!n&&c()}function f(){return e(t.getLogger("esri.geometry.operators.geodeticDistanceOperator"),"isLoaded is deprecated. Use geodeticDistanceIsLoaded instead.",{replacement:"geodeticDistanceIsLoaded",warnOnce:!0}),m()}async function l(){if(!m()){const[e]=await Promise.all([import("./support/apiConverter.js"),i()]);n=e.fromGeometry,d=e.fromSpatialReference,p=e.getSpatialReference,g=a(),u=g}}function D(){return e(t.getLogger("esri.geometry.operators.geodeticDistanceOperator"),"load is deprecated. Use geodeticDistanceLoad instead.",{replacement:"geodeticDistanceLoad",warnOnce:!0}),l()}function L(e,t,i={}){const{curveType:a="geodesic",unit:c}=i,g=p(e);let u=o(n(e),n(t),d(g),s[a]);return u&&c&&(u=r(u,"meters",c)),u}function y(r,o,i={}){return e(t.getLogger("esri.geometry.operators.geodeticDistanceOperator"),"execute is deprecated. Use geodeticDistanceExecute instead.",{replacement:"geodeticDistanceExecute",warnOnce:!0}),L(r,o,i)}export{y as execute,L as geodeticDistanceExecute,m as geodeticDistanceIsLoaded,l as geodeticDistanceLoad,g as geodeticDistanceSupportsCurves,f as isLoaded,D as load,u as supportsCurves};

package/geometry/operators/geodeticLengthOperator.d.ts

@@ -13,7 +13,7 @@
 import type { LengthUnit } from "../../core/units.js";
 import type { GeometryUnion, GeodeticCurveType } from "../types.js";
 
-export interface Options {
+export interface GeodeticLengthOptions {
   /**
    * The type of geodetic curve used to determine the length.
    *
@@ -28,16 +28,36 @@ export interface Options {
   unit?: LengthUnit;
 }
 
+/** @deprecated since 5.2 use [GeodeticLengthOptions](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/geodeticLengthOperator/#GeodeticLengthOptions) */
+export type Options = GeodeticLengthOptions;
+
+/**
+ * Indicates if all dependencies of this module have been loaded.
+ *
+ * @returns Returns `true` if this module's dependencies have been loaded.
+ */
+export function geodeticLengthIsLoaded(): boolean;
+
 /**
  * Indicates if all dependencies of this module have been loaded.
  *
+ * @deprecated since 5.2 use [geodeticLengthIsLoaded()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/geodeticLengthOperator/#geodeticLengthIsLoaded)
  * @returns Returns `true` if this module's dependencies have been loaded.
  */
 export function isLoaded(): boolean;
 
+/**
+ * Loads this module's dependencies. This method must be called first if `geodeticLengthIsLoaded` returns `false`.
+ *
+ * @returns Resolves when the dependencies have been loaded.
+ * @see [geodeticLengthIsLoaded()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/geodeticLengthOperator/#geodeticLengthIsLoaded)
+ */
+export function geodeticLengthLoad(): Promise<void>;
+
 /**
  * Loads this module's dependencies. This method must be called first if `isLoaded` returns `false`.
  *
+ * @deprecated since 5.2 use [geodeticLengthLoad()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/geodeticLengthOperator/#geodeticLengthLoad)
  * @returns Resolves when the dependencies have been loaded.
  * @see [isLoaded()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/geodeticLengthOperator/#isLoaded)
  */
@@ -51,17 +71,43 @@ export function load(): Promise<void>;
  * @param options - Additional options.
  * @returns Returns the geodetic length of the input geometry.
  * @example
- * if (!geodeticLengthOperator.isLoaded()) {
- *   await geodeticLengthOperator.load();
+ * if (!geodeticLengthIsLoaded()) {
+ *   await geodeticLengthLoad();
  * }
  *
  * // Calculate the geodetic length of a polyline
- * const length = geodeticLengthOperator.execute(polyline);
+ * const length = geodeticLengthExecute(polyline);
  */
-export function execute(geometry: GeometryUnion, options?: Options): number;
+export function geodeticLengthExecute(geometry: GeometryUnion, options?: GeodeticLengthOptions): number;
+
+/**
+ * Calculates the geodetic length of the input Geometry.
+ * Unless the `unit` option is set, the default is meters.
+ *
+ * @deprecated since 5.2 use [geodeticLengthExecute()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/geodeticLengthOperator/#geodeticLengthExecute)
+ * @param geometry - The input geometry.
+ * @param options - Additional options.
+ * @returns Returns the geodetic length of the input geometry.
+ * @example
+ * if (!geodeticLengthIsLoaded()) {
+ *   await geodeticLengthLoad();
+ * }
+ *
+ * // Calculate the geodetic length of a polyline
+ * const length = geodeticLengthExecute(polyline);
+ */
+export function execute(geometry: GeometryUnion, options?: GeodeticLengthOptions): number;
 
 /**
  * Indicates if the operator supports input geometries that contain curves.
  * The value is `null` or `undefined` until the operator is loaded, then it will always be `true`.
  */
+export const geodeticLengthSupportsCurves: boolean | null | undefined;
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value is `null` or `undefined` until the operator is loaded, then it will always be `true`.
+ *
+ * @deprecated since 5.2 use [geodeticLengthSupportsCurves](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/geodeticLengthOperator/#geodeticLengthSupportsCurves)
+ */
 export const supportsCurves: boolean | null | undefined;

package/geometry/operators/geodeticLengthOperator.js

@@ -1,2 +1,2 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{convertUnit as e}from"../../core/units.js";import{load as t,supportsCurves as r,execute as o,isLoaded as s}from"./gx/operatorGeodeticLength.js";import{geodeticCurveType as i}from"./support/geodeticCurveType.js";let n,p,a,c;function u(){return!!n&&s()}async function m(){if(!u()){const[e]=await Promise.all([import("./support/apiConverter.js"),t()]);n=e.fromGeometry,p=e.fromSpatialReference,a=e.getSpatialReference,c=r()}}function f(t,r={}){const{curveType:s="geodesic",unit:c}=r,u=a(t);let m=o(n(t),p(u),i[s]);return m&&c&&(m=e(m,"meters",c)),m}export{f as execute,u as isLoaded,m as load,c as supportsCurves};
+import{deprecatedFunction as e}from"../../core/deprecate.js";import t from"../../core/Logger.js";import{convertUnit as r}from"../../core/units.js";import{load as o,supportsCurves as n,execute as i,isLoaded as a}from"./gx/operatorGeodeticLength.js";import{geodeticCurveType as c}from"./support/geodeticCurveType.js";let s,g,d,p,u;function m(){return!!s&&a()}function L(){return e(t.getLogger("esri.geometry.operators.geodeticLengthOperator"),"isLoaded is deprecated. Use geodeticLengthIsLoaded instead.",{replacement:"geodeticLengthIsLoaded",warnOnce:!0}),m()}async function f(){if(!m()){const[e]=await Promise.all([import("./support/apiConverter.js"),o()]);s=e.fromGeometry,g=e.fromSpatialReference,d=e.getSpatialReference,p=n(),u=p}}function l(){return e(t.getLogger("esri.geometry.operators.geodeticLengthOperator"),"load is deprecated. Use geodeticLengthLoad instead.",{replacement:"geodeticLengthLoad",warnOnce:!0}),f()}function h(e,t={}){const{curveType:o="geodesic",unit:n}=t,a=d(e);let p=i(s(e),g(a),c[o]);return p&&n&&(p=r(p,"meters",n)),p}function y(r,o={}){return e(t.getLogger("esri.geometry.operators.geodeticLengthOperator"),"execute is deprecated. Use geodeticLengthExecute instead.",{replacement:"geodeticLengthExecute",warnOnce:!0}),h(r,o)}export{y as execute,h as geodeticLengthExecute,m as geodeticLengthIsLoaded,f as geodeticLengthLoad,p as geodeticLengthSupportsCurves,L as isLoaded,l as load,u as supportsCurves};

package/geometry/operators/geodeticUtilsOperator.d.ts

@@ -14,7 +14,7 @@ import type Point from "../Point.js";
 import type { LengthUnit } from "../../core/units.js";
 import type { GeodeticCurveType } from "../types.js";
 
-export interface Options {
+export interface GeodeticUtilsOptions {
   /**
    * The type of geodetic curve along which distance will be measured.
    * The default curveType of geodesic returns the shortest distance between `point1` and `point2`.
@@ -30,6 +30,9 @@ export interface Options {
   unit?: LengthUnit;
 }
 
+/** @deprecated since 5.2 use [GeodeticUtilsOptions](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/geodeticUtilsOperator/#GeodeticUtilsOptions) */
+export type Options = GeodeticUtilsOptions;
+
 /**
  * Object returned by the [calculateDistanceAndAzimuth()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/geodeticUtilsOperator/#calculateDistanceAndAzimuth) method.
  * Azimuths are in positive degrees from 0 to 360, measured clockwise from due north.
@@ -58,11 +61,28 @@ export interface CalculateDistanceAndAzimuthResult {
  *
  * @returns Returns `true` if this module's dependencies have been loaded.
  */
+export function geodeticUtilsIsLoaded(): boolean;
+
+/**
+ * Indicates if all dependencies of this module have been loaded.
+ *
+ * @deprecated since 5.2 use [geodeticUtilsIsLoaded()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/geodeticUtilsOperator/#geodeticUtilsIsLoaded)
+ * @returns Returns `true` if this module's dependencies have been loaded.
+ */
 export function isLoaded(): boolean;
 
+/**
+ * Loads this module's dependencies. This method must be called first if `geodeticUtilsIsLoaded` returns `false`.
+ *
+ * @returns Resolves when the dependencies have been loaded.
+ * @see [geodeticUtilsIsLoaded()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/geodeticUtilsOperator/#geodeticUtilsIsLoaded)
+ */
+export function geodeticUtilsLoad(): Promise<void>;
+
 /**
  * Loads this module's dependencies. This method must be called first if `isLoaded` returns `false`.
  *
+ * @deprecated since 5.2 use [geodeticUtilsLoad()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/geodeticUtilsOperator/#geodeticUtilsLoad)
  * @returns Resolves when the dependencies have been loaded.
  * @see [isLoaded()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/geodeticUtilsOperator/#isLoaded)
  */
@@ -79,16 +99,65 @@ export function load(): Promise<void>;
  * @param options - Additional options.
  * @returns Returns an object containing the distance and azimuths between the two points.
  * @example
- * if (!geodeticUtilsOperator.isLoaded()) {
- *   await geodeticUtilsOperator.load();
+ * if (!geodeticUtilsIsLoaded()) {
+ *   await geodeticUtilsLoad();
+ * }
+ *
+ * const distanceAndAzimuthResult = geodeticUtilsCalculateDistanceAndAzimuth(
+ *   new Point({ x: -118.805, y: 34.027, spatialReference: { wkid: 4326 } }),
+ *   new Point({ x: -118.802, y: 34.029, spatialReference: { wkid: 4326 } })
+ * );
+ */
+export function geodeticUtilsCalculateDistanceAndAzimuth(point1: Point, point2: Point, options?: GeodeticUtilsOptions): CalculateDistanceAndAzimuthResult;
+
+/**
+ * Geodetically calculates the distance and direction between two points.
+ * Unless the `unit` option is set, the default is meters.
+ *
+ * ![Calculate Distance and Azimuth operator](https://developers.arcgis.com/javascript/latest/assets/references/core/operators/calculateDistanceAndAzimuth.avif "Calculate Distance and Azimuth operator")
+ *
+ * @deprecated since 5.2 use [geodeticUtilsCalculateDistanceAndAzimuth()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/geodeticUtilsOperator/#geodeticUtilsCalculateDistanceAndAzimuth)
+ * @param point1 - The starting point.
+ * @param point2 - The ending point.
+ * @param options - Additional options.
+ * @returns Returns an object containing the distance and azimuths between the two points.
+ * @example
+ * if (!geodeticUtilsIsLoaded()) {
+ *   await geodeticUtilsLoad();
  * }
  *
- * const distanceAndAzimuthResult = geodeticUtilsOperator.calculateDistanceAndAzimuth(
+ * const distanceAndAzimuthResult = geodeticUtilsCalculateDistanceAndAzimuth(
  *   new Point({ x: -118.805, y: 34.027, spatialReference: { wkid: 4326 } }),
  *   new Point({ x: -118.802, y: 34.029, spatialReference: { wkid: 4326 } })
  * );
  */
-export function calculateDistanceAndAzimuth(point1: Point, point2: Point, options?: Options): CalculateDistanceAndAzimuthResult;
+export function calculateDistanceAndAzimuth(point1: Point, point2: Point, options?: GeodeticUtilsOptions): CalculateDistanceAndAzimuthResult;
+
+/**
+ * Geodetically calculates a point location at a defined distance and direction from a known point.
+ * Unless the `unit` option is set, the default is meters.
+ *
+ * ![Point From Distance operator](https://developers.arcgis.com/javascript/latest/assets/references/core/operators/pointFromDistance.avif "Point From Distance operator")
+ *
+ * @param point - Origin location.
+ * @param distance - Distance from the origin point.
+ * @param azimuth - Direction in degrees (0 +/- 360) from the origin point, where both 0 and 360 degrees represent due north.
+ * A positive azimuth is measured clockwise from north.
+ * A negative azimuth is measured counter-clockwise from north.
+ * @param options - Additional options.
+ * @returns Returns the new point or `null` if the point cannot be represented in the spatial reference.
+ * @example
+ * if (!geodeticUtilsIsLoaded()) {
+ *   await geodeticUtilsLoad();
+ * }
+ *
+ * const point = geodeticUtilsPointFromDistance(
+ *   new Point({ x: -118.805, y: 34.027, spatialReference: { wkid: 4326 } }),
+ *   350,
+ *   45
+ * );
+ */
+export function geodeticUtilsPointFromDistance(point: Point, distance: number, azimuth: number, options?: GeodeticUtilsOptions): Point | null | undefined;
 
 /**
  * Geodetically calculates a point location at a defined distance and direction from a known point.
@@ -96,6 +165,7 @@ export function calculateDistanceAndAzimuth(point1: Point, point2: Point, option
  *
  * ![Point From Distance operator](https://developers.arcgis.com/javascript/latest/assets/references/core/operators/pointFromDistance.avif "Point From Distance operator")
  *
+ * @deprecated since 5.2 use [geodeticUtilsPointFromDistance()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/geodeticUtilsOperator/#geodeticUtilsPointFromDistance)
  * @param point - Origin location.
  * @param distance - Distance from the origin point.
  * @param azimuth - Direction in degrees (0 +/- 360) from the origin point, where both 0 and 360 degrees represent due north.
@@ -104,14 +174,14 @@ export function calculateDistanceAndAzimuth(point1: Point, point2: Point, option
  * @param options - Additional options.
  * @returns Returns the new point or `null` if the point cannot be represented in the spatial reference.
  * @example
- * if (!geodeticUtilsOperator.isLoaded()) {
- *   await geodeticUtilsOperator.load();
+ * if (!geodeticUtilsIsLoaded()) {
+ *   await geodeticUtilsLoad();
  * }
  *
- * const point = geodeticUtilsOperator.pointFromDistance(
+ * const point = geodeticUtilsPointFromDistance(
  *   new Point({ x: -118.805, y: 34.027, spatialReference: { wkid: 4326 } }),
  *   350,
  *   45
  * );
  */
-export function pointFromDistance(point: Point, distance: number, azimuth: number, options?: Options): Point | null | undefined;
+export function pointFromDistance(point: Point, distance: number, azimuth: number, options?: GeodeticUtilsOptions): Point | null | undefined;

package/geometry/operators/geodeticUtilsOperator.js

@@ -1,2 +1,2 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{convertUnit as e}from"../../core/units.js";import t from"../Point.js";import{calculateDistanceAndAzimuth as r,load as n,movePointsByDistance as i,isLoaded as o}from"./gx/geodeticUtils.js";import{geodeticCurveType as s}from"./support/geodeticCurveType.js";let a,c,u;function m(){return!!a&&o()}async function p(){if(!m()){const[e]=await Promise.all([import("./support/apiConverter.js"),n()]);a=e.fromPoint,c=e.fromSpatialReference,u=e.getSpatialReference}}function f(t,n,i={}){const{curveType:o="geodesic",unit:m}=i,p=u(t),f=[0],d=[0];let g=r(c(p),a(t).getXY(),a(n).getXY(),s[o],f,d);g&&m&&(g=e(g,"meters",m));const y=t=>l(e(t,"radians","degrees"));return{distance:g,azimuth12:y(f[0]),azimuth21:y(d[0])}}function d(r,n,o,m={}){const{curveType:p="geodesic",unit:f}=m;f&&(n=e(n,f,"meters"));const d=u(r),l=[a(r).getXY()];i(c(d),l,1,n,e(o,"degrees","radians"),s[p]);const g=l[0];return g.isNAN()?null:new t({x:g.x,y:g.y,spatialReference:d})}function l(e){return e<0?e+360:e}export{f as calculateDistanceAndAzimuth,m as isLoaded,p as load,d as pointFromDistance,l as shiftDegreesTo360};
+import{deprecatedFunction as e}from"../../core/deprecate.js";import t from"../../core/Logger.js";import{convertUnit as r}from"../../core/units.js";import i from"../Point.js";import{calculateDistanceAndAzimuth as o,load as s,movePointsByDistance as n,isLoaded as a}from"./gx/geodeticUtils.js";import{geodeticCurveType as c}from"./support/geodeticCurveType.js";let d,g,p;function l(){return!!d&&a()}function u(){return e(t.getLogger("esri.geometry.operators.geodeticUtilsOperator"),"isLoaded is deprecated. Use geodeticUtilsIsLoaded instead.",{replacement:"geodeticUtilsIsLoaded",warnOnce:!0}),l()}async function m(){if(!l()){const[e]=await Promise.all([import("./support/apiConverter.js"),s()]);d=e.fromPoint,g=e.fromSpatialReference,p=e.getSpatialReference}}function f(){return e(t.getLogger("esri.geometry.operators.geodeticUtilsOperator"),"load is deprecated. Use geodeticUtilsLoad instead.",{replacement:"geodeticUtilsLoad",warnOnce:!0}),m()}function U(e,t,i={}){const{curveType:s="geodesic",unit:n}=i,a=p(e),l=[0],u=[0];let m=o(g(a),d(e).getXY(),d(t).getXY(),c[s],l,u);m&&n&&(m=r(m,"meters",n));const f=e=>O(r(e,"radians","degrees"));return{distance:m,azimuth12:f(l[0]),azimuth21:f(u[0])}}function L(r,i,o={}){return e(t.getLogger("esri.geometry.operators.geodeticUtilsOperator"),"calculateDistanceAndAzimuth is deprecated. Use geodeticUtilsCalculateDistanceAndAzimuth instead.",{replacement:"geodeticUtilsCalculateDistanceAndAzimuth",warnOnce:!0}),U(r,i,o)}function y(e,t,o,s={}){const{curveType:a="geodesic",unit:l}=s;l&&(t=r(t,l,"meters"));const u=p(e),m=[d(e).getXY()];n(g(u),m,1,t,r(o,"degrees","radians"),c[a]);const f=m[0];return f.isNAN()?null:new i({x:f.x,y:f.y,spatialReference:u})}function D(r,i,o,s={}){return e(t.getLogger("esri.geometry.operators.geodeticUtilsOperator"),"pointFromDistance is deprecated. Use geodeticUtilsPointFromDistance instead.",{replacement:"geodeticUtilsPointFromDistance",warnOnce:!0}),y(r,i,o,s)}function O(e){return e<0?e+360:e}function h(r){return e(t.getLogger("esri.geometry.operators.geodeticUtilsOperator"),"shiftDegreesTo360 is deprecated. Use geodeticUtilsShiftDegreesTo360 instead.",{replacement:"geodeticUtilsShiftDegreesTo360",warnOnce:!0}),O(r)}export{L as calculateDistanceAndAzimuth,U as geodeticUtilsCalculateDistanceAndAzimuth,l as geodeticUtilsIsLoaded,m as geodeticUtilsLoad,y as geodeticUtilsPointFromDistance,O as geodeticUtilsShiftDegreesTo360,u as isLoaded,f as load,D as pointFromDistance,h as shiftDegreesTo360};

package/geometry/operators/graphicBufferOperator.d.ts

@@ -9,7 +9,7 @@ import type Polygon from "../Polygon.js";
 import type { LengthUnit } from "../../core/units.js";
 import type { GeometryUnion } from "../types.js";
 
-export interface Options {
+export interface GraphicBufferOptions {
   /**
    * The max deviation of the result buffer from the true buffer in the geometries spatial reference units.
    * When the value is NaN, internal logic is used to select the deviation based on the buffer distance.
@@ -44,12 +44,47 @@ export interface Options {
   unit?: LengthUnit;
 }
 
+/** @deprecated since 5.2 use [GraphicBufferOptions](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/graphicBufferOperator/#GraphicBufferOptions) */
+export type Options = GraphicBufferOptions;
+
+/**
+ * Creates a buffer around the input geometries, using graphical joins and caps.
+ *
+ * Both `maxDeviation` and `maxVerticesInFullCircle` control the quality of round joins that are in the buffers.
+ * The precision of each buffer is defined by `maxDeviation` unless the number of required vertices is too large.
+ *
+ * @param geometries - The input geometries to be buffered.
+ * All the geometries must have the same spatial reference.
+ * @param distances - The buffer distances for the geometries.
+ * If the size of this array is less than the number of geometries in the input `geometries`, the last distance value is used for the rest of geometries.
+ * Unless the `unit` option is set, the default is the geometries spatial reference unit.
+ * @param joins - Defines the buffers shape where geometries are joined.
+ * * Miter joins are replaced with bevel when the ratio of the miter thickness to the buffer distance is greater than miter limit. The miter thickness is the distance from the vertex to the mitered corner of the buffer that this vertex generates.
+ * @param caps - Defines the buffers shape at the end points of the geometries.
+ * * Points with square caps will be drawn as squares.
+ * * Open polylines paths with square caps degenerate to a point and will be drawn as squares (degenerate with zero tolerance).
+ * * Open polylines paths with round caps degenerate to a point and will be drawn as circles (degenerate with zero tolerance).
+ * @param options - Additional options.
+ * @returns Returns the buffered geometries.
+ * @example
+ * // Buffer two polylines with different distances and buffer styles.
+ * const buffers = graphicBufferExecuteMany(
+ *   [polyline1, polyline2],
+ *   [1000, 1500],
+ *   "square",
+ *   "round",
+ *   10,
+ * );
+ */
+export function graphicBufferExecuteMany(geometries: GeometryUnion[], distances: number[], joins: "round" | "miter" | "bevel", caps: "round" | "butt" | "square", options?: GraphicBufferOptions): Polygon[];
+
 /**
  * Creates a buffer around the input geometries, using graphical joins and caps.
  *
  * Both `maxDeviation` and `maxVerticesInFullCircle` control the quality of round joins that are in the buffers.
  * The precision of each buffer is defined by `maxDeviation` unless the number of required vertices is too large.
  *
+ * @deprecated since 5.2 use [graphicBufferExecuteMany()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/graphicBufferOperator/#graphicBufferExecuteMany)
  * @param geometries - The input geometries to be buffered.
  * All the geometries must have the same spatial reference.
  * @param distances - The buffer distances for the geometries.
@@ -65,7 +100,7 @@ export interface Options {
  * @returns Returns the buffered geometries.
  * @example
  * // Buffer two polylines with different distances and buffer styles.
- * const buffers = graphicBufferOperator.executeMany(
+ * const buffers = graphicBufferExecuteMany(
  *   [polyline1, polyline2],
  *   [1000, 1500],
  *   "square",
@@ -73,10 +108,18 @@ export interface Options {
  *   10,
  * );
  */
-export function executeMany(geometries: GeometryUnion[], distances: number[], joins: "round" | "miter" | "bevel", caps: "round" | "butt" | "square", options?: Options): Polygon[];
+export function executeMany(geometries: GeometryUnion[], distances: number[], joins: "round" | "miter" | "bevel", caps: "round" | "butt" | "square", options?: GraphicBufferOptions): Polygon[];
 
 /**
  * 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 graphicBufferSupportsCurves: 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 [graphicBufferSupportsCurves](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/graphicBufferOperator/#graphicBufferSupportsCurves)
+ */
+export const supportsCurves: ReturnType<typeof Boolean>;

package/geometry/operators/graphicBufferOperator.js

@@ -1,2 +1,2 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{isSome as r}from"../../core/arrayUtils.js";import{convertToSpatialReferenceUnit as t}from"../../core/units.js";import{supportsCurves as o,executeMany as e}from"./gx/operatorGraphicBuffer.js";import{fromGeometry as i,getSpatialReference as s,fromSpatialReference as a,toPolygon as m}from"./support/apiConverter.js";const n={round:0,miter:1,bevel:2},p={round:0,butt:1,square:2};function u(o,u,c,f,l={}){let{maxDeviation:x=NaN,maxVerticesInFullCircle:j=96,miterLimit:v=10,union:C=!1,unit:b}=l;const d=o.map(i),y=s(o);return b&&(u=u.map(r=>t(r,b,y)),x&&(x=t(x,b,y))),e(d,a(y),u,n[c],p[f],v,x,j,C).map(r=>m(r,y)).filter(r)}const c=o();export{u as executeMany,c 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{convertToSpatialReferenceUnit as o}from"../../core/units.js";import{supportsCurves as a,executeMany as i}from"./gx/operatorGraphicBuffer.js";import{fromGeometry as n,getSpatialReference as p,fromSpatialReference as s,toPolygon as c}from"./support/apiConverter.js";const u={round:0,miter:1,bevel:2},m={round:0,butt:1,square:2};function f(e,t,a,f,g={}){let{maxDeviation:l=NaN,maxVerticesInFullCircle:x=96,miterLimit:d=10,union:j=!1,unit:y}=g;const B=e.map(n),h=p(e);return y&&(t=t.map(r=>o(r,y,h)),l&&(l=o(l,y,h))),i(B,s(h),t,u[a],m[f],d,l,x,j).map(r=>c(r,h)).filter(r)}function g(r,o,a,i,n={}){return e(t.getLogger("esri.geometry.operators.graphicBufferOperator"),"executeMany is deprecated. Use graphicBufferExecuteMany instead.",{replacement:"graphicBufferExecuteMany",warnOnce:!0}),f(r,o,a,i,n)}const l=a(),x=Boolean(l);export{g as executeMany,f as graphicBufferExecuteMany,l as graphicBufferSupportsCurves,x as supportsCurves};

package/geometry/operators/integrateOperator.d.ts

@@ -18,7 +18,21 @@ import type { GeometryUnion, GeometryWithoutMeshUnion } from "../types.js";
  * The operation filters out degenerate segments and returns `null` for empty geometries.
  * @example
  * // Integrate a set of geometries
- * const result = integrateOperator.executeMany(geometries);
+ * const result = integrateExecuteMany(geometries);
+ */
+export function integrateExecuteMany(geometries: GeometryUnion[]): (GeometryWithoutMeshUnion | null | undefined)[];
+
+/**
+ * Performs the topological integration of the geometry set in the XY plane.
+ *
+ * @deprecated since 5.2 use [integrateExecuteMany()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/integrateOperator/#integrateExecuteMany)
+ * @param geometries - The set of geometries to integrate.
+ * All the geometries must have the same spatial reference.
+ * @returns Returns the result of the subtraction.
+ * The operation filters out degenerate segments and returns `null` for empty geometries.
+ * @example
+ * // Integrate a set of geometries
+ * const result = integrateExecuteMany(geometries);
  */
 export function executeMany(geometries: GeometryUnion[]): (GeometryWithoutMeshUnion | null | undefined)[];
 
@@ -26,4 +40,12 @@ export function executeMany(geometries: GeometryUnion[]): (GeometryWithoutMeshUn
  * Indicates if the operator supports input geometries that contain curves.
  * The value will always be `true`.
  */
-export const supportsCurves: boolean;
+export const integrateSupportsCurves: boolean;
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ *
+ * @deprecated since 5.2 use [integrateSupportsCurves](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/integrateOperator/#integrateSupportsCurves)
+ */
+export const supportsCurves: ReturnType<typeof Boolean>;

package/geometry/operators/integrateOperator.js

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

package/geometry/operators/intersectionOperator.d.ts

@@ -13,6 +13,15 @@ import type { GeometryUnion, GeometryWithoutMeshUnion } from "../types.js";
  * @param geometry - The geometry to accelerate.
  * @returns Returns `true` if the geometry was successfully accelerated.
  */
+export function intersectionAccelerateGeometry(geometry: GeometryUnion): boolean;
+
+/**
+ * Accelerate a geometry. This method prepares the geometry for faster intersection 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 [intersectionAccelerateGeometry()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/intersectionOperator/#intersectionAccelerateGeometry)
+ * @param geometry - The geometry to accelerate.
+ * @returns Returns `true` if the geometry was successfully accelerated.
+ */
 export function accelerateGeometry(geometry: GeometryUnion): boolean;
 
 /**
@@ -37,14 +46,54 @@ export function accelerateGeometry(geometry: GeometryUnion): boolean;
  * Point | Point | Point
  * Multipoint | Multipoint | Multipoint
  *
- * Note that two intersecting polylines will not return point geometries. Instead, this operator will return polyline paths that are equal or overlap between the two geometries. See [executyMany()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/intersectionOperator/#executeMany) to find the point intersections of two polylines.
+ * Note that two intersecting polylines will not return point geometries. Instead, this operator
+ * will return polyline paths that are equal or overlap between the two geometries. See
+ * [intersectionExecuteMany()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/intersectionOperator/#intersectionExecuteMany)
+ * to find the point intersections of two polylines.
  *
  * @param geometry1 - The geometry to intersect with  `geometry2`.
  * @param geometry2 - The geometry to intersect with `geometry1`.
  * @returns Returns the result of the intersection of the two geometries or null.
  * @example
  * // Creates a new geometry based on the intersection of two polygons
- * const intersection = intersectionOperator.execute(polygon1, polygon2);
+ * const intersection = intersectionExecute(polygon1, polygon2);
+ */
+export function intersectionExecute(geometry1: GeometryUnion, geometry2: GeometryUnion): GeometryWithoutMeshUnion | null | undefined;
+
+/**
+ * Performs the topological intersection operation on two geometries.
+ *
+ * If the input geometries have different dimensions (i.e. point = 0; polyline = 1; polygon = 2),
+ * then the result's dimension will be equal to the lowest dimension of the inputs.
+ *
+ * The table below describes the expected output for various combinations of geometry
+ * types. Note that the geometries are interchangeable in this operation
+ * and will return the same result if flipped.
+ *
+ * `geometry1` type | `geometry2` type | Result geometry type
+ * --------------|---------------------------|---------------------
+ * Polygon/Extent | Polygon/Extent | Polygon
+ * Polygon/Extent | Polyline | Polyline
+ * Polygon | Point | Point
+ * Polygon | Multipoint | Multipoint
+ * Polyline | Polyline | Polyline
+ * Polyline | Point | Point
+ * Polyline | Multipoint | Multipoint
+ * Point | Point | Point
+ * Multipoint | Multipoint | Multipoint
+ *
+ * Note that two intersecting polylines will not return point geometries. Instead, this operator
+ * will return polyline paths that are equal or overlap between the two geometries. See
+ * [intersectionExecuteMany()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/intersectionOperator/#intersectionExecuteMany)
+ * to find the point intersections of two polylines.
+ *
+ * @deprecated since 5.2 use [intersectionExecute()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/intersectionOperator/#intersectionExecute)
+ * @param geometry1 - The geometry to intersect with  `geometry2`.
+ * @param geometry2 - The geometry to intersect with `geometry1`.
+ * @returns Returns the result of the intersection of the two geometries or null.
+ * @example
+ * // Creates a new geometry based on the intersection of two polygons
+ * const intersection = intersectionExecute(polygon1, polygon2);
  */
 export function execute(geometry1: GeometryUnion, geometry2: GeometryUnion): GeometryWithoutMeshUnion | null | undefined;
 
@@ -73,10 +122,46 @@ export function execute(geometry1: GeometryUnion, geometry2: GeometryUnion): Geo
  * @returns Returns an array of geometries created by intersecting
  * every geometry in the input geometries with the `intersector`, or an empty array if there is no intersection.
  */
+export function intersectionExecuteMany(geometries: GeometryUnion[], intersector: GeometryUnion): GeometryWithoutMeshUnion[];
+
+/**
+ * Performs the topological intersection operation on the geometry set.
+ *
+ * The table below describes the potential results for various combinations of geometry
+ * types based on how they intersect. For example, a polyline that touches a polygon would return a multipoint.
+ * If the geometries do not intersect, an empty array will be returned.
+ *
+ * Input geometry type | Intersector geometry type | Result geometry types
+ * --------------|---------------------------|---------------------
+ * Point/Multipoint | Point/Multipoint | Multipoint
+ * Point/Multipoint | Polyline | Multipoint
+ * Point/Multipoint | Polygon/Extent | Multipoint
+ * Polyline | Point, Multipoint | Multipoint
+ * Polyline | Polyline | Polyline, Multipoint
+ * Polyline | Polygon/Extent | Polyline, Multipoint
+ * Polygon/Extent | Point/Multipoint | Multipoint
+ * Polygon/Extent | Polyline | Multipoint, Polyline
+ * Polygon/Extent | Polygon/Extent | Multipoint, Polyline, Polygon
+ *
+ * @deprecated since 5.2 use [intersectionExecuteMany()](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/intersectionOperator/#intersectionExecuteMany)
+ * @param geometries - The set of input geometries to be intersected by the `intersector`.
+ * All the geometries must have the same spatial reference.
+ * @param intersector - The geometry to intersect with the `geometries`.
+ * @returns Returns an array of geometries created by intersecting
+ * every geometry in the input geometries with the `intersector`, or an empty array if there is no intersection.
+ */
 export function executeMany(geometries: GeometryUnion[], intersector: GeometryUnion): GeometryWithoutMeshUnion[];
 
 /**
  * Indicates if the operator supports input geometries that contain curves.
  * The value will always be `true`.
  */
-export const supportsCurves: boolean;
+export const intersectionSupportsCurves: boolean;
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ *
+ * @deprecated since 5.2 use [intersectionSupportsCurves](https://developers.arcgis.com/javascript/latest/references/core/geometry/operators/intersectionOperator/#intersectionSupportsCurves)
+ */
+export const supportsCurves: ReturnType<typeof Boolean>;