@esri/solutions-components 0.8.2 → 0.8.3

package/dist/solutions-components/utils-32df4a1e.js

@@ -0,0 +1,133 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+import { b as getLocaleComponentStrings } from './locale-4cfbae3e.js';
+import { c as createStore } from './index-91eeaf01.js';
+
+var EInputType;
+(function (EInputType) {
+  EInputType["User"] = "user";
+  EInputType["Translation"] = "translation";
+})(EInputType || (EInputType = {}));
+var ESettingType;
+(function (ESettingType) {
+  ESettingType["String"] = "string";
+  ESettingType["TextEditor"] = "textEditor";
+})(ESettingType || (ESettingType = {}));
+var EIcons;
+(function (EIcons) {
+  EIcons["ExpandCollapse"] = "list-merge";
+  EIcons["SettingIndicator"] = "list-button";
+  EIcons["Popover"] = "information";
+  EIcons["Expanded"] = "chevron-down";
+  EIcons["Collapsed"] = "chevron-right";
+  EIcons["Copy"] = "copy-to-clipboard";
+  EIcons["Breadcrumb"] = "chevron-right";
+  EIcons["DefaultIcon"] = "language";
+  EIcons["Title"] = "title";
+  EIcons["Subtitle"] = "subheading";
+  EIcons["Text"] = "text";
+  EIcons["Description"] = "description";
+  EIcons["Button"] = "button";
+  EIcons["String"] = "string";
+})(EIcons || (EIcons = {}));
+var ECalciteMode;
+(function (ECalciteMode) {
+  ECalciteMode["Light"] = "calcite-mode-light";
+  ECalciteMode["Dark"] = "calcite-mode-dark";
+})(ECalciteMode || (ECalciteMode = {}));
+
+const LanguageTranslatorStore = createStore({
+  uiData: null,
+  currentLanguage: null,
+  lastSave: null,
+  saving: false,
+  currentLocaleSettingItem: null,
+  portalItemResource: null,
+  portalItemResourceT9n: null,
+});
+const languageTranslatorState = LanguageTranslatorStore.state;
+const onLanguageTranslatorChange = LanguageTranslatorStore.onChange;
+const store = LanguageTranslatorStore;
+
+function generateUIData(appSettings, locales) {
+  var _a;
+  if (!appSettings)
+    return;
+  const existingUIData = store.get('uiData');
+  const uiData = new Map();
+  uiData.set('locales', locales);
+  uiData.set('translatedLanguageLabels', Object.assign({}, appSettings.translatedLanguageLabels));
+  appSettings.content.forEach(contentItem => {
+    var _a, _b;
+    const { type, label, value, uiLocation } = contentItem;
+    const setting = existingUIData === null || existingUIData === void 0 ? void 0 : existingUIData.get(contentItem.id);
+    uiData.set(contentItem.id, {
+      userLocaleData: {
+        type: type !== null && type !== void 0 ? type : null,
+        label: label !== null && label !== void 0 ? label : null,
+        value: value !== null && value !== void 0 ? value : null,
+      },
+      expanded: true,
+      selected: (_a = setting === null || setting === void 0 ? void 0 : setting['selected']) !== null && _a !== void 0 ? _a : false,
+      uiLocation,
+      tip: (_b = contentItem === null || contentItem === void 0 ? void 0 : contentItem.tip) !== null && _b !== void 0 ? _b : null,
+    });
+  });
+  const settingKeys = appSettings.content.map(contentItem => contentItem.id);
+  const noneSelected = settingKeys.every((key) => {
+    const setting = uiData.get(key);
+    return !setting.selected;
+  });
+  const setting = uiData.get(settingKeys[0]);
+  if (noneSelected && setting) {
+    const existingData = existingUIData === null || existingUIData === void 0 ? void 0 : existingUIData.get(settingKeys[0]);
+    setting.selected = (_a = existingData === null || existingData === void 0 ? void 0 : existingData['selected']) !== null && _a !== void 0 ? _a : true;
+  }
+  return uiData;
+}
+async function getMessages(el) {
+  const messages = await getLocaleComponentStrings(el);
+  return messages[0];
+}
+function getUIDataKeys() {
+  var _a;
+  const settingKeys = [];
+  (_a = languageTranslatorState.uiData) === null || _a === void 0 ? void 0 : _a.forEach((_value, key) => {
+    if (key !== 'locales' && key !== 'translatedLanguageLabels') {
+      settingKeys.push(key);
+    }
+  });
+  return settingKeys;
+}
+async function getPortalItemResourceT9nData(resource) {
+  if (!resource)
+    return null;
+  try {
+    const t9nData = await resource.fetch();
+    return Promise.resolve(t9nData);
+  }
+  catch (_a) {
+    return Promise.resolve(null);
+  }
+}
+function getT9nData(locale, data) {
+  const portalItemResourceT9n = store.get('portalItemResourceT9n');
+  let dataToWrite;
+  if (!(portalItemResourceT9n === null || portalItemResourceT9n === void 0 ? void 0 : portalItemResourceT9n[locale])) {
+    portalItemResourceT9n[locale] = {};
+  }
+  dataToWrite = Object.assign(Object.assign({}, portalItemResourceT9n), { [locale]: Object.assign(Object.assign({}, portalItemResourceT9n[locale]), data) });
+  return dataToWrite;
+}
+function getLocales(localeItems) {
+  var _a;
+  return (_a = localeItems === null || localeItems === void 0 ? void 0 : localeItems.map(localeItem => localeItem.locale)) !== null && _a !== void 0 ? _a : [];
+}
+function isCalciteModeDark() {
+  return document.body.classList.contains(ECalciteMode.Dark);
+}
+
+export { EIcons as E, generateUIData as a, getLocales as b, getUIDataKeys as c, ESettingType as d, ECalciteMode as e, EInputType as f, getMessages as g, getT9nData as h, isCalciteModeDark as i, languageTranslatorState as l, store as s };

