@esri/solutions-components 0.5.3 → 0.5.4

package/dist/solutions-components/utils/downloadUtils.js

@@ -0,0 +1,386 @@
+/** @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.
+ */
+//#region Declarations
+import { exportCSV } from "./csvUtils";
+import { exportPDF } from "./pdfUtils";
+import { loadModules } from "./loadModules";
+import { queryFeaturesByID } from "./queryUtils";
+export { ILabel } from "./pdfUtils";
+const lineSeparatorChar = "|";
+//#endregion
+//#region Public functions
+/**
+ * Downloads csv of mailing labels for the provided list of ids
+ *
+ * @param selectionSetNames Names of the selection sets used to provide ids
+ * @param layer Layer providing features and attributes for download
+ * @param ids List of ids to download
+ * @param formatUsingLayerPopup When true, the layer's popup is used to choose attributes for each column; when false,
+ * all attributes are exported
+ * @param removeDuplicates When true a single label is generated when multiple featues have a shared address value
+ * @param addColumnTitle Indicates if column headings should be included in output
+ * @returns Promise resolving when function is done
+ */
+export async function downloadCSV(selectionSetNames, layer, ids, formatUsingLayerPopup, removeDuplicates = false, addColumnTitle = false) {
+    const labels = await _prepareLabels(layer, ids, removeDuplicates, formatUsingLayerPopup, addColumnTitle);
+    exportCSV(_createFilename(selectionSetNames), labels);
+    return Promise.resolve();
+}
+/**
+ * Downloads csv of mailing labels for the provided list of ids
+ *
+ * @param selectionSetNames Names of the selection sets used to provide ids
+ * @param layer Layer providing features and attributes for download
+ * @param ids List of ids to download
+ * @param labelPageDescription Provides PDF page layout info
+ * @param removeDuplicates When true a single label is generated when multiple featues have a shared address value
+ * @param includeMap When true, the first page of the output is a map showing the selection area
+ * @param includeTitle When true, a title is included on every page
+ * @param title Title for each page when `includeTitle` is true
+ * @returns Promise resolving when function is done
+ */
+export async function downloadPDF(selectionSetNames, layer, ids, labelPageDescription, removeDuplicates = false, includeMap = false, includeTitle = false, title = "") {
+    let labels = await _prepareLabels(layer, ids, removeDuplicates);
+    labels =
+        // Remove empty lines in labels
+        labels.map(labelLines => labelLines.filter(line => line.length > 0))
+            // Remove empty labels
+            .filter(label => label.length > 0);
+    exportPDF(_createFilename(selectionSetNames), labels, labelPageDescription, includeMap, includeTitle, title);
+    return Promise.resolve();
+}
+//#endregion
+//#region Private functions
+/**
+ * Converts a set of fieldInfos into template lines.
+ *
+ * @param fieldInfos Layer's fieldInfos structure
+ * @param bypassFieldVisiblity Indicates if the configured fieldInfo visibility property should be ignored
+ * @return Label spec with lines separated by `lineSeparatorChar`
+ */
+export function _convertPopupFieldsToLabelSpec(fieldInfos, bypassFieldVisiblity = false) {
+    const labelSpec = [];
+    // Every visible attribute is used
+    fieldInfos.forEach(fieldInfo => {
+        if (fieldInfo.visible || bypassFieldVisiblity) {
+            labelSpec.push(`{${fieldInfo.fieldName}}`);
+        }
+    });
+    return labelSpec.join(lineSeparatorChar);
+}
+;
+/**
+ * Converts the text of a custom popup into a multiline label specification; conversion splits text into
+ * lines on <br>s, and removes HTML tags. It does not handle Arcade and related records.
+ *
+ * @param popupInfo Layer's popupInfo structure containing description, fieldInfos, and expressionInfos, e.g.,
+ * "<div style='text-align: left;'>{NAME}<br />{STREET}<br />{CITY}, {STATE} {ZIP} <br /></div>"
+ * @return Label spec with lines separated by `lineSeparatorChar`
+ */
+export function _convertPopupTextToLabelSpec(popupInfo) {
+    // Replace <br> variants with the line separator character
+    popupInfo = popupInfo.replace(/<br\s*\/?>/gi, lineSeparatorChar);
+    // Replace <p> variants with the line separator character, except in the first position
+    popupInfo = popupInfo.replace(/<p[^>]*>/gi, lineSeparatorChar).trim().replace(/^\|/, "");
+    // Remove </p>
+    popupInfo = popupInfo.replace(/<\/p>/gi, "");
+    // Replace \n with the line separator character
+    popupInfo = popupInfo.replace(/\n/gi, "|");
+    // Remove remaining HTML tags, replace 0xA0 that popup uses for spaces, and replace some char representations
+    let labelSpec = popupInfo
+        .replace(/<[\s.]*[^<>]*\/?>/gi, "")
+        .replace(/\xA0/gi, " ")
+        .replace(/&lt;/gi, "<")
+        .replace(/&gt;/gi, ">")
+        .replace(/&nbsp;/gi, " ");
+    // Trim each line
+    labelSpec = labelSpec.replace(/\s*\|\s*/g, "|");
+    // Remove empty lines
+    while (labelSpec.match(/\|\|/)) {
+        labelSpec = labelSpec.replace(/\|\|/, "|");
+    }
+    // Remove leading and trailing line feeds
+    labelSpec = labelSpec.replace(/^\|/, "");
+    labelSpec = labelSpec.replace(/\|$/, "");
+    return labelSpec.trim();
+}
+;
+/**
+ * Extracts Arcade expressions from the lines of a label format and creates an Arcade executor for each
+ * referenced expression name.
+ *
+ * @param labelFormat Label to examine
+ * @param layer Layer from which to fetch features
+ * @return Promise resolving to a set of executors keyed using the expression name
+ */
+async function _createArcadeExecutors(labelFormat, layer) {
+    const arcadeExecutors = {};
+    // Are any Arcade expressions in the layer?
+    if (!Array.isArray(layer.popupTemplate.expressionInfos) || layer.popupTemplate.expressionInfos.length === 0) {
+        return Promise.resolve(arcadeExecutors);
+    }
+    // Are there any Arcade expressions in the label format?
+    const arcadeExpressionRegExp = /\{expression\/\w+\}/g;
+    const arcadeExpressionsMatches = labelFormat.match(arcadeExpressionRegExp);
+    if (!arcadeExpressionsMatches) {
+        return Promise.resolve(arcadeExecutors);
+    }
+    // Generate an Arcade executor for each match
+    const [arcade] = await loadModules(["esri/arcade"]);
+    const labelingProfile = {
+        variables: [
+            {
+                name: "$feature",
+                type: "feature"
+            },
+            {
+                name: "$layer",
+                type: "featureSet"
+            },
+            {
+                name: "$datastore",
+                type: "featureSetCollection"
+            },
+            {
+                name: "$map",
+                type: "featureSetCollection"
+            }
+        ]
+    };
+    const createArcadeExecutorPromises = {};
+    arcadeExpressionsMatches.forEach((match) => {
+        const expressionName = match.substring(match.indexOf("/") + 1, match.length - 1);
+        (layer.popupTemplate.expressionInfos || []).forEach(expressionInfo => {
+            if (expressionInfo.name === expressionName) {
+                createArcadeExecutorPromises[expressionName] =
+                    arcade.createArcadeExecutor(expressionInfo.expression, labelingProfile);
+            }
+        });
+    });
+    const promises = Object.values(createArcadeExecutorPromises);
+    return Promise.all(promises)
+        .then(executors => {
+        const expressionNames = Object.keys(createArcadeExecutorPromises);
+        for (let i = 0; i < expressionNames.length; ++i) {
+            arcadeExecutors[expressionNames[i]] = executors[i].valueOf();
+        }
+        return arcadeExecutors;
+    });
+}
+/**
+ * Creates a title from a list of selection set names.
+ *
+ * @param selectionSetNames Names to use in title
+ * @return Title composed of the selectionSetNames separated by commas; if there are no
+ * selection set names supplied, "download" is returned
+ */
+export function _createFilename(selectionSetNames) {
+    // Windows doesn't permit the characters \/:*?"<>|
+    const title = selectionSetNames.length > 0 ? selectionSetNames.join(", ") : "download";
+    return title;
+}
+/**
+ * Prepares an attribute's value by applying domain and type information.
+ *
+ * @param attributeValue Value of attribute
+ * @param attributeType Type of attribute
+ * @param attributeDomain Domain info for attribute, if any
+ * @param attributeFormat Format info for attribute, if any
+ * @param intl esri/intl
+ * @return Attribute value modified appropriate to domain and type
+ */
+function _prepareAttributeValue(attributeValue, attributeType, attributeDomain, attributeFormat, intl) {
+    if (attributeDomain && attributeDomain.type === "coded-value") {
+        // "coded-value" domain field
+        const value = attributeDomain.getName(attributeValue);
+        return value;
+    }
+    else {
+        // Non-domain field or unsupported domain type
+        let value = attributeValue;
+        switch (attributeType) {
+            case "date":
+                if (attributeFormat === null || attributeFormat === void 0 ? void 0 : attributeFormat.dateFormat) {
+                    const dateFormatIntlOptions = intl.convertDateFormatToIntlOptions(attributeFormat.dateFormat);
+                    value = intl.formatDate(value, dateFormatIntlOptions);
+                }
+                else {
+                    value = intl.formatDate(value);
+                }
+                // Format date produces odd characters for the space between the time and the AM/PM text,
+                // e.g., "12/31/1969, 4:00 PM"
+                value = value.replace(/\xe2\x80\xaf/g, "");
+                break;
+            case "double":
+            case "integer":
+            case "long":
+            case "small-integer":
+                if (attributeFormat) {
+                    const numberFormatIntlOptions = intl.convertNumberFormatToIntlOptions(attributeFormat);
+                    value = intl.formatNumber(value, numberFormatIntlOptions);
+                }
+                else {
+                    value = intl.formatNumber(value);
+                }
+                break;
+        }
+        return value;
+    }
+}
+/**
+ * Creates labels from items.
+ *
+ * @param layer Layer from which to fetch features
+ * @param ids List of ids to download
+ * @param removeDuplicates When true a single label is generated when multiple featues have a shared address value
+ * @param formatUsingLayerPopup When true, the layer's popup is used to choose attributes for each column; when false,
+ * all attributes are exported
+ * @param includeHeaderNames Add the label format at the front of the list of generated labels
+ * @returns Promise resolving when function is done
+ */
+async function _prepareLabels(layer, ids, removeDuplicates = true, formatUsingLayerPopup = true, includeHeaderNames = false) {
+    var _a, _b, _c, _d;
+    const [intl] = await loadModules(["esri/intl"]);
+    // Get the features to export
+    const featureSet = await queryFeaturesByID(ids, layer);
+    let features = featureSet.features;
+    if (!removeDuplicates && ids.length > features.length) {
+        const oidField = layer.objectIdField;
+        features = featureSet.features.reduce((prev, cur) => {
+            const id = cur.attributes[oidField];
+            // remove the first instance of the id
+            const i = ids.indexOf(id);
+            if (i > -1) {
+                ids = ids.splice(i, 1);
+            }
+            // add the first instance of the feature to the new array
+            prev.push(cur);
+            // test for any duplicates
+            if (ids.indexOf(id) > -1) {
+                // could be more than once..
+                const _ids = ids.filter(_id => _id !== id);
+                const num = ids.length - _ids.length;
+                for (let _i = 0; _i < num; _i++) {
+                    prev.push(cur);
+                }
+                ids = _ids;
+            }
+            return prev;
+        }, []);
+    }
+    // Get field data types. Do we have any domain-based fields?
+    const attributeTypes = {};
+    const attributeDomains = {};
+    layer.fields.forEach(field => {
+        attributeTypes[field.name] = field.type;
+        attributeDomains[field.name] = field.domain;
+    });
+    const attributeFormats = {};
+    // Get the label formatting, if any
+    let labelFormat;
+    let arcadeExecutors = {};
+    if (layer.popupEnabled) {
+        layer.popupTemplate.fieldInfos.forEach(
+        // Extract any format info that we have
+        fieldInfo => {
+            if (fieldInfo.format) {
+                attributeFormats[fieldInfo.fieldName] = fieldInfo.format;
+            }
+        });
+        // What data fields are used in the labels?
+        // Example labelFormat: ['{NAME}', '{STREET}', '{CITY}, {STATE} {ZIP}']
+        if (formatUsingLayerPopup && ((_b = (_a = layer.popupTemplate) === null || _a === void 0 ? void 0 : _a.content[0]) === null || _b === void 0 ? void 0 : _b.type) === "fields") {
+            labelFormat = _convertPopupFieldsToLabelSpec(layer.popupTemplate.fieldInfos);
+            // If popup is configured with "no attribute information", then no fields will visible
+            if (labelFormat.length === 0) {
+                // Can we use the popup title?
+                // eslint-disable-next-line unicorn/prefer-ternary
+                if (typeof layer.popupTemplate.title === "string") {
+                    labelFormat = layer.popupTemplate.title;
+                    // Otherwise revert to using attributes
+                }
+                else {
+                    labelFormat = _convertPopupFieldsToLabelSpec(layer.popupTemplate.fieldInfos, true);
+                }
+            }
+        }
+        else if (formatUsingLayerPopup && ((_d = (_c = layer.popupTemplate) === null || _c === void 0 ? void 0 : _c.content[0]) === null || _d === void 0 ? void 0 : _d.type) === "text") {
+            labelFormat = _convertPopupTextToLabelSpec(layer.popupTemplate.content[0].text);
+            // Do we need any Arcade executors?
+            arcadeExecutors = await _createArcadeExecutors(labelFormat, layer);
+        }
+    }
+    // Apply the label format
+    let labels;
+    // eslint-disable-next-line unicorn/prefer-ternary
+    if (labelFormat) {
+        const arcadeExpressionRegExp = /\{expression\/\w+\}/g;
+        const attributeRegExp = /\{\w+\}/g;
+        // Find the label fields that we need to replace with values
+        const arcadeExpressionMatches = labelFormat.match(arcadeExpressionRegExp);
+        const attributeMatches = labelFormat.match(attributeRegExp);
+        // Convert feature attributes into an array of labels
+        labels = features.map(feature => {
+            let labelPrep = labelFormat;
+            // Replace Arcade expressions
+            if (arcadeExpressionMatches) {
+                arcadeExpressionMatches.forEach((match) => {
+                    const expressionName = match.substring(match.indexOf("/") + 1, match.length - 1);
+                    const value = arcadeExecutors[expressionName].execute({ "$feature": feature });
+                    labelPrep = labelPrep.replace(match, value);
+                });
+            }
+            // Replace non-Arcade fields
+            if (attributeMatches) {
+                attributeMatches.forEach((match) => {
+                    const attributeName = match.substring(1, match.length - 1);
+                    const value = _prepareAttributeValue(feature.attributes[attributeName], attributeTypes[attributeName], attributeDomains[attributeName], attributeFormats[attributeName], intl);
+                    labelPrep = labelPrep.replace(match, value);
+                });
+            }
+            // Split label into lines
+            let label = labelPrep.split(lineSeparatorChar);
+            // Trim lines
+            label = label.map(line => line.trim());
+            return label;
+        });
+    }
+    else {
+        // Export all attributes
+        labels = features.map(feature => {
+            return Object.keys(feature.attributes).map((attributeName) => {
+                const value = _prepareAttributeValue(feature.attributes[attributeName], attributeTypes[attributeName], attributeDomains[attributeName], null, intl);
+                return `${value}`;
+            });
+        });
+    }
+    // Add header names
+    if (includeHeaderNames) {
+        let headerNames = [];
+        if (labelFormat) {
+            headerNames = labelFormat.replace(/\{/g, "").replace(/\}/g, "").split(lineSeparatorChar);
+        }
+        else {
+            const featuresAttrs = features[0].attributes;
+            Object.keys(featuresAttrs).forEach(k => {
+                headerNames.push(k);
+            });
+        }
+        labels.unshift(headerNames);
+    }
+    return Promise.resolve(labels);
+}
+//#endregion

