@arcgis/map-components 1.0.0-beta.14

package/dist/esm/index-ad26b6d0.js

@@ -0,0 +1,638 @@
+const amd = "define" in window && typeof window.define === "function" && "amd" in window.define;
+function requireModule(modulePath) {
+    return new Promise((resolve) => window.require([modulePath], (moduleDefault) => {
+        resolve(moduleDefault);
+    }));
+}
+async function importLayersFeatureLayer() {
+    if (amd) {
+        return requireModule("esri/layers/FeatureLayer");
+    }
+    const module = await import('@arcgis/core/layers/FeatureLayer.js');
+    return module.default;
+}
+async function newLayersFeatureLayer(properties) {
+    const ModConstructor = await importLayersFeatureLayer();
+    return new ModConstructor(properties);
+}
+async function importLayersGraphicsLayer() {
+    if (amd) {
+        return requireModule("esri/layers/GraphicsLayer");
+    }
+    const module = await import('@arcgis/core/layers/GraphicsLayer.js');
+    return module.default;
+}
+async function newLayersGraphicsLayer(properties) {
+    const ModConstructor = await importLayersGraphicsLayer();
+    return new ModConstructor(properties);
+}
+async function importLayersRouteLayer() {
+    if (amd) {
+        return requireModule("esri/layers/RouteLayer");
+    }
+    const module = await import('@arcgis/core/layers/RouteLayer.js');
+    return module.default;
+}
+async function newLayersRouteLayer(properties) {
+    const ModConstructor = await importLayersRouteLayer();
+    return new ModConstructor(properties);
+}
+async function importViewsMapView() {
+    if (amd) {
+        return requireModule("esri/views/MapView");
+    }
+    const module = await import('@arcgis/core/views/MapView.js');
+    return module.default;
+}
+async function newViewsMapView(properties) {
+    const ModConstructor = await importViewsMapView();
+    return new ModConstructor(properties);
+}
+async function importViewsSceneView() {
+    if (amd) {
+        return requireModule("esri/views/SceneView");
+    }
+    const module = await import('@arcgis/core/views/SceneView.js');
+    return module.default;
+}
+async function newViewsSceneView(properties) {
+    const ModConstructor = await importViewsSceneView();
+    return new ModConstructor(properties);
+}
+async function importWebMap() {
+    if (amd) {
+        return requireModule("esri/WebMap");
+    }
+    const module = await import('@arcgis/core/WebMap.js');
+    return module.default;
+}
+async function newWebMap(properties) {
+    const ModConstructor = await importWebMap();
+    return new ModConstructor(properties);
+}
+async function importWebScene() {
+    if (amd) {
+        return requireModule("esri/WebScene");
+    }
+    const module = await import('@arcgis/core/WebScene.js');
+    return module.default;
+}
+async function newWebScene(properties) {
+    const ModConstructor = await importWebScene();
+    return new ModConstructor(properties);
+}
+async function importWidgetsAreaMeasurement2D() {
+    if (amd) {
+        return requireModule("esri/widgets/AreaMeasurement2D");
+    }
+    const module = await import('@arcgis/core/widgets/AreaMeasurement2D.js');
+    return module.default;
+}
+async function newWidgetsAreaMeasurement2D(properties) {
+    const ModConstructor = await importWidgetsAreaMeasurement2D();
+    return new ModConstructor(properties);
+}
+async function importWidgetsAreaMeasurement3D() {
+    if (amd) {
+        return requireModule("esri/widgets/AreaMeasurement3D");
+    }
+    const module = await import('@arcgis/core/widgets/AreaMeasurement3D.js');
+    return module.default;
+}
+async function newWidgetsAreaMeasurement3D(properties) {
+    const ModConstructor = await importWidgetsAreaMeasurement3D();
+    return new ModConstructor(properties);
+}
+async function importWidgetsAttachments() {
+    if (amd) {
+        return requireModule("esri/widgets/Attachments");
+    }
+    const module = await import('@arcgis/core/widgets/Attachments.js');
+    return module.default;
+}
+async function newWidgetsAttachments(properties) {
+    const ModConstructor = await importWidgetsAttachments();
+    return new ModConstructor(properties);
+}
+async function importWidgetsBasemapGallery() {
+    if (amd) {
+        return requireModule("esri/widgets/BasemapGallery");
+    }
+    const module = await import('@arcgis/core/widgets/BasemapGallery.js');
+    return module.default;
+}
+async function newWidgetsBasemapGallery(properties) {
+    const ModConstructor = await importWidgetsBasemapGallery();
+    return new ModConstructor(properties);
+}
+async function importWidgetsBasemapLayerList() {
+    if (amd) {
+        return requireModule("esri/widgets/BasemapLayerList");
+    }
+    const module = await import('@arcgis/core/widgets/BasemapLayerList.js');
+    return module.default;
+}
+async function newWidgetsBasemapLayerList(properties) {
+    const ModConstructor = await importWidgetsBasemapLayerList();
+    return new ModConstructor(properties);
+}
+async function importWidgetsBasemapToggle() {
+    if (amd) {
+        return requireModule("esri/widgets/BasemapToggle");
+    }
+    const module = await import('@arcgis/core/widgets/BasemapToggle.js');
+    return module.default;
+}
+async function newWidgetsBasemapToggle(properties) {
+    const ModConstructor = await importWidgetsBasemapToggle();
+    return new ModConstructor(properties);
+}
+async function importWidgetsBookmarks() {
+    if (amd) {
+        return requireModule("esri/widgets/Bookmarks");
+    }
+    const module = await import('@arcgis/core/widgets/Bookmarks.js');
+    return module.default;
+}
+async function newWidgetsBookmarks(properties) {
+    const ModConstructor = await importWidgetsBookmarks();
+    return new ModConstructor(properties);
+}
+async function importWidgetsBuildingExplorer() {
+    if (amd) {
+        return requireModule("esri/widgets/BuildingExplorer");
+    }
+    const module = await import('@arcgis/core/widgets/BuildingExplorer.js');
+    return module.default;
+}
+async function newWidgetsBuildingExplorer(properties) {
+    const ModConstructor = await importWidgetsBuildingExplorer();
+    return new ModConstructor(properties);
+}
+async function importWidgetsCompass() {
+    if (amd) {
+        return requireModule("esri/widgets/Compass");
+    }
+    const module = await import('@arcgis/core/widgets/Compass.js');
+    return module.default;
+}
+async function newWidgetsCompass(properties) {
+    const ModConstructor = await importWidgetsCompass();
+    return new ModConstructor(properties);
+}
+async function importWidgetsCoordinateConversion() {
+    if (amd) {
+        return requireModule("esri/widgets/CoordinateConversion");
+    }
+    const module = await import('@arcgis/core/widgets/CoordinateConversion.js');
+    return module.default;
+}
+async function newWidgetsCoordinateConversion(properties) {
+    const ModConstructor = await importWidgetsCoordinateConversion();
+    return new ModConstructor(properties);
+}
+async function importWidgetsDaylight() {
+    if (amd) {
+        return requireModule("esri/widgets/Daylight");
+    }
+    const module = await import('@arcgis/core/widgets/Daylight.js');
+    return module.default;
+}
+async function newWidgetsDaylight(properties) {
+    const ModConstructor = await importWidgetsDaylight();
+    return new ModConstructor(properties);
+}
+async function importWidgetsDirections() {
+    if (amd) {
+        return requireModule("esri/widgets/Directions");
+    }
+    const module = await import('@arcgis/core/widgets/Directions.js');
+    return module.default;
+}
+async function newWidgetsDirections(properties) {
+    const ModConstructor = await importWidgetsDirections();
+    return new ModConstructor(properties);
+}
+async function importWidgetsDirectLineMeasurement3D() {
+    if (amd) {
+        return requireModule("esri/widgets/DirectLineMeasurement3D");
+    }
+    const module = await import('@arcgis/core/widgets/DirectLineMeasurement3D.js');
+    return module.default;
+}
+async function newWidgetsDirectLineMeasurement3D(properties) {
+    const ModConstructor = await importWidgetsDirectLineMeasurement3D();
+    return new ModConstructor(properties);
+}
+async function importWidgetsDistanceMeasurement2D() {
+    if (amd) {
+        return requireModule("esri/widgets/DistanceMeasurement2D");
+    }
+    const module = await import('@arcgis/core/widgets/DistanceMeasurement2D.js');
+    return module.default;
+}
+async function newWidgetsDistanceMeasurement2D(properties) {
+    const ModConstructor = await importWidgetsDistanceMeasurement2D();
+    return new ModConstructor(properties);
+}
+async function importWidgetsEditor() {
+    if (amd) {
+        return requireModule("esri/widgets/Editor");
+    }
+    const module = await import('@arcgis/core/widgets/Editor.js');
+    return module.default;
+}
+async function newWidgetsEditor(properties) {
+    const ModConstructor = await importWidgetsEditor();
+    return new ModConstructor(properties);
+}
+async function importWidgetsElevationProfile() {
+    if (amd) {
+        return requireModule("esri/widgets/ElevationProfile");
+    }
+    const module = await import('@arcgis/core/widgets/ElevationProfile.js');
+    return module.default;
+}
+async function newWidgetsElevationProfile(properties) {
+    const ModConstructor = await importWidgetsElevationProfile();
+    return new ModConstructor(properties);
+}
+async function importWidgetsExpand() {
+    if (amd) {
+        return requireModule("esri/widgets/Expand");
+    }
+    const module = await import('@arcgis/core/widgets/Expand.js');
+    return module.default;
+}
+async function newWidgetsExpand(properties) {
+    const ModConstructor = await importWidgetsExpand();
+    return new ModConstructor(properties);
+}
+async function importWidgetsFeature() {
+    if (amd) {
+        return requireModule("esri/widgets/Feature");
+    }
+    const module = await import('@arcgis/core/widgets/Feature.js');
+    return module.default;
+}
+async function newWidgetsFeature(properties) {
+    const ModConstructor = await importWidgetsFeature();
+    return new ModConstructor(properties);
+}
+async function importWidgetsFeatureForm() {
+    if (amd) {
+        return requireModule("esri/widgets/FeatureForm");
+    }
+    const module = await import('@arcgis/core/widgets/FeatureForm.js');
+    return module.default;
+}
+async function newWidgetsFeatureForm(properties) {
+    const ModConstructor = await importWidgetsFeatureForm();
+    return new ModConstructor(properties);
+}
+async function importWidgetsFeatures() {
+    if (amd) {
+        return requireModule("esri/widgets/Features");
+    }
+    const module = await import('@arcgis/core/widgets/Features.js');
+    return module.default;
+}
+async function newWidgetsFeatures(properties) {
+    const ModConstructor = await importWidgetsFeatures();
+    return new ModConstructor(properties);
+}
+async function importWidgetsFeatureTable() {
+    if (amd) {
+        return requireModule("esri/widgets/FeatureTable");
+    }
+    const module = await import('@arcgis/core/widgets/FeatureTable.js');
+    return module.default;
+}
+async function newWidgetsFeatureTable(properties) {
+    const ModConstructor = await importWidgetsFeatureTable();
+    return new ModConstructor(properties);
+}
+async function importWidgetsFeatureTemplates() {
+    if (amd) {
+        return requireModule("esri/widgets/FeatureTemplates");
+    }
+    const module = await import('@arcgis/core/widgets/FeatureTemplates.js');
+    return module.default;
+}
+async function newWidgetsFeatureTemplates(properties) {
+    const ModConstructor = await importWidgetsFeatureTemplates();
+    return new ModConstructor(properties);
+}
+async function importWidgetsFloorFilter() {
+    if (amd) {
+        return requireModule("esri/widgets/FloorFilter");
+    }
+    const module = await import('@arcgis/core/widgets/FloorFilter.js');
+    return module.default;
+}
+async function newWidgetsFloorFilter(properties) {
+    const ModConstructor = await importWidgetsFloorFilter();
+    return new ModConstructor(properties);
+}
+async function importWidgetsFullscreen() {
+    if (amd) {
+        return requireModule("esri/widgets/Fullscreen");
+    }
+    const module = await import('@arcgis/core/widgets/Fullscreen.js');
+    return module.default;
+}
+async function newWidgetsFullscreen(properties) {
+    const ModConstructor = await importWidgetsFullscreen();
+    return new ModConstructor(properties);
+}
+async function importWidgetsHistogram() {
+    if (amd) {
+        return requireModule("esri/widgets/Histogram");
+    }
+    const module = await import('@arcgis/core/widgets/Histogram.js');
+    return module.default;
+}
+async function newWidgetsHistogram(properties) {
+    const ModConstructor = await importWidgetsHistogram();
+    return new ModConstructor(properties);
+}
+async function importWidgetsHistogramRangeSlider() {
+    if (amd) {
+        return requireModule("esri/widgets/HistogramRangeSlider");
+    }
+    const module = await import('@arcgis/core/widgets/HistogramRangeSlider.js');
+    return module.default;
+}
+async function newWidgetsHistogramRangeSlider(properties) {
+    const ModConstructor = await importWidgetsHistogramRangeSlider();
+    return new ModConstructor(properties);
+}
+async function importWidgetsHome() {
+    if (amd) {
+        return requireModule("esri/widgets/Home");
+    }
+    const module = await import('@arcgis/core/widgets/Home.js');
+    return module.default;
+}
+async function newWidgetsHome(properties) {
+    const ModConstructor = await importWidgetsHome();
+    return new ModConstructor(properties);
+}
+async function importWidgetsLayerList() {
+    if (amd) {
+        return requireModule("esri/widgets/LayerList");
+    }
+    const module = await import('@arcgis/core/widgets/LayerList.js');
+    return module.default;
+}
+async function newWidgetsLayerList(properties) {
+    const ModConstructor = await importWidgetsLayerList();
+    return new ModConstructor(properties);
+}
+async function importWidgetsLegend() {
+    if (amd) {
+        return requireModule("esri/widgets/Legend");
+    }
+    const module = await import('@arcgis/core/widgets/Legend.js');
+    return module.default;
+}
+async function newWidgetsLegend(properties) {
+    const ModConstructor = await importWidgetsLegend();
+    return new ModConstructor(properties);
+}
+async function importWidgetsLineOfSight() {
+    if (amd) {
+        return requireModule("esri/widgets/LineOfSight");
+    }
+    const module = await import('@arcgis/core/widgets/LineOfSight.js');
+    return module.default;
+}
+async function newWidgetsLineOfSight(properties) {
+    const ModConstructor = await importWidgetsLineOfSight();
+    return new ModConstructor(properties);
+}
+async function importWidgetsLocate() {
+    if (amd) {
+        return requireModule("esri/widgets/Locate");
+    }
+    const module = await import('@arcgis/core/widgets/Locate.js');
+    return module.default;
+}
+async function newWidgetsLocate(properties) {
+    const ModConstructor = await importWidgetsLocate();
+    return new ModConstructor(properties);
+}
+async function importWidgetsMeasurement() {
+    if (amd) {
+        return requireModule("esri/widgets/Measurement");
+    }
+    const module = await import('@arcgis/core/widgets/Measurement.js');
+    return module.default;
+}
+async function newWidgetsMeasurement(properties) {
+    const ModConstructor = await importWidgetsMeasurement();
+    return new ModConstructor(properties);
+}
+async function importWidgetsNavigationToggle() {
+    if (amd) {
+        return requireModule("esri/widgets/NavigationToggle");
+    }
+    const module = await import('@arcgis/core/widgets/NavigationToggle.js');
+    return module.default;
+}
+async function newWidgetsNavigationToggle(properties) {
+    const ModConstructor = await importWidgetsNavigationToggle();
+    return new ModConstructor(properties);
+}
+async function importWidgetsPrint() {
+    if (amd) {
+        return requireModule("esri/widgets/Print");
+    }
+    const module = await import('@arcgis/core/widgets/Print.js');
+    return module.default;
+}
+async function newWidgetsPrint(properties) {
+    const ModConstructor = await importWidgetsPrint();
+    return new ModConstructor(properties);
+}
+async function importWidgetsScaleBar() {
+    if (amd) {
+        return requireModule("esri/widgets/ScaleBar");
+    }
+    const module = await import('@arcgis/core/widgets/ScaleBar.js');
+    return module.default;
+}
+async function newWidgetsScaleBar(properties) {
+    const ModConstructor = await importWidgetsScaleBar();
+    return new ModConstructor(properties);
+}
+async function importWidgetsScaleRangeSlider() {
+    if (amd) {
+        return requireModule("esri/widgets/ScaleRangeSlider");
+    }
+    const module = await import('@arcgis/core/widgets/ScaleRangeSlider.js');
+    return module.default;
+}
+async function newWidgetsScaleRangeSlider(properties) {
+    const ModConstructor = await importWidgetsScaleRangeSlider();
+    return new ModConstructor(properties);
+}
+async function importWidgetsSearch() {
+    if (amd) {
+        return requireModule("esri/widgets/Search");
+    }
+    const module = await import('@arcgis/core/widgets/Search.js');
+    return module.default;
+}
+async function newWidgetsSearch(properties) {
+    const ModConstructor = await importWidgetsSearch();
+    return new ModConstructor(properties);
+}
+async function importWidgetsShadowCast() {
+    if (amd) {
+        return requireModule("esri/widgets/ShadowCast");
+    }
+    const module = await import('@arcgis/core/widgets/ShadowCast.js');
+    return module.default;
+}
+async function newWidgetsShadowCast(properties) {
+    const ModConstructor = await importWidgetsShadowCast();
+    return new ModConstructor(properties);
+}
+async function importWidgetsSketch() {
+    if (amd) {
+        return requireModule("esri/widgets/Sketch");
+    }
+    const module = await import('@arcgis/core/widgets/Sketch.js');
+    return module.default;
+}
+async function newWidgetsSketch(properties) {
+    const ModConstructor = await importWidgetsSketch();
+    return new ModConstructor(properties);
+}
+async function importWidgetsSlice() {
+    if (amd) {
+        return requireModule("esri/widgets/Slice");
+    }
+    const module = await import('@arcgis/core/widgets/Slice.js');
+    return module.default;
+}
+async function newWidgetsSlice(properties) {
+    const ModConstructor = await importWidgetsSlice();
+    return new ModConstructor(properties);
+}
+async function importWidgetsSlider() {
+    if (amd) {
+        return requireModule("esri/widgets/Slider");
+    }
+    const module = await import('@arcgis/core/widgets/Slider.js');
+    return module.default;
+}
+async function newWidgetsSlider(properties) {
+    const ModConstructor = await importWidgetsSlider();
+    return new ModConstructor(properties);
+}
+async function importWidgetsSwipe() {
+    if (amd) {
+        return requireModule("esri/widgets/Swipe");
+    }
+    const module = await import('@arcgis/core/widgets/Swipe.js');
+    return module.default;
+}
+async function newWidgetsSwipe(properties) {
+    const ModConstructor = await importWidgetsSwipe();
+    return new ModConstructor(properties);
+}
+async function importWidgetsTableList() {
+    if (amd) {
+        return requireModule("esri/widgets/TableList");
+    }
+    const module = await import('@arcgis/core/widgets/TableList.js');
+    return module.default;
+}
+async function newWidgetsTableList(properties) {
+    const ModConstructor = await importWidgetsTableList();
+    return new ModConstructor(properties);
+}
+async function importWidgetsTimeSlider() {
+    if (amd) {
+        return requireModule("esri/widgets/TimeSlider");
+    }
+    const module = await import('@arcgis/core/widgets/TimeSlider.js');
+    return module.default;
+}
+async function newWidgetsTimeSlider(properties) {
+    const ModConstructor = await importWidgetsTimeSlider();
+    return new ModConstructor(properties);
+}
+async function importWidgetsTrack() {
+    if (amd) {
+        return requireModule("esri/widgets/Track");
+    }
+    const module = await import('@arcgis/core/widgets/Track.js');
+    return module.default;
+}
+async function newWidgetsTrack(properties) {
+    const ModConstructor = await importWidgetsTrack();
+    return new ModConstructor(properties);
+}
+async function importWidgetsUtilityNetworkTrace() {
+    if (amd) {
+        return requireModule("esri/widgets/UtilityNetworkTrace");
+    }
+    const module = await import('@arcgis/core/widgets/UtilityNetworkTrace.js');
+    return module.default;
+}
+async function newWidgetsUtilityNetworkTrace(properties) {
+    const ModConstructor = await importWidgetsUtilityNetworkTrace();
+    return new ModConstructor(properties);
+}
+async function importWidgetsValuePicker() {
+    if (amd) {
+        return requireModule("esri/widgets/ValuePicker");
+    }
+    const module = await import('@arcgis/core/widgets/ValuePicker.js');
+    return module.default;
+}
+async function newWidgetsValuePicker(properties) {
+    const ModConstructor = await importWidgetsValuePicker();
+    return new ModConstructor(properties);
+}
+async function importWidgetsWeather() {
+    if (amd) {
+        return requireModule("esri/widgets/Weather");
+    }
+    const module = await import('@arcgis/core/widgets/Weather.js');
+    return module.default;
+}
+async function newWidgetsWeather(properties) {
+    const ModConstructor = await importWidgetsWeather();
+    return new ModConstructor(properties);
+}
+async function importWidgetsZoom() {
+    if (amd) {
+        return requireModule("esri/widgets/Zoom");
+    }
+    const module = await import('@arcgis/core/widgets/Zoom.js');
+    return module.default;
+}
+async function newWidgetsZoom(properties) {
+    const ModConstructor = await importWidgetsZoom();
+    return new ModConstructor(properties);
+}
+async function importConfig() {
+    if (amd) {
+        return requireModule("esri/config");
+    }
+    const module = await import('@arcgis/core/config.js');
+    return module.default;
+}
+async function importCoreReactiveUtils() {
+    if (amd) {
+        return requireModule("esri/core/reactiveUtils");
+    }
+    const module = await import('@arcgis/core/core/reactiveUtils.js');
+    return module;
+}
+
+export { newWidgetsTrack as $, newWidgetsFeatureTemplates as A, newWidgetsFeatures as B, newWidgetsFloorFilter as C, newWidgetsFullscreen as D, newWidgetsHistogram as E, newWidgetsHistogramRangeSlider as F, newWidgetsHome as G, newWidgetsLayerList as H, newWidgetsLegend as I, newWidgetsLineOfSight as J, newWidgetsLocate as K, newWidgetsMeasurement as L, newWidgetsNavigationToggle as M, newWidgetsPrint as N, newWidgetsScaleBar as O, newWidgetsScaleRangeSlider as P, newWebScene as Q, newViewsSceneView as R, newWidgetsSearch as S, newWidgetsShadowCast as T, newWidgetsSketch as U, newLayersGraphicsLayer as V, newWidgetsSlice as W, newWidgetsSlider as X, newWidgetsSwipe as Y, newWidgetsTableList as Z, newWidgetsTimeSlider as _, newWidgetsExpand as a, newWidgetsUtilityNetworkTrace as a0, newWidgetsValuePicker as a1, newWidgetsWeather as a2, newWidgetsZoom as a3, importConfig as b, newWebMap as c, newViewsMapView as d, newWidgetsAreaMeasurement2D as e, newWidgetsAreaMeasurement3D as f, newWidgetsAttachments as g, newWidgetsBasemapLayerList as h, importCoreReactiveUtils as i, newWidgetsBasemapToggle as j, newWidgetsBookmarks as k, newWidgetsBuildingExplorer as l, newWidgetsCompass as m, newWidgetsBasemapGallery as n, newWidgetsCoordinateConversion as o, newWidgetsDaylight as p, newLayersRouteLayer as q, newWidgetsDirections as r, newWidgetsDirectLineMeasurement3D as s, newWidgetsDistanceMeasurement2D as t, newWidgetsEditor as u, newWidgetsElevationProfile as v, newWidgetsFeature as w, newWidgetsFeatureForm as x, newLayersFeatureLayer as y, newWidgetsFeatureTable as z };