@esri/calcite-components 1.0.0-beta.64 → 1.0.0-beta.68

package/dist/esm/resources-037b842c.js

@@ -1,321 +0,0 @@
-import { f as focusElement, a as getSlotted, g as getElementDir } from './dom-0b02c0cf.js';
-import { g as getRoundRobinIndex } from './array-af19adb2.js';
-import { d as debounce } from './debounce-047e09f4.js';
-import { h, H as Host } from './index-1554a132.js';
-
-function mutationObserverCallback() {
-  this.setUpItems();
-  this.setUpFilter();
-}
-const SUPPORTED_ARROW_KEYS = ["ArrowUp", "ArrowDown"];
-// --------------------------------------------------------------------------
-//
-//  Lifecycle
-//
-// --------------------------------------------------------------------------
-function initialize() {
-  this.setUpItems();
-  this.setUpFilter();
-  this.emitCalciteListChange = debounce(internalCalciteListChangeEvent.bind(this), 0);
-}
-function initializeObserver() {
-  var _a;
-  (_a = this.mutationObserver) === null || _a === void 0 ? void 0 : _a.observe(this.el, { childList: true, subtree: true });
-}
-function cleanUpObserver() {
-  var _a;
-  (_a = this.mutationObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
-}
-// --------------------------------------------------------------------------
-//
-//  Listeners
-//
-// --------------------------------------------------------------------------
-function calciteListItemChangeHandler(event) {
-  const { selectedValues } = this;
-  const { item, value, selected, shiftPressed } = event.detail;
-  if (selected) {
-    if (this.multiple && shiftPressed) {
-      this.selectSiblings(item);
-    }
-    if (!this.multiple) {
-      this.deselectSiblingItems(item);
-    }
-    selectedValues.set(value, item);
-  }
-  else {
-    selectedValues.delete(value);
-    if (this.multiple && shiftPressed) {
-      this.selectSiblings(item, true);
-    }
-  }
-  if (!this.multiple) {
-    toggleSingleSelectItemTabbing(item, selected);
-    if (selected) {
-      focusElement(item);
-    }
-  }
-  this.lastSelectedItem = item;
-  this.emitCalciteListChange();
-}
-function calciteListItemValueChangeHandler(event) {
-  event.stopPropagation();
-  const oldValue = event.detail.oldValue;
-  const selectedValues = this.selectedValues;
-  if (selectedValues.has(oldValue)) {
-    const item = selectedValues.get(oldValue);
-    selectedValues.delete(oldValue);
-    selectedValues.set(event.detail.newValue, item);
-  }
-}
-// --------------------------------------------------------------------------
-//
-//  Private Methods
-//
-// --------------------------------------------------------------------------
-function isValidNavigationKey(key) {
-  return !!SUPPORTED_ARROW_KEYS.find((k) => k === key);
-}
-function calciteListFocusOutHandler(event) {
-  const { el, items, multiple, selectedValues } = this;
-  if (multiple) {
-    return;
-  }
-  const focusedInside = !!el.contains(event.relatedTarget);
-  if (focusedInside) {
-    toggleSingleSelectItemTabbing(event.target, false);
-    return;
-  }
-  items.forEach((item) => toggleSingleSelectItemTabbing(item, selectedValues.size === 0 ? event.target === item : item.selected));
-}
-function keyDownHandler(event) {
-  const { key, target } = event;
-  if (!isValidNavigationKey(key)) {
-    return;
-  }
-  const { items, multiple, selectionFollowsFocus } = this;
-  const { length: totalItems } = items;
-  const currentIndex = items.indexOf(target);
-  if (!totalItems || currentIndex === -1) {
-    return;
-  }
-  event.preventDefault();
-  const index = getRoundRobinIndex(currentIndex + (key === "ArrowUp" ? -1 : 1), totalItems);
-  const item = items[index];
-  items.forEach((i) => toggleSingleSelectItemTabbing(i, i === item));
-  if (!multiple && selectionFollowsFocus) {
-    item.selected = true;
-  }
-  focusElement(item);
-}
-function internalCalciteListChangeEvent() {
-  this.calciteListChange.emit(this.selectedValues);
-}
-function removeItem(event) {
-  if (event.defaultPrevented) {
-    return;
-  }
-  const item = event.target;
-  const selectedValues = this.selectedValues;
-  if (item.parentElement.tagName === "CALCITE-PICK-LIST-GROUP") {
-    item.parentElement.remove();
-    Array.from(item.parentElement.children).forEach((item) => selectedValues.delete(item.value));
-  }
-  else {
-    item.remove();
-    selectedValues.delete(item.value);
-  }
-  this.emitCalciteListChange();
-}
-function toggleSingleSelectItemTabbing(item, selectable) {
-  // using attribute intentionally
-  if (selectable) {
-    item.removeAttribute("tabindex");
-  }
-  else {
-    item.setAttribute("tabindex", "-1");
-  }
-}
-async function setFocus(focusId) {
-  if (this.filterEnabled && focusId === "filter") {
-    await focusElement(this.filterEl);
-    return;
-  }
-  const { items, multiple, selectionFollowsFocus } = this;
-  if (items.length === 0) {
-    return;
-  }
-  if (multiple) {
-    return items[0].setFocus();
-  }
-  const focusTarget = items.find((item) => item.selected) || items[0];
-  if (selectionFollowsFocus) {
-    focusTarget.selected = true;
-  }
-  return focusTarget.setFocus();
-}
-function setUpItems(tagName) {
-  this.items = Array.from(this.el.querySelectorAll(tagName));
-  let hasSelected = false;
-  const { items } = this;
-  items.forEach((item) => {
-    item.icon = this.getIconType();
-    if (!this.multiple) {
-      item.disableDeselect = true;
-      toggleSingleSelectItemTabbing(item, false);
-    }
-    if (item.selected) {
-      hasSelected = true;
-      toggleSingleSelectItemTabbing(item, true);
-      this.selectedValues.set(item.value, item);
-    }
-  });
-  const [first] = items;
-  if (!hasSelected && first) {
-    toggleSingleSelectItemTabbing(first, true);
-  }
-}
-function deselectSiblingItems(item) {
-  this.items.forEach((currentItem) => {
-    if (currentItem.value !== item.value) {
-      currentItem.toggleSelected(false);
-      if (this.selectedValues.has(currentItem.value)) {
-        this.selectedValues.delete(currentItem.value);
-      }
-    }
-  });
-}
-function selectSiblings(item, deselect = false) {
-  if (!this.lastSelectedItem) {
-    return;
-  }
-  const { items } = this;
-  const start = items.findIndex((currentItem) => {
-    return currentItem.value === this.lastSelectedItem.value;
-  });
-  const end = items.findIndex((currentItem) => {
-    return currentItem.value === item.value;
-  });
-  items.slice(Math.min(start, end), Math.max(start, end)).forEach((currentItem) => {
-    currentItem.toggleSelected(!deselect);
-    if (!deselect) {
-      this.selectedValues.set(currentItem.value, currentItem);
-    }
-    else {
-      this.selectedValues.delete(currentItem.value);
-    }
-  });
-}
-let groups;
-function handleFilter(event) {
-  const filteredData = event.detail;
-  const values = filteredData.map((item) => item.value);
-  let hasSelectedMatch = false;
-  if (!groups) {
-    groups = new Set();
-  }
-  const matchedItems = this.items.filter((item) => {
-    const parent = item.parentElement;
-    const grouped = parent.matches("calcite-pick-list-group");
-    if (grouped) {
-      groups.add(parent);
-    }
-    const matches = values.includes(item.value);
-    item.hidden = !matches;
-    if (!hasSelectedMatch) {
-      hasSelectedMatch = matches && item.selected;
-    }
-    return matches;
-  });
-  groups.forEach((group) => {
-    const hasAtLeastOneMatch = matchedItems.some((item) => group.contains(item));
-    group.hidden = !hasAtLeastOneMatch;
-    if (!hasAtLeastOneMatch) {
-      return;
-    }
-    const parentItem = getSlotted(group, "parent-item");
-    if (parentItem) {
-      parentItem.hidden = false;
-      if (matchedItems.includes(parentItem)) {
-        Array.from(group.children).forEach((child) => (child.hidden = false));
-      }
-    }
-  });
-  groups.clear();
-  if (matchedItems.length > 0 && !hasSelectedMatch && !this.multiple) {
-    toggleSingleSelectItemTabbing(matchedItems[0], true);
-  }
-}
-function getItemData() {
-  return this.items.map((item) => ({
-    label: item.label,
-    description: item.description,
-    metadata: item.metadata,
-    value: item.value
-  }));
-}
-
-const CSS$1 = {
-  sticky: "sticky"
-};
-var ICON_TYPES;
-(function (ICON_TYPES) {
-  ICON_TYPES["circle"] = "circle";
-  ICON_TYPES["square"] = "square";
-  ICON_TYPES["grip"] = "grip";
-})(ICON_TYPES || (ICON_TYPES = {}));
-const SLOTS$1 = {
-  menuActions: "menu-actions"
-};
-
-var __rest = (undefined && undefined.__rest) || function (s, e) {
-  var t = {};
-  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-    t[p] = s[p];
-  if (s != null && typeof Object.getOwnPropertySymbols === "function")
-    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-        t[p[i]] = s[p[i]];
-    }
-  return t;
-};
-const List = (_a) => {
-  var { props: { disabled, loading, filterEnabled, dataForFilter, handleFilter, filterPlaceholder, el, setFilterEl } } = _a, rest = __rest(_a, ["props"]);
-  const defaultSlot = h("slot", null);
-  return (h(Host, Object.assign({ "aria-busy": loading.toString(), "aria-disabled": disabled.toString(), role: "menu" }, rest),
-    h("section", null,
-      h("header", { class: { [CSS$1.sticky]: true } },
-        filterEnabled ? (h("calcite-filter", { "aria-label": filterPlaceholder, data: dataForFilter, dir: getElementDir(el), disabled: loading || disabled, onCalciteFilterChange: handleFilter, placeholder: filterPlaceholder, ref: setFilterEl })) : null,
-        h("slot", { name: SLOTS$1.menuActions })),
-      loading || disabled ? h("calcite-scrim", { loading: loading }) : null,
-      defaultSlot)));
-};
-
-const CSS = {
-  actions: "actions",
-  actionsEnd: "actions--end",
-  actionsStart: "actions--start",
-  description: "description",
-  handle: "handle",
-  handleActivated: "handle--activated",
-  highlight: "highlight",
-  icon: "icon",
-  iconDot: "icon-dot",
-  label: "label",
-  remove: "remove",
-  title: "title",
-  textContainer: "text-container"
-};
-const ICONS = {
-  checked: "check",
-  remove: "x"
-};
-const SLOTS = {
-  actionsEnd: "actions-end",
-  actionsStart: "actions-start"
-};
-const TEXT = {
-  remove: "Remove"
-};
-
-export { CSS as C, ICON_TYPES as I, List as L, SLOTS as S, TEXT as T, initializeObserver as a, calciteListItemChangeHandler as b, cleanUpObserver as c, deselectSiblingItems as d, calciteListItemValueChangeHandler as e, setUpItems as f, getItemData as g, handleFilter as h, initialize as i, setFocus as j, keyDownHandler as k, calciteListFocusOutHandler as l, mutationObserverCallback as m, ICONS as n, removeItem as r, selectSiblings as s };

