@esri/solutions-components 0.7.1 → 0.7.2

package/dist/cjs/uk-117902c4.js

@@ -0,0 +1,104 @@
+/*!
+ * 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-07edd190.js');
+require('./index-2d5760f2.js');
+require('./form-81cf84d1.js');
+require('./dom-5c1fefc1.js');
+require('./guid-c95a49d2.js');
+require('./resources-89626d92.js');
+require('./interactive-85d0402d.js');
+require('./browser-abd0e2fa.js');
+require('./key-cdf99d14.js');
+require('./label-8a389916.js');
+require('./loadable-3358bfc7.js');
+require('./locale-44d38e1a.js');
+require('./observers-0f180f88.js');
+require('./focusTrapComponent-21d85ddf.js');
+require('./time-bfaa8f38.js');
+require('./math-950b6ada.js');
+require('./t9n-02f62c58.js');
+require('./openCloseComponent-7afeb520.js');
+require('./component-98c27d5f.js');
+
+// Ukrainian [uk]
+var monthFormat = 'січня_лютого_березня_квітня_травня_червня_липня_серпня_вересня_жовтня_листопада_грудня'.split('_');
+var monthStandalone = 'січень_лютий_березень_квітень_травень_червень_липень_серпень_вересень_жовтень_листопад_грудень'.split('_');
+var MONTHS_IN_FORMAT = /D[oD]?(\[[^[\]]*\]|\s)+MMMM?/;
+
+function plural(word, num) {
+  var forms = word.split('_');
+  return num % 10 === 1 && num % 100 !== 11 ? forms[0] : num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20) ? forms[1] : forms[2]; // eslint-disable-line
+}
+
+function relativeTimeWithPlural(number, withoutSuffix, key) {
+  var format = {
+    ss: withoutSuffix ? 'секунда_секунди_секунд' : 'секунду_секунди_секунд',
+    mm: withoutSuffix ? 'хвилина_хвилини_хвилин' : 'хвилину_хвилини_хвилин',
+    hh: withoutSuffix ? 'година_години_годин' : 'годину_години_годин',
+    dd: 'день_дні_днів',
+    MM: 'місяць_місяці_місяців',
+    yy: 'рік_роки_років'
+  };
+
+  if (key === 'm') {
+    return withoutSuffix ? 'хвилина' : 'хвилину';
+  } else if (key === 'h') {
+    return withoutSuffix ? 'година' : 'годину';
+  }
+
+  return number + " " + plural(format[key], +number);
+}
+
+var months = function months(dayjsInstance, format) {
+  if (MONTHS_IN_FORMAT.test(format)) {
+    return monthFormat[dayjsInstance.month()];
+  }
+
+  return monthStandalone[dayjsInstance.month()];
+};
+
+months.s = monthStandalone;
+months.f = monthFormat;
+var locale = {
+  name: 'uk',
+  weekdays: 'неділя_понеділок_вівторок_середа_четвер_п’ятниця_субота'.split('_'),
+  weekdaysShort: 'ндл_пнд_втр_срд_чтв_птн_сбт'.split('_'),
+  weekdaysMin: 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
+  months: months,
+  monthsShort: 'січ_лют_бер_квіт_трав_черв_лип_серп_вер_жовт_лист_груд'.split('_'),
+  weekStart: 1,
+  relativeTime: {
+    future: 'за %s',
+    past: '%s тому',
+    s: 'декілька секунд',
+    m: relativeTimeWithPlural,
+    mm: relativeTimeWithPlural,
+    h: relativeTimeWithPlural,
+    hh: relativeTimeWithPlural,
+    d: 'день',
+    dd: relativeTimeWithPlural,
+    M: 'місяць',
+    MM: relativeTimeWithPlural,
+    y: 'рік',
+    yy: relativeTimeWithPlural
+  },
+  ordinal: function ordinal(n) {
+    return n;
+  },
+  formats: {
+    LT: 'HH:mm',
+    LTS: 'HH:mm:ss',
+    L: 'DD.MM.YYYY',
+    LL: 'D MMMM YYYY р.',
+    LLL: 'D MMMM YYYY р., HH:mm',
+    LLLL: 'dddd, D MMMM YYYY р., HH:mm'
+  }
+};
+calciteInputTimePicker_entry.dayjs.locale(locale, null, true);
+
+exports.default = locale;

package/dist/cjs/utils-4d5934ab.js

@@ -0,0 +1,95 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+'use strict';
+
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-design-system/blob/main/LICENSE.md for details.
+ * v1.11.0
+ */
+const CSS = {
+  container: "container",
+  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",
+  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-circle-f",
+  selectedSingle: "circle-f",
+  unselected: "blank",
+  closedLTR: "caret-right",
+  closedRTL: "caret-left",
+  open: "caret-down",
+  blank: "blank",
+  close: "x",
+};
+
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-design-system/blob/main/LICENSE.md for details.
+ * v1.11.0
+ */
+const listSelector = "calcite-list";
+const listItemGroupSelector = "calcite-list-item-group";
+const listItemSelector = "calcite-list-item";
+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) {
+  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;
+}
+
+exports.CSS = CSS;
+exports.ICONS = ICONS;
+exports.MAX_COLUMNS = MAX_COLUMNS;
+exports.SLOTS = SLOTS;
+exports.getDepth = getDepth;
+exports.getListItemChildren = getListItemChildren;
+exports.updateListItemChildren = updateListItemChildren;