package/dist/solutions-components/utils-57e2ccde.js

@@ -0,0 +1,61 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+import { j as getAssetPath } from './index-bdfaac50.js';
+import { e as dateFromISO } from './date-74c7f03b.js';
+import { g as getSupportedLocale } from './locale-857f39cf.js';
+
+/*!
+ * 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
+ */
+/**
+ * CLDR cache.
+ * Exported for testing purposes.
+ *
+ * @private
+ */
+const translationCache = {};
+/**
+ * CLDR request cache.
+ * Exported for testing purposes.
+ *
+ * @private
+ */
+const requestCache = {};
+/**
+ * Fetch calendar data for a given locale from list of supported languages
+ *
+ * @param lang
+ * @public
+ */
+async function getLocaleData(lang) {
+    const locale = getSupportedLocale(lang);
+    if (translationCache[locale]) {
+        return translationCache[locale];
+    }
+    if (!requestCache[locale]) {
+        requestCache[locale] = fetch(getAssetPath(`./assets/date-picker/nls/${locale}.json`))
+            .then((resp) => resp.json())
+            .catch(() => {
+            console.error(`Translations for "${locale}" not found or invalid, falling back to english`);
+            return getLocaleData("en");
+        });
+    }
+    const data = await requestCache[locale];
+    translationCache[locale] = data;
+    return data;
+}
+/**
+ *  Maps value to valueAsDate
+ *
+ * @param value
+ */
+function getValueAsDateRange(value) {
+    return value.map((v, index) => dateFromISO(v, index === 1));
+}
+
+export { getLocaleData as a, getValueAsDateRange as g };

package/dist/solutions-components/utils-7db4ecdc.js

