WebDocument2D

AMD: require(["esri/WebDocument2D"], (WebDocument2D) => { /* code goes here */ });
ESM: import WebDocument2D from "@arcgis/core/WebDocument2D.js";
Class: esri/WebDocument2D
Inheritance: WebDocument2DMapAccessor
Subclasses: WebLinkChart , WebMap
Since: ArcGIS Maps SDK for JavaScript 4.31

WebDocument2D is the base class for all 2D web documents. To construct 2D documents see WebMap and WebLinkChart.

See also

Property Overview

Any properties can be set, retrieved or listened to. See the Working with Properties topic.
Show inherited properties Hide inherited properties
Name Type Summary Class

A flattened collection of all layers in the map.

Map

A flattened collection of tables anywhere in the map's hierarchy.

Map

The applicationProperties contains the viewing properties of the WebMap.

WebDocument2D

The name of the application that authored the WebMap.

WebDocument2D

The version of the application that authored the WebMap.

WebDocument2D

Specifies a basemap for the map.

Map

An array of saved geographic extents that allow end users to quickly navigate to a particular area of interest.

WebDocument2D

The name of the class.

Accessor

A collection of editable layers.

Map

When a web map is configured as floor-aware, it has a floorInfo property defined.

WebDocument2D

Specifies the surface properties for the map.

Map

The initial view of the WebMap.

WebDocument2D

A collection of operational layers.

Map

The Error object returned if an error occurred while loading.

WebDocument2D

Represents the status of a load operation.

WebDocument2D

Indicates whether the instance has loaded.

WebDocument2D

The portal item from which the WebMap is loaded.

WebDocument2D

A collection of layer instances that are tables saved in a Map and/or a WebMap.

Map

The URL to the thumbnail used for the webmap.

WebDocument2D

The widgets object contains widgets that are exposed to the user.

WebDocument2D

Property Details

allLayers

Inherited
Property
allLayers Collection<Layer>readonly
Inherited from Map

A flattened collection of all layers in the map. This collection contains basemap layers, operational layers and ground layers. Group Layers and their children layers are also part of this collection. Reference layers in the basemap will always be included at the end of the collection.

Layers should not be added directly to this collection. They must only be added via the layers, basemap or ground properties.

To access a flattened collection of tables, use the allTables property instead.

Example
// Find a layer with title "US Counties"
const foundLayer = map.allLayers.find(function(layer) {
 return layer.title === "US Counties";
});

// Create a filtered collection of the non-group layers
const nonGroupLayers = map.allLayers.filter(function(layer) {
 return !foundLayer.layers;
});

// Listen for any layer being added or removed in the Map
map.allLayers.on("change", function(event) {
 console.log("Layer added: ", event.added);
 console.log("Layer removed: ", event.removed);
 console.log("Layer moved: ", event.moved);
});

// Watching for changes to the visible layers in the Map
reactiveUtils.watch(
  () => view.map.allLayers.filter((layer) => layer.visible),
  (newVisibleLayers, oldVisibleLayers) => {
    const added = newVisibleLayers.filter(
      (layer) => !oldVisibleLayers.includes(layer)
    );
    const removed = oldVisibleLayers.filter(
      (layer) => !newVisibleLayers.includes(layer)
    );
    added.forEach((layer) => console.log(layer.title, "is visible"));
    removed.forEach((layer) => console.log(layer.title, "is not visible"));
  }
);

allTables

Inherited
Property
allTables Collection<Layer>readonly
Inherited from Map

A flattened collection of tables anywhere in the map's hierarchy. This will contain individual tables within the map's tables, in addition to any group layer tables. In order for the table(s) to be recognized as such, the FeatureLayer property must return true.

  • Currently, only feature layer tables are recognized.
  • To access spatial layers, use the allLayers property instead.
Example
// A feature layer where isTable = true.
const foundTable = map.allTables.find(function(table) {
  // Find a table with title "US Counties"
  return table.title === "US Counties";
});

applicationProperties

Property
applicationProperties ApplicationProperties

The applicationProperties contains the viewing properties of the WebMap.

authoringApp

Property
authoringApp String

The name of the application that authored the WebMap.

authoringAppVersion

