@esri/solutions-components 0.6.1 → 0.6.2

package/dist/esm/mapViewUtils-06a77be9.js

@@ -0,0 +1,362 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+import { c as EWorkflowType } from './interfaces-523c6558.js';
+
+/** @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.
+ */
+/**
+ * Query the layer for all features
+ *
+ * @param start zero-based index indicating where to begin retrieving features
+ * @param layer the layer to retrieve features from
+ * @param graphics stores the features
+ *
+ * @returns Promise with the featureSet from the layer that match the provided ids
+ */
+async function queryAllFeatures(start, layer, graphics) {
+  const num = layer.capabilities.query.maxRecordCount;
+  const query = layer.createQuery();
+  query.start = start;
+  query.num = num;
+  // TODO think through this once I'm back on crowdsource...seems like we may want an arg to control this
+  query.where = layer.definitionExpression || "1=1";
+  const result = await layer.queryFeatures(query);
+  graphics = graphics.concat(result.features);
+  return result.exceededTransferLimit ?
+    queryAllFeatures(start += num, layer, graphics) :
+    Promise.resolve(graphics);
+}
+/**
+ * Query the layer for OIDs based on any user drawn geometries or buffers
+ *
+ * @param geometries Array of geometries used for the selection of ids from the layer
+ * @param layer the layer to retrieve ids from
+ *
+ * @returns Promise with the OIDs of features from the layer that interset the provided geometries
+ */
+async function queryObjectIds(geometries, layer) {
+  let ids = [];
+  const queryDefs = geometries ? geometries.map(g => _intersectQuery(g, layer)) : [Promise.resolve()];
+  const results = await Promise.all(queryDefs);
+  results.forEach(resultIds => {
+    ids = [
+      ...ids,
+      ...resultIds || []
+    ];
+  });
+  return ids;
+}
+/**
+ * Query the layer for features that have the provided OIDs
+ *
+ * @param ids array of ObjectIDs to be used to query for features in a layer
+ * @param layer the layer to retrieve features from
+ * @param graphics the result graphics array
+ *
+ * @returns Promise with the featureSet from the layer that match the provided ids
+ */
+async function queryFeaturesByID(ids, layer, graphics) {
+  const num = layer.capabilities.query.maxRecordCount;
+  const start = 0;
+  const q = layer.createQuery();
+  q.start = start;
+  q.num = num;
+  q.objectIds = ids.slice(start, num);
+  const result = await layer.queryFeatures(q);
+  graphics = graphics.concat(result.features);
+  const remainingIds = ids.slice(num, ids.length);
+  return remainingIds.length > 0 ?
+    queryFeaturesByID(remainingIds, layer, graphics) :
+    Promise.resolve(graphics);
+}
+/**
+ * Query the layer for features that intersect the provided geometry
+ *
+ * @param start zero-based index indicating where to begin retrieving features
+ * @param layer the layer to retrieve features from
+ * @param geometry the geometry to apply to the spatial filter
+ * @param featuresCollection
+ *
+ * @returns Promise with the featureSet from the layer that match the provided ids
+ */
+async function queryFeaturesByGeometry(start, layer, geometry, featuresCollection) {
+  const num = layer.capabilities.query.maxRecordCount;
+  const query = layer.createQuery();
+  query.start = start;
+  query.num = num;
+  query.geometry = geometry;
+  const result = await layer.queryFeatures(query);
+  featuresCollection[layer.id] = featuresCollection[layer.id].concat(result.features);
+  return result.exceededTransferLimit ?
+    queryFeaturesByGeometry(start += num, layer, geometry, featuresCollection) :
+    Promise.resolve(featuresCollection);
+}
+/**
+ * Query the layer for the extent of features with the provided OIDs
+ *
+ * @param ids array of ObjectIDs to be used to query for features in a layer
+ * @param layer the layer to query
+ *
+ * @returns Promise with the Extent of all features that match the provided ids
+ */
+async function queryExtent(ids, layer) {
+  const query = layer.createQuery();
+  query.objectIds = ids;
+  return layer.queryExtent(query);
+}
+/**
+ * Union geometries based on geometry type
+ *
+ * @param geometries Array of geometries to union
+ * @param geometryEngine the geometry engine instance to perform the unions
+ *
+ * @returns Array of single unioned geometry for each geometry type
+ */
+function getQueryGeoms(geometries, geometryEngine) {
+  // sort and union by geom type so we have a single geom for each type to query with
+  return [
+    ..._unionGeoms(geometries, "polygon", geometryEngine),
+    ..._unionGeoms(geometries, "polyline", geometryEngine),
+    ..._unionGeoms(geometries, "point", geometryEngine)
+  ];
+}
+/**
+ * Union geometries based on geometry type
+ *
+ * @param geometries array of geometries to union
+ * @param type the current geometry type to union
+ * @param geometryEngine the geometry engine instance to perform the unions
+ *
+ * @returns Array of single unioned geometry for the provided geometry type
+ */
+function _unionGeoms(geometries, type, geometryEngine) {
+  const geoms = (geometries === null || geometries === void 0 ? void 0 : geometries.filter(g => g.type === type)) || [];
+  return geoms.length <= 1 ? geoms : [geometryEngine.union(geoms)];
+}
+/**
+ * Query the layer for ObjectIds of features that intersect the provided geometry
+ *
+ * @param geometry Geometry used for the selection of ids from the select layer view
+ * @param layer the layer to query
+ *
+ * @returns Promise that will contain the selected ids
+ */
+async function _intersectQuery(geometry, layer) {
+  const q = layer.createQuery();
+  q.spatialRelationship = "intersects";
+  q.geometry = geometry;
+  return layer.queryObjectIds(q);
+}
+
+/** @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.
+ */
+/**
+ * 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
+ *
+ */
+async function getMapLayerHash(mapView) {
+  let layerHash = {};
+  await mapView.when(() => {
+    layerHash = mapView.map.allLayers.toArray().reduce((prev, cur) => {
+      if (cur.type === "feature") {
+        prev[cur.id] = cur.title;
+      }
+      return prev;
+    }, {});
+  });
+  return layerHash;
+}
+/**
+ * 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
+ *
+ */
+async function getMapLayerIds(mapView) {
+  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;
+}
+/**
+ * Get a layer view by id
+ *
+ * @param mapView the map view to fetch the layer from
+ * @param id the id if the layer to fetch
+ *
+ * @returns Promise resolving with the fetched layer view
+ *
+ */
+async function getMapLayerView(mapView, id) {
+  const layer = await getMapLayer(mapView, id);
+  return layer ? await mapView.whenLayerView(layer) : undefined;
+}
+/**
+ * Get a layer by id
+ *
+ * @param mapView the map view to fetch the layer from
+ * @param id the id if the layer to fetch
+ *
+ * @returns Promise resolving with the fetched layer
+ *
+ */
+async function getMapLayer(mapView, id) {
+  let layers = [];
+  await mapView.when(() => {
+    layers = mapView.map.allLayers.toArray().filter((l) => {
+      return l.id === id;
+    });
+  });
+  return layers.length > 0 ? layers[0] : undefined;
+}
+/**
+ * Highlight features by OID
+ *
+ * @param ids the OIDs from the layer to highlight
+ * @param layerView the layer view to highlight
+ * @param mapView the map view used if updateExtent is true
+ * @param updateExtent optional (default false) boolean to indicate if we should zoom to the extent
+ *
+ * @returns Promise resolving with the highlight handle
+ *
+ */
+async function highlightFeatures(ids, layerView, mapView, updateExtent = false) {
+  if (updateExtent) {
+    await goToSelection(ids, layerView, mapView, false);
+  }
+  return layerView.highlight(ids);
+}
+/**
+ * Highlights features from all sets including the refine set
+ *
+ * @param selectionSets The selection sets to highlight
+ *
+ * @returns Promise resolving with the highlight handles
+ *
+ */
+async function highlightAllFeatures(selectionSets) {
+  const highlightInfos = getIdSets(selectionSets);
+  return Object.keys(highlightInfos).reduce((prev, cur) => {
+    const highlightInfo = highlightInfos[cur];
+    prev.push(highlightInfo.layerView.highlight(highlightInfo.ids));
+    return prev;
+  }, []);
+}
+/**
+ * Highlights features from all sets including the refine set
+ *
+ * @param selectionSets The selection sets to highlight
+ *
+ * @returns Promise resolving with the highlight handles
+ *
+ */
+function getIdSets(selectionSets) {
+  return selectionSets.reduce((prev, cur) => {
+    const lv = cur.layerView;
+    const id = lv === null || lv === void 0 ? void 0 : lv.layer.id;
+    if (id && Object.keys(prev).indexOf(id) > -1) {
+      prev[id].ids = [...new Set([
+          ...cur.selectedIds,
+          ...prev[id].ids
+        ])];
+    }
+    else if (id) {
+      prev[id] = {
+        layerView: lv,
+        ids: cur.selectedIds
+      };
+    }
+    if (cur.workflowType === EWorkflowType.REFINE) {
+      Object.keys(cur.refineInfos).forEach(k => {
+        const refineInfo = cur.refineInfos[k];
+        if (Object.keys(prev).indexOf(k) > -1) {
+          prev[k].ids = [...new Set([
+              ...refineInfo.addIds,
+              ...prev[k].ids
+            ])];
+          prev[k].ids = prev[k].ids.filter(_id => refineInfo.removeIds.indexOf(_id) < 0);
+        }
+      });
+    }
+    return prev;
+  }, {});
+}
+/**
+ * Flash features by OID
+ *
+ * @param ids the OIDs from the layer to highlight
+ * @param layerView the layer view to highlight
+ *
+ * @returns Promise resolving when the operation is complete
+ *
+ */
+async function flashSelection(ids, layerView, featureEffect) {
+  const filter = {
+    objectIds: ids
+  };
+  layerView.featureEffect = Object.assign(Object.assign({}, featureEffect), { filter });
+  setTimeout(() => {
+    layerView.featureEffect = undefined;
+  }, 1300);
+}
+/**
+ * Zoom to features based on OID
+ *
+ * @param ids the OIDs from the layer to go to
+ * @param layerView the layer view that contains the OIDs
+ * @param mapView the map view to show the extent change
+ * @param flashFeatures optional (default true) boolean to indicate if we should flash the features
+ *
+ * @returns Promise resolving when the operation is complete
+ *
+ */
+async function goToSelection(ids, layerView, mapView, flashFeatures = true, featureEffect = undefined) {
+  const result = await queryExtent(ids, layerView.layer);
+  await mapView.goTo(result.extent);
+  if (flashFeatures) {
+    await flashSelection(ids, layerView, featureEffect);
+  }
+}
+
+export { queryObjectIds as a, getQueryGeoms as b, getMapLayerView as c, queryFeaturesByGeometry as d, getIdSets as e, highlightAllFeatures as f, goToSelection as g, highlightFeatures as h, getMapLayerIds as i, queryAllFeatures as j, getMapLayerHash as k, queryFeaturesByID as q };