@@ -0,0 +1,100 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+import { f as Build } from './index-bdfaac50.js';
+
+/*!
+ * 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 CSS = {
+    container: "container",
+    containerHover: "container--hover",
+    containerBorder: "container--border",
+    containerBorderSelected: "container--border-selected",
+    containerBorderUnselected: "container--border-unselected",
+    contentContainer: "content-container",
+    contentContainerSelectable: "content-container--selectable",
+    contentContainerHasCenterContent: "content-container--has-center-content",
+    nestedContainer: "nested-container",
+    nestedContainerHidden: "nested-container--hidden",
+    content: "content",
+    customContent: "custom-content",
+    actionsStart: "actions-start",
+    contentStart: "content-start",
+    label: "label",
+    description: "description",
+    contentEnd: "content-end",
+    contentBottom: "content-bottom",
+    actionsEnd: "actions-end",
+    selectionContainer: "selection-container",
+    selectionContainerSingle: "selection-container--single",
+    openContainer: "open-container",
+    dragContainer: "drag-container",
+};
+const SLOTS = {
+    actionsStart: "actions-start",
+    contentStart: "content-start",
+    content: "content",
+    contentBottom: "content-bottom",
+    contentEnd: "content-end",
+    actionsEnd: "actions-end",
+};
+// Set to zero to extend until the end of the table section.
+const MAX_COLUMNS = 0;
+const ICONS = {
+    selectedMultiple: "check-square-f",
+    selectedSingle: "bullet-point-large",
+    unselectedMultiple: "square",
+    unselectedSingle: "bullet-point-large",
+    closedLTR: "chevron-right",
+    closedRTL: "chevron-left",
+    open: "chevron-down",
+    blank: "blank",
+    close: "x",
+};
+const activeCellTestAttribute = "data-test-active";
+
+/*!
+ * 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 listSelector = "calcite-list";
+const listItemGroupSelector = "calcite-list-item-group";
+const listItemSelector = "calcite-list-item";
+function getListItemChildLists(slotEl) {
+    return Array.from(slotEl.assignedElements({ flatten: true }).filter((el) => el.matches(listSelector)));
+}
+function getListItemChildren(slotEl) {
+    const assignedElements = slotEl.assignedElements({ flatten: true });
+    const listItemGroupChildren = assignedElements.filter((el) => el?.matches(listItemGroupSelector))
+        .map((group) => Array.from(group.querySelectorAll(listItemSelector)))
+        .reduce((previousValue, currentValue) => [...previousValue, ...currentValue], []);
+    const listItemChildren = assignedElements.filter((el) => el?.matches(listItemSelector));
+    const listItemListChildren = assignedElements.filter((el) => el?.matches(listSelector))
+        .map((list) => Array.from(list.querySelectorAll(listItemSelector)))
+        .reduce((previousValue, currentValue) => [...previousValue, ...currentValue], []);
+    return [...listItemListChildren, ...listItemGroupChildren, ...listItemChildren];
+}
+function updateListItemChildren(listItemChildren) {
+    listItemChildren.forEach((listItem) => {
+        listItem.setPosition = listItemChildren.indexOf(listItem) + 1;
+        listItem.setSize = listItemChildren.length;
+    });
+}
+function getDepth(element, includeGroup = false) {
+    if (!Build.isBrowser) {
+        return 0;
+    }
+    const expression = includeGroup
+        ? "ancestor::calcite-list-item | ancestor::calcite-list-item-group"
+        : "ancestor::calcite-list-item";
+    const result = document.evaluate(expression, element, null, XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE, null);
+    return result.snapshotLength;
+}
+
+export { CSS as C, ICONS as I, MAX_COLUMNS as M, SLOTS as S, getListItemChildren as a, activeCellTestAttribute as b, getListItemChildLists as c, getDepth as g, updateListItemChildren as u };

package/dist/solutions-components/utils-95e9dd51.js

@@ -0,0 +1,55 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+import { n as nodeListToArray } from './dom-b91aa537.js';
+import { f as Build } from './index-bdfaac50.js';
+
+/*!
+ * 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 ComboboxItem = "CALCITE-COMBOBOX-ITEM";
+const ComboboxItemGroup = "CALCITE-COMBOBOX-ITEM-GROUP";
+const ComboboxChildSelector = `${ComboboxItem}, ${ComboboxItemGroup}`;
+const CSS = {
+    chipInvisible: "chip--invisible",
+    selectionDisplayFit: "selection-display-fit",
+    selectionDisplaySingle: "selection-display-single",
+    listContainer: "list-container",
+};
+
+/*!
+ * 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
+ */
+function getAncestors(element) {
+    const parent = element.parentElement?.closest(ComboboxChildSelector);
+    const grandparent = parent?.parentElement?.closest(ComboboxChildSelector);
+    return [parent, grandparent].filter((el) => el);
+}
+function getItemAncestors(item) {
+    return (item.ancestors?.filter((el) => el.nodeName === "CALCITE-COMBOBOX-ITEM") || []);
+}
+function getItemChildren(item) {
+    return nodeListToArray(item.querySelectorAll("calcite-combobox-item"));
+}
+function hasActiveChildren(node) {
+    const items = nodeListToArray(node.querySelectorAll("calcite-combobox-item"));
+    return items.filter((item) => item.selected).length > 0;
+}
+function getDepth(element) {
+    if (!Build.isBrowser) {
+        return 0;
+    }
+    const result = document.evaluate("ancestor::calcite-combobox-item | ancestor::calcite-combobox-item-group", element, null, XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE, null);
+    return result.snapshotLength;
+}
+function isSingleLike(selectionMode) {
+    return selectionMode.includes("single");
+}
+
+export { ComboboxItemGroup as C, getDepth as a, CSS as b, ComboboxChildSelector as c, getItemAncestors as d, getItemChildren as e, ComboboxItem as f, getAncestors as g, hasActiveChildren as h, isSingleLike as i };

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