Property
authoringAppVersion String

The version of the application that authored the WebMap.

basemap

Inherited
Property
basemap Basemapautocast
Inherited from Map
Autocasts from String|Object

Specifies a basemap for the map. The basemap is a set of layers that give geographic context to the MapView or SceneView and the other operational layers in the map.

The basemap can be created in a variety of ways:

  1. From the basemap styles service (v2)
  2. From an instance of the Basemap class
  3. From a basemap id

Use of these basemaps requires either an ArcGIS Location Platform account, ArcGIS Online organizational subscription, or an ArcGIS Enterprise license.

To authenticate basemap requests, you may need an access token. You can use an API key or OAuth 2.0. When using an API key, the key must have privileges to access the appropriate location service.

Basemap Id

3D

Since version 4.28

The 3D Basemaps can be accessed using the basemap id in the table below. They are designed to be used as basemaps in SceneView.

Value Source
topo-3d Topographic
navigation-3d Navigation
navigation-dark-3d Navigation (Dark)
osm-3d OpenStreetMap
gray-3d Light Gray Canvas
dark-gray-3d Dark Gray Canvas
streets-3d Streets
streets-dark-3d Streets (Dark)

Known Limitations

2D (legacy)

Since version 4.0

The legacy basemaps can be accessed using the basemap id in the table below. These are references to enhanced basemap endpoints.

Value Source
satellite World Imagery
hybrid Hybrid Reference Layer and World Imagery
oceans World Ocean Reference and World Ocean Base
osm OpenStreetMapLayer
terrain World Reference Overlay and World Terrain Base
dark-gray / dark-gray-vector Dark Gray Canvas
gray / gray-vector Light Gray Canvas
streets / streets-vector World Street Map
streets-night-vector World Street Map (Night)
streets-navigation-vector World Navigation Map
topo / topo-vector World Hillshade and World Topographic Map
streets-relief-vector World Hillshade and World Street Map (with Relief)
Examples
// create the basemap from a string id representing the basemap style
const map = new Map({
  basemap: "osm/blueprint"
});

// create the basemap from a BasemapStyle object
const map = new Map({
 basemap: {
  style: {
   id:  "arcgis/outdoor",
   language: "es" // place labels will be displayed in spanish
  }
 }
});
// Set the basemap from a string ID in the constructor
const map = new Map({
  basemap: "dark-gray-3d"
});

// Set the basemap after the map instance is created
map.basemap = "topo-3d";
// Create a VectorTileLayer from a style URL
const mapBaseLayer = new VectorTileLayer({
  url: "https://arcgis.com/sharing/rest/content/items/b5676525747f499687f12746441101ef/resources/styles/root.json"
});

// Create a Basemap with the VectorTileLayer
const customBasemap = new Basemap({
  baseLayers: [mapBaseLayer],
  title: "Terrain"
});

// Set the basemap to the customBasemap
const map = new Map({
  basemap: customBasemap
});

bookmarks

Property
bookmarks Collection<Bookmark>autocast

An array of saved geographic extents that allow end users to quickly navigate to a particular area of interest.

declaredClass

Inherited
Property
declaredClass Stringreadonly
Inherited from Accessor

The name of the class. The declared class name is formatted as esri.folder.className.

editableLayers

Inherited
Property
editableLayers Collection<(FeatureLayer|SceneLayer|SubtypeGroupLayer|GeoJSONLayer|OrientedImageryLayer)>readonly
Inherited from Map

A collection of editable layers. Layers are considered editable if they have editing capabilities, and if the authenticated user has the necessary privileges needed to edit the layers.

floorInfo

Property
floorInfo MapFloorInfoautocast

When a web map is configured as floor-aware, it has a floorInfo property defined. A floor-aware map is a map that contains indoor GIS data representing floor plan features. The floor info must contain levelLayer and facilityLayer properties at a minimum. The siteLayer property is optional.

ground

Inherited
Property
ground Groundautocast
Inherited from Map
Autocasts from String|Object

Specifies the surface properties for the map. In MapView, this property is used by the ElevationProfile widget when the profile contains an ElevationProfileLineGround. In 3D SceneView, it renders the terrain or topographical variations in the real world on the map's surface with a collection of ElevationLayers.