package/dist/esm/math-778f9699.js

@@ -0,0 +1,25 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.
+ * v1.4.2
+ */
+const clamp = (value, min, max) => Math.max(min, Math.min(value, max));
+const decimalNumberRegex = new RegExp(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/);
+const decimalPlaces = (value) => {
+  const match = ("" + value).match(decimalNumberRegex);
+  if (!match) {
+    return 0;
+  }
+  return Math.max(0, 
+  // Number of digits right of decimal point.
+  (match[1] ? match[1].length : 0) -
+    // Adjust for scientific notation.
+    (match[2] ? +match[2] : 0));
+};
+
+export { clamp as c, decimalPlaces as d };

package/dist/esm/mk-d08e7df4.js

@@ -0,0 +1,60 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+import { d as dayjs } from './calcite-input-time-picker-379ab2c4.js';
+import './index-d298aca9.js';
+import './form-58f5ab7c.js';
+import './dom-e14bb980.js';
+import './guid-5c8ddb45.js';
+import './resources-a9874e81.js';
+import './interactive-eaa1e00b.js';
+import './key-2c25459c.js';
+import './label-10a81bc6.js';
+import './loadable-fca3f617.js';
+import './locale-b550eae4.js';
+import './observers-b17e5da7.js';
+import './focusTrapComponent-45081255.js';
+import './time-18f4bea6.js';
+import './t9n-4c43412c.js';
+
+// Macedonian [mk]
+var locale = {
+  name: 'mk',
+  weekdays: 'недела_понеделник_вторник_среда_четврток_петок_сабота'.split('_'),
+  months: 'јануари_февруари_март_април_мај_јуни_јули_август_септември_октомври_ноември_декември'.split('_'),
+  weekStart: 1,
+  weekdaysShort: 'нед_пон_вто_сре_чет_пет_саб'.split('_'),
+  monthsShort: 'јан_фев_мар_апр_мај_јун_јул_авг_сеп_окт_ное_дек'.split('_'),
+  weekdaysMin: 'нe_пo_вт_ср_че_пе_сa'.split('_'),
+  ordinal: function ordinal(n) {
+    return n;
+  },
+  formats: {
+    LT: 'H:mm',
+    LTS: 'H:mm:ss',
+    L: 'D.MM.YYYY',
+    LL: 'D MMMM YYYY',
+    LLL: 'D MMMM YYYY H:mm',
+    LLLL: 'dddd, D MMMM YYYY H:mm'
+  },
+  relativeTime: {
+    future: 'после %s',
+    past: 'пред %s',
+    s: 'неколку секунди',
+    m: 'минута',
+    mm: '%d минути',
+    h: 'час',
+    hh: '%d часа',
+    d: 'ден',
+    dd: '%d дена',
+    M: 'месец',
+    MM: '%d месеци',
+    y: 'година',
+    yy: '%d години'
+  }
+};
+dayjs.locale(locale, null, true);
+
+export default locale;

