@esri/solutions-components 0.6.2 → 0.6.3

package/dist/cjs/lv-cb236d46.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-a27cc51a.js');
+require('./index-6654298b.js');
+require('./form-f62ca3df.js');
+require('./dom-af578b3b.js');
+require('./guid-100bd1be.js');
+require('./resources-3a47be9f.js');
+require('./interactive-e8f05d26.js');
+require('./browser-e514d838.js');
+require('./key-2522c20b.js');
+require('./label-71d4d3b5.js');
+require('./loadable-6571b6b9.js');
+require('./locale-83870af6.js');
+require('./observers-5c9538b2.js');
+require('./focusTrapComponent-65d39be9.js');
+require('./time-a1d60db6.js');
+require('./t9n-f82f4304.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/map-tools.cjs.entry.js

@@ -0,0 +1,111 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-6654298b.js');
+const locale = require('./locale-b113c6b2.js');
+const interfaces = require('./interfaces-ad03ec39.js');
+require('./_commonjsHelpers-384729db.js');
+
+const mapToolsCss = ":host{display:block}.display-none{display:none}.border{border:1px solid var(--calcite-ui-border-3)}.margin-top-1-2{margin-top:0.5rem}";
+
+const MapTools = class {
+  constructor(hostRef) {
+    index.registerInstance(this, hostRef);
+    this.expandMap = index.createEvent(this, "expandMap", 7);
+    this.layout = "vertical";
+    this.mapView = undefined;
+    this._translations = undefined;
+    this._showTools = true;
+    this._showBasemapPicker = false;
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Functions (lifecycle)
+  //
+  //--------------------------------------------------------------------------
+  /**
+   * StencilJS: Called once just after the component is first connected to the DOM.
+   */
+  async componentWillLoad() {
+    await this._getTranslations();
+  }
+  /**
+   * StencilJS: Renders the component.
+   */
+  render() {
+    const toggleIcon = this._showTools ? "chevrons-up" : "chevrons-down";
+    const toolsClass = this._showTools ? "" : "display-none";
+    return (index.h(index.Host, null, index.h("div", { class: "display-flex" }, index.h("calcite-action", { alignment: "center", class: "border", compact: false, icon: toggleIcon, onClick: () => { this._toggleTools(); }, text: "" }), index.h("calcite-action-bar", { class: `border margin-top-1-2 ${toolsClass}`, "expand-disabled": true, layout: this.layout }, this._getActionGroup("home", false, this._translations.home, () => this._goHome()), this._getActionGroup("plus", false, this._translations.zoomIn, () => this._zoomIn()), this._getActionGroup("minus", false, this._translations.zoomOut, () => this._zoomOut()), this._getActionGroup("list", false, this._translations.list, () => this._showList()), this._getActionGroup("magnifying-glass", false, this._translations.search, () => this._search()), this._getActionGroup("expand", false, this._translations.expand, () => this._expand()), this._getActionGroup("basemap", false, this._translations.basemap, () => this._toggleBasemapPicker())))));
+  }
+  /**
+   * Get a calcite action group for the current action
+   *
+   * @param icon the icon to display for the current action
+   * @param disabled should the action be disabled
+   * @param tip information tip to display helpful details to end user
+   * @param func the associated onClick function to execute
+   *
+   * @returns the dom node for the action group
+   *
+   * @protected
+   */
+  _getActionGroup(icon, disabled, tip, func) {
+    return (index.h("calcite-action-group", null, index.h("calcite-action", { alignment: "center", compact: false, disabled: disabled, icon: icon, id: icon, onClick: func, text: "" }, index.h("calcite-icon", { icon: "cheveron-up", scale: "s", slot: "icon" })), index.h("calcite-tooltip", { label: "", placement: "bottom", "reference-element": icon }, index.h("span", null, tip))));
+  }
+  // Need to discuss this with the team
+  _goHome() {
+    alert("go home");
+  }
+  // need to discuss this with the team
+  _showList() {
+    alert("show list");
+  }
+  // Need to discuss this with the team
+  _search() {
+    alert("search");
+  }
+  // Need to explore map fixed zoom in considerations
+  _zoomIn() {
+    alert("zoom in");
+  }
+  // Need to explore map fixed zoom out considerations
+  _zoomOut() {
+    alert("zoom out");
+  }
+  _toggleBasemapPicker() {
+    this._showBasemapPicker = !this._showBasemapPicker;
+  }
+  /**
+   * Emit the expand map event
+   *
+   * @returns void
+   *
+   * @protected
+   */
+  _expand() {
+    this.expandMap.emit(interfaces.EExpandType.EXPAND);
+  }
+  _toggleTools() {
+    this._showTools = !this._showTools;
+  }
+  /**
+   * Fetches the component's translations
+   *
+   * @returns Promise when complete
+   * @protected
+   */
+  async _getTranslations() {
+    const messages = await locale.getLocaleComponentStrings(this.el);
+    this._translations = messages[0];
+  }
+  get el() { return index.getElement(this); }
+};
+MapTools.style = mapToolsCss;
+
+exports.map_tools = MapTools;

package/dist/cjs/mapViewUtils-efc49df7.js

@@ -0,0 +1,369 @@
+/*!
+ * 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-ad03ec39.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 IDs
+ *
+ * @param layer the layer to retrieve features from
+ *
+ * @returns Promise with the featureSet from the layer that match the provided ids
+ */
+async function queryAllIds(layer) {
+  const query = layer.createQuery();
+  query.where = "1=1";
+  return await layer.queryObjectIds(query);
+}
+/**
+ * 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, returnGeometry, outSpatialReference) {
+  const num = layer.capabilities.query.maxRecordCount;
+  const start = 0;
+  const q = layer.createQuery();
+  q.start = start;
+  q.num = num;
+  q.returnGeometry = returnGeometry;
+  q.objectIds = ids.slice(start, num);
+  if (outSpatialReference) {
+    q.outSpatialReference = outSpatialReference;
+  }
+  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, returnGeometry, outSpatialReference) :
+    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.queryAllIds = queryAllIds;
+exports.queryFeaturesByGeometry = queryFeaturesByGeometry;
+exports.queryFeaturesByID = queryFeaturesByID;
+exports.queryObjectIds = queryObjectIds;

package/dist/cjs/math-0eb2ec5c.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.3
+ */
+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-00e34bda.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-a27cc51a.js');
+require('./index-6654298b.js');
+require('./form-f62ca3df.js');
+require('./dom-af578b3b.js');
+require('./guid-100bd1be.js');
+require('./resources-3a47be9f.js');
+require('./interactive-e8f05d26.js');
+require('./browser-e514d838.js');
+require('./key-2522c20b.js');
+require('./label-71d4d3b5.js');
+require('./loadable-6571b6b9.js');
+require('./locale-83870af6.js');
+require('./observers-5c9538b2.js');
+require('./focusTrapComponent-65d39be9.js');
+require('./time-a1d60db6.js');
+require('./t9n-f82f4304.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-6e0d9b4c.js

@@ -0,0 +1,64 @@
+/*!
+ * 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-a27cc51a.js');
+require('./index-6654298b.js');
+require('./form-f62ca3df.js');
+require('./dom-af578b3b.js');
+require('./guid-100bd1be.js');
+require('./resources-3a47be9f.js');
+require('./interactive-e8f05d26.js');
+require('./browser-e514d838.js');
+require('./key-2522c20b.js');
+require('./label-71d4d3b5.js');
+require('./loadable-6571b6b9.js');
+require('./locale-83870af6.js');
+require('./observers-5c9538b2.js');
+require('./focusTrapComponent-65d39be9.js');
+require('./time-a1d60db6.js');
+require('./t9n-f82f4304.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;