This value can be an instance of Ground, or one of the following strings:

  • world-elevation for a default instance of ground using the Terrain3D Service.
  • world-topobathymetry for an instance of ground that combines surface elevation and bathymetry using the TopoBathy3D Service.

The ground may not be set to null or undefined, it is guaranteed to always contain an instance of type Ground. The elevation can be removed from the ground by setting the ground property to a new empty Ground instance or by removing all the ground layers.

Examples
// Use the world elevation service
const map = new Map({
  basemap: "topo-vector",
  ground: "world-elevation"
});
// Create a map with the world elevation layer overlaid by a custom elevation layer
const worldElevation = new ElevationLayer({
  url: "//elevation3d.arcgis.com/arcgis/rest/services/WorldElevation3D/Terrain3D/ImageServer"
});
const customElevation = new ElevationLayer({
  url: "https://my.server.com/arcgis/rest/service/MyElevationService/ImageServer"
});
const map = new Map({
  basemap: "topo-vector",
  ground: new Ground({
   layers: [ worldElevation, customElevation ]
  })
});

initialViewProperties

Property
initialViewProperties InitialViewPropertiesautocast

The initial view of the WebMap. This object contains properties such as viewpoint, spatialReference, that will be applied to the view when the WebMap loads.

layers

Inherited
Property
layers Collection<Layer>autocast
Inherited from Map
Autocasts from Layer[]

A collection of operational layers. This property contains the operational layers, such as FeatureLayers, WebTileLayers and GraphicsLayers that may be queried, assigned different renderers, analyzed, etc. It does not include basemaps.

A layer is a collection of one or more features, or graphics, that represent real-world phenomena. Each feature contains a symbol and geographic data that allows it to be rendered on the map as a graphic with spatial context. Features within the layer may also contain data attributes that provide additional information that may be viewed in popup windows and used for rendering the layer.

Layers may be added in the constructor, with the add() or addMany() methods, or directly to the layers collection using add() or addMany().

In 3D, for layers that are rendered on the terrain, the order of the layers also depends on the type of layer. Tiled layers (BaseTileLayer, ImageryTileLayer, OpenStreetMapLayer, TileLayer, VectorTileLayer, WCSLayer, WebTileLayer and WMTSLayer) are always drawn first in the same order as specified in the layer collection. Dynamic layers (MapImageLayer, ImageryLayer, WMSLayer, and feature based layers with elevation mode on-the-ground) are rendered on top using the order from the layer collection.

A layer may only be added to one parent. Adding the same layer to multiple Maps or GroupLayers is not possible. If you attempt to do so, the layer will automatically be removed from its current parent and placed in the new parent.

let layer = new GraphicsLayer();
// The layer belongs to map1
map1.layers.add(layer);
// The layer now belongs to map2
// and implicitly does: map1.layers.remove(layer)
map2.layers.add(layer);

To access tables from feature layers, use the tables property in either Map or WebMap classes.

Example
// Add layers in the constructor of Map using an array
let fl = new FeatureLayer(url);
let gl = new GraphicsLayer();
let map = new Map({
  layers: [fl, gl]
});

// Add layers using add()
map.addMany([fl, gl]);

// Add layers using layers collection
map.layers.addMany([fl, gl]);

// Add layers using layers collection's push method
map.layers.push(fl, gl);

loadError

Property
loadError Errorreadonly

The Error object returned if an error occurred while loading.

Default Value:null

loadStatus

Property
loadStatus Stringreadonly

Represents the status of a load operation.

Value Description
not-loaded The object's resources have not loaded.
loading The object's resources are currently loading.
loaded The object's resources have loaded without errors.
failed The object's resources failed to load. See loadError for more details.

Possible Values:"not-loaded" |"loading" |"failed" |"loaded"

Default Value:"not-loaded"

loaded

Property
loaded Booleanreadonly

Indicates whether the instance has loaded. When true, the properties of the object can be accessed. A WebMap is considered loaded when its layers and basemap are created, but not yet loaded.

Default Value:false

portalItem

Property
portalItem PortalItemautocast

The portal item from which the WebMap is loaded.

tables

