@esri/solutions-components 0.6.1 → 0.6.2

package/dist/cjs/lv-7ed56721.js

@@ -0,0 +1,62 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+'use strict';
+
+const calciteInputTimePicker_entry = require('./calcite-input-time-picker-1c90d5aa.js');
+require('./index-6654298b.js');
+require('./form-bbb48e39.js');
+require('./dom-5fd13fa0.js');
+require('./guid-66679eda.js');
+require('./resources-17e31c94.js');
+require('./interactive-39ec70c2.js');
+require('./key-5b33d77d.js');
+require('./label-345b79b7.js');
+require('./loadable-30ee9cda.js');
+require('./locale-180f4242.js');
+require('./observers-f7aad52c.js');
+require('./focusTrapComponent-8e851fe9.js');
+require('./time-0ae619db.js');
+require('./t9n-44f8e750.js');
+
+// Latvian [lv]
+var locale = {
+  name: 'lv',
+  weekdays: 'svētdiena_pirmdiena_otrdiena_trešdiena_ceturtdiena_piektdiena_sestdiena'.split('_'),
+  months: 'janvāris_februāris_marts_aprīlis_maijs_jūnijs_jūlijs_augusts_septembris_oktobris_novembris_decembris'.split('_'),
+  weekStart: 1,
+  weekdaysShort: 'Sv_P_O_T_C_Pk_S'.split('_'),
+  monthsShort: 'jan_feb_mar_apr_mai_jūn_jūl_aug_sep_okt_nov_dec'.split('_'),
+  weekdaysMin: 'Sv_P_O_T_C_Pk_S'.split('_'),
+  ordinal: function ordinal(n) {
+    return n;
+  },
+  formats: {
+    LT: 'HH:mm',
+    LTS: 'HH:mm:ss',
+    L: 'DD.MM.YYYY.',
+    LL: 'YYYY. [gada] D. MMMM',
+    LLL: 'YYYY. [gada] D. MMMM, HH:mm',
+    LLLL: 'YYYY. [gada] D. MMMM, dddd, HH:mm'
+  },
+  relativeTime: {
+    future: 'pēc %s',
+    past: 'pirms %s',
+    s: 'dažām sekundēm',
+    m: 'minūtes',
+    mm: '%d minūtēm',
+    h: 'stundas',
+    hh: '%d stundām',
+    d: 'dienas',
+    dd: '%d dienām',
+    M: 'mēneša',
+    MM: '%d mēnešiem',
+    y: 'gada',
+    yy: '%d gadiem'
+  }
+};
+calciteInputTimePicker_entry.dayjs.locale(locale, null, true);
+
+exports.default = locale;

package/dist/cjs/mapViewUtils-9c67134b.js

@@ -0,0 +1,375 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+'use strict';
+
+const interfaces = require('./interfaces-842c84a1.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 === interfaces.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);
+  }
+}
+
+exports.getIdSets = getIdSets;
+exports.getMapLayerHash = getMapLayerHash;
+exports.getMapLayerIds = getMapLayerIds;
+exports.getMapLayerView = getMapLayerView;
+exports.getQueryGeoms = getQueryGeoms;
+exports.goToSelection = goToSelection;
+exports.highlightAllFeatures = highlightAllFeatures;
+exports.highlightFeatures = highlightFeatures;
+exports.queryAllFeatures = queryAllFeatures;
+exports.queryFeaturesByGeometry = queryFeaturesByGeometry;
+exports.queryFeaturesByID = queryFeaturesByID;
+exports.queryObjectIds = queryObjectIds;

package/dist/cjs/math-c948c17d.js

@@ -0,0 +1,28 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+'use strict';
+
+/*!
+ * 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));
+};
+
+exports.clamp = clamp;
+exports.decimalPlaces = decimalPlaces;

package/dist/cjs/mk-f6d33563.js

@@ -0,0 +1,62 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+'use strict';
+
+const calciteInputTimePicker_entry = require('./calcite-input-time-picker-1c90d5aa.js');
+require('./index-6654298b.js');
+require('./form-bbb48e39.js');
+require('./dom-5fd13fa0.js');
+require('./guid-66679eda.js');
+require('./resources-17e31c94.js');
+require('./interactive-39ec70c2.js');
+require('./key-5b33d77d.js');
+require('./label-345b79b7.js');
+require('./loadable-30ee9cda.js');
+require('./locale-180f4242.js');
+require('./observers-f7aad52c.js');
+require('./focusTrapComponent-8e851fe9.js');
+require('./time-0ae619db.js');
+require('./t9n-44f8e750.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 години'
+  }
+};
+calciteInputTimePicker_entry.dayjs.locale(locale, null, true);
+
+exports.default = locale;

package/dist/cjs/nb-bd0ca554.js

@@ -0,0 +1,63 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+'use strict';
+
+const calciteInputTimePicker_entry = require('./calcite-input-time-picker-1c90d5aa.js');
+require('./index-6654298b.js');
+require('./form-bbb48e39.js');
+require('./dom-5fd13fa0.js');
+require('./guid-66679eda.js');
+require('./resources-17e31c94.js');
+require('./interactive-39ec70c2.js');
+require('./key-5b33d77d.js');
+require('./label-345b79b7.js');
+require('./loadable-30ee9cda.js');
+require('./locale-180f4242.js');
+require('./observers-f7aad52c.js');
+require('./focusTrapComponent-8e851fe9.js');
+require('./time-0ae619db.js');
+require('./t9n-44f8e750.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'
+  }
+};
+calciteInputTimePicker_entry.dayjs.locale(locale, null, true);
+
+exports.default = locale;

package/dist/cjs/nl-eadfdfb4.js

@@ -0,0 +1,63 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+'use strict';
+
+const calciteInputTimePicker_entry = require('./calcite-input-time-picker-1c90d5aa.js');
+require('./index-6654298b.js');
+require('./form-bbb48e39.js');
+require('./dom-5fd13fa0.js');
+require('./guid-66679eda.js');
+require('./resources-17e31c94.js');
+require('./interactive-39ec70c2.js');
+require('./key-5b33d77d.js');
+require('./label-345b79b7.js');
+require('./loadable-30ee9cda.js');
+require('./locale-180f4242.js');
+require('./observers-f7aad52c.js');
+require('./focusTrapComponent-8e851fe9.js');
+require('./time-0ae619db.js');
+require('./t9n-44f8e750.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'
+  }
+};
+calciteInputTimePicker_entry.dayjs.locale(locale, null, true);
+
+exports.default = locale;