@esri/calcite-components 1.0.0-next.677 → 1.0.0-next.679

package/dist/cjs/dom-7155cb03.js

@@ -0,0 +1,255 @@
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.
+ * v1.0.0-next.679
+ */
+'use strict';
+
+const resources = require('./resources-c39f2198.js');
+const guid = require('./guid-92d3ff00.js');
+
+/**
+ * This helper will guarantee an ID on the provided element.
+ *
+ * If it already has an ID, it will be preserved, otherwise a unique one will be generated and assigned.
+ *
+ * @param el
+ * @returns {string} The element's ID.
+ */
+function ensureId(el) {
+  if (!el) {
+    return "";
+  }
+  return (el.id = el.id || `${el.tagName.toLowerCase()}-${guid.guid()}`);
+}
+function nodeListToArray(nodeList) {
+  return Array.isArray(nodeList) ? nodeList : Array.from(nodeList);
+}
+function getThemeName(el) {
+  const closestElWithTheme = closestElementCrossShadowBoundary(el, `.${resources.CSS_UTILITY.darkTheme}, .${resources.CSS_UTILITY.lightTheme}`);
+  return closestElWithTheme?.classList.contains("calcite-theme-dark") ? "dark" : "light";
+}
+function getElementDir(el) {
+  const prop = "dir";
+  const selector = `[${prop}]`;
+  const closest = closestElementCrossShadowBoundary(el, selector);
+  return closest ? closest.getAttribute(prop) : "ltr";
+}
+function getElementProp(el, prop, fallbackValue) {
+  const selector = `[${prop}]`;
+  const closest = el.closest(selector);
+  return closest ? closest.getAttribute(prop) : fallbackValue;
+}
+function getRootNode(el) {
+  return el.getRootNode();
+}
+function getHost(root) {
+  return root.host || null;
+}
+/**
+ * This helper queries an element's rootNode and any ancestor rootNodes.
+ *
+ * If both an 'id' and 'selector' are supplied, 'id' will take precedence over 'selector'.
+ *
+ * @param element
+ * @param root0
+ * @param root0.selector
+ * @param root0.id
+ * @returns {Element} The element.
+ */
+function queryElementRoots(element, { selector, id }) {
+  // Gets the rootNode and any ancestor rootNodes (shadowRoot or document) of an element and queries them for a selector.
+  // Based on: https://stackoverflow.com/q/54520554/194216
+  function queryFrom(el) {
+    if (!el) {
+      return null;
+    }
+    if (el.assignedSlot) {
+      el = el.assignedSlot;
+    }
+    const rootNode = getRootNode(el);
+    const found = id
+      ? "getElementById" in rootNode
+        ? /*
+          Check to make sure 'getElementById' exists in cases where element is no longer connected to the DOM and getRootNode() returns the element.
+          https://github.com/Esri/calcite-components/pull/4280
+           */
+          rootNode.getElementById(id)
+        : null
+      : selector
+        ? rootNode.querySelector(selector)
+        : null;
+    const host = getHost(rootNode);
+    return found ? found : host ? queryFrom(host) : null;
+  }
+  return queryFrom(element);
+}
+function closestElementCrossShadowBoundary(element, selector) {
+  // based on https://stackoverflow.com/q/54520554/194216
+  function closestFrom(el) {
+    return el ? el.closest(selector) || closestFrom(getHost(getRootNode(el))) : null;
+  }
+  return closestFrom(element);
+}
+/**
+ * This utility helps invoke a callback as it traverses a node and its ancestors until reaching the root document.
+ *
+ * Returning early or undefined in `onVisit` will continue traversing up the DOM tree. Otherwise, traversal will halt with the returned value as the result of the function
+ *
+ * @param element
+ * @param onVisit
+ */
+function walkUpAncestry(element, onVisit) {
+  return visit(element, onVisit);
+}
+function visit(node, onVisit) {
+  if (!node) {
+    return;
+  }
+  const result = onVisit(node);
+  if (result !== undefined) {
+    return result;
+  }
+  const { parentNode } = node;
+  return visit(parentNode instanceof ShadowRoot ? parentNode.host : parentNode, onVisit);
+}
+function containsCrossShadowBoundary(element, maybeDescendant) {
+  return !!walkUpAncestry(maybeDescendant, (node) => (node === element ? true : undefined));
+}
+function isCalciteFocusable(el) {
+  return typeof el?.setFocus === "function";
+}
+async function focusElement(el) {
+  if (!el) {
+    return;
+  }
+  return isCalciteFocusable(el) ? el.setFocus() : el.focus();
+}
+const defaultSlotSelector = ":not([slot])";
+function getSlotted(element, slotName, options) {
+  if (slotName && !Array.isArray(slotName) && typeof slotName !== "string") {
+    options = slotName;
+    slotName = null;
+  }
+  const slotSelector = slotName
+    ? Array.isArray(slotName)
+      ? slotName.map((name) => `[slot="${name}"]`).join(",")
+      : `[slot="${slotName}"]`
+    : defaultSlotSelector;
+  if (options?.all) {
+    return queryMultiple(element, slotSelector, options);
+  }
+  return querySingle(element, slotSelector, options);
+}
+function getDirectChildren(el, selector) {
+  return el ? Array.from(el.children || []).filter((child) => child?.matches(selector)) : [];
+}
+function queryMultiple(element, slotSelector, options) {
+  let matches = slotSelector === defaultSlotSelector
+    ? getDirectChildren(element, defaultSlotSelector)
+    : Array.from(element.querySelectorAll(slotSelector));
+  matches = options && options.direct === false ? matches : matches.filter((el) => el.parentElement === element);
+  matches = options?.matches ? matches.filter((el) => el?.matches(options.matches)) : matches;
+  const selector = options?.selector;
+  return selector
+    ? matches
+      .map((item) => Array.from(item.querySelectorAll(selector)))
+      .reduce((previousValue, currentValue) => [...previousValue, ...currentValue], [])
+      .filter((match) => !!match)
+    : matches;
+}
+function querySingle(element, slotSelector, options) {
+  let match = slotSelector === defaultSlotSelector
+    ? getDirectChildren(element, defaultSlotSelector)[0] || null
+    : element.querySelector(slotSelector);
+  match = options && options.direct === false ? match : match?.parentElement === element ? match : null;
+  match = options?.matches ? (match?.matches(options.matches) ? match : null) : match;
+  const selector = options?.selector;
+  return selector ? match?.querySelector(selector) : match;
+}
+function filterDirectChildren(el, selector) {
+  return Array.from(el.children).filter((child) => child.matches(selector));
+}
+// set a default icon from a defined set or allow an override with an icon name string
+function setRequestedIcon(iconObject, iconValue, matchedValue) {
+  if (typeof iconValue === "string" && iconValue !== "") {
+    return iconValue;
+  }
+  else if (iconValue === "") {
+    return iconObject[matchedValue];
+  }
+}
+function intersects(rect1, rect2) {
+  return !(rect2.left > rect1.right ||
+    rect2.right < rect1.left ||
+    rect2.top > rect1.bottom ||
+    rect2.bottom < rect1.top);
+}
+/**
+ * This helper makes sure that boolean aria attributes are properly converted to a string.
+ *
+ * It should only be used for aria attributes that require a string value of "true" or "false".
+ *
+ * @param value
+ * @returns {string} The string conversion of a boolean value ("true" | "false").
+ */
+function toAriaBoolean(value) {
+  return Boolean(value).toString();
+}
+/**
+ * This helper returns `true` if the target `slot` element from the `onSlotchange` event has an assigned element.
+ *
+ * ```
+ * <slot onSlotchange={(event) => this.mySlotHasElement = slotChangeHasAssignedElement(event)} />}
+ * ```
+ *
+ * @param event
+ * @returns {boolean} Whether the slot has any assigned elements.
+ */
+function slotChangeHasAssignedElement(event) {
+  return !!slotChangeGetAssignedElements(event).length;
+}
+/**
+ * This helper returns the assigned elements on a `slot` element from the `onSlotchange` event.
+ *
+ * ```
+ * <slot onSlotchange={(event) => this.mySlotElements = slotChangeGetAssignedElements(event)} />}
+ * ```
+ *
+ * @param event
+ * @returns {boolean} Whether the slot has any assigned elements.
+ */
+function slotChangeGetAssignedElements(event) {
+  return event.target.assignedElements({
+    flatten: true
+  });
+}
+/**
+ * This helper returns true if the pointer event fired from the primary button of the device.
+ *
+ * See https://www.w3.org/TR/pointerevents/#the-button-property.
+ *
+ * @param event
+ * @returns {boolean}
+ */
+function isPrimaryPointerButton(event) {
+  return !!(event.isPrimary && event.button === 0);
+}
+
+exports.closestElementCrossShadowBoundary = closestElementCrossShadowBoundary;
+exports.containsCrossShadowBoundary = containsCrossShadowBoundary;
+exports.ensureId = ensureId;
+exports.filterDirectChildren = filterDirectChildren;
+exports.focusElement = focusElement;
+exports.getElementDir = getElementDir;
+exports.getElementProp = getElementProp;
+exports.getRootNode = getRootNode;
+exports.getSlotted = getSlotted;
+exports.getThemeName = getThemeName;
+exports.intersects = intersects;
+exports.isPrimaryPointerButton = isPrimaryPointerButton;
+exports.nodeListToArray = nodeListToArray;
+exports.queryElementRoots = queryElementRoots;
+exports.setRequestedIcon = setRequestedIcon;
+exports.slotChangeHasAssignedElement = slotChangeHasAssignedElement;
+exports.toAriaBoolean = toAriaBoolean;