Inherited
Property
tables Collection<Layer>autocast
Inherited from Map
Autocasts from Layer[]

A collection of layer instances that are tables saved in a Map and/or a WebMap. In order for the table(s) to be recognized as such, the FeatureLayer's isTable property must return true. A table can be created via one of the options below:

  • Referencing the URL to a table in a feature service.
  • Create a feature layer using the Layer.fromArcGISServerUrl method and confirm that it is a table using feature layer's isTable property. This can be either a feature service or feature collection.
  • Create a feature layer using the Layer.fromPortalItem method and confirm that it is a table using feature layer's isTable property. This can be either a feature service or feature collection.
  • Create an in-memory, non-spatial, client-side feature layer.

Beginning with 4.17, it is possible to persist non-spatial, tables in a feature service to a WebMap, although in-memory (feature collection) tables are not yet supported.

Persisting tables within a GroupLayer is not yet supported. If this is needed, add them to the Map and/or WebMap.

  • Currently, only feature service feature layers are recognized.
  • To access spatial layers, use the layers property in either Map or WebMap classes
Examples
// This snippet shows how to add a table to a map's table collection.

// FeatureLayer.isTable = false
const featureLayer = new FeatureLayer({
  url: "https://sampleserver6.arcgisonline.com/arcgis/rest/services/SF311/FeatureServer/0"
});

// FeatureLayer.isTable = true
const table = new FeatureLayer({
  url: "https://sampleserver6.arcgisonline.com/arcgis/rest/services/SF311/FeatureServer/1"
});

// Add featureLayer to the map
map.add(featureLayer);

// In order for the table to be stored within
// the map's table collection, load it and confirm it is the right type.

table.load().then(() => {
  // Add the table to the collection
  map.tables.add(table);
  console.log("Table is added to map's table collection");
});
// This snippet shows how to persist a table to an existing web map

// FeatureLayer.isTable = true
const table = new FeatureLayer({
  url: "https://services.arcgis.com/V6ZHFr6zdgNZuVG0/arcgis/rest/services/Crash_details_table/FeatureServer/0"
});

// Create Webmap instance
const webmap = new WebMap({
  portalItem: {
    id: webmapId
  }
});

// When web map is ready, load the table and add it to the web map
webmap.when(() => {
  table.load().then(() => {
    console.log("Adding table");
    // Add table to the webmap's table collection
    webmap.tables.add(table);
  });
});

// Call updateFrom on webmap and pass in the existing view
webmap.updateFrom(view).then(() => {
  // Call saveAs (or save) on the web map
  webmap.saveAs({
    // autocasts as new PortalItem()
    title: "New WebMap"
  });
});
// This snippet shows how to add an in-memory table to a map

// Create the array of objects containing field info
const fields = [{
  name: "ObjectID",
  alias: "ObjectID",
  type: "oid"
},
{
  name: "tree_type",
  alias: "Tree type",
  type: "string"
},
{
  name: "species",
  alias: "Species",
  type: "string"
}];

// Create the array of graphics holding attribute info
const graphics = [{
  attributes: {
    "tree_type": "deciduous",
    "species": "maple",
    "ObjectID": 2
  }
}, {
  attributes: {
    "tree_type": "coniferous",
    "species": "pine",
    "ObjectID": 3
  }
}];

// Create the feature layer (feature collection) table
const table = new FeatureLayer({
  fields: fields,
  objectIdField: "ObjectID",
  source: graphics
});

// Check when map is ready and load the table
map.when(() => {
  table.load().then(() => {
    console.log("Adding table");
    map.tables.add(table);
  });
});

thumbnailUrl

Property
thumbnailUrl String

The URL to the thumbnail used for the webmap. The thumbnailUrl will default to the thumbnail URL from the portal item associated to the webmap. The thumbnail of the webmap may be updated by changing the thumbnail URL and saving the webmap. Use updateFrom to update the thumbnail automatically from a specified view.

Example
webmap.updateFrom(view)
  .then(function() {
    return webmap.save();
  })
  // thumbnail will be updated based on current extent of webmap
  .then(function(portalItem) {
    console.log("Saved to portal", portalItem.id);
  })
  .catch(function(error) {
    console.error("Error saving to portal", error);
  });

widgets