package/dist/solutions-components/utils/interfaces.js

@@ -0,0 +1,56 @@
+/** @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.
+ */
+export var ELayoutMode;
+(function (ELayoutMode) {
+    ELayoutMode["GRID"] = "GRID";
+    ELayoutMode["HORIZONTAL"] = "HORIZONTAL";
+    ELayoutMode["VERTICAL"] = "VERTICAL";
+})(ELayoutMode || (ELayoutMode = {}));
+/**
+ * Resource update types
+ */
+export var EUpdateType;
+(function (EUpdateType) {
+    EUpdateType[EUpdateType["Add"] = 0] = "Add";
+    EUpdateType[EUpdateType["Update"] = 1] = "Update";
+    EUpdateType[EUpdateType["Remove"] = 2] = "Remove";
+    EUpdateType[EUpdateType["None"] = 3] = "None";
+    EUpdateType[EUpdateType["Obsolete"] = 4] = "Obsolete";
+})(EUpdateType || (EUpdateType = {}));
+export var EPageType;
+(function (EPageType) {
+    EPageType[EPageType["LIST"] = 0] = "LIST";
+    EPageType[EPageType["SELECT"] = 1] = "SELECT";
+    EPageType[EPageType["EXPORT"] = 2] = "EXPORT";
+})(EPageType || (EPageType = {}));
+export var ESelectionType;
+(function (ESelectionType) {
+    ESelectionType["POINT"] = "POINT";
+    ESelectionType["LINE"] = "LINE";
+    ESelectionType["POLY"] = "POLY";
+    ESelectionType["RECT"] = "RECT";
+})(ESelectionType || (ESelectionType = {}));
+export var EExpandType;
+(function (EExpandType) {
+    EExpandType["EXPAND"] = "EXPAND";
+    EExpandType["COLLAPSE"] = "COLLAPSE";
+})(EExpandType || (EExpandType = {}));
+export var EWorkflowType;
+(function (EWorkflowType) {
+    EWorkflowType["SEARCH"] = "SEARCH";
+    EWorkflowType["SELECT"] = "SELECT";
+    EWorkflowType["SKETCH"] = "SKETCH";
+})(EWorkflowType || (EWorkflowType = {}));

