@esri/solutions-components 0.5.3 → 0.5.4

package/dist/collection/components/map-search/test/map-search.spec.js

@@ -0,0 +1,53 @@
+/** @license
+ * Copyright 2022 Esri
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { h } from '@stencil/core';
+import { newSpecPage } from '@stencil/core/testing';
+import { MapSearch } from '../map-search';
+import * as locale from "../../../utils/locale";
+import * as translations from "../../../assets/t9n/map-search/resources.json";
+jest.setTimeout(30000);
+afterEach(() => {
+    jest.restoreAllMocks();
+});
+let mapView;
+beforeEach(() => {
+    jest.spyOn(locale, "getLocaleComponentStrings").mockImplementation(() => [
+        translations
+    ]);
+    mapView = {
+        map: {
+            layers: {
+                add: () => { },
+                getItemAt: () => { return -1; },
+                findIndex: () => { return -1; }
+            }
+        }
+    };
+});
+describe('map-search', () => {
+    xit('renders', async () => {
+        const page = await newSpecPage({
+            components: [MapSearch],
+            template: () => (h("map-search", { mapView: mapView })),
+        });
+        expect(page.root).toEqualHtml(`
+      <map-search>
+        <div class="search-widget"></div>
+      </map-search>
+    `);
+        await page.root.clear();
+    });
+});

package/dist/collection/components/map-select-tools/map-select-tools.js

@@ -421,34 +421,37 @@ export class MapSelectTools {
    */
   async _sketchGraphicsChanged(event, forceUpdate = false) {
     const graphics = event.detail.graphics;
-    if (!forceUpdate) {
-      this._sketchGraphic = graphics[0];
-    }
-    this._workflowType = this._useLayerFeaturesEnabled ? EWorkflowType.SELECT : EWorkflowType.SKETCH;
-    if (this._workflowType === EWorkflowType.SKETCH) {
-      this._drawTools.updateGraphics();
-    }
-    this._updateLabel();
-    this._clearSearchWidget();
-    if (this._useLayerFeaturesEnabled && !forceUpdate) {
-      const geometries = Array.isArray(graphics) && graphics.length > 0 && graphics[0] ? graphics.map(g => g.geometry) : this.geometries;
-      await this._selectLayerFeatures(geometries[0]);
-    }
-    else {
-      const oids = graphics.reduce((prev, cur) => {
-        var _a;
-        if ((_a = cur === null || cur === void 0 ? void 0 : cur.layer) === null || _a === void 0 ? void 0 : _a.objectIdField) {
-          prev.push(cur.attributes[cur.layer.objectIdField]);
-        }
-        else if (cur.getObjectId) {
-          prev.push(cur.getObjectId());
+    if (graphics.length > 0 && graphics[0]) {
+      if (!forceUpdate) {
+        this._sketchGraphic = graphics[0];
+      }
+      this._workflowType = this._useLayerFeaturesEnabled ? EWorkflowType.SELECT : EWorkflowType.SKETCH;
+      if (this._workflowType === EWorkflowType.SKETCH) {
+        this._drawTools.updateGraphics();
+      }
+      this._updateLabel();
+      this._clearSearchWidget();
+      if (this._useLayerFeaturesEnabled && !forceUpdate) {
+        // Will only ever be a single graphic
+        const geometries = Array.isArray(graphics) ? graphics.map(g => g.geometry) : this.geometries;
+        await this._selectLayerFeatures(geometries[0]);
+      }
+      else {
+        const oids = graphics.reduce((prev, cur) => {
+          var _a;
+          if ((_a = cur === null || cur === void 0 ? void 0 : cur.layer) === null || _a === void 0 ? void 0 : _a.objectIdField) {
+            prev.push(cur.attributes[cur.layer.objectIdField]);
+          }
+          else if (cur.getObjectId) {
+            prev.push(cur.getObjectId());
+          }
+          return prev;
+        }, []);
+        const useOIDs = event.detail.useOIDs && oids.length > 0;
+        this._updateSelection(graphics, useOIDs, oids);
+        if (useOIDs) {
+          await this._highlightFeatures(oids);
         }
-        return prev;
-      }, []);
-      const useOIDs = event.detail.useOIDs && oids.length > 0;
-      this._updateSelection(graphics, useOIDs, oids);
-      if (useOIDs) {
-        await this._highlightFeatures(oids);
       }
     }
   }
@@ -570,7 +573,6 @@ export class MapSelectTools {
     this._selectedIds = [];
     this._distance = undefined;
     this._unit = undefined;
-    this._sketchGraphic = undefined;
     if (clearLabel) {
       this._selectionLabel = "";
       this._labelName.value = "";
@@ -737,14 +739,12 @@ export class MapSelectTools {
    */
   _useLayerFeaturesEnabledChanged() {
     this._useLayerFeaturesEnabled = !this._useLayerFeaturesEnabled;
-    if (this._sketchGraphic) {
-      void this._sketchGraphicsChanged({
-        detail: {
-          graphics: [this._sketchGraphic],
-          useOIDs: false
-        }
-      });
-    }
+    void this._sketchGraphicsChanged({
+      detail: {
+        graphics: [this._sketchGraphic],
+        useOIDs: false
+      }
+    });
   }
   /**
    * Fetches the component's translations

package/dist/collection/components/map-select-tools/test/map-select-tools.e2e.js

@@ -0,0 +1,24 @@
+/** @license
+ * Copyright 2022 Esri
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { newE2EPage } from '@stencil/core/testing';
+xdescribe('map-select-tools', () => {
+    it('renders', async () => {
+        const page = await newE2EPage();
+        await page.setContent('<map-select-tools></map-select-tools>');
+        const element = await page.find('map-select-tools');
+        expect(element).toHaveClass('hydrated');
+    });
+});

package/dist/collection/components/map-select-tools/test/map-select-tools.spec.js

@@ -0,0 +1,349 @@
+/** @license
+ * Copyright 2022 Esri
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { h } from '@stencil/core';
+import { newSpecPage } from '@stencil/core/testing';
+import { MapSelectTools } from '../map-select-tools';
+import * as locale from "../../../utils/locale";
+import * as translations from "../../../assets/t9n/map-select-tools/resources.json";
+import { LayerView } from "../../../utils/test/mocks/jsApi";
+import * as mapViewUtils from "../../../utils/mapViewUtils";
+import * as queryUtils from "../../../utils/queryUtils";
+import { EWorkflowType } from '../../../utils/interfaces';
+jest.setTimeout(30000);
+afterEach(() => {
+    jest.restoreAllMocks();
+});
+let mapView;
+let _unknown;
+beforeEach(() => {
+    jest.spyOn(locale, "getLocaleComponentStrings").mockImplementation(() => [
+        translations
+    ]);
+    jest.spyOn(mapViewUtils, "highlightFeatures").mockImplementation(async () => {
+        return { remove: () => { } };
+    });
+    jest.spyOn(mapViewUtils, "goToSelection").mockImplementation(async () => { });
+    jest.spyOn(queryUtils, "getQueryGeoms").mockImplementation((geoms) => {
+        return geoms;
+    });
+    jest.spyOn(queryUtils, "queryObjectIds").mockImplementation(async (oids) => {
+        return oids.map((oid, i) => i);
+    });
+    jest.spyOn(console, 'warn').mockImplementation(() => { });
+    mapView = {
+        map: {
+            layers: {
+                add: () => { },
+                getItemAt: () => { return -1; },
+                findIndex: () => { return -1; }
+            }
+        }
+    };
+    _unknown = {};
+});
+xdescribe('map-select-tools', () => {
+    it('renders', async () => {
+        const page = await newSpecPage({
+            components: [MapSelectTools],
+            template: () => (h("map-select-tools", { mapView: mapView })),
+        });
+        expect(page.root).toEqualHtml(`
+      <map-select-tools>
+       <div class="padding-bottom-1">
+         <calcite-radio-group class="w-100">
+           <calcite-radio-group-item checked="" class="end-border w-50" value="SEARCH">
+             Search
+           </calcite-radio-group-item>
+           <calcite-radio-group-item class="w-50" value="SKETCH">
+             Sketch
+           </calcite-radio-group-item>
+         </calcite-radio-group>
+       </div>
+       <div class="div-visible-search">
+         <div class="search-widget"></div>
+       </div>
+       <div class="div-not-visible">
+         <calcite-label layout="inline">
+           <calcite-checkbox></calcite-checkbox>
+           Use layer features
+         </calcite-label>
+       </div>
+       <div class="div-not-visible">
+         <map-draw-tools active="" border=""></map-draw-tools>
+       </div>
+       <div class="div-not-visible">
+         <refine-selection-tools active="" border="" mode="ADD" refinemode="SUBSET"></refine-selection-tools>
+       </div>
+       <calcite-label class="search-distance">
+         Search Distance
+         <buffer-tools></buffer-tools>
+       </calcite-label>
+     </map-select-tools>
+    `);
+        const actual = await page.root.getSelection();
+        expect(actual.workflowType).toEqual(EWorkflowType.SEARCH);
+        expect(actual.selectedIds.length).toEqual(0);
+    });
+    it('fires selectionSetChange event when geometries are cleared', async () => {
+        const page = await newSpecPage({
+            components: [MapSelectTools],
+            template: () => (h("map-select-tools", { geometries: [_unknown], mapView: mapView })),
+        });
+        expect(page.root.geometries.length).toEqual(1);
+        page.doc.addEventListener("selectionSetChange", (evt) => {
+            expect(evt.detail).toEqual(0);
+        });
+        page.root.geometries = [];
+    });
+    it('fires selectionSetChange event when geometries are changed', async () => {
+        const page = await newSpecPage({
+            components: [MapSelectTools],
+            template: () => (h("map-select-tools", { geometries: [_unknown], mapView: mapView, selectLayerView: new LayerView() })),
+        });
+        expect(page.root.geometries.length).toEqual(1);
+        let selectionSetChange = (evt) => {
+            expect(evt.detail).toEqual(2);
+        };
+        page.doc.addEventListener("selectionSetChange", selectionSetChange);
+        page.root.geometries = [...page.root.geometries, _unknown];
+    });
+    it('clears geometries on clearSelection', async () => {
+        const page = await newSpecPage({
+            components: [MapSelectTools],
+            template: () => (h("map-select-tools", { geometries: [_unknown], mapView: mapView, selectLayerView: new LayerView() })),
+        });
+        expect(page.root.geometries.length).toEqual(1);
+        let selectionSetChange = (evt) => {
+            expect(evt.detail).toEqual(0);
+        };
+        page.doc.addEventListener("selectionSetChange", selectionSetChange);
+        page.root.clearSelection();
+    });
+    it('can reload existing SELECT selectionSet', async () => {
+        const layerView = new LayerView();
+        const selectionSet = {
+            id: 12345,
+            workflowType: EWorkflowType.SELECT,
+            searchResult: undefined,
+            buffer: _unknown,
+            distance: 100,
+            download: true,
+            unit: "feet",
+            label: "selection-label",
+            selectedIds: [0],
+            layerView,
+            geometries: [_unknown],
+            refineSelectLayers: [],
+            refineIds: undefined
+        };
+        const page = await newSpecPage({
+            components: [MapSelectTools],
+            template: () => (h("map-select-tools", { selectLayerView: layerView, selectionSet: selectionSet, mapView: mapView })),
+        });
+        page.doc.addEventListener("workflowTypeChange", (evt) => {
+            expect(evt.detail).toEqual(EWorkflowType.SELECT);
+        });
+        expect(page.root).toEqualHtml(`
+      <map-select-tools>
+       <div class="padding-bottom-1">
+         <calcite-radio-group class="w-100">
+           <calcite-radio-group-item class="end-border w-50" value="SEARCH">
+             Search
+           </calcite-radio-group-item>
+           <calcite-radio-group-item checked="" class="w-50" value="SKETCH">
+             Sketch
+           </calcite-radio-group-item>
+         </calcite-radio-group>
+       </div>
+       <div class="div-not-visible">
+         <div class="search-widget"></div>
+       </div>
+       <div class="div-visible">
+         <calcite-label layout="inline">
+           <calcite-checkbox></calcite-checkbox>
+           Use layer features
+         </calcite-label>
+       </div>
+       <div class="div-visible">
+         <map-draw-tools active="" border=""></map-draw-tools>
+       </div>
+       <div class="div-not-visible">
+         <refine-selection-tools active="" border="" mode="ADD" refinemode="SUBSET"></refine-selection-tools>
+       </div>
+       <calcite-label class="search-distance">
+         Search Distance
+         <buffer-tools distance="100" unit="feet"></buffer-tools>
+       </calcite-label>
+     </map-select-tools>
+    `);
+        const actual = await page.root.getSelection();
+        expect(actual.label.startsWith("Layer")).toEqual(true);
+    });
+    it('can reload existing SKETCH selectionSet', async () => {
+        const layerView = new LayerView();
+        const selectionSet = {
+            id: 12345,
+            workflowType: EWorkflowType.SKETCH,
+            searchResult: undefined,
+            buffer: _unknown,
+            distance: 100,
+            download: true,
+            unit: "feet",
+            label: "selection-label",
+            selectedIds: [0],
+            layerView,
+            geometries: [_unknown],
+            refineSelectLayers: [],
+            refineIds: undefined
+        };
+        const page = await newSpecPage({
+            components: [MapSelectTools],
+            template: () => (h("map-select-tools", { selectLayerView: layerView, selectionSet: selectionSet, mapView: mapView })),
+        });
+        page.doc.addEventListener("workflowTypeChange", (evt) => {
+            expect(evt.detail).toEqual(EWorkflowType.SKETCH);
+        });
+        expect(page.root).toEqualHtml(`
+     <map-select-tools>
+       <div class="padding-bottom-1">
+         <calcite-radio-group class="w-100">
+           <calcite-radio-group-item class="end-border w-50" value="SEARCH">
+             Search
+           </calcite-radio-group-item>
+           <calcite-radio-group-item checked="" class="w-50" value="SKETCH">
+             Sketch
+           </calcite-radio-group-item>
+         </calcite-radio-group>
+       </div>
+       <div class="div-not-visible">
+         <div class="search-widget"></div>
+       </div>
+       <div class="div-visible">
+         <calcite-label layout="inline">
+           <calcite-checkbox></calcite-checkbox>
+           Use layer features
+         </calcite-label>
+       </div>
+       <div class="div-visible">
+         <map-draw-tools active="" border=""></map-draw-tools>
+       </div>
+       <div class="div-not-visible">
+         <refine-selection-tools active="" border="" mode="ADD" refinemode="SUBSET"></refine-selection-tools>
+       </div>
+       <calcite-label class="search-distance">
+         Search Distance
+         <buffer-tools distance="100" unit="feet"></buffer-tools>
+       </calcite-label>
+     </map-select-tools>
+    `);
+        const actual = await page.root.getSelection();
+        expect(actual.label.startsWith("Sketch")).toEqual(true);
+    });
+    it('can reload existing SEARCH selectionSet', async () => {
+        const layerView = new LayerView();
+        const selectionSet = {
+            id: 12345,
+            workflowType: EWorkflowType.SEARCH,
+            searchResult: undefined,
+            buffer: _unknown,
+            distance: 100,
+            download: true,
+            unit: "feet",
+            label: "selection-label",
+            selectedIds: [0, 1],
+            layerView,
+            geometries: [_unknown, _unknown],
+            refineSelectLayers: [],
+            refineIds: undefined
+        };
+        const page = await newSpecPage({
+            components: [MapSelectTools],
+            template: () => (h("map-select-tools", { isUpdate: true, selectLayerView: layerView, selectionSet: selectionSet, mapView: mapView })),
+        });
+        page.doc.addEventListener("workflowTypeChange", (evt) => {
+            expect(evt.detail).toEqual(EWorkflowType.SEARCH);
+        });
+        expect(page.root).toEqualHtml(`
+     <map-select-tools>
+       <div class="padding-bottom-1">
+         <calcite-radio-group class="w-100">
+           <calcite-radio-group-item checked="" class="end-border w-50" value="SEARCH">
+             Search
+           </calcite-radio-group-item>
+           <calcite-radio-group-item class="w-50" value="SKETCH">
+             Sketch
+           </calcite-radio-group-item>
+         </calcite-radio-group>
+       </div>
+       <div class="div-visible-search">
+         <div class="search-widget"></div>
+       </div>
+       <div class="div-not-visible">
+         <calcite-label layout="inline">
+           <calcite-checkbox></calcite-checkbox>
+           Use layer features
+         </calcite-label>
+       </div>
+       <div class="div-not-visible">
+         <map-draw-tools active="" border=""></map-draw-tools>
+       </div>
+       <div class="div-not-visible">
+         <refine-selection-tools active="" border="" mode="ADD" refinemode="SUBSET"></refine-selection-tools>
+       </div>
+       <calcite-label class="search-distance">
+         Search Distance
+         <buffer-tools distance="100" unit="feet"></buffer-tools>
+       </calcite-label>
+     </map-select-tools>
+    `);
+        const actual = await page.root.getSelection();
+        expect(actual.id).toEqual(selectionSet.id);
+    });
+    it('handles sketchGraphicsChange', async () => {
+        const page = await newSpecPage({
+            components: [MapSelectTools],
+            template: () => (h("map-select-tools", { geometries: [_unknown], mapView: mapView, selectLayerView: new LayerView() })),
+        });
+        expect(page.root.geometries.length).toEqual(1);
+        page.win.dispatchEvent(new CustomEvent("sketchGraphicsChange", { detail: [] }));
+        expect(page.root.geometries.length).toEqual(0);
+        _unknown = { geometry: {} };
+        page.win.dispatchEvent(new CustomEvent("sketchGraphicsChange", { detail: [_unknown, _unknown] }));
+        expect(page.root.geometries.length).toEqual(2);
+        page.win.dispatchEvent(new CustomEvent("sketchGraphicsChange", { detail: undefined }));
+        expect(page.root.geometries.length).toEqual(2);
+    });
+    it('handles sketchGraphicsChange', async () => {
+        const page = await newSpecPage({
+            components: [MapSelectTools],
+            template: () => (h("map-select-tools", { geometries: [], mapView: mapView, selectLayerView: new LayerView() })),
+        });
+        page.win.dispatchEvent(new CustomEvent("layerSelectionGraphicsChange", { detail: undefined }));
+        expect(page.root.geometries.length).toEqual(0);
+        page.doc.addEventListener("selectionSetChange", (evt) => {
+            expect(evt.detail).toEqual(1);
+        });
+        _unknown = {
+            attributes: { "OID": 1 },
+            layer: {
+                objectIdField: "OID"
+            },
+            geometry: {}
+        };
+        page.win.dispatchEvent(new CustomEvent("layerSelectionGraphicsChange", { detail: [_unknown] }));
+        expect(page.root.geometries.length).toEqual(1);
+    });
+});

package/dist/collection/components/media-card/test/media-card.e2e.js

@@ -0,0 +1,24 @@
+/** @license
+ * Copyright 2022 Esri
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { newE2EPage } from '@stencil/core/testing';
+xdescribe('media-card', () => {
+    it('renders', async () => {
+        const page = await newE2EPage();
+        await page.setContent('<media-card></media-card>');
+        const element = await page.find('media-card');
+        expect(element).toHaveClass('hydrated');
+    });
+});

package/dist/collection/components/media-card/test/media-card.spec.js

@@ -0,0 +1,32 @@
+/** @license
+ * Copyright 2022 Esri
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { newSpecPage } from '@stencil/core/testing';
+import { MediaCard } from '../media-card';
+xdescribe('media-card', () => {
+    it('renders', async () => {
+        const page = await newSpecPage({
+            components: [MediaCard],
+            html: `<media-card></media-card>`,
+        });
+        expect(page.root).toEqualHtml(`
+      <media-card>
+        <mock:shadow-root>
+          <slot></slot>
+        </mock:shadow-root>
+      </media-card>
+    `);
+    });
+});

package/dist/collection/components/pci-calculator/test/pci-calculator.e2e.js

@@ -0,0 +1,24 @@
+/** @license
+ * Copyright 2022 Esri
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { newE2EPage } from '@stencil/core/testing';
+xdescribe('pci-calculator', () => {
+    it('renders', async () => {
+        const page = await newE2EPage();
+        await page.setContent('<pci-calculator></pci-calculator>');
+        const element = await page.find('pci-calculator');
+        expect(element).toHaveClass('hydrated');
+    });
+});

package/dist/collection/components/pci-calculator/test/pci-calculator.spec.js

@@ -0,0 +1,32 @@
+/** @license
+ * Copyright 2022 Esri
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { newSpecPage } from '@stencil/core/testing';
+import { PciCalculator } from '../pci-calculator';
+xdescribe('pci-calculator', () => {
+    it('renders', async () => {
+        const page = await newSpecPage({
+            components: [PciCalculator],
+            html: `<pci-calculator></pci-calculator>`,
+        });
+        expect(page.root).toEqualHtml(`
+      <pci-calculator>
+        <mock:shadow-root>
+          <slot></slot>
+        </mock:shadow-root>
+      </pci-calculator>
+    `);
+    });
+});