Property
widgets Widgets

The widgets object contains widgets that are exposed to the user.

Method Overview

Show inherited methods Hide inherited methods
Name Return Type Summary Class

Adds a layer to the layers collection.

Map

Adds one or more handles which are to be tied to the lifecycle of the object.

Accessor

Adds a layer or an array of layers to the layers collection.

Map

Destroys the webmap, and any associated resources, including its layers, basemap, ground, tables, and portalItem.

WebDocument2D

Returns a layer based on the given layer ID.

Map

Returns a table based on the given table ID.

Map

Returns true if a named group of handles exist.

Accessor

isFulfilled() may be used to verify if creating an instance of the class is fulfilled (either resolved or rejected).

WebDocument2D

isRejected() may be used to verify if creating an instance of the class is rejected.

WebDocument2D

isResolved() may be used to verify if creating an instance of the class is resolved.

WebDocument2D
Promise

Triggers the loading of the WebMap instance.

WebDocument2D
Promise<WebMap>

Loads all the externally loadable resources associated with the webmap.

WebDocument2D

Removes the specified layer from the layers collection.

Map

Removes all layers.

Map

Removes a group of handles owned by the object.

Accessor

Removes the specified layers.

Map

Changes the layer order.

Map
Promise

Update properties of the WebMap related to the view.

WebDocument2D
Promise

when() may be leveraged once an instance of the class is created.

WebDocument2D

Method Details

add

Inherited
Method
add(layer, index)
Inherited from Map

Adds a layer to the layers collection. The before-changes, before-add, after-add, after-changes and change events will be emitted when this method is called.

Parameters
layer Layer|Promise

Layer or a promise that resolves to a layer to add to the layers collection.

index Number
optional

A layer can be added at a specified index in the layers collection. If no index is specified or the index specified is greater than the current number of layers, the layer is automatically appended to the list of layers in the layers collection and the index is normalized.

Example
// add() and push methods can be used
// to add a layer to layers collection

// add a layer to layers collection using add
map.add(layer);

// add a layer at the end of layers collection
map.layers.push(layer);

addHandles

Inherited
Method
addHandles(handleOrHandles, groupKey)
Inherited from Accessor

Adds one or more handles which are to be tied to the lifecycle of the object. The handles will be removed when the object is destroyed.

// Manually manage handles
const handle = reactiveUtils.when(
  () => !view.updating,
  () => {
    wkidSelect.disabled = false;
  },
  { once: true }
);

this.addHandles(handle);

// Destroy the object
this.destroy();
Parameters
handleOrHandles WatchHandle|WatchHandle[]

Handles marked for removal once the object is destroyed.

groupKey *
optional

Key identifying the group to which the handles should be added. All the handles in the group can later be removed with Accessor.removeHandles(). If no key is provided the handles are added to a default group.

addMany

Inherited
Method
addMany(layers, index)
Inherited from Map

Adds a layer or an array of layers to the layers collection. The before-changes, before-add, after-add, after-changes and change events will be emitted when this method is called.

The push() method on the layers collection also can be used to add a layer or layers.

Parameters
layers Layer[]

Layer(s) to be added to the layers collection.

index Number
optional

A layer can be added at a specified index in the layers collection. If no index is specified or the index specified is greater than the current number of layers, the layer is automatically appended to the list of layers in the layers collection and the index is normalized.

Example
// addMany and push methods can be used
// to add layers to layers collection

// add an array of layers to layers collection using addMany
map.addMany([layer, layer2]);

// add layers to layers collection using push method
map.layers.push(layer, layer2);

destroy

Method
destroy()

Destroys the webmap, and any associated resources, including its layers, basemap, ground, tables, and portalItem. These can no longer be used once the map has been destroyed. To prevent these objects from being destroyed, remove them from the webmap before calling destroy().

// prevent the layers from being destroyed by removing them from the webmap
const layers = webmap.layers.removeAll();

// prevent the tables from being destroyed by removing them from the webmap
const tables = webmap.tables.removeAll();

// unset basemap from the webmap so that it is not destroyed
const basemap = webmap.basemap;
webmap.basemap = null;

// unset portalItem from the webmap so that it is not destroyed
const portalItem = webmap.portalItem;
webmap.portalItem = null;

