@esri/solutions-components 0.6.12 → 0.6.14

package/dist/collection/utils/mapViewUtils.ts

@@ -21,89 +21,73 @@ import { EWorkflowType, IMapItemHash, ISelectionSet } from "./interfaces";
  * Gets the layer names from the current map
  *
  * @param mapView the map view to fetch the layer names from
+ * @param onlyShowUpdatableLayers when true only layers that support editing and updates will be returned
  *
  * @returns Promise resolving with an array of layer names
  *
  */
 export async function getMapLayerHash(
-  mapView: __esri.MapView
+  mapView: __esri.MapView,
+  onlyShowUpdatableLayers: boolean
 ): Promise<IMapItemHash> {
-  let layerHash = {};
+  let layerHash;
   await mapView.when(() => {
     layerHash = mapView.map.allLayers.toArray().reduce((prev, cur) => {
       if (cur.type === "feature") {
-        prev[cur.id] = cur.title;
+        prev[cur.id] = {
+          name: cur.title,
+          supportsUpdate: undefined
+        };
       }
       return prev;
     }, {});
   });
-  return layerHash;
+
+  return onlyShowUpdatableLayers ? Object.keys(layerHash).reduce(async (prev, cur) => {
+    const layer = await getLayerOrTable(mapView, cur);
+    await layer.when(() => {
+      prev[cur] = {
+        name: layerHash[cur].name,
+        supportsUpdate: layer.editingEnabled && layer.capabilities.operations.supportsUpdate
+      };
+    });
+    return prev;
+  }, {}) : layerHash;
 }
 
 /**
  * Gets the table names from the current map
  *
  * @param mapView the map view to fetch the table names from
+ * @param onlyShowUpdatableLayers when true only layers that support editing and updates will be returned
  *
  * @returns Promise resolving with an array of table names
  *
  */
 export async function getMapTableHash(
-  mapView: __esri.MapView
+  mapView: __esri.MapView,
+  onlyShowUpdatableTables: boolean
 ): Promise<IMapItemHash> {
-  let tableHash = {};
+  let tableHash;
   await mapView.when(() => {
     tableHash = mapView.map.allTables.toArray().reduce((prev, cur) => {
-      prev[cur.id] = cur.title;
+      prev[cur.id] = {
+        name: cur.title,
+        supportsUpdate: undefined
+      };
       return prev;
     }, {});
   });
-  return tableHash;
-}
-
-/**
- * Gets the layer names from the current map
- *
- * @param mapView the map view to fetch the layer names from
- *
- * @returns Promise resolving with an array of layer names
- *
- */
-export async function getMapLayerIds(
-  mapView: __esri.MapView
-): Promise<string[]> {
-  let layerIds = [];
-  await mapView.when(() => {
-    layerIds = mapView.map.allLayers.toArray().reduce((prev, cur) => {
-      if (cur.type === "feature") {
-        prev.push(cur.id);
-      }
-      return prev;
-    }, []);
-  });
-  return layerIds;
-}
 
-/**
- * Gets the table names from the current map
- *
- * @param mapView the map view to fetch the table names from
- *
- * @returns Promise resolving with an array of table names
- *
- */
-export async function getMapTableIds(
-  mapView: __esri.MapView
-): Promise<string[]> {
-  // TODO...seems like its the same as the hash...see if I can remove this
-  let tableIds = [];
-  await mapView.when(() => {
-    tableIds = mapView.map.allTables.toArray().reduce((prev, cur) => {
-      prev.push(cur.id);
-      return prev;
-    }, []);
-  });
-  return tableIds;
+  return onlyShowUpdatableTables ? Object.keys(tableHash).reduce(async (prev, cur) => {
+    const item = await getLayerOrTable(mapView, cur);
+    await item.load();
+    prev[cur] = {
+      name: tableHash[cur].name,
+      supportsUpdate: item.editingEnabled && item.capabilities.operations.supportsUpdate
+    };
+    return prev;
+  }, {}) : tableHash;
 }
 
 /**
@@ -119,20 +103,20 @@ export async function getFeatureLayerView(
   mapView: __esri.MapView,
   id: string
 ): Promise<__esri.FeatureLayerView> {
-  const layer = await getLayer(mapView, id);
+  const layer = await getLayerOrTable(mapView, id);
   return layer ? await mapView.whenLayerView(layer) : undefined;
 }
 
 /**
- * Get a layer by id
+ * Get a layer or table by id
  *
  * @param mapView the map view to fetch the layer from
- * @param id the id if the layer to fetch
+ * @param id the id of the layer or table to fetch
  *
- * @returns Promise resolving with the fetched layer
+ * @returns Promise resolving with the fetched layer or table
  *
  */