@@ -0,0 +1,208 @@
+/*!
+ * 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 hexChar = /^[0-9A-F]$/i;
+const shorthandHex = /^#[0-9A-F]{3}$/i;
+const longhandHex = /^#[0-9A-F]{6}$/i;
+const shorthandHexWithAlpha = /^#[0-9A-F]{4}$/i;
+const longhandHexWithAlpha = /^#[0-9A-F]{8}$/i;
+const alphaToOpacity = (alpha) => Number((alpha * 100).toFixed());
+const opacityToAlpha = (opacity) => Number((opacity / 100).toFixed(2));
+function isValidHex(hex, hasAlpha = false) {
+    return isShorthandHex(hex, hasAlpha) || isLonghandHex(hex, hasAlpha);
+}
+function canConvertToHexa(hex) {
+    const validHex = isValidHex(hex, false);
+    const validHexa = isValidHex(hex, true);
+    return !validHexa && validHex;
+}
+function evaluateHex(hex, length, pattern) {
+    if (!hex) {
+        return false;
+    }
+    return hex.length === length && pattern.test(hex);
+}
+function isShorthandHex(hex, hasAlpha = false) {
+    const hexLength = hasAlpha ? 5 : 4;
+    const hexPattern = hasAlpha ? shorthandHexWithAlpha : shorthandHex;
+    return evaluateHex(hex, hexLength, hexPattern);
+}
+function isLonghandHex(hex, hasAlpha = false) {
+    const hexLength = hasAlpha ? 9 : 7;
+    const hexPattern = hasAlpha ? longhandHexWithAlpha : longhandHex;
+    return evaluateHex(hex, hexLength, hexPattern);
+}
+function normalizeHex(hex, hasAlpha = false, convertFromHexToHexa = false) {
+    hex = hex.toLowerCase();
+    if (!hex.startsWith("#")) {
+        hex = `#${hex}`;
+    }
+    if (isShorthandHex(hex, hasAlpha)) {
+        return rgbToHex(hexToRGB(hex, hasAlpha));
+    }
+    if (hasAlpha && convertFromHexToHexa && isValidHex(hex, false /* we only care about RGB hex for conversion */)) {
+        const isShorthand = isShorthandHex(hex, false);
+        return rgbToHex(hexToRGB(`${hex}${isShorthand ? "f" : "ff"}`, true));
+    }
+    return hex;
+}
+function hexify(color, hasAlpha = false) {
+    return hasAlpha ? color.hexa() : color.hex();
+}
+function rgbToHex(color) {
+    const { r, g, b } = color;
+    const rChars = numToHex(r);
+    const gChars = numToHex(g);
+    const bChars = numToHex(b);
+    const alphaChars = "a" in color ? numToHex(color.a * 255) : "";
+    return `#${rChars}${gChars}${bChars}${alphaChars}`.toLowerCase();
+}
+function numToHex(num) {
+    return num.toString(16).padStart(2, "0");
+}
+function normalizeAlpha(colorObject) {
+    const normalized = { ...colorObject, a: colorObject.alpha ?? 1 /* Color() will omit alpha if 1 */ };
+    delete normalized.alpha;
+    return normalized;
+}
+function normalizeColor(alphaColorObject) {
+    const normalized = { ...alphaColorObject, alpha: alphaColorObject.a ?? 1 };
+    delete normalized.a;
+    return normalized;
+}
+function hexToRGB(hex, hasAlpha = false) {
+    if (!isValidHex(hex, hasAlpha)) {
+        return null;
+    }
+    hex = hex.replace("#", "");
+    let r;
+    let g;
+    let b;
+    let a;
+    const isShorthand = hex.length === 3 || hex.length === 4;
+    if (isShorthand) {
+        const [first, second, third, fourth] = hex.split("");
+        r = parseInt(`${first}${first}`, 16);
+        g = parseInt(`${second}${second}`, 16);
+        b = parseInt(`${third}${third}`, 16);
+        a = parseInt(`${fourth}${fourth}`, 16) / 255;
+    }
+    else {
+        r = parseInt(hex.slice(0, 2), 16);
+        g = parseInt(hex.slice(2, 4), 16);
+        b = parseInt(hex.slice(4, 6), 16);
+        a = parseInt(hex.slice(6, 8), 16) / 255;
+    }
+    return isNaN(a) ? { r, g, b } : { r, g, b, a };
+}
+// these utils allow users to pass enum values as strings without having to access the enum
+// based on the approach suggested by https://github.com/microsoft/TypeScript/issues/17690#issuecomment-321365759,
+const enumify = (x) => x;
+const CSSColorMode = enumify({
+    HEX: "hex",
+    HEXA: "hexa",
+    RGB_CSS: "rgb-css",
+    RGBA_CSS: "rgba-css",
+    HSL_CSS: "hsl-css",
+    HSLA_CSS: "hsla-css",
+});
+const ObjectColorMode = enumify({
+    RGB: "rgb",
+    RGBA: "rgba",
+    HSL: "hsl",
+    HSLA: "hsla",
+    HSV: "hsv",
+    HSVA: "hsva",
+});
+function parseMode(colorValue) {
+    if (typeof colorValue === "string") {
+        if (colorValue.startsWith("#")) {
+            const { length } = colorValue;
+            if (length === 4 || length === 7) {
+                return CSSColorMode.HEX;
+            }
+            if (length === 5 || length === 9) {
+                return CSSColorMode.HEXA;
+            }
+        }
+        if (colorValue.startsWith("rgba(")) {
+            return CSSColorMode.RGBA_CSS;
+        }
+        if (colorValue.startsWith("rgb(")) {
+            return CSSColorMode.RGB_CSS;
+        }
+        if (colorValue.startsWith("hsl(")) {
+            return CSSColorMode.HSL_CSS;
+        }
+        if (colorValue.startsWith("hsla(")) {
+            return CSSColorMode.HSLA_CSS;
+        }
+    }
+    if (typeof colorValue === "object") {
+        if (hasChannels(colorValue, "r", "g", "b")) {
+            return hasChannels(colorValue, "a") ? ObjectColorMode.RGBA : ObjectColorMode.RGB;
+        }
+        if (hasChannels(colorValue, "h", "s", "l")) {
+            return hasChannels(colorValue, "a") ? ObjectColorMode.HSLA : ObjectColorMode.HSL;
+        }
+        if (hasChannels(colorValue, "h", "s", "v")) {
+            return hasChannels(colorValue, "a") ? ObjectColorMode.HSVA : ObjectColorMode.HSV;
+        }
+    }
+    return null;
+}
+function hasChannels(colorObject, ...channels) {
+    return channels.every((channel) => channel && colorObject && `${channel}` in colorObject);
+}
+function colorEqual(value1, value2) {
+    return value1?.rgb().array().toString() === value2?.rgb().array().toString();
+}
+function alphaCompatible(mode) {
+    return (mode === CSSColorMode.HEXA ||
+        mode === CSSColorMode.RGBA_CSS ||
+        mode === CSSColorMode.HSLA_CSS ||
+        mode === ObjectColorMode.RGBA ||
+        mode === ObjectColorMode.HSLA ||
+        mode === ObjectColorMode.HSVA);
+}
+function toAlphaMode(mode) {
+    const alphaMode = mode === CSSColorMode.HEX
+        ? CSSColorMode.HEXA
+        : mode === CSSColorMode.RGB_CSS
+            ? CSSColorMode.RGBA_CSS
+            : mode === CSSColorMode.HSL_CSS
+                ? CSSColorMode.HSLA_CSS
+                : mode === ObjectColorMode.RGB
+                    ? ObjectColorMode.RGBA
+                    : mode === ObjectColorMode.HSL
+                        ? ObjectColorMode.HSLA
+                        : mode === ObjectColorMode.HSV
+                            ? ObjectColorMode.HSVA
+                            : mode;
+    return alphaMode;
+}
+function toNonAlphaMode(mode) {
+    const nonAlphaMode = mode === CSSColorMode.HEXA
+        ? CSSColorMode.HEX
+        : mode === CSSColorMode.RGBA_CSS
+            ? CSSColorMode.RGB_CSS
+            : mode === CSSColorMode.HSLA_CSS
+                ? CSSColorMode.HSL_CSS
+                : mode === ObjectColorMode.RGBA
+                    ? ObjectColorMode.RGB
+                    : mode === ObjectColorMode.HSLA
+                        ? ObjectColorMode.HSL
+                        : mode === ObjectColorMode.HSVA
+                            ? ObjectColorMode.HSV
+                            : mode;
+    return nonAlphaMode;
+}
+
+export { CSSColorMode as C, alphaCompatible as a, alphaToOpacity as b, normalizeColor as c, colorEqual as d, toNonAlphaMode as e, normalizeAlpha as f, hexToRGB as g, hexify as h, isValidHex as i, isLonghandHex as j, hexChar as k, normalizeHex as n, opacityToAlpha as o, parseMode as p, rgbToHex as r, toAlphaMode as t };

