@esri/solutions-components 0.8.2 → 0.8.3

package/dist/solutions-components/map-tools.entry.js

@@ -0,0 +1,371 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+import { r as registerInstance, h, a as Host, g as getElement } from './index-bdfaac50.js';
+import { g as getLocaleComponentStrings } from './locale-d9463a95.js';
+import { l as loadModules } from './loadModules-827c5581.js';
+import './esri-loader-af2bbfd5.js';
+import './_commonjsHelpers-3cd6d4ee.js';
+
+const mapToolsCss = ":host{display:block}.display-none{display:none}.margin-top-1-2{margin-top:0.5rem}.square-32{width:32px;height:32px}.square-40{width:40px;height:40px}.square-48{width:48px;height:48px}.width-40{width:40px}.square-40-41{width:40px;height:41px}.border-bottom{border-bottom:1px solid var(--calcite-color-border-3)}.box-shadow{box-shadow:0 1px 2px rgba(0, 0, 0, 0.3)}.margin-bottom-1-2{margin-bottom:0.5rem}";
+
+const MapTools = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        /**
+         * string[]: List of widget names that have been added to the UI
+         * This prop is only used when enableSingleExpand is false
+         */
+        this._widgets = [];
+        this.basemapConfig = undefined;
+        this.enableLegend = undefined;
+        this.enableFloorFilter = undefined;
+        this.enableFullscreen = undefined;
+        this.enableSearch = undefined;
+        this.enableBasemap = undefined;
+        this.enableHome = undefined;
+        this.enableSingleExpand = undefined;
+        this.homeZoomToolsSize = "m";
+        this.layout = "vertical";
+        this.mapView = undefined;
+        this.mapWidgetsSize = "m";
+        this.position = "top-right";
+        this.searchConfiguration = undefined;
+        this.stackTools = true;
+        this.toolOrder = undefined;
+        this._hasFloorInfo = false;
+        this._translations = undefined;
+        this._showTools = true;
+        this._showBasemapWidget = false;
+        this._showFloorFilter = false;
+        this._showFullscreen = false;
+        this._showLegendWidget = false;
+        this._showSearchWidget = false;
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Watch handlers
+    //
+    //--------------------------------------------------------------------------
+    /**
+     * When the mapView loads check if it supports floor awareness
+     */
+    async mapViewWatchHandler() {
+        await this.mapView.when(() => {
+            var _a, _b;
+            this._hasFloorInfo = (_b = (_a = this.mapView) === null || _a === void 0 ? void 0 : _a.map) === null || _b === void 0 ? void 0 : _b.floorInfo;
+        });
+    }
+    /**
+     * When the _showBasemapWidget property is true display the basemap gallery
+     */
+    async _showBasemapWidgetWatchHandler(v) {
+        if (v) {
+            this.mapView.ui.add(this._basemapElement.basemapWidget, {
+                position: this.position,
+                index: 1
+            });
+        }
+        else {
+            this.mapView.ui.remove(this._basemapElement.basemapWidget);
+        }
+    }
+    /**
+     * When the _showBasemapWidget property is true display the basemap gallery
+     */
+    async _showFloorFilterWatchHandler(v) {
+        const widget = this._floorFilterElement.floorFilterWidget;
+        if (v) {
+            this.mapView.ui.add(widget, {
+                position: this.position,
+                index: 1
+            });
+        }
+        else {
+            this.mapView.ui.remove(widget);
+        }
+    }
+    /**
+     * When the _showFullscreen property is true the app will consume the full screen
+     */
+    async _showFullscreenWatchHandler(v) {
+        const fs = this._fullscreenElement.fullscreenWidget;
+        if (v) {
+            if (fs.viewModel.state === "ready") {
+                fs.viewModel.enter();
+            }
+        }
+        else {
+            if (fs.viewModel.state === "active") {
+                fs.viewModel.exit();
+            }
+        }
+    }
+    /**
+     * When the _showLegendWidget property is true display the search widget
+     */
+    async _showLegendWidgetWatchHandler(v) {
+        if (v) {
+            this.mapView.ui.add(this._legendElement.legendWidget, {
+                position: this.position,
+                index: 1
+            });
+        }
+        else {
+            this.mapView.ui.remove(this._legendElement.legendWidget);
+        }
+    }
+    /**
+     * When the _showSearchWidget property is true display the search widget
+     */
+    async _showSearchWidgetWatchHandler(v) {
+        if (v) {
+            this.mapView.ui.add(this._searchElement.searchWidget, {
+                position: this.position,
+                index: 1
+            });
+        }
+        else {
+            this.mapView.ui.remove(this._searchElement.searchWidget);
+        }
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Methods (public)
+    //
+    //--------------------------------------------------------------------------
+    //--------------------------------------------------------------------------
+    //
+    //  Events (public)
+    //
+    //--------------------------------------------------------------------------
+    //--------------------------------------------------------------------------
+    //
+    //  Functions (lifecycle)
+    //
+    //--------------------------------------------------------------------------
+    /**
+     * StencilJS: Called once just after the component is first connected to the DOM.
+     */
+    async componentWillLoad() {
+        await this._getTranslations();
+        await this._initModules();
+    }
+    /**
+     * StencilJS: Renders the component.
+     */
+    render() {
+        this._setZoomToolsSize();
+        const toggleIcon = this._showTools ? "chevrons-up" : "chevrons-down";
+        const toolsClass = this._showTools ? "" : "display-none";
+        const searchClass = this._showSearchWidget ? "" : "display-none";
+        const basemapClass = this._showBasemapWidget ? "" : "display-none";
+        const legendClass = this._showLegendWidget ? "" : "display-none";
+        const floorFilterClass = this._showFloorFilter ? "" : "display-none";
+        const fullscreenClass = this._showFullscreen ? "" : "display-none";
+        const expandTip = this._showTools ? this._translations.collapse : this._translations.expand;
+        const containerClass = !this.enableBasemap && !this.enableFullscreen && !this.enableLegend && !this.enableSearch ? "display-none" : "";
+        const toolMarginClass = this.enableSingleExpand ? "margin-top-1-2" : "";
+        const toolOrder = this.toolOrder ? this.toolOrder : ["legend", "search", "fullscreen", "floorfilter"];
+        const shadowClass = this.stackTools ? "box-shadow" : "";
+        return (h(Host, null, h("div", { class: containerClass }, this.enableSingleExpand ? (h("div", { class: "box-shadow" }, this._getActionGroup(toggleIcon, false, expandTip, () => this._toggleTools()))) : undefined, h("div", { class: `${toolMarginClass} ${shadowClass} ${toolsClass}` }, this._getMapWidgets(toolOrder))), h("basemap-gallery", { basemapConfig: this.basemapConfig, class: basemapClass, mapView: this.mapView, ref: (el) => { this._basemapElement = el; } }), h("map-search", { class: searchClass, mapView: this.mapView, ref: (el) => { this._searchElement = el; }, resultGraphicEnabled: true, searchConfiguration: this.searchConfiguration }), h("map-legend", { class: legendClass, mapView: this.mapView, ref: (el) => { this._legendElement = el; } }), h("map-fullscreen", { class: fullscreenClass, mapView: this.mapView, onFullscreenStateChange: (evt) => this._fullscreenStateChange(evt.detail), ref: (el) => { this._fullscreenElement = el; } }), h("floor-filter", { class: floorFilterClass, enabled: this.enableFloorFilter, mapView: this.mapView, ref: (el) => { this._floorFilterElement = el; } })));
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Functions (protected)
+    //
+    //--------------------------------------------------------------------------
+    /**
+     * Load esri javascript api modules
+     *
+     * @returns Promise resolving when function is done
+     *
+     * @protected
+     */
+    async _initModules() {
+        const [Expand] = await loadModules([
+            "esri/widgets/Expand"
+        ]);
+        this.Expand = Expand;
+    }
+    /**
+     * Set the size of the zoom tools based on the user defined homeZoomToolsSize variable.
+     *
+     * @protected
+     */
+    _setZoomToolsSize() {
+        var _a, _b;
+        const zoomIn = (_a = document.getElementsByClassName("esri-zoom")[0]) === null || _a === void 0 ? void 0 : _a.children[0];
+        const zoomOut = (_b = document.getElementsByClassName("esri-zoom")[0]) === null || _b === void 0 ? void 0 : _b.children[1];
+        if (zoomIn && zoomOut) {
+            const size = this.homeZoomToolsSize === "s" ? "32px" : this.homeZoomToolsSize === "m" ? "40px" : "48px";
+            zoomIn.style.width = size;
+            zoomIn.style.height = size;
+            zoomOut.style.width = size;
+            zoomOut.style.height = size;
+        }
+    }
+    /**
+     * Get the map widgets considering the user defined enabled values and tool order
+     *
+     * @protected
+     */
+    _getMapWidgets(toolOrder) {
+        const fullscreenIcon = this._showFullscreen ? "full-screen-exit" : "full-screen";
+        const fullscreenTip = this._showFullscreen ? this._translations.exitFullscreen : this._translations.enterFullscreen;
+        return toolOrder.map(t => {
+            var _a, _b, _c, _d, _e;
+            switch (t) {
+                case "legend":
+                    return this.enableLegend && this.enableSingleExpand ?
+                        this._getActionGroup("legend", false, this._translations.legend, () => this._showLegend()) :
+                        this.enableLegend ? this._getWidget(t, (_a = this._legendElement) === null || _a === void 0 ? void 0 : _a.legendWidget, true) : undefined;
+                case "search":
+                    return this.enableSearch && this.enableSingleExpand ?
+                        this._getActionGroup("magnifying-glass", false, this._translations.search, () => this._search()) :
+                        this.enableSearch ? this._getWidget(t, (_b = this._searchElement) === null || _b === void 0 ? void 0 : _b.searchWidget, true) : undefined;
+                case "fullscreen":
+                    return this.enableFullscreen && this.enableSingleExpand ?
+                        this._getActionGroup(fullscreenIcon, false, fullscreenTip, () => this._expand()) :
+                        this.enableFullscreen ? this._getWidget(t, (_c = this._fullscreenElement) === null || _c === void 0 ? void 0 : _c.fullscreenWidget, false) : undefined;
+                case "basemap":
+                    return this.enableBasemap && this.enableSingleExpand ?
+                        this._getActionGroup("basemap", false, this._translations.basemap, () => this._toggleBasemapPicker()) :
+                        this.enableBasemap ? this._getWidget(t, (_d = this._basemapElement) === null || _d === void 0 ? void 0 : _d.basemapWidget, true) : undefined;
+                case "floorfilter":
+                    return this.enableFloorFilter && this._hasFloorInfo && this.enableSingleExpand ?
+                        this._getActionGroup("urban-model", false, this._translations.floorFilter, () => this._toggleFloorFilter()) :
+                        this.enableFloorFilter && this._hasFloorInfo ? this._getWidget(t, (_e = this._floorFilterElement) === null || _e === void 0 ? void 0 : _e.floorFilterWidget, true) : undefined;
+                default:
+                    break;
+            }
+        });
+    }
+    /**
+     * Respond to fullscreen state change and ensure our state var is in sync
+     *
+     * @param state The fullscreen view model's state.
+     *
+     * @protected
+     */
+    _fullscreenStateChange(state) {
+        if (state === "ready" && this._showFullscreen) {
+            this._showFullscreen = false;
+        }
+        else if (state === "active" && !this._showFullscreen) {
+            this._showFullscreen = true;
+        }
+    }
+    /**
+     * 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) {
+        const sizeClass = this.mapWidgetsSize === "s" ? "square-32" : this.mapWidgetsSize === "m" ? "square-40" : "square-48";
+        const stackClass = this.stackTools ? "" : "margin-bottom-1-2";
+        const shadowClass = this.stackTools ? "" : "box-shadow";
+        return (h("div", null, h("calcite-action", { alignment: "center", class: `${sizeClass} ${stackClass} border-bottom ${shadowClass}`, compact: false, disabled: disabled, icon: icon, id: icon, onClick: func, scale: "s", text: "" }, h("calcite-icon", { icon: "cheveron-up", scale: "s", slot: "icon" })), h("calcite-tooltip", { label: "", placement: "trailing", "reference-element": icon }, h("span", null, tip))));
+    }
+    /**
+     * Add the widget to the UI and optionally to an Expand widget
+     *
+     * @param name the icon to display for the current action
+     * @param content the widget to display
+     * @param internalExpand when true the widget will be added to an Expand widget
+     *
+     * @protected
+     */
+    _getWidget(name, content, internalExpand) {
+        if (this._widgets.indexOf(name) < 0 && this.mapView && content) {
+            const i = this.toolOrder.indexOf(name);
+            const exp = new this.Expand({
+                view: this.mapView,
+                content
+            });
+            const v = this.enableHome ? 2 : 1;
+            this.mapView.ui.add(internalExpand ? exp : content, {
+                position: this.position,
+                index: i > -1 ? i + v : 1
+            });
+            this._widgets.push(name);
+        }
+    }
+    /**
+     * Show/Hide the legend widget
+     */
+    _showLegend() {
+        this._showLegendWidget = !this._showLegendWidget;
+        this._showTools = false;
+    }
+    /**
+     * Show/Hide the search widget
+     */
+    _search() {
+        this._showSearchWidget = !this._showSearchWidget;
+        this._showTools = false;
+    }
+    /**
+     * Show/Hide the basemap picker
+     */
+    _toggleBasemapPicker() {
+        this._showBasemapWidget = !this._showBasemapWidget;
+        this._showTools = false;
+    }
+    /**
+     * Show/Hide the floor filter
+     */
+    _toggleFloorFilter() {
+        this._showFloorFilter = !this._showFloorFilter;
+        this._showTools = false;
+    }
+    /**
+     * Enter/Exit fullscreen mode
+     */
+    _expand() {
+        this._showFullscreen = !this._showFullscreen;
+    }
+    /**
+     * Show/Hide the map tools
+     */
+    _toggleTools() {
+        if (!this._showTools) {
+            this._showBasemapWidget = false;
+            this._showSearchWidget = false;
+            this._showLegendWidget = false;
+            this._showFloorFilter = false;
+        }
+        this._showTools = !this._showTools;
+    }
+    /**
+     * Fetches the component's translations
+     *
+     * @returns Promise when complete
+     * @protected
+     */
+    async _getTranslations() {
+        const messages = await getLocaleComponentStrings(this.el);
+        this._translations = messages[0];
+    }
+    get el() { return getElement(this); }
+    static get watchers() { return {
+        "mapView": ["mapViewWatchHandler"],
+        "_showBasemapWidget": ["_showBasemapWidgetWatchHandler"],
+        "_showFloorFilter": ["_showFloorFilterWatchHandler"],
+        "_showFullscreen": ["_showFullscreenWatchHandler"],
+        "_showLegendWidget": ["_showLegendWidgetWatchHandler"],
+        "_showSearchWidget": ["_showSearchWidgetWatchHandler"]
+    }; }
+};
+MapTools.style = mapToolsCss;
+
+export { MapTools as map_tools };

package/dist/solutions-components/mapViewUtils-436a516e.js

@@ -0,0 +1,261 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+import { q as queryExtent } from './queryUtils-2529c537.js';
+import { a as EWorkflowType } from './interfaces-586e863c.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.
+ */
+/**
+ * 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") {
+                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(() => {
+        layerViewPromises = layers.map(l => mapView.whenLayerView(l));
+    });
+    await Promise.allSettled(layerViewPromises);
+    return layers;
+}
+/**
+ * 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);
+        //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 === 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 { getAllLayers as a, getFeatureLayerView as b, goToSelection as c, getMapLayerHash as d, getIdSets as e, highlightAllFeatures as f, getLayerOrTable as g, highlightFeatures as h, getMapTableHash as i };

package/dist/solutions-components/math-efada7a9.js

@@ -0,0 +1,54 @@
+/*!
+ * 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-design-system/blob/main/LICENSE.md for details.
+ * v2.4.0
+ */
+const clamp = (value, min, max) => Math.max(min, Math.min(value, max));
+const decimalNumberRegex = new RegExp(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/);
+/**
+ * Returns the quantity of real decimal places for a number, which excludes trailing zeros.
+ *
+ * Adapted from {@link https://stackoverflow.com/questions/10454518/javascript-how-to-retrieve-the-number-of-decimals-of-a-string-number}.
+ *
+ * @param decimal - decimal value
+ * @param value
+ * @returns {number} the amount of decimal places in a number
+ */
+const decimalPlaces = (value) => {
+    const match = ("" + value).match(decimalNumberRegex);
+    if (!match || parseInt(match[1]) === 0) {
+        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));
+};
+function getDecimals(value) {
+    if (decimalPlaces(value) > 0 && value > 0) {
+        return parseFloat(`0.${value.toString().split(".")[1]}`);
+    }
+    return value;
+}
+function remap(value, fromMin, fromMax, toMin, toMax) {
+    return ((value - fromMin) * (toMax - toMin)) / (fromMax - fromMin) + toMin;
+}
+/**
+ * Helper to determine if a value is close to the edge of a range within a threshold.
+ *
+ * @param value
+ * @param range
+ * @param threshold
+ * @returns -1 if close to lower edge, 1 if close to upper edge, 0 otherwise.
+ */
+function closeToRangeEdge(value, range, threshold) {
+    return value < threshold ? -1 : value > range - threshold ? 1 : 0;
+}
+
+export { closeToRangeEdge as a, clamp as c, decimalPlaces as d, getDecimals as g, remap as r };