-export async function getLayer(
+export async function getLayerOrTable(
   mapView: __esri.MapView,
   id: string
 ): Promise<__esri.FeatureLayer> {

package/dist/collection/utils/publicNotificationStore.js

@@ -26,10 +26,6 @@ const { state, onChange } = createStore({
   managedTables: [],
   // Handle[]: https://developers.arcgis.com/javascript/latest/api-reference/esri-core-Handles.html#Handle
   highlightHandles: [],
-  // IMapItemHash title: id lookup to be used across components
-  layerNameHash: {},
-  // IMapItemHash title: id lookup to be used across components
-  tableNameHash: {},
   // remove all handles
   removeHandles: () => {
     state.highlightHandles.forEach(h => h === null || h === void 0 ? void 0 : h.remove());

package/dist/collection/utils/publicNotificationStore.ts

@@ -23,10 +23,6 @@ const { state, onChange } = createStore({
 	managedTables: [],
 	// Handle[]: https://developers.arcgis.com/javascript/latest/api-reference/esri-core-Handles.html#Handle
 	highlightHandles: [],
-	// IMapItemHash title: id lookup to be used across components
-	layerNameHash: {},
-	// IMapItemHash title: id lookup to be used across components
-	tableNameHash: {},
 	// remove all handles
 	removeHandles: () => {
 		state.highlightHandles.forEach(h => h?.remove());

package/dist/collection/utils/test/downloadUtils.spec.js

@@ -445,224 +445,246 @@ describe("downloadUtils", () => {
       expect(downloadUtils._getFieldNamesFromFieldExpressions(expressions)).toEqual(names);
     });
   });
+  /*
   describe('_getLabelFormat', () => {
+
     it('should prepare labels from visible popup fields', async () => {
       const popupTemplate = {
         title: '{name}',
         content: [{
-            type: 'fields'
-          }],
+          type: 'fields'
+        }],
         fieldInfos: [{
-            fieldName: 'name',
-            visible: true
-          }, {
-            fieldName: 'age',
-            format: {
-              places: 0,
-              digitSeparator: true
-            },
-            visible: true
-          }, {
-            fieldName: 'start',
-            format: {
-              dateFormat: 'short-date'
-            },
-            visible: true
-          }]
+          fieldName: 'name',
+          visible: true
+        }, {
+          fieldName: 'age',
+          format: {
+            places: 0,
+            digitSeparator: true
+          },
+          visible: true
+        }, {
+          fieldName: 'start',
+          format: {
+            dateFormat: 'short-date'
+          },
+          visible: true
+        }]
       };
       const layer = {
         popupEnabled: true,
         popupTemplate
       };
       const formatUsingLayerPopup = true;
-      const attributeFormats = {};
-      const result = await downloadUtils._getLabelFormat(layer, formatUsingLayerPopup, attributeFormats);
+
+      const attributeFormats: downloadUtils.IAttributeFormats = {};
+      const result: downloadUtils.ILabelFormat =
+        await downloadUtils._getLabelFormat(layer as any, formatUsingLayerPopup, attributeFormats);
       expect(result.type).toEqual('pattern');
       expect(result.format).toEqual('{name}|{age}|{start}');
     });
+
     it('should prepare labels from a partial set of visible popup fields', async () => {
       const popupTemplate = {
         title: '{name}',
         content: [{
-            type: 'fields'
-          }],
+          type: 'fields'
+        }],
         fieldInfos: [{
-            fieldName: 'name',
-            visible: false
-          }, {
-            fieldName: 'age',
-            format: {
-              places: 0,
-              digitSeparator: true
-            },
-            visible: false
-          }, {
-            fieldName: 'start',
-            format: {
-              dateFormat: 'short-date'
-            },
-            visible: true
-          }]
+          fieldName: 'name',
+          visible: false
+        }, {
+          fieldName: 'age',
+          format: {
+            places: 0,
+            digitSeparator: true
+          },
+          visible: false
+        }, {
+          fieldName: 'start',
+          format: {
+            dateFormat: 'short-date'
+          },
+          visible: true
+        }]
       };
       const layer = {
         popupEnabled: true,
         popupTemplate
       };
       const formatUsingLayerPopup = true;
-      const attributeFormats = {};
-      const result = await downloadUtils._getLabelFormat(layer, formatUsingLayerPopup, attributeFormats);
+
+      const attributeFormats: downloadUtils.IAttributeFormats = {};
+      const result: downloadUtils.ILabelFormat =
+        await downloadUtils._getLabelFormat(layer as any, formatUsingLayerPopup, attributeFormats);
       expect(result.type).toEqual('pattern');
       expect(result.format).toEqual('{start}');
     });
+
     it('should prepare labels from invisible popup fields, but title is present', async () => {
       const popupTemplate = {
         title: '{name}',
         content: [{
-            type: 'fields'
-          }],
+          type: 'fields'
+        }],
         fieldInfos: [{
-            fieldName: 'name',
-            visible: false
-          }, {
-            fieldName: 'age',
-            format: {
-              places: 0,
-              digitSeparator: true
-            },
-            visible: false
-          }, {
-            fieldName: 'start',
-            format: {
-              dateFormat: 'short-date'
-            },
-            visible: false
-          }]
+          fieldName: 'name',
+          visible: false
+        }, {
+          fieldName: 'age',
+          format: {
+            places: 0,
+            digitSeparator: true
+          },
+          visible: false
+        }, {
+          fieldName: 'start',
+          format: {
+            dateFormat: 'short-date'
+          },
+          visible: false
+        }]
       };
       const layer = {
         popupEnabled: true,
         popupTemplate
       };
       const formatUsingLayerPopup = true;
-      const attributeFormats = {};
-      const result = await downloadUtils._getLabelFormat(layer, formatUsingLayerPopup, attributeFormats);
+
+      const attributeFormats: downloadUtils.IAttributeFormats = {};
+      const result: downloadUtils.ILabelFormat =
+        await downloadUtils._getLabelFormat(layer as any, formatUsingLayerPopup, attributeFormats);
       expect(result.type).toEqual('pattern');
       expect(result.format).toEqual('{name}');
     });
+
     it('should prepare labels from invisible popup fields with no title present', async () => {
       const popupTemplate = {
         title: '',
         content: [{
-            type: 'fields'
-          }],
+          type: 'fields'
+        }],
         fieldInfos: [{
-            fieldName: 'name',
-            visible: false
-          }, {
-            fieldName: 'age',
-            format: {
-              places: 0,
-              digitSeparator: true
-            },
-            visible: false
-          }, {
-            fieldName: 'start',
-            format: {
-              dateFormat: 'short-date'
-            },
-            visible: false
-          }]
+          fieldName: 'name',
+          visible: false
+        }, {
+          fieldName: 'age',
+          format: {
+            places: 0,
+            digitSeparator: true
+          },
+          visible: false
+        }, {
+          fieldName: 'start',
+          format: {
+            dateFormat: 'short-date'
+          },
+          visible: false
+        }]
       };
       const layer = {
         popupEnabled: true,
         popupTemplate
       };
       const formatUsingLayerPopup = true;
-      const attributeFormats = {};
-      const result = await downloadUtils._getLabelFormat(layer, formatUsingLayerPopup, attributeFormats);
+
+      const attributeFormats: downloadUtils.IAttributeFormats = {};
+      const result: downloadUtils.ILabelFormat =
+        await downloadUtils._getLabelFormat(layer as any, formatUsingLayerPopup, attributeFormats);
       expect(result.type).toEqual('pattern');
       expect(result.format).toEqual('{name}|{age}|{start}');
     });
+
     it('should prepare labels from popup text', async () => {
       const popupTemplate = {
         title: '{name}',
         content: [{
-            type: 'text',
-            text: '<p>{name} {age} years &nbsp;</p><p>started: {start}</p>'
-          }],
+          type: 'text',
+          text: '<p>{name} {age} years &nbsp;</p><p>started: {start}</p>'
+        }],
         fieldInfos: [{
-            fieldName: 'name',
-            visible: true
-          }, {
-            fieldName: 'age',
-            format: {
-              places: 0,
-              digitSeparator: true
-            },
-            visible: true
-          }, {
-            fieldName: 'start',
-            format: {
-              dateFormat: 'short-date'
-            },
-            visible: true
-          }]
+          fieldName: 'name',
+          visible: true
+        }, {
+          fieldName: 'age',
+          format: {
+            places: 0,
+            digitSeparator: true
+          },
+          visible: true
+        }, {
+          fieldName: 'start',
+          format: {
+            dateFormat: 'short-date'
+          },
+          visible: true
+        }]
       };
       const layer = {
         popupEnabled: true,
         popupTemplate
       };
       const formatUsingLayerPopup = true;
-      const attributeFormats = {};
-      const result = await downloadUtils._getLabelFormat(layer, formatUsingLayerPopup, attributeFormats);
+
+      const attributeFormats: downloadUtils.IAttributeFormats = {};
+      const result: downloadUtils.ILabelFormat =
+        await downloadUtils._getLabelFormat(layer as any, formatUsingLayerPopup, attributeFormats);
       expect(result.type).toEqual('pattern');
       expect(result.format).toEqual('{name} {age} years|started: {start}');
     });
+
     it('should prepare labels from popup Arcade', async () => {
       const Arcade = {
-        createArcadeExecutor: () => {
-          const executor = {};
+        createArcadeExecutor: (): Promise<__esri.ArcadeExecutor> => {
+          const executor: __esri.ArcadeExecutor = {} as __esri.ArcadeExecutor;
           return Promise.resolve(executor);
         }
       };
       const loadModulesSpy = jest.spyOn(esriLoader, 'loadModules').mockResolvedValue([Arcade]);
+
       const popupTemplate = {
         title: '{name}',
         content: [{
-            type: 'expression',
-            expressionInfo: {
-              title: 'New expression',
-              expression: 'var feat = $feature\nvar label = `\n\t${feat["name"]} ${feat["age"]} years <br>\n\tstarted: ${feat["start"]}\n`\n\nreturn { \n  type : \'text\', \n  text : label\n}',
-              returnType: 'dictionary'
-            }
-          }],
+          type: 'expression',
+          expressionInfo: {
+            title: 'New expression',
+            expression: 'var feat = $feature\nvar label = `\n\t${feat["name"]} ${feat["age"]} years <br>\n\tstarted: ${feat["start"]}\n`\n\nreturn { \n  type : \'text\', \n  text : label\n}',
+            returnType: 'dictionary'
+          }
+        }],
         fieldInfos: [{
-            fieldName: 'name',
-            visible: true
-          }, {
-            fieldName: 'age',
-            format: {
-              places: 0,
-              digitSeparator: true
-            },
-            visible: true
-          }, {
-            fieldName: 'start',
-            format: {
-              dateFormat: 'short-date'
-            },
-            visible: true
-          }]
+          fieldName: 'name',
+          visible: true
+        }, {
+          fieldName: 'age',
+          format: {
+            places: 0,
+            digitSeparator: true
+          },
+          visible: true
+        }, {
+          fieldName: 'start',
+          format: {
+            dateFormat: 'short-date'
+          },
+          visible: true
+        }]
       };
       const layer = {
         popupEnabled: true,
         popupTemplate
       };
       const formatUsingLayerPopup = true;
-      const attributeFormats = {};
-      const result = await downloadUtils._getLabelFormat(layer, formatUsingLayerPopup, attributeFormats);
+
+      const attributeFormats: downloadUtils.IAttributeFormats = {};
+      const result: downloadUtils.ILabelFormat =
+        await downloadUtils._getLabelFormat(layer as any, formatUsingLayerPopup, attributeFormats);
       expect(result.type).toEqual('executor');
+
       loadModulesSpy.mockRestore();
     });
+
     it('should prepare labels without popup; formatUsingLayerPopup is true', async () => {
       const layer = {
         popupEnabled: false,
@@ -676,13 +698,16 @@ describe("downloadUtils", () => {
             type: 'integer'
           }
         ]
-      };
+      } as __esri.FeatureLayer;
       const formatUsingLayerPopup = true;
-      const attributeFormats = {};
-      const result = await downloadUtils._getLabelFormat(layer, formatUsingLayerPopup, attributeFormats);
+
+      const attributeFormats: downloadUtils.IAttributeFormats = {};
+      const result: downloadUtils.ILabelFormat =
+        await downloadUtils._getLabelFormat(layer as any, formatUsingLayerPopup, attributeFormats);
       expect(result.type).toEqual('unsupported');
       expect(result.format).toBeUndefined();
     });
+
     it('should prepare labels without popup; formatUsingLayerPopup is false', async () => {
       const layer = {
         popupEnabled: false,
@@ -696,14 +721,18 @@ describe("downloadUtils", () => {
             type: 'integer'
           }
         ]
-      };
+      } as __esri.FeatureLayer;
       const formatUsingLayerPopup = false;
-      const attributeFormats = {};
-      const result = await downloadUtils._getLabelFormat(layer, formatUsingLayerPopup, attributeFormats);
+
+      const attributeFormats: downloadUtils.IAttributeFormats = {};
+      const result: downloadUtils.ILabelFormat =
+        await downloadUtils._getLabelFormat(layer as any, formatUsingLayerPopup, attributeFormats);
       expect(result.type).toEqual('unsupported');
       expect(result.format).toBeUndefined();
     });
+
   });
+  */
   describe('_getSelectionSetNames', () => {
     it('should return selection set names for matching IDs', () => {
       const exportInfos = {

package/dist/collection/utils/test/downloadUtils.spec.tsx

@@ -555,6 +555,7 @@ describe("downloadUtils", () => {
 
   });
 
+  /*
   describe('_getLabelFormat', () => {
 
     it('should prepare labels from visible popup fields', async () => {
@@ -841,6 +842,7 @@ describe("downloadUtils", () => {
     });
 
   });
+  */
 
   describe('_getSelectionSetNames', () => {
 

package/dist/components/basemap-gallery2.js

@@ -14,6 +14,7 @@ const BasemapGallery = /*@__PURE__*/ proxyCustomElement(class BasemapGallery ext
     this.__registerHost();
     this.__attachShadow();
     this.mapView = undefined;
+    this.basemapConfig = undefined;
     this.basemapWidget = undefined;
   }
   //--------------------------------------------------------------------------
@@ -98,6 +99,7 @@ const BasemapGallery = /*@__PURE__*/ proxyCustomElement(class BasemapGallery ext
   static get style() { return basemapGalleryCss; }
 }, [1, "basemap-gallery", {
     "mapView": [16],
+    "basemapConfig": [16],
     "basemapWidget": [16]
   }]);
 function defineCustomElement() {