package/dist/esm/nb-35ca03d9.js

@@ -0,0 +1,61 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+import { d as dayjs } from './calcite-input-time-picker-379ab2c4.js';
+import './index-d298aca9.js';
+import './form-58f5ab7c.js';
+import './dom-e14bb980.js';
+import './guid-5c8ddb45.js';
+import './resources-a9874e81.js';
+import './interactive-eaa1e00b.js';
+import './key-2c25459c.js';
+import './label-10a81bc6.js';
+import './loadable-fca3f617.js';
+import './locale-b550eae4.js';
+import './observers-b17e5da7.js';
+import './focusTrapComponent-45081255.js';
+import './time-18f4bea6.js';
+import './t9n-4c43412c.js';
+
+// Norwegian Bokmål [nb]
+var locale = {
+  name: 'nb',
+  weekdays: 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
+  weekdaysShort: 'sø._ma._ti._on._to._fr._lø.'.split('_'),
+  weekdaysMin: 'sø_ma_ti_on_to_fr_lø'.split('_'),
+  months: 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
+  monthsShort: 'jan._feb._mars_april_mai_juni_juli_aug._sep._okt._nov._des.'.split('_'),
+  ordinal: function ordinal(n) {
+    return n + ".";
+  },
+  weekStart: 1,
+  yearStart: 4,
+  formats: {
+    LT: 'HH:mm',
+    LTS: 'HH:mm:ss',
+    L: 'DD.MM.YYYY',
+    LL: 'D. MMMM YYYY',
+    LLL: 'D. MMMM YYYY [kl.] HH:mm',
+    LLLL: 'dddd D. MMMM YYYY [kl.] HH:mm'
+  },
+  relativeTime: {
+    future: 'om %s',
+    past: '%s siden',
+    s: 'noen sekunder',
+    m: 'ett minutt',
+    mm: '%d minutter',
+    h: 'en time',
+    hh: '%d timer',
+    d: 'en dag',
+    dd: '%d dager',
+    M: 'en måned',
+    MM: '%d måneder',
+    y: 'ett år',
+    yy: '%d år'
+  }
+};
+dayjs.locale(locale, null, true);
+
+export default locale;

