054af09032
This updates ESLint and our shared eslint-config-openlayers to use Prettier. Most formatting changes were automatically applied with this:
npm run lint -- --fix
A few manual changes were required:
* In `examples/offscreen-canvas.js`, the `//eslint-disable-line` comment needed to be moved to the appropriate line to disable the error about the `'worker-loader!./offscreen-canvas.worker.js'` import.
* In `examples/webpack/exapmle-builder.js`, spaces could not be added after a couple `function`s for some reason. While editing this, I reworked `ExampleBuilder` to be a class.
* In `src/ol/format/WMSGetFeatureInfo.js`, the `// @ts-ignore` comment needed to be moved down one line so it applied to the `parsersNS` argument.
576 lines
18 KiB
JavaScript
576 lines
18 KiB
JavaScript
/**
|
|
* @module ol/format/EsriJSON
|
|
*/
|
|
import Feature from '../Feature.js';
|
|
import GeometryLayout from '../geom/GeometryLayout.js';
|
|
import GeometryType from '../geom/GeometryType.js';
|
|
import JSONFeature from './JSONFeature.js';
|
|
import LineString from '../geom/LineString.js';
|
|
import LinearRing from '../geom/LinearRing.js';
|
|
import MultiLineString from '../geom/MultiLineString.js';
|
|
import MultiPoint from '../geom/MultiPoint.js';
|
|
import MultiPolygon from '../geom/MultiPolygon.js';
|
|
import Point from '../geom/Point.js';
|
|
import Polygon from '../geom/Polygon.js';
|
|
import {assert} from '../asserts.js';
|
|
import {containsExtent} from '../extent.js';
|
|
import {deflateCoordinates} from '../geom/flat/deflate.js';
|
|
import {get as getProjection} from '../proj.js';
|
|
import {isEmpty} from '../obj.js';
|
|
import {linearRingIsClockwise} from '../geom/flat/orient.js';
|
|
import {transformGeometryWithOptions} from './Feature.js';
|
|
|
|
/**
|
|
* @typedef {import("arcgis-rest-api").Feature} EsriJSONFeature
|
|
* @typedef {import("arcgis-rest-api").FeatureSet} EsriJSONFeatureSet
|
|
* @typedef {import("arcgis-rest-api").Geometry} EsriJSONGeometry
|
|
* @typedef {import("arcgis-rest-api").Point} EsriJSONPoint
|
|
* @typedef {import("arcgis-rest-api").Polyline} EsriJSONPolyline
|
|
* @typedef {import("arcgis-rest-api").Polygon} EsriJSONPolygon
|
|
* @typedef {import("arcgis-rest-api").Multipoint} EsriJSONMultipoint
|
|
* @typedef {import("arcgis-rest-api").HasZM} EsriJSONHasZM
|
|
* @typedef {import("arcgis-rest-api").Position} EsriJSONPosition
|
|
* @typedef {import("arcgis-rest-api").SpatialReferenceWkid} EsriJSONSpatialReferenceWkid
|
|
*/
|
|
|
|
/**
|
|
* @typedef {Object} EsriJSONMultiPolygon
|
|
* @property {Array<Array<Array<Array<number>>>>} rings Rings for the MultiPolygon.
|
|
* @property {boolean} [hasM] If the polygon coordinates have an M value.
|
|
* @property {boolean} [hasZ] If the polygon coordinates have a Z value.
|
|
* @property {EsriJSONSpatialReferenceWkid} [spatialReference] The coordinate reference system.
|
|
*/
|
|
|
|
/**
|
|
* @const
|
|
* @type {Object<import("../geom/GeometryType.js").default, function(EsriJSONGeometry): import("../geom/Geometry.js").default>}
|
|
*/
|
|
const GEOMETRY_READERS = {};
|
|
GEOMETRY_READERS[GeometryType.POINT] = readPointGeometry;
|
|
GEOMETRY_READERS[GeometryType.LINE_STRING] = readLineStringGeometry;
|
|
GEOMETRY_READERS[GeometryType.POLYGON] = readPolygonGeometry;
|
|
GEOMETRY_READERS[GeometryType.MULTI_POINT] = readMultiPointGeometry;
|
|
GEOMETRY_READERS[GeometryType.MULTI_LINE_STRING] = readMultiLineStringGeometry;
|
|
GEOMETRY_READERS[GeometryType.MULTI_POLYGON] = readMultiPolygonGeometry;
|
|
|
|
/**
|
|
* @const
|
|
* @type {Object<string, function(import("../geom/Geometry.js").default, import("./Feature.js").WriteOptions=): (EsriJSONGeometry)>}
|
|
*/
|
|
const GEOMETRY_WRITERS = {};
|
|
GEOMETRY_WRITERS[GeometryType.POINT] = writePointGeometry;
|
|
GEOMETRY_WRITERS[GeometryType.LINE_STRING] = writeLineStringGeometry;
|
|
GEOMETRY_WRITERS[GeometryType.POLYGON] = writePolygonGeometry;
|
|
GEOMETRY_WRITERS[GeometryType.MULTI_POINT] = writeMultiPointGeometry;
|
|
GEOMETRY_WRITERS[GeometryType.MULTI_LINE_STRING] = writeMultiLineStringGeometry;
|
|
GEOMETRY_WRITERS[GeometryType.MULTI_POLYGON] = writeMultiPolygonGeometry;
|
|
|
|
/**
|
|
* @typedef {Object} Options
|
|
* @property {string} [geometryName] Geometry name to use when creating features.
|
|
*/
|
|
|
|
/**
|
|
* @classdesc
|
|
* Feature format for reading and writing data in the EsriJSON format.
|
|
*
|
|
* @api
|
|
*/
|
|
class EsriJSON extends JSONFeature {
|
|
/**
|
|
* @param {Options=} opt_options Options.
|
|
*/
|
|
constructor(opt_options) {
|
|
const options = opt_options ? opt_options : {};
|
|
|
|
super();
|
|
|
|
/**
|
|
* Name of the geometry attribute for features.
|
|
* @type {string|undefined}
|
|
* @private
|
|
*/
|
|
this.geometryName_ = options.geometryName;
|
|
}
|
|
|
|
/**
|
|
* @param {Object} object Object.
|
|
* @param {import("./Feature.js").ReadOptions=} opt_options Read options.
|
|
* @param {string=} opt_idField Name of the field where to get the id from.
|
|
* @protected
|
|
* @return {import("../Feature.js").default} Feature.
|
|
*/
|
|
readFeatureFromObject(object, opt_options, opt_idField) {
|
|
const esriJSONFeature = /** @type {EsriJSONFeature} */ (object);
|
|
const geometry = readGeometry(esriJSONFeature.geometry, opt_options);
|
|
const feature = new Feature();
|
|
if (this.geometryName_) {
|
|
feature.setGeometryName(this.geometryName_);
|
|
}
|
|
feature.setGeometry(geometry);
|
|
if (esriJSONFeature.attributes) {
|
|
feature.setProperties(esriJSONFeature.attributes, true);
|
|
const id = esriJSONFeature.attributes[opt_idField];
|
|
if (id !== undefined) {
|
|
feature.setId(/** @type {number} */ (id));
|
|
}
|
|
}
|
|
return feature;
|
|
}
|
|
|
|
/**
|
|
* @param {Object} object Object.
|
|
* @param {import("./Feature.js").ReadOptions=} opt_options Read options.
|
|
* @protected
|
|
* @return {Array<Feature>} Features.
|
|
*/
|
|
readFeaturesFromObject(object, opt_options) {
|
|
const options = opt_options ? opt_options : {};
|
|
if (object['features']) {
|
|
const esriJSONFeatureSet = /** @type {EsriJSONFeatureSet} */ (object);
|
|
/** @type {Array<import("../Feature.js").default>} */
|
|
const features = [];
|
|
const esriJSONFeatures = esriJSONFeatureSet.features;
|
|
for (let i = 0, ii = esriJSONFeatures.length; i < ii; ++i) {
|
|
features.push(
|
|
this.readFeatureFromObject(
|
|
esriJSONFeatures[i],
|
|
options,
|
|
object.objectIdFieldName
|
|
)
|
|
);
|
|
}
|
|
return features;
|
|
} else {
|
|
return [this.readFeatureFromObject(object, options)];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {EsriJSONGeometry} object Object.
|
|
* @param {import("./Feature.js").ReadOptions=} opt_options Read options.
|
|
* @protected
|
|
* @return {import("../geom/Geometry.js").default} Geometry.
|
|
*/
|
|
readGeometryFromObject(object, opt_options) {
|
|
return readGeometry(object, opt_options);
|
|
}
|
|
|
|
/**
|
|
* @param {Object} object Object.
|
|
* @protected
|
|
* @return {import("../proj/Projection.js").default} Projection.
|
|
*/
|
|
readProjectionFromObject(object) {
|
|
if (
|
|
object['spatialReference'] &&
|
|
object['spatialReference']['wkid'] !== undefined
|
|
) {
|
|
const spatialReference = /** @type {EsriJSONSpatialReferenceWkid} */ (object[
|
|
'spatialReference'
|
|
]);
|
|
const crs = spatialReference.wkid;
|
|
return getProjection('EPSG:' + crs);
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Encode a geometry as a EsriJSON object.
|
|
*
|
|
* @param {import("../geom/Geometry.js").default} geometry Geometry.
|
|
* @param {import("./Feature.js").WriteOptions=} opt_options Write options.
|
|
* @return {EsriJSONGeometry} Object.
|
|
* @api
|
|
*/
|
|
writeGeometryObject(geometry, opt_options) {
|
|
return writeGeometry(geometry, this.adaptOptions(opt_options));
|
|
}
|
|
|
|
/**
|
|
* Encode a feature as a esriJSON Feature object.
|
|
*
|
|
* @param {import("../Feature.js").default} feature Feature.
|
|
* @param {import("./Feature.js").WriteOptions=} opt_options Write options.
|
|
* @return {Object} Object.
|
|
* @api
|
|
*/
|
|
writeFeatureObject(feature, opt_options) {
|
|
opt_options = this.adaptOptions(opt_options);
|
|
const object = {};
|
|
const geometry = feature.getGeometry();
|
|
if (geometry) {
|
|
object['geometry'] = writeGeometry(geometry, opt_options);
|
|
if (opt_options && opt_options.featureProjection) {
|
|
object['geometry'][
|
|
'spatialReference'
|
|
] = /** @type {EsriJSONSpatialReferenceWkid} */ ({
|
|
wkid: Number(
|
|
getProjection(opt_options.featureProjection)
|
|
.getCode()
|
|
.split(':')
|
|
.pop()
|
|
),
|
|
});
|
|
}
|
|
}
|
|
const properties = feature.getProperties();
|
|
delete properties[feature.getGeometryName()];
|
|
if (!isEmpty(properties)) {
|
|
object['attributes'] = properties;
|
|
} else {
|
|
object['attributes'] = {};
|
|
}
|
|
return object;
|
|
}
|
|
|
|
/**
|
|
* Encode an array of features as a EsriJSON object.
|
|
*
|
|
* @param {Array<import("../Feature.js").default>} features Features.
|
|
* @param {import("./Feature.js").WriteOptions=} opt_options Write options.
|
|
* @return {EsriJSONFeatureSet} EsriJSON Object.
|
|
* @api
|
|
*/
|
|
writeFeaturesObject(features, opt_options) {
|
|
opt_options = this.adaptOptions(opt_options);
|
|
const objects = [];
|
|
for (let i = 0, ii = features.length; i < ii; ++i) {
|
|
objects.push(this.writeFeatureObject(features[i], opt_options));
|
|
}
|
|
return {
|
|
'features': objects,
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {EsriJSONGeometry} object Object.
|
|
* @param {import("./Feature.js").ReadOptions=} opt_options Read options.
|
|
* @return {import("../geom/Geometry.js").default} Geometry.
|
|
*/
|
|
function readGeometry(object, opt_options) {
|
|
if (!object) {
|
|
return null;
|
|
}
|
|
/** @type {import("../geom/GeometryType.js").default} */
|
|
let type;
|
|
if (typeof object['x'] === 'number' && typeof object['y'] === 'number') {
|
|
type = GeometryType.POINT;
|
|
} else if (object['points']) {
|
|
type = GeometryType.MULTI_POINT;
|
|
} else if (object['paths']) {
|
|
const esriJSONPolyline = /** @type {EsriJSONPolyline} */ (object);
|
|
if (esriJSONPolyline.paths.length === 1) {
|
|
type = GeometryType.LINE_STRING;
|
|
} else {
|
|
type = GeometryType.MULTI_LINE_STRING;
|
|
}
|
|
} else if (object['rings']) {
|
|
const esriJSONPolygon = /** @type {EsriJSONPolygon} */ (object);
|
|
const layout = getGeometryLayout(esriJSONPolygon);
|
|
const rings = convertRings(esriJSONPolygon.rings, layout);
|
|
if (rings.length === 1) {
|
|
type = GeometryType.POLYGON;
|
|
object = Object.assign({}, object, {['rings']: rings[0]});
|
|
} else {
|
|
type = GeometryType.MULTI_POLYGON;
|
|
object = Object.assign({}, object, {['rings']: rings});
|
|
}
|
|
}
|
|
const geometryReader = GEOMETRY_READERS[type];
|
|
return transformGeometryWithOptions(
|
|
geometryReader(object),
|
|
false,
|
|
opt_options
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Determines inner and outer rings.
|
|
* Checks if any polygons in this array contain any other polygons in this
|
|
* array. It is used for checking for holes.
|
|
* Logic inspired by: https://github.com/Esri/terraformer-arcgis-parser
|
|
* @param {Array<!Array<!Array<number>>>} rings Rings.
|
|
* @param {import("../geom/GeometryLayout.js").default} layout Geometry layout.
|
|
* @return {Array<!Array<!Array<!Array<number>>>>} Transformed rings.
|
|
*/
|
|
function convertRings(rings, layout) {
|
|
const flatRing = [];
|
|
const outerRings = [];
|
|
const holes = [];
|
|
let i, ii;
|
|
for (i = 0, ii = rings.length; i < ii; ++i) {
|
|
flatRing.length = 0;
|
|
deflateCoordinates(flatRing, 0, rings[i], layout.length);
|
|
// is this ring an outer ring? is it clockwise?
|
|
const clockwise = linearRingIsClockwise(
|
|
flatRing,
|
|
0,
|
|
flatRing.length,
|
|
layout.length
|
|
);
|
|
if (clockwise) {
|
|
outerRings.push([rings[i]]);
|
|
} else {
|
|
holes.push(rings[i]);
|
|
}
|
|
}
|
|
while (holes.length) {
|
|
const hole = holes.shift();
|
|
let matched = false;
|
|
// loop over all outer rings and see if they contain our hole.
|
|
for (i = outerRings.length - 1; i >= 0; i--) {
|
|
const outerRing = outerRings[i][0];
|
|
const containsHole = containsExtent(
|
|
new LinearRing(outerRing).getExtent(),
|
|
new LinearRing(hole).getExtent()
|
|
);
|
|
if (containsHole) {
|
|
// the hole is contained push it into our polygon
|
|
outerRings[i].push(hole);
|
|
matched = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!matched) {
|
|
// no outer rings contain this hole turn it into and outer
|
|
// ring (reverse it)
|
|
outerRings.push([hole.reverse()]);
|
|
}
|
|
}
|
|
return outerRings;
|
|
}
|
|
|
|
/**
|
|
* @param {EsriJSONPoint} object Object.
|
|
* @return {import("../geom/Geometry.js").default} Point.
|
|
*/
|
|
function readPointGeometry(object) {
|
|
let point;
|
|
if (object.m !== undefined && object.z !== undefined) {
|
|
point = new Point(
|
|
[object.x, object.y, object.z, object.m],
|
|
GeometryLayout.XYZM
|
|
);
|
|
} else if (object.z !== undefined) {
|
|
point = new Point([object.x, object.y, object.z], GeometryLayout.XYZ);
|
|
} else if (object.m !== undefined) {
|
|
point = new Point([object.x, object.y, object.m], GeometryLayout.XYM);
|
|
} else {
|
|
point = new Point([object.x, object.y]);
|
|
}
|
|
return point;
|
|
}
|
|
|
|
/**
|
|
* @param {EsriJSONPolyline} object Object.
|
|
* @return {import("../geom/Geometry.js").default} LineString.
|
|
*/
|
|
function readLineStringGeometry(object) {
|
|
const layout = getGeometryLayout(object);
|
|
return new LineString(object.paths[0], layout);
|
|
}
|
|
|
|
/**
|
|
* @param {EsriJSONPolyline} object Object.
|
|
* @return {import("../geom/Geometry.js").default} MultiLineString.
|
|
*/
|
|
function readMultiLineStringGeometry(object) {
|
|
const layout = getGeometryLayout(object);
|
|
return new MultiLineString(object.paths, layout);
|
|
}
|
|
|
|
/**
|
|
* @param {EsriJSONHasZM} object Object.
|
|
* @return {import("../geom/GeometryLayout.js").default} The geometry layout to use.
|
|
*/
|
|
function getGeometryLayout(object) {
|
|
let layout = GeometryLayout.XY;
|
|
if (object.hasZ === true && object.hasM === true) {
|
|
layout = GeometryLayout.XYZM;
|
|
} else if (object.hasZ === true) {
|
|
layout = GeometryLayout.XYZ;
|
|
} else if (object.hasM === true) {
|
|
layout = GeometryLayout.XYM;
|
|
}
|
|
return layout;
|
|
}
|
|
|
|
/**
|
|
* @param {EsriJSONMultipoint} object Object.
|
|
* @return {import("../geom/Geometry.js").default} MultiPoint.
|
|
*/
|
|
function readMultiPointGeometry(object) {
|
|
const layout = getGeometryLayout(object);
|
|
return new MultiPoint(object.points, layout);
|
|
}
|
|
|
|
/**
|
|
* @param {EsriJSONMultiPolygon} object Object.
|
|
* @return {import("../geom/Geometry.js").default} MultiPolygon.
|
|
*/
|
|
function readMultiPolygonGeometry(object) {
|
|
const layout = getGeometryLayout(object);
|
|
return new MultiPolygon(object.rings, layout);
|
|
}
|
|
|
|
/**
|
|
* @param {EsriJSONPolygon} object Object.
|
|
* @return {import("../geom/Geometry.js").default} Polygon.
|
|
*/
|
|
function readPolygonGeometry(object) {
|
|
const layout = getGeometryLayout(object);
|
|
return new Polygon(object.rings, layout);
|
|
}
|
|
|
|
/**
|
|
* @param {import("../geom/Point.js").default} geometry Geometry.
|
|
* @param {import("./Feature.js").WriteOptions=} opt_options Write options.
|
|
* @return {EsriJSONPoint} EsriJSON geometry.
|
|
*/
|
|
function writePointGeometry(geometry, opt_options) {
|
|
const coordinates = geometry.getCoordinates();
|
|
/** @type {EsriJSONPoint} */
|
|
let esriJSON;
|
|
const layout = geometry.getLayout();
|
|
if (layout === GeometryLayout.XYZ) {
|
|
esriJSON = {
|
|
x: coordinates[0],
|
|
y: coordinates[1],
|
|
z: coordinates[2],
|
|
};
|
|
} else if (layout === GeometryLayout.XYM) {
|
|
esriJSON = {
|
|
x: coordinates[0],
|
|
y: coordinates[1],
|
|
m: coordinates[2],
|
|
};
|
|
} else if (layout === GeometryLayout.XYZM) {
|
|
esriJSON = {
|
|
x: coordinates[0],
|
|
y: coordinates[1],
|
|
z: coordinates[2],
|
|
m: coordinates[3],
|
|
};
|
|
} else if (layout === GeometryLayout.XY) {
|
|
esriJSON = {
|
|
x: coordinates[0],
|
|
y: coordinates[1],
|
|
};
|
|
} else {
|
|
assert(false, 34); // Invalid geometry layout
|
|
}
|
|
return esriJSON;
|
|
}
|
|
|
|
/**
|
|
* @param {import("../geom/SimpleGeometry.js").default} geometry Geometry.
|
|
* @return {Object} Object with boolean hasZ and hasM keys.
|
|
*/
|
|
function getHasZM(geometry) {
|
|
const layout = geometry.getLayout();
|
|
return {
|
|
hasZ: layout === GeometryLayout.XYZ || layout === GeometryLayout.XYZM,
|
|
hasM: layout === GeometryLayout.XYM || layout === GeometryLayout.XYZM,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {import("../geom/LineString.js").default} lineString Geometry.
|
|
* @param {import("./Feature.js").WriteOptions=} opt_options Write options.
|
|
* @return {EsriJSONPolyline} EsriJSON geometry.
|
|
*/
|
|
function writeLineStringGeometry(lineString, opt_options) {
|
|
const hasZM = getHasZM(lineString);
|
|
return {
|
|
hasZ: hasZM.hasZ,
|
|
hasM: hasZM.hasM,
|
|
paths: [
|
|
/** @type {Array<EsriJSONPosition>} */ (lineString.getCoordinates()),
|
|
],
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {import("../geom/Polygon.js").default} polygon Geometry.
|
|
* @param {import("./Feature.js").WriteOptions=} opt_options Write options.
|
|
* @return {EsriJSONPolygon} EsriJSON geometry.
|
|
*/
|
|
function writePolygonGeometry(polygon, opt_options) {
|
|
// Esri geometries use the left-hand rule
|
|
const hasZM = getHasZM(polygon);
|
|
return {
|
|
hasZ: hasZM.hasZ,
|
|
hasM: hasZM.hasM,
|
|
rings: /** @type {Array<Array<EsriJSONPosition>>} */ (polygon.getCoordinates(
|
|
false
|
|
)),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {import("../geom/MultiLineString.js").default} multiLineString Geometry.
|
|
* @param {import("./Feature.js").WriteOptions=} opt_options Write options.
|
|
* @return {EsriJSONPolyline} EsriJSON geometry.
|
|
*/
|
|
function writeMultiLineStringGeometry(multiLineString, opt_options) {
|
|
const hasZM = getHasZM(multiLineString);
|
|
return {
|
|
hasZ: hasZM.hasZ,
|
|
hasM: hasZM.hasM,
|
|
paths: /** @type {Array<Array<EsriJSONPosition>>} */ (multiLineString.getCoordinates()),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {import("../geom/MultiPoint.js").default} multiPoint Geometry.
|
|
* @param {import("./Feature.js").WriteOptions=} opt_options Write options.
|
|
* @return {EsriJSONMultipoint} EsriJSON geometry.
|
|
*/
|
|
function writeMultiPointGeometry(multiPoint, opt_options) {
|
|
const hasZM = getHasZM(multiPoint);
|
|
return {
|
|
hasZ: hasZM.hasZ,
|
|
hasM: hasZM.hasM,
|
|
points: /** @type {Array<EsriJSONPosition>} */ (multiPoint.getCoordinates()),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {import("../geom/MultiPolygon.js").default} geometry Geometry.
|
|
* @param {import("./Feature.js").WriteOptions=} opt_options Write options.
|
|
* @return {EsriJSONPolygon} EsriJSON geometry.
|
|
*/
|
|
function writeMultiPolygonGeometry(geometry, opt_options) {
|
|
const hasZM = getHasZM(geometry);
|
|
const coordinates = geometry.getCoordinates(false);
|
|
const output = [];
|
|
for (let i = 0; i < coordinates.length; i++) {
|
|
for (let x = coordinates[i].length - 1; x >= 0; x--) {
|
|
output.push(coordinates[i][x]);
|
|
}
|
|
}
|
|
return {
|
|
hasZ: hasZM.hasZ,
|
|
hasM: hasZM.hasM,
|
|
rings: /** @type {Array<Array<EsriJSONPosition>>} */ (output),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {import("../geom/Geometry.js").default} geometry Geometry.
|
|
* @param {import("./Feature.js").WriteOptions=} opt_options Write options.
|
|
* @return {EsriJSONGeometry} EsriJSON geometry.
|
|
*/
|
|
function writeGeometry(geometry, opt_options) {
|
|
const geometryWriter = GEOMETRY_WRITERS[geometry.getType()];
|
|
return geometryWriter(
|
|
transformGeometryWithOptions(geometry, true, opt_options),
|
|
opt_options
|
|
);
|
|
}
|
|
|
|
export default EsriJSON;
|