package/dist/solutions-components/utils/languageUtil.js

@@ -0,0 +1,85 @@
+/*
+ *   Copyright (c) 2022 Esri
+ *   All rights reserved.
+ *   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.
+ */
+import { loadModules } from "./loadModules";
+export const languageMap = new Map([
+    ["ar", "ar"],
+    ["bg", "bg"],
+    ["bs", "bs"],
+    ["ca", "ca"],
+    ["cs", "cs"],
+    ["da", "da"],
+    ["de", "de"],
+    ["el", "el"],
+    ["en", "en"],
+    ["es", "es"],
+    ["et", "et"],
+    ["fi", "fi"],
+    ["fr", "fr"],
+    ["he", "he"],
+    ["hr", "hr"],
+    ["hu", "hu"],
+    ["id", "id"],
+    ["it", "it"],
+    ["ja", "ja"],
+    ["ko", "ko"],
+    ["lt", "lt"],
+    ["lv", "lv"],
+    ["nb", "nb"],
+    ["nl", "nl"],
+    ["pl", "pl"],
+    ["pt-br", "pt-BR"],
+    ["pt-pt", "pt-PT"],
+    ["ro", "ro"],
+    ["ru", "ru"],
+    ["sk", "sk"],
+    ["sl", "sl"],
+    ["sr", "sr"],
+    ["sv", "sv"],
+    ["th", "th"],
+    ["tr", "tr"],
+    ["uk", "uk"],
+    ["vi", "vi"],
+    ["zh-cn", "zh-CN"],
+    ["zh-hk", "zh-HK"],
+    ["zh-tw", "zh-TW"],
+]);
+// rtl
+export function getElementDir(el) {
+    return getElementProp(el, "dir", "ltr");
+}
+function getElementProp(el, prop, value) {
+    const closestWithProp = el.closest(`[${prop}]`);
+    return closestWithProp ? closestWithProp.getAttribute(prop) : value;
+}
+// css
+export const CSS_UTILITY = {
+    rtl: "arcgis--rtl",
+};
+export async function formatNumber(number, options) {
+    const { api = 4, type = "decimal", places = 2 } = options || {};
+    if (api === 4) {
+        const [intl] = await loadModules(["esri/intl"]);
+        const numberFormatIntlOptions = intl.convertNumberFormatToIntlOptions({
+            places,
+            type,
+            digitSeparator: true,
+        });
+        return intl.formatNumber(number, numberFormatIntlOptions);
+    }
+    const [dojoNumber] = await loadModules(["dojo/number"]);
+    return dojoNumber.format(number, {
+        type,
+        places,
+    });
+}