package/dist/esm/nl-e815c488.js

@@ -0,0 +1,61 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+import { d as dayjs } from './calcite-input-time-picker-379ab2c4.js';
+import './index-d298aca9.js';
+import './form-58f5ab7c.js';
+import './dom-e14bb980.js';
+import './guid-5c8ddb45.js';
+import './resources-a9874e81.js';
+import './interactive-eaa1e00b.js';
+import './key-2c25459c.js';
+import './label-10a81bc6.js';
+import './loadable-fca3f617.js';
+import './locale-b550eae4.js';
+import './observers-b17e5da7.js';
+import './focusTrapComponent-45081255.js';
+import './time-18f4bea6.js';
+import './t9n-4c43412c.js';
+
+// Dutch [nl]
+var locale = {
+  name: 'nl',
+  weekdays: 'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split('_'),
+  weekdaysShort: 'zo._ma._di._wo._do._vr._za.'.split('_'),
+  weekdaysMin: 'zo_ma_di_wo_do_vr_za'.split('_'),
+  months: 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split('_'),
+  monthsShort: 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split('_'),
+  ordinal: function ordinal(n) {
+    return "[" + n + (n === 1 || n === 8 || n >= 20 ? 'ste' : 'de') + "]";
+  },
+  weekStart: 1,
+  yearStart: 4,
+  formats: {
+    LT: 'HH:mm',
+    LTS: 'HH:mm:ss',
+    L: 'DD-MM-YYYY',
+    LL: 'D MMMM YYYY',
+    LLL: 'D MMMM YYYY HH:mm',
+    LLLL: 'dddd D MMMM YYYY HH:mm'
+  },
+  relativeTime: {
+    future: 'over %s',
+    past: '%s geleden',
+    s: 'een paar seconden',
+    m: 'een minuut',
+    mm: '%d minuten',
+    h: 'een uur',
+    hh: '%d uur',
+    d: 'een dag',
+    dd: '%d dagen',
+    M: 'een maand',
+    MM: '%d maanden',
+    y: 'een jaar',
+    yy: '%d jaar'
+  }
+};
+dayjs.locale(locale, null, true);
+
+export default locale;