package/dist/cjs/utils-75231cf1.js

@@ -0,0 +1,221 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+'use strict';
+
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-design-system/blob/main/LICENSE.md for details.
+ * v1.11.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 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;
+}
+
+exports.CSSColorMode = CSSColorMode;
+exports.alphaCompatible = alphaCompatible;
+exports.alphaToOpacity = alphaToOpacity;
+exports.colorEqual = colorEqual;
+exports.hexChar = hexChar;
+exports.hexToRGB = hexToRGB;
+exports.hexify = hexify;
+exports.isLonghandHex = isLonghandHex;
+exports.isValidHex = isValidHex;
+exports.normalizeAlpha = normalizeAlpha;
+exports.normalizeColor = normalizeColor;
+exports.normalizeHex = normalizeHex;
+exports.opacityToAlpha = opacityToAlpha;
+exports.parseMode = parseMode;
+exports.rgbToHex = rgbToHex;
+exports.toAlphaMode = toAlphaMode;
+exports.toNonAlphaMode = toNonAlphaMode;

package/dist/cjs/utils-90ce30aa.js

@@ -0,0 +1,64 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+'use strict';
+
+const index = require('./index-2d5760f2.js');
+const date = require('./date-628b8529.js');
+const locale = require('./locale-44d38e1a.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.
+ * v1.11.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$1 = locale.getSupportedLocale(lang);
+  if (translationCache[locale$1]) {
+    return translationCache[locale$1];
+  }
+  if (!requestCache[locale$1]) {
+    requestCache[locale$1] = fetch(index.getAssetPath(`./assets/date-picker/nls/${locale$1}.json`))
+      .then((resp) => resp.json())
+      .catch(() => {
+      console.error(`Translations for "${locale$1}" not found or invalid, falling back to english`);
+      return getLocaleData("en");
+    });
+  }
+  const data = await requestCache[locale$1];
+  translationCache[locale$1] = data;
+  return data;
+}
+/**
+ *  Maps value to valueAsDate
+ *
+ * @param value
+ */
+function getValueAsDateRange(value) {
+  return value.map((v, index) => date.dateFromISO(v, index === 1));
+}
+
+exports.getLocaleData = getLocaleData;
+exports.getValueAsDateRange = getValueAsDateRange;

package/dist/cjs/utils-b6e28e37.js

@@ -0,0 +1,62 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+'use strict';
+
+const dom = require('./dom-5c1fefc1.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.
+ * v1.11.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.
+ * v1.11.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 dom.nodeListToArray(item.querySelectorAll("calcite-combobox-item"));
+}
+function hasActiveChildren(node) {
+  const items = dom.nodeListToArray(node.querySelectorAll("calcite-combobox-item"));
+  return items.filter((item) => item.selected).length > 0;
+}
+function getDepth(element) {
+  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");
+}
+
+exports.CSS = CSS;
+exports.ComboboxChildSelector = ComboboxChildSelector;
+exports.ComboboxItem = ComboboxItem;
+exports.ComboboxItemGroup = ComboboxItemGroup;
+exports.getAncestors = getAncestors;
+exports.getDepth = getDepth;
+exports.getItemAncestors = getItemAncestors;
+exports.getItemChildren = getItemChildren;
+exports.hasActiveChildren = hasActiveChildren;
+exports.isSingleLike = isSingleLike;

package/dist/cjs/vi-6ef0f273.js

@@ -0,0 +1,70 @@
+/*!
+ * 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-07edd190.js');
+require('./index-2d5760f2.js');
+require('./form-81cf84d1.js');
+require('./dom-5c1fefc1.js');
+require('./guid-c95a49d2.js');
+require('./resources-89626d92.js');
+require('./interactive-85d0402d.js');
+require('./browser-abd0e2fa.js');
+require('./key-cdf99d14.js');
+require('./label-8a389916.js');
+require('./loadable-3358bfc7.js');
+require('./locale-44d38e1a.js');
+require('./observers-0f180f88.js');
+require('./focusTrapComponent-21d85ddf.js');
+require('./time-bfaa8f38.js');
+require('./math-950b6ada.js');
+require('./t9n-02f62c58.js');
+require('./openCloseComponent-7afeb520.js');
+require('./component-98c27d5f.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'
+  }
+};
+calciteInputTimePicker_entry.dayjs.locale(locale, null, true);
+
+exports.default = locale;