package/dist/solutions-components/utils/loadModules.js

@@ -0,0 +1,20 @@
+/** @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.
+ */
+import { loadModules as _loadModules } from "esri-loader";
+export const loadModules = async (moduleNames, options) => {
+    const mods = await _loadModules(moduleNames, options);
+    return mods.map((mod) => (mod.__esModule && mod.default ? mod.default : mod));
+};

package/dist/solutions-components/utils/locale.js

@@ -0,0 +1,56 @@
+/** @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.
+ */
+// https://medium.com/stencil-tricks/implementing-internationalisation-i18n-with-stencil-5e6559554117
+import { languageMap } from "./languageUtil";
+import { getAssetPath } from "@stencil/core";
+export function getComponentClosestLanguage(element) {
+    var _a, _b, _c;
+    const closestElement = (_a = (element.closest("[lang]"))) !== null && _a !== void 0 ? _a : (_c = (_b = element.shadowRoot) === null || _b === void 0 ? void 0 : _b.ownerDocument) === null || _c === void 0 ? void 0 : _c.documentElement;
+    // language set by the calling application or browser. defaults to english.
+    const lang = ((closestElement === null || closestElement === void 0 ? void 0 : closestElement.lang) || (navigator === null || navigator === void 0 ? void 0 : navigator.language) || "en").toLowerCase();
+    if (languageMap.has(lang)) {
+        return languageMap.get(lang);
+    }
+    else {
+        // "ru-RU" maps to "ru" use case
+        return languageMap.has(lang.slice(0, 2)) ? languageMap.get(lang.slice(0, 2)) : "en";
+    }
+}
+function fetchLocaleStringsForComponent(componentName, locale) {
+    return new Promise((resolve, reject) => {
+        fetch(getAssetPath(`../assets/t9n/${componentName}/resources_${locale}.json`)).then(result => {
+            if (result.ok) {
+                resolve(result.json());
+            }
+            else {
+                reject();
+            }
+        }, () => reject());
+    });
+}
+export async function getLocaleComponentStrings(element) {
+    const componentName = element.tagName.toLowerCase();
+    const componentLanguage = getComponentClosestLanguage(element);
+    let strings;
+    try {
+        strings = await fetchLocaleStringsForComponent(componentName, componentLanguage);
+    }
+    catch (e) {
+        console.warn(`no locale for ${componentName} (${componentLanguage}) loading default locale en.`);
+        strings = await fetchLocaleStringsForComponent(componentName, "en");
+    }
+    return [strings, componentLanguage];
+}