package/dist/solutions-components/vi-29345f79.js

@@ -0,0 +1,69 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+import { d as dayjs } from './calcite-input-time-picker-e5cd4d26.js';
+import './index-bdfaac50.js';
+import './form-f2181470.js';
+import './dom-b91aa537.js';
+import './guid-b75a5f7b.js';
+import './resources-0f8db821.js';
+import './interactive-71585ecc.js';
+import './browser-b8d08bed.js';
+import './key-9a10d862.js';
+import './label-16184ce7.js';
+import './component-edd2c3cd.js';
+import './loadable-aea90723.js';
+import './locale-857f39cf.js';
+import './observers-5ba39eee.js';
+import './focusTrapComponent-2fe6623b.js';
+import './time-4a90614b.js';
+import './math-efada7a9.js';
+import './t9n-b39c5433.js';
+import './openCloseComponent-b4b3788b.js';
+import './Validation-59a77488.js';
+
+// Vietnamese [vi]
+var locale = {
+  name: 'vi',
+  weekdays: 'chủ nhật_thứ hai_thứ ba_thứ tư_thứ năm_thứ sáu_thứ bảy'.split('_'),
+  months: 'tháng 1_tháng 2_tháng 3_tháng 4_tháng 5_tháng 6_tháng 7_tháng 8_tháng 9_tháng 10_tháng 11_tháng 12'.split('_'),
+  weekStart: 1,
+  weekdaysShort: 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
+  monthsShort: 'Th01_Th02_Th03_Th04_Th05_Th06_Th07_Th08_Th09_Th10_Th11_Th12'.split('_'),
+  weekdaysMin: 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
+  ordinal: function ordinal(n) {
+    return n;
+  },
+  formats: {
+    LT: 'HH:mm',
+    LTS: 'HH:mm:ss',
+    L: 'DD/MM/YYYY',
+    LL: 'D MMMM [năm] YYYY',
+    LLL: 'D MMMM [năm] YYYY HH:mm',
+    LLLL: 'dddd, D MMMM [năm] YYYY HH:mm',
+    l: 'DD/M/YYYY',
+    ll: 'D MMM YYYY',
+    lll: 'D MMM YYYY HH:mm',
+    llll: 'ddd, D MMM YYYY HH:mm'
+  },
+  relativeTime: {
+    future: '%s tới',
+    past: '%s trước',
+    s: 'vài giây',
+    m: 'một phút',
+    mm: '%d phút',
+    h: 'một giờ',
+    hh: '%d giờ',
+    d: 'một ngày',
+    dd: '%d ngày',
+    M: 'một tháng',
+    MM: '%d tháng',
+    y: 'một năm',
+    yy: '%d năm'
+  }
+};
+dayjs.locale(locale, null, true);
+
+export default locale;