@esri/solutions-components 0.8.37 → 0.8.38

package/dist/cjs/lv-ac3b6560.js

@@ -0,0 +1,67 @@
+/*!
+ * 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-686f45e7.js');
+require('./index-ff18be0d.js');
+require('./form-71a108a7.js');
+require('./dom-1c78fa73.js');
+require('./guid-a7528dfa.js');
+require('./resources-1c0e54c1.js');
+require('./interactive-7e5c7df4.js');
+require('./browser-d12b6cd5.js');
+require('./key-7ed07912.js');
+require('./label-85cf6821.js');
+require('./component-d48747c9.js');
+require('./loadable-5d538ba2.js');
+require('./locale-d2a1066a.js');
+require('./observers-2a59d471.js');
+require('./focusTrapComponent-0c672330.js');
+require('./time-089ab043.js');
+require('./math-11993213.js');
+require('./t9n-ef615628.js');
+require('./openCloseComponent-e752f2a5.js');
+require('./Validation-425b2de4.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-select-tools_3.cjs.entry.js

@@ -7,17 +7,17 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const index = require('./index-79b35510.js');
-const locale = require('./locale-48d76c59.js');
-const mapViewUtils = require('./mapViewUtils-911698e5.js');
+const index = require('./index-ff18be0d.js');
+const locale = require('./locale-6973733d.js');
+const mapViewUtils = require('./mapViewUtils-78b14528.js');
 const interfaces = require('./interfaces-7cd0a48a.js');
-const publicNotificationStore = require('./publicNotificationStore-3bfbbed3.js');
-const downloadUtils = require('./downloadUtils-83bf79ba.js');
+const publicNotificationStore = require('./publicNotificationStore-691f6f30.js');
+const downloadUtils = require('./downloadUtils-839a1425.js');
 require('./esri-loader-fce6a9cb.js');
-require('./index-c078ea5f.js');
-require('./solution-resource-a577e84f.js');
+require('./index-97020c9d.js');
+require('./solution-resource-ffe3c333.js');
 require('./index-f64944ad.js');
-require('./restHelpersGet-dbaa28df.js');
+require('./restHelpersGet-afc74285.js');
 
 const mapSelectToolsCss = ":host{display:block}.div-visible{display:inherit}.div-visible-search{display:flex;height:44px;align-items:center;padding-bottom:0}.div-not-visible{display:none}.padding-bottom-1{padding-bottom:1rem}.padding-top-1{padding-top:1rem}.search-widget{width:100% !important;border:1px solid var(--calcite-color-border-input)}.w-100{width:100%}.w-50{width:50%}.search-distance-container{padding-top:\"1rem\" !important}.end-border{border-inline-end:1px solid var(--calcite-color-border-2)}.search-distance{display:flex;padding-top:1rem}.font-bold{font:bold}.border-bottom{border-bottom:1px solid var(--calcite-color-border-2)}.tooltip-container{display:flex}.padding-start-1-2{padding-inline-start:0.5rem}.icon{--calcite-color-icon-color:var(--calcite-color-brand)}.tooltip-message{padding:5px 8px;font-weight:var(--calcite-font-weight-normal);color:var(--calcite-color-text-2)}";
 const MapSelectToolsStyle0 = mapSelectToolsCss;

package/dist/cjs/mapViewUtils-78b14528.js

@@ -0,0 +1,510 @@
+/*!
+ * 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-7cd0a48a.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 OIDs valid for any definition expressions applied to the layer.
+ *
+ * This query allows OIDs to be returned in the same order as shown in the FeatureTable.
+ * FeatureLayer.queryObjectIds can return OIDs in a different order.
+ *
+ * @param start zero-based index indicating where to begin retrieving features
+ * @param layer the layer to retrieve features from
+ * @param graphics stores the features
+ * @param orderBy One or more field names used to order the query results.
+ *                Specify ASC (ascending) or DESC (descending) after the field name to control the order.
+ *                The default order is ASC.
+ *
+ * @returns Promise with the OIDs sorted based on any orderBy definitions
+ */
+async function queryAllOidsWithQueryFeatures(start, layer, graphics, orderBy) {
+    const num = layer.capabilities.query.maxRecordCount;
+    const query = layer.createQuery();
+    query.start = start;
+    query.num = num;
+    query.returnGeometry = false;
+    query.orderByFields = orderBy;
+    query.outFields = [layer.objectIdField];
+    query.where = layer.definitionExpression || "1=1";
+    const result = await layer.queryFeatures(query);
+    graphics = graphics.concat(result.features);
+    return result.exceededTransferLimit ?
+        queryAllOidsWithQueryFeatures(start += num, layer, graphics, orderBy) :
+        Promise.resolve(graphics.map(g => g.attributes[layer.objectIdField]));
+}
+/**
+ * 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 = layer.definitionExpression || "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
+ * If no ids are provided all features will be returned
+ *
+ * @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, fields) {
+    var _a;
+    const num = (_a = layer.capabilities) === null || _a === void 0 ? void 0 : _a.query.maxRecordCount;
+    const start = 0;
+    if (ids.length === 0) {
+        ids = await layer.queryObjectIds();
+    }
+    const q = layer.createQuery();
+    q.returnGeometry = returnGeometry;
+    q.objectIds = ids.slice(start, num);
+    if (outSpatialReference) {
+        q.outSpatialReference = outSpatialReference;
+    }
+    if (fields) {
+        q.outFields = fields;
+    }
+    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, fields) :
+        Promise.resolve(graphics);
+}
+/**
+ * Query the layer for features that have the provided globalId
+ *
+ * @param globalId globalId to be used to query for a feature in a layer
+ * @param layer the layer to retrieve features from
+ *
+ * @returns Promise with the featureSet from the layer that match the provided globalId
+ */
+async function queryFeaturesByGlobalID(globalIds, layer) {
+    const globalIdField = layer.globalIdField;
+    if (!globalIdField) {
+        return [];
+    }
+    const q = layer.createQuery();
+    q.returnGeometry = false;
+    q.outFields = [layer.objectIdField];
+    q.where = globalIds.map(g => `${globalIdField} = '${g}'`).join(" or ");
+    const result = await layer.queryFeatures(q);
+    return result.features;
+}
+/**
+ * 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
+ * @param onlyShowUpdatableLayers when true only layers that support editing and updates will be returned
+ *
+ * @returns Promise resolving with an array of layer names
+ *
+ */
+async function getMapLayerHash(mapView, onlyShowUpdatableLayers) {
+    let layerHash;
+    await mapView.when(() => {
+        layerHash = mapView.map.allLayers.toArray().reduce((prev, cur) => {
+            if (cur.type === "feature" || (cur === null || cur === void 0 ? void 0 : cur.type) === "subtype-group") {
+                prev[cur.id] = {
+                    name: cur.title,
+                    supportsUpdate: undefined
+                };
+            }
+            return prev;
+        }, {});
+    });
+    return _getFinalHash(onlyShowUpdatableLayers, layerHash, mapView);
+}
+/**
+ * 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
+ *
+ */
+async function getMapTableHash(mapView, onlyShowUpdatableTables) {
+    let tableHash;
+    await mapView.when(() => {
+        tableHash = mapView.map.allTables.toArray().reduce((prev, cur) => {
+            prev[cur.id] = {
+                name: cur.title,
+                supportsUpdate: undefined
+            };
+            return prev;
+        }, {});
+    });
+    return _getFinalHash(onlyShowUpdatableTables, tableHash, mapView);
+}
+/**
+ * Get the final hash
+ *
+ * @param onlyShowUpdatable boolean when true only layers that support editing and the update capability will be returned
+ * @param hash IMapItemHash key: layer id, values: name, supportsUpdate
+ * @param mapView the map view to fetch the layer from
+ *
+ * @returns Promise resolving with IMapItemHash
+ *
+ */
+async function _getFinalHash(onlyShowUpdatable, hash, mapView) {
+    if (onlyShowUpdatable) {
+        const editableHash = {};
+        const keys = Object.keys(hash);
+        for (let i = 0; i < keys.length; i++) {
+            const id = keys[i];
+            const layer = await getLayerOrTable(mapView, id);
+            await layer.load();
+            await layer.when();
+            editableHash[id] = {
+                name: hash[id].name,
+                supportsUpdate: layer.editingEnabled && layer.capabilities.operations.supportsUpdate
+            };
+        }
+        return editableHash;
+    }
+    else {
+        return hash;
+    }
+}
+/**
+ * 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 getFeatureLayerView(mapView, id) {
+    const layer = await getLayerOrTable(mapView, id);
+    return layer ? await mapView.whenLayerView(layer) : undefined;
+}
+/**
+ * Get a layer or table by id
+ *
+ * @param mapView the map view to fetch the layer from
+ * @param id the id of the layer or table to fetch
+ *
+ * @returns Promise resolving with the fetched layer or table
+ *
+ */
+async function getLayerOrTable(mapView, id) {
+    let layers = [];
+    await mapView.when(() => {
+        layers = [
+            ...mapView.map.allLayers.toArray(),
+            ...mapView.map.allTables.toArray()
+        ].filter((l) => {
+            return l.id === id;
+        });
+    });
+    return layers.length > 0 ? layers[0] : undefined;
+}
+/**
+ * Gets all of the layers from the current map when the map and their layerView is ready
+ *
+ * @param mapView the map view to fetch the layer names from
+ *
+ * @returns Promise resolving with an array of all layers
+ *
+ */
+async function getAllLayers(mapView) {
+    const layers = mapView.map.allLayers.toArray();
+    let layerViewPromises;
+    await mapView.when(() => {
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        layerViewPromises = layers.map(l => mapView.whenLayerView(l));
+    });
+    await Promise.allSettled(layerViewPromises);
+    return layers;
+}
+/**
+ * Get all of the tables from the current map when the map and their layerView is ready
+ * @param mapView the map view to fetch the table names from
+ * @returns Promise resolving with an array of all tables
+ *
+ */
+async function getAllTables(mapView) {
+    const tables = mapView.map.allTables.toArray();
+    let layerViewPromises;
+    await mapView.when(() => {
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        layerViewPromises = tables.map(t => t.load());
+    });
+    await Promise.allSettled(layerViewPromises);
+    return tables;
+}
+/**
+ * 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
+ * @param zoomToScale optional (default 0) zoomScale that individual points will use when zoomed to
+ *
+ * @returns Promise resolving with the highlight handle
+ */
+async function highlightFeatures(ids, layerView, mapView, updateExtent = false, zoomToScale = 0) {
+    if (updateExtent) {
+        await goToSelection(ids, layerView, mapView, false, undefined, zoomToScale);
+        //wait for sometime to load the feature in layerView then only the highlight will work
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    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
+ * @param featureEffect optional (default undefined) feature effect when flashing the features
+ * @param zoomToScale optional (default to 0) zoomScale that individual points will use when zoomed to
+ * @returns Promise resolving when the operation is complete
+ *
+ */
+async function goToSelection(ids, layerView, mapView, flashFeatures = true, featureEffect = undefined, zoomToScale = 0) {
+    const result = await queryExtent(ids, layerView.layer);
+    const goToParams = { target: result.extent };
+    if (result.count === 1 && layerView.layer.geometryType === 'point' && zoomToScale) {
+        goToParams.scale = zoomToScale;
+    }
+    await mapView.goTo(goToParams);
+    if (flashFeatures) {
+        await flashSelection(ids, layerView, featureEffect);
+    }
+}
+
+exports.getAllLayers = getAllLayers;
+exports.getAllTables = getAllTables;
+exports.getFeatureLayerView = getFeatureLayerView;
+exports.getIdSets = getIdSets;
+exports.getLayerOrTable = getLayerOrTable;
+exports.getMapLayerHash = getMapLayerHash;
+exports.getMapTableHash = getMapTableHash;
+exports.getQueryGeoms = getQueryGeoms;
+exports.goToSelection = goToSelection;
+exports.highlightAllFeatures = highlightAllFeatures;
+exports.highlightFeatures = highlightFeatures;
+exports.queryAllIds = queryAllIds;
+exports.queryAllOidsWithQueryFeatures = queryAllOidsWithQueryFeatures;
+exports.queryFeaturesByGeometry = queryFeaturesByGeometry;
+exports.queryFeaturesByGlobalID = queryFeaturesByGlobalID;
+exports.queryFeaturesByID = queryFeaturesByID;
+exports.queryObjectIds = queryObjectIds;

package/dist/cjs/mk-a3053dea.js

@@ -0,0 +1,67 @@
+/*!
+ * 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-686f45e7.js');
+require('./index-ff18be0d.js');
+require('./form-71a108a7.js');
+require('./dom-1c78fa73.js');
+require('./guid-a7528dfa.js');
+require('./resources-1c0e54c1.js');
+require('./interactive-7e5c7df4.js');
+require('./browser-d12b6cd5.js');
+require('./key-7ed07912.js');
+require('./label-85cf6821.js');
+require('./component-d48747c9.js');
+require('./loadable-5d538ba2.js');
+require('./locale-d2a1066a.js');
+require('./observers-2a59d471.js');
+require('./focusTrapComponent-0c672330.js');
+require('./time-089ab043.js');
+require('./math-11993213.js');
+require('./t9n-ef615628.js');
+require('./openCloseComponent-e752f2a5.js');
+require('./Validation-425b2de4.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/mode-3478ba36.js

@@ -0,0 +1,19 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+'use strict';
+
+const lightMode = 'calcite-mode-light';
+const darkMode = 'calcite-mode-dark';
+function getMode(el) {
+    const closestEl = el === null || el === void 0 ? void 0 : el.closest(`.${darkMode}, .${lightMode}`);
+    if (closestEl == null) {
+        const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+        return prefersDark ? 'dark' : 'light';
+    }
+    return (closestEl === null || closestEl === void 0 ? void 0 : closestEl.classList.contains(darkMode)) ? 'dark' : 'light';
+}
+
+exports.getMode = getMode;