package/dist/esm/resources-82817f70.js

@@ -1,13 +0,0 @@
-const CSS = {
-  menu: "menu",
-  defaultTrigger: "default-trigger"
-};
-const SLOTS = {
-  tooltip: "tooltip",
-  trigger: "trigger"
-};
-const ICONS = {
-  menu: "ellipsis"
-};
-
-export { CSS as C, ICONS as I, SLOTS as S };

package/dist/esm/resources-a7a29b39.js

@@ -1,212 +0,0 @@
-import { a as getAssetPath } from './index-1554a132.js';
-import { a as locales } from './locale-8436bbe1.js';
-
-/**
- * Get supported locale code from raw user input
- * Exported for testing purposes.
- * @private
- */
-function getSupportedLocale(lang = "") {
-  if (locales.indexOf(lang) > -1) {
-    return lang;
-  }
-  else {
-    const base = lang.split("-")[0];
-    return locales.indexOf(base) > -1 ? base : "en";
-  }
-}
-/**
- * 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
- * @public
- */
-async function getLocaleData(lang) {
-  const locale = getSupportedLocale(lang);
-  if (translationCache[locale]) {
-    return translationCache[locale];
-  }
-  if (!requestCache[locale]) {
-    requestCache[locale] = fetch(getAssetPath(`./assets/calcite-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;
-}
-
-/**
- * Check if date is within a min and max
- */
-function inRange(date, min, max) {
-  const time = date.getTime();
-  const afterMin = !(min instanceof Date) || time >= min.getTime();
-  const beforeMax = !(max instanceof Date) || time <= max.getTime();
-  return afterMin && beforeMax;
-}
-/**
- * Ensures date is within range,
- * returns min or max if out of bounds
- */
-function dateFromRange(date, min, max) {
-  if (!(date instanceof Date)) {
-    return null;
-  }
-  const time = date.getTime();
-  const beforeMin = min instanceof Date && time < min.getTime();
-  const afterMax = max instanceof Date && time > max.getTime();
-  if (beforeMin) {
-    return min;
-  }
-  if (afterMax) {
-    return max;
-  }
-  return date;
-}
-/**
- * Parse an iso8601 string (YYYY-mm-dd) into a valid date.
- * TODO: handle time when time of day UI is added
- */
-function dateFromISO(iso8601) {
-  if (iso8601 instanceof Date) {
-    return iso8601;
-  }
-  if (!iso8601 || typeof iso8601 !== "string") {
-    return null;
-  }
-  const d = iso8601.split(/[: T-]/).map(parseFloat);
-  const date = new Date(d[0], (d[1] || 1) - 1, d[2] || 1);
-  date.setFullYear(d[0]);
-  if (isNaN(date.getTime())) {
-    throw new Error(`Invalid ISO 8601 date: "${iso8601}"`);
-  }
-  return date;
-}
-/**
- * Return first portion of ISO string (YYYY-mm-dd)
- */
-function dateToISO(date) {
-  if (typeof date === "string") {
-    return date;
-  }
-  if (date instanceof Date) {
-    return new Date(date.getTime() - date.getTimezoneOffset() * 60000).toISOString().split("T")[0];
-  }
-  return "";
-}
-/**
- * Check if two dates are the same day, month, year
- */
-function sameDate(d1, d2) {
-  return (d1 instanceof Date &&
-    d2 instanceof Date &&
-    d1.getDate() === d2.getDate() &&
-    d1.getMonth() === d2.getMonth() &&
-    d1.getFullYear() === d2.getFullYear());
-}
-/**
- * Get a date one month in the past
- */
-function prevMonth(date) {
-  const month = date.getMonth();
-  const nextDate = new Date(date);
-  nextDate.setMonth(month - 1);
-  // date doesn't exist in new month, use last day
-  if (month === nextDate.getMonth()) {
-    return new Date(date.getFullYear(), month, 0);
-  }
-  return nextDate;
-}
-/**
- * Get a date one month in the future
- */
-function nextMonth(date) {
-  const month = date.getMonth();
-  const nextDate = new Date(date);
-  nextDate.setMonth(month + 1);
-  // date doesn't exist in new month, use last day
-  if ((month + 2) % 7 === nextDate.getMonth() % 7) {
-    return new Date(date.getFullYear(), month + 2, 0);
-  }
-  return nextDate;
-}
-/**
- * Translate a number into a given locals numeral system
- */
-function localizeNumber(num, localeData) {
-  return String(num)
-    .split("")
-    .map((i) => localeData.numerals[i])
-    .join("");
-}
-/**
- * Calculate actual number from localized string
- */
-function parseNumber(str, localeData) {
-  const numerals = "0123456789";
-  return parseInt(str
-    .split("")
-    .map((i) => numerals[localeData.numerals.indexOf(i)])
-    .filter((num) => num)
-    .join(""));
-}
-/**
- * Parse numeric units for day, month, and year from a localized string
- * month starts at 0 (can pass to date constructor)
- */
-function parseDateString(str, localeData) {
-  const { separator, unitOrder } = localeData;
-  const order = getOrder(unitOrder);
-  const values = replaceArabicNumerals(str).split(separator);
-  return {
-    day: parseInt(values[order.indexOf("d")]),
-    month: parseInt(values[order.indexOf("m")]) - 1,
-    year: parseInt(values[order.indexOf("y")])
-  };
-}
-/**
- * Convert eastern arbic numerals
- */
-function replaceArabicNumerals(str = "") {
-  return str
-    .replace(/[\u0660-\u0669]/g, (c) => (c.charCodeAt(0) - 0x0660))
-    .replace(/[\u06f0-\u06f9]/g, (c) => (c.charCodeAt(0) - 0x06f0));
-}
-/**
- * Based on the unitOrder string, find order of month, day, and year for locale
- */
-function getOrder(unitOrder) {
-  const signifiers = ["d", "m", "y"];
-  const order = unitOrder.toLowerCase();
-  return signifiers.sort((a, b) => order.indexOf(a) - order.indexOf(b));
-}
-/**
- * Get number of days between two dates
- */
-function getDaysDiff(date1, date2) {
-  const ts1 = date1.getTime();
-  const ts2 = date2.getTime();
-  return (ts1 - ts2) / (1000 * 3600 * 24);
-}
-
-const HEADING_LEVEL = 2;
-const TEXT = {
-  nextMonth: "Next month",
-  prevMonth: "Previous month"
-};
-
-export { HEADING_LEVEL as H, TEXT as T, dateFromISO as a, dateFromRange as b, getDaysDiff as c, dateToISO as d, getOrder as e, prevMonth as f, getLocaleData as g, parseNumber as h, inRange as i, localizeNumber as l, nextMonth as n, parseDateString as p, sameDate as s };

package/dist/esm/resources-c72ebfea.js

@@ -1,12 +0,0 @@
-const SLOTS = {
-  menuActions: "menu-actions",
-  menuTooltip: "menu-tooltip"
-};
-const TEXT = {
-  more: "More"
-};
-const ICONS = {
-  menu: "ellipsis"
-};
-
-export { ICONS as I, SLOTS as S, TEXT as T };