// prevent the utility networks from being destroyed by removing them from the webmap
const networks = webmap.utilityNetworks.removeAll();

// destroy the webmap and any remaining associated resources
webmap.destroy();

findLayerById

Inherited
Method
findLayerById(layerId){Layer}
Inherited from Map

Returns a layer based on the given layer ID.

Parameter
layerId String

The ID assigned to the layer.

Returns
Type Description
Layer Returns the requested layer object.

findTableById

Inherited
Method
findTableById(tableId){Layer}
Inherited from Map

Returns a table based on the given table ID.

Parameter
tableId String

The ID assigned to the table.

Returns
Type Description
Layer Returns the requested table object.

hasHandles

Inherited
Method
hasHandles(groupKey){Boolean}
Inherited from Accessor

Returns true if a named group of handles exist.

Parameter
groupKey *
optional

A group key.

Returns
Type Description
Boolean Returns true if a named group of handles exist.
Example
// Remove a named group of handles if they exist.
if (obj.hasHandles("watch-view-updates")) {
  obj.removeHandles("watch-view-updates");
}

isFulfilled

Method
isFulfilled(){Boolean}

isFulfilled() may be used to verify if creating an instance of the class is fulfilled (either resolved or rejected). If it is fulfilled, true will be returned.

Returns
Type Description
Boolean Indicates whether creating an instance of the class has been fulfilled (either resolved or rejected).

isRejected

Method
isRejected(){Boolean}

isRejected() may be used to verify if creating an instance of the class is rejected. If it is rejected, true will be returned.

Returns
Type Description
Boolean Indicates whether creating an instance of the class has been rejected.

isResolved

Method
isResolved(){Boolean}

isResolved() may be used to verify if creating an instance of the class is resolved. If it is resolved, true will be returned.

Returns
Type Description
Boolean Indicates whether creating an instance of the class has been resolved.

load

Method
load(){Promise}

Triggers the loading of the WebMap instance.

A WebMap is considered loaded when its operational layers and basemap are fully created. When created with a portalItem, load() will first fetch its data to create the content, otherwise it resolves immediately.

The MapView automatically calls the load() method when a WebMap instance is added to its map property so it can display in the view and load each individual layer. If the WebMap is used outside of a view, for example to preload it, you must call load() explicitly to interact with its resources.

Returns
Type Description
Promise Resolves when the WebMap is loaded.
See also
Example
require([
  "esri/WebMap"
], function(
  WebMap
) {

  const map = new WebMap({
    portalItem: {
      id: "e691172598f04ea8881cd2a4adaa45ba"
    }
  });

  map.load()
    .then(function() {
      // load the basemap to get its layers created
      return map.basemap.load();
    })
    .then(function() {
      // grab all the layers and load them
      const allLayers = map.allLayers;
      const promises = allLayers.map(function(layer) {
        return layer.load();
      });
      return Promise.all(promises.toArray());
    })
    .then(function(layers) {
      // each layer load promise resolves with the layer
      console.log("all " + layers.length + " layers loaded");
    })
    .catch(function(error) {
      console.error(error);
    });
});

loadAll

Method
loadAll(){Promise<WebMap>}

Loads all the externally loadable resources associated with the webmap. For the webmap this will load the ground, basemap and layers.

Returns
Type Description
Promise<WebMap> Resolves when all the loadable resources have been loaded. Rejects if at least one of the loadable resources failed to load.
See also
Example
// Load all resources but ignore if one or more of them failed to load
webmap.loadAll()
  .catch(function(error) {
    // Ignore any failed resources
  })
  .then(function() {
    console.log("All loaded");
  });

remove

Inherited
Method
remove(layer){Layer}
Inherited from Map

Removes the specified layer from the layers collection. The before-changes, before-remove, after-remove, after-changes and change events will be emitted when this method is called.

Parameter
layer Layer

Layer to remove from the layers collection.

Returns
Type Description
Layer Returns the layer removed from the layers collection.

removeAll

Inherited
Method
removeAll(){Layer[]}
Inherited from Map

Removes all layers. The before-changes, before-remove, after-remove, after-changes and change events will be emitted when this method is called.