package/dist/esm/observers-b17e5da7.js

@@ -0,0 +1,51 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.
+ * v1.4.2
+ */
+/**
+ * This utility ensures observers are created only for browser contexts.
+ *
+ * @param type - the type of observer to create
+ * @param callback - the observer callback
+ * @param options - the observer options
+ */
+function createObserver(type, callback, options) {
+  const Observer = getObserver(type);
+  return new Observer(callback, options);
+}
+function getObserver(type) {
+  // based on https://github.com/whatwg/dom/issues/126#issuecomment-1049814948
+  class ExtendedMutationObserver extends window.MutationObserver {
+    constructor(callback) {
+      super(callback);
+      this.observedEntry = [];
+      this.callback = callback;
+    }
+    observe(target, options) {
+      this.observedEntry.push({ target, options });
+      return super.observe(target, options);
+    }
+    unobserve(target) {
+      const newObservedEntries = this.observedEntry.filter((observed) => observed.target !== target);
+      this.observedEntry = [];
+      this.callback(super.takeRecords(), this);
+      this.disconnect();
+      newObservedEntries.forEach((observed) => this.observe(observed.target, observed.options));
+    }
+  }
+  return (function () {
+    return (type === "intersection"
+      ? window.IntersectionObserver
+      : type === "mutation"
+        ? ExtendedMutationObserver
+        : window.ResizeObserver);
+  })();
+}
+
+export { createObserver as c };