Returns
Type Description
Layer[] Returns the layers removed from the layers collection.

removeHandles

Inherited
Method
removeHandles(groupKey)
Inherited from Accessor

Removes a group of handles owned by the object.

Parameter
groupKey *
optional

A group key or an array or collection of group keys to remove.

Example
obj.removeHandles(); // removes handles from default group

obj.removeHandles("handle-group");
obj.removeHandles("other-handle-group");

removeMany

Inherited
Method
removeMany(layers){Layer[]}
Inherited from Map

Removes the specified layers. The before-changes, before-remove, after-remove, after-changes and change events will be emitted when this method is called.

Parameter
layers Layer[]

Array of layers to remove from the layers collection.

Returns
Type Description
Layer[] Returns the layers removed from the layers collection.

reorder

Inherited
Method
reorder(layer, index){Layer}
Inherited from Map

Changes the layer order. The first layer added is always the base layer, even if its order is changed. The change event will be emitted when this method is called.

In 3D, for layers that are rendered on the terrain, the order of the layers also depends on the type of layer. Tiled layers (BaseTileLayer, ImageryTileLayer, OpenStreetMapLayer, TileLayer, VectorTileLayer, WCSLayer, WebTileLayer and WMTSLayer) are always drawn first in the same order as specified in the layer collection. Dynamic layers (MapImageLayer, ImageryLayer, WMSLayer, and feature based layers with elevation mode on-the-ground) are rendered on top using the order from the layer collection.

Parameters
layer Layer

The layer to be moved.

index Number

The index location for placing the layer. The bottom-most layer has an index of 0.

Returns
Type Description
Layer Returns the layer that was moved.

updateFrom

Method
updateFrom(view, options){Promise}

Update properties of the WebMap related to the view. This should usually be called just before saving a webmap. The following properties are updated from the view:

  1. InitialViewProperties.spatialReference

Depending on the provided options, the following properties are also updated:

  1. The rotation, scale, and targetGeometry properties of InitialViewProperties.viewpoint
  2. The thumbnail of the PortalItem
Parameters
Specification
view MapView

The view to update from.

options Object
optional

Update options.

Specification
backgroundExcluded Boolean
optional

When true, the view's background will not be updated for the webmap. The default is false meaning the background will be updated for the webmap if there is a background.

viewpointExcluded Boolean
optional

When true, the initial viewpoint of the view will not be updated for the webmap. Defaults to false, meaning the viewpoint will be updated for the webmap. Must set scalePreserved to true if the view's scale should be updated for the webmap.

scalePreserved Boolean
optional

When true, the view's scale will be updated for the webmap. Defaults to false meaning view's scale will not be updated for the webmap. It is ignored when viewpointExcluded is true.

thumbnailExcluded Boolean
optional

When true, the thumbnail will not be updated for the webmap. Defaults to false meaning the thumbnail will be updated for the webmap.

thumbnailSize Object
optional

The size of the thumbnail. Defaults to 600x400 (ratio 1.5:1). Note that the thumbnail size may currently not be larger than the size of the view.

Specification
width Number

The width of the thumbnail.

height Number

The height of the thumbnail.

widgetsExcluded Boolean
optional

When true, the webmap's widgets property will not be updated. When false, the definition of the first TimeSlider assigned to the View will be used to update the WebMap.widgets property. The default value is false.

Returns
Type Description
Promise Resolves when the update has completed.
See also

when

Method
when(callback, errback){Promise}

when() may be leveraged once an instance of the class is created. This method takes two input parameters: a callback function and an errback function. The callback executes when the instance of the class loads. The errback executes if the instance of the class fails to load.

Parameters
callback Function
optional

The function to call when the promise resolves.

errback Function
optional

The function to execute when the promise fails.

Returns
Type Description
Promise Returns a new promise for the result of callback that may be used to chain additional functions.
Example
// Although this example uses MapView, any class instance that is a promise may use when() in the same way
let view = new MapView();
view.when(function(){
  // This function will execute once the promise is resolved
}, function(error){
  // This function will execute if the promise is rejected due to an error
});

Your browser is no longer supported. Please upgrade your browser for the best experience. See our browser deprecation post for more details.