@arcgis/toolkit 4.34.0-next.100

package/dist/dom/index.js

@@ -0,0 +1,198 @@
+function slotChangeHasContent(event) {
+  return slotChangeHasAssignedElement(event) || slotChangeHasTextContent(event);
+}
+function slotChangeGetTextContent(event) {
+  return slotChangeGetAssignedNodes(event).filter((node) => node.nodeType === Node.TEXT_NODE).map((node) => node.textContent).join("").trim();
+}
+function slotChangeHasTextContent(event) {
+  return slotChangeGetTextContent(event).length > 0;
+}
+function slotChangeHasAssignedNode(event) {
+  return slotChangeGetAssignedNodes(event).length > 0;
+}
+function slotChangeGetAssignedNodes(event) {
+  return event.currentTarget.assignedNodes({
+    flatten: true
+  });
+}
+function slotChangeHasAssignedElement(event) {
+  return slotChangeGetAssignedElements(event).length > 0;
+}
+function slotChangeGetAssignedElements(event, selector) {
+  return getSlotAssignedElements(event.target, selector);
+}
+function getSlotAssignedElements(slot, selector) {
+  const assignedElements = slot.assignedElements({
+    flatten: true
+  });
+  return selector ? assignedElements.filter((element) => element.matches(selector)) : assignedElements;
+}
+const classes = (...classes2) => {
+  const effectiveClasses = [];
+  for (let i = 0; i < classes2.length; i++) {
+    const arg = classes2[i];
+    if (typeof arg === "string") {
+      effectiveClasses.push(arg);
+    } else if (Array.isArray(arg)) {
+      effectiveClasses.push.apply(effectiveClasses, arg);
+    } else if (typeof arg === "object") {
+      for (const prop in arg) {
+        if (arg[prop]) {
+          effectiveClasses.push(prop);
+        }
+      }
+    }
+  }
+  const className = effectiveClasses.join(" ");
+  effectiveClasses.length = 0;
+  return className;
+};
+const inTargetElement = (element, targetElement) => {
+  let currentElement = element;
+  while (currentElement) {
+    if (currentElement === targetElement) {
+      return true;
+    }
+    if (!currentElement.parentNode) {
+      return false;
+    }
+    if (currentElement.parentNode instanceof ShadowRoot) {
+      currentElement = currentElement.parentNode.host;
+    } else {
+      currentElement = currentElement.parentNode;
+    }
+  }
+  return false;
+};
+const observeAncestorsMutation = (element, attributeFilter, callback) => {
+  const subscribe = observe(attributeFilter).subscribe;
+  return subscribe((mutations) => {
+    const matched = mutations.some((mutation) => inTargetElement(element, mutation.target));
+    if (matched) {
+      callback();
+    }
+  });
+};
+const observers = {};
+const observe = (attributeFilter) => {
+  const attributes = attributeFilter.join(",");
+  const previousObserver = observers[attributes];
+  if (previousObserver !== void 0) {
+    return previousObserver;
+  }
+  const subscribers = /* @__PURE__ */ new Set();
+  const mutationObserver = new MutationObserver((mutations) => subscribers.forEach((callback) => callback(mutations)));
+  if (globalThis.document) {
+    mutationObserver.observe(document.documentElement, {
+      attributes: true,
+      attributeFilter,
+      subtree: true
+    });
+  }
+  const observer = {
+    subscribe: (callback) => {
+      subscribers.add(callback);
+      return () => {
+        subscribers.delete(callback);
+        if (subscribers.size === 0) {
+          mutationObserver.disconnect();
+          observers[attributes] = void 0;
+        }
+      };
+    }
+  };
+  observers[attributes] = observer;
+  return observer;
+};
+const getClosestElement = (base, selector) => {
+  let currentElement = base;
+  while (currentElement) {
+    const element = currentElement.closest?.(selector);
+    if (element) {
+      return element;
+    }
+    const rootElement = currentElement.getRootNode?.();
+    if (rootElement === globalThis.document) {
+      return;
+    }
+    currentElement = rootElement.host;
+  }
+  return;
+};
+function unsafeGetCalciteModeName(el) {
+  const closestElWithMode = getClosestElement(el, `.calcite-mode-dark, .calcite-mode-light, .calcite-mode-auto`);
+  return closestElWithMode?.classList.contains("calcite-mode-dark") || closestElWithMode?.classList.contains("calcite-mode-auto") && window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+}
+const unsafeGetElementDirection = (el) => (
+  //#endregion unsafeGetElementDirection
+  getElementAttribute(el, "dir", "ltr")
+);
+const getElementAttribute = (el, attributeName, fallbackValue) => {
+  const closest = getClosestElement(el, `[${attributeName}]`);
+  return closest?.getAttribute(attributeName) ?? fallbackValue;
+};
+const focusElement = async (el) => {
+  if (el == null) {
+    return;
+  }
+  if (hasSetFocus(el)) {
+    await el.setFocus();
+  } else {
+    el.focus();
+  }
+};
+const hasSetFocus = (ref) => typeof ref.setFocus === "function";
+const setFocusOnElement = (ref, selector) => {
+  if (!ref?.shadowRoot) {
+    return;
+  }
+  if (ref.hasAttribute("hydrated") || ref.hasAttribute("calcite-hydrated")) {
+    setFocus(ref, selector);
+    return;
+  }
+  void Promise.resolve(ref.componentOnReady?.()).then(() => setFocus(ref, selector));
+};
+const isElement = (ref) => ref.nodeType === Node.ELEMENT_NODE;
+const setFocus = (ref, selector = "") => {
+  if (!isElement(ref)) {
+    return false;
+  }
+  if (ref.matches(selector)) {
+    if (hasSetFocus(ref)) {
+      setTimeout(() => void ref.setFocus(), 0);
+    }
+    return true;
+  }
+  for (const child of ref.children) {
+    if (setFocus(child, selector)) {
+      return true;
+    }
+  }
+  const shadowRoot = ref.shadowRoot;
+  if (shadowRoot) {
+    for (const child of shadowRoot.children) {
+      if (setFocus(child, selector)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+export {
+  classes,
+  focusElement,
+  getClosestElement,
+  getElementAttribute,
+  getSlotAssignedElements,
+  observeAncestorsMutation,
+  setFocusOnElement,
+  slotChangeGetAssignedElements,
+  slotChangeGetAssignedNodes,
+  slotChangeGetTextContent,
+  slotChangeHasAssignedElement,
+  slotChangeHasAssignedNode,
+  slotChangeHasContent,
+  slotChangeHasTextContent,
+  unsafeGetCalciteModeName,
+  unsafeGetElementDirection
+};

package/dist/dom/slots.d.cts

@@ -0,0 +1,93 @@
+/**
+ * Returns `true` if the target `slot` element from the `onSlotchange` event has any content (text or elements).
+ *
+ * @param event The event.
+ * @returns Whether the slot has any content.
+ *
+ * @example
+ * ```tsx
+ * <slot onSlotchange={(event) => this.mySlotHasContent = slotChangeHasContent(event)} />}
+ * ```
+ */
+export declare function slotChangeHasContent(event: Event): boolean;
+/**
+ * Returns a string of textContent if the target `slot` element from the `onSlotchange` event has any text content.
+ *
+ * @param event The event.
+ * @returns {string} The slots text.
+ *
+ * @example
+ * ```tsx
+ * <slot onSlotchange={(event) => this.mySlotText = slotChangeGetTextContent(event)} />}
+ * ```
+ */
+export declare function slotChangeGetTextContent(event: Event): string;
+/**
+ * Returns `true` if the target `slot` element from the `onSlotchange` event has any text content.
+ *
+ * @param event The event.
+ * @returns Whether the slot has any text content.
+ *
+ * @example
+ * ```tsx
+ * <slot onSlotchange={(event) => this.mySlotHasTextContent = slotChangeHasTextContent(event)} />}
+ * ```
+ */
+export declare function slotChangeHasTextContent(event: Event): boolean;
+/**
+ * Returns `true` if the target `slot` element from the `onSlotchange` event has an assigned node.
+ *
+ * @param event The event.
+ * @returns Whether the slot has any assigned nodes.
+ *
+ * @example
+ * ```tsx
+ * <slot onSlotchange={(event) => this.mySlotHasNode = slotChangeHasAssignedNode(event)} />}
+ * ```
+ */
+export declare function slotChangeHasAssignedNode(event: Event): boolean;
+/**
+ * Returns the assigned nodes on a `slot` element from the `onSlotchange` event.
+ *
+ * @param event The event.
+ * @returns Whether the slot has any assigned nodes.
+ *
+ * @example
+ * ```tsx
+ * <slot onSlotchange={(event) => this.mySlotNodes = slotChangeGetAssignedNodes(event)} />}
+ * ```
+ */
+export declare function slotChangeGetAssignedNodes(event: Event): Node[];
+/**
+ * Returns `true` if the target `slot` element from the `onSlotchange` event has an assigned element.
+ *
+ * @param event The event.
+ * @returns Whether the slot has any assigned elements.
+ *
+ * @example
+ * ```tsx
+ * <slot onSlotchange={(event) => this.mySlotHasElement = slotChangeHasAssignedElement(event)} />}
+ * ```
+ */
+export declare function slotChangeHasAssignedElement(event: Event): boolean;
+/**
+ * Returns the assigned elements on a `slot` element from the `onSlotchange` event.
+ *
+ * @param {Event} event The event.
+ * @param {string} selector The CSS selector string to filter the returned elements by.
+ * @returns {Element[]} An array of elements.
+ *
+ * @example
+ * ```tsx
+ * <slot onSlotchange={(event) => this.mySlotElements = slotChangeGetAssignedElements(event)} />}
+ * ```
+ */
+export declare function slotChangeGetAssignedElements<T extends Element>(event: Event, selector?: string): T[];
+/**
+ * Returns the assigned elements on a `slot` element, filtered by an optional css selector.
+ *
+ * @param {HTMLSlotElement} slot The slot element.
+ * @param {string} selector CSS selector string to filter the returned elements by.
+ * @returns {Element[]} An array of elements.
+ */
+export declare function getSlotAssignedElements<T extends Element>(slot: HTMLSlotElement, selector?: string): T[];

package/dist/dom/slots.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Returns `true` if the target `slot` element from the `onSlotchange` event has any content (text or elements).
+ *
+ * @param event The event.
+ * @returns Whether the slot has any content.
+ *
+ * @example
+ * ```tsx
+ * <slot onSlotchange={(event) => this.mySlotHasContent = slotChangeHasContent(event)} />}
+ * ```
+ */
+export declare function slotChangeHasContent(event: Event): boolean;
+/**
+ * Returns a string of textContent if the target `slot` element from the `onSlotchange` event has any text content.
+ *
+ * @param event The event.
+ * @returns {string} The slots text.
+ *
+ * @example
+ * ```tsx
+ * <slot onSlotchange={(event) => this.mySlotText = slotChangeGetTextContent(event)} />}
+ * ```
+ */
+export declare function slotChangeGetTextContent(event: Event): string;
+/**
+ * Returns `true` if the target `slot` element from the `onSlotchange` event has any text content.
+ *
+ * @param event The event.
+ * @returns Whether the slot has any text content.
+ *
+ * @example
+ * ```tsx
+ * <slot onSlotchange={(event) => this.mySlotHasTextContent = slotChangeHasTextContent(event)} />}
+ * ```
+ */
+export declare function slotChangeHasTextContent(event: Event): boolean;
+/**
+ * Returns `true` if the target `slot` element from the `onSlotchange` event has an assigned node.
+ *
+ * @param event The event.
+ * @returns Whether the slot has any assigned nodes.
+ *
+ * @example
+ * ```tsx
+ * <slot onSlotchange={(event) => this.mySlotHasNode = slotChangeHasAssignedNode(event)} />}
+ * ```
+ */
+export declare function slotChangeHasAssignedNode(event: Event): boolean;
+/**
+ * Returns the assigned nodes on a `slot` element from the `onSlotchange` event.
+ *
+ * @param event The event.
+ * @returns Whether the slot has any assigned nodes.
+ *
+ * @example
+ * ```tsx
+ * <slot onSlotchange={(event) => this.mySlotNodes = slotChangeGetAssignedNodes(event)} />}
+ * ```
+ */
+export declare function slotChangeGetAssignedNodes(event: Event): Node[];
+/**
+ * Returns `true` if the target `slot` element from the `onSlotchange` event has an assigned element.
+ *
+ * @param event The event.
+ * @returns Whether the slot has any assigned elements.
+ *
+ * @example
+ * ```tsx
+ * <slot onSlotchange={(event) => this.mySlotHasElement = slotChangeHasAssignedElement(event)} />}
+ * ```
+ */
+export declare function slotChangeHasAssignedElement(event: Event): boolean;
+/**
+ * Returns the assigned elements on a `slot` element from the `onSlotchange` event.
+ *
+ * @param {Event} event The event.
+ * @param {string} selector The CSS selector string to filter the returned elements by.
+ * @returns {Element[]} An array of elements.
+ *
+ * @example
+ * ```tsx
+ * <slot onSlotchange={(event) => this.mySlotElements = slotChangeGetAssignedElements(event)} />}
+ * ```
+ */
+export declare function slotChangeGetAssignedElements<T extends Element>(event: Event, selector?: string): T[];
+/**
+ * Returns the assigned elements on a `slot` element, filtered by an optional css selector.
+ *
+ * @param {HTMLSlotElement} slot The slot element.
+ * @param {string} selector CSS selector string to filter the returned elements by.
+ * @returns {Element[]} An array of elements.
+ */
+export declare function getSlotAssignedElements<T extends Element>(slot: HTMLSlotElement, selector?: string): T[];

package/dist/error/index.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isEsriInternalEnv = () => (
+  //#endregion isEsriInternalEnv
+  /*
+   * `globalThis.` is important here. Some bundlers remove the `typeof process`
+   * checks, but don't remove the usages of undefined variables - this can cause
+   * runtime error. By adding `globalThis.`, we avoid having `typeof process`
+   * check removed by the bundler.
+   * This does meant tree-shaking won't happen for the isEsriInternalEnv()
+   * check, but this is ok since this check is meant to always be behind the
+   * development/test guard.
+   * See https://devtopia.esri.com/WebGIS/arcgis-web-components/pull/2087#issuecomment-5152454
+   */
+  typeof globalThis.process === "object" && !!process.env.ESRI_INTERNAL
+);
+const safeCall = (callback, thisContext, ...rest) => {
+  try {
+    return callback?.call(thisContext, ...rest);
+  } catch (error) {
+    console.error(error, callback);
+  }
+  return void 0;
+};
+const safeAsyncCall = async (callback, thisContext, ...rest) => {
+  try {
+    const result = callback?.call(thisContext, ...rest);
+    return await result;
+  } catch (error) {
+    console.error(error, callback);
+  }
+  return void 0;
+};
+exports.isEsriInternalEnv = isEsriInternalEnv;
+exports.safeAsyncCall = safeAsyncCall;
+exports.safeCall = safeCall;

package/dist/error/index.d.cts

@@ -0,0 +1,32 @@
+/**
+ * Check whether the code is executing in an Esri internal environment (for
+ * example, Lumina dev server). When true, your code can enable extra validation
+ * to detect incorrect usages or do runtime bug detection.
+ *
+ * The call to isEsriInternalEnv() MUST always appear behind one of the
+ * following guards to ensure it is correctly eliminated in production bundles:
+ *
+ * - `process.env.NODE_ENV !== "production"`
+ * - `process.env.NODE_ENV === "development"`
+ * - `process.env.NODE_ENV === "test"`
+ *
+ * [Documentation](https://qawebgis.esri.com/components/lumina/publishing#internal-esri-environment)
+ *
+ * @remarks
+ * This function is primary for usage in support packages. In Lumina component
+ * packages, simpler alternatives are provided:
+ * https://qawebgis.esri.com/components/lumina/publishing#bundling-code-conditionally
+ */
+export declare const isEsriInternalEnv: () => boolean;
+/**
+ * Calls a sync method and catch any errors. Returns undefined if error occurred.
+ *
+ * Can also provide a thisContext and rest arguments
+ */
+export declare const safeCall: <Callback extends (...args: never[]) => unknown>(callback?: Callback, thisContext?: ThisParameterType<Callback>, ...rest: Parameters<Callback>) => ReturnType<Callback> | void;
+/**
+ * Calls an async method and catch any errors. Returns undefined if error occurred.
+ *
+ * Can also provide a thisContext and rest arguments
+ */
+export declare const safeAsyncCall: <Callback extends (...args: never[]) => unknown>(callback?: Callback, thisContext?: ThisParameterType<Callback>, ...rest: Parameters<Callback>) => Promise<Awaited<ReturnType<Callback>> | void>;

package/dist/error/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Check whether the code is executing in an Esri internal environment (for
+ * example, Lumina dev server). When true, your code can enable extra validation
+ * to detect incorrect usages or do runtime bug detection.
+ *
+ * The call to isEsriInternalEnv() MUST always appear behind one of the
+ * following guards to ensure it is correctly eliminated in production bundles:
+ *
+ * - `process.env.NODE_ENV !== "production"`
+ * - `process.env.NODE_ENV === "development"`
+ * - `process.env.NODE_ENV === "test"`
+ *
+ * [Documentation](https://qawebgis.esri.com/components/lumina/publishing#internal-esri-environment)
+ *
+ * @remarks
+ * This function is primary for usage in support packages. In Lumina component
+ * packages, simpler alternatives are provided:
+ * https://qawebgis.esri.com/components/lumina/publishing#bundling-code-conditionally
+ */
+export declare const isEsriInternalEnv: () => boolean;
+/**
+ * Calls a sync method and catch any errors. Returns undefined if error occurred.
+ *
+ * Can also provide a thisContext and rest arguments
+ */
+export declare const safeCall: <Callback extends (...args: never[]) => unknown>(callback?: Callback, thisContext?: ThisParameterType<Callback>, ...rest: Parameters<Callback>) => ReturnType<Callback> | void;
+/**
+ * Calls an async method and catch any errors. Returns undefined if error occurred.
+ *
+ * Can also provide a thisContext and rest arguments
+ */
+export declare const safeAsyncCall: <Callback extends (...args: never[]) => unknown>(callback?: Callback, thisContext?: ThisParameterType<Callback>, ...rest: Parameters<Callback>) => Promise<Awaited<ReturnType<Callback>> | void>;

package/dist/error/index.js

@@ -0,0 +1,36 @@
+const isEsriInternalEnv = () => (
+  //#endregion isEsriInternalEnv
+  /*
+   * `globalThis.` is important here. Some bundlers remove the `typeof process`
+   * checks, but don't remove the usages of undefined variables - this can cause
+   * runtime error. By adding `globalThis.`, we avoid having `typeof process`
+   * check removed by the bundler.
+   * This does meant tree-shaking won't happen for the isEsriInternalEnv()
+   * check, but this is ok since this check is meant to always be behind the
+   * development/test guard.
+   * See https://devtopia.esri.com/WebGIS/arcgis-web-components/pull/2087#issuecomment-5152454
+   */
+  typeof globalThis.process === "object" && !!process.env.ESRI_INTERNAL
+);
+const safeCall = (callback, thisContext, ...rest) => {
+  try {
+    return callback?.call(thisContext, ...rest);
+  } catch (error) {
+    console.error(error, callback);
+  }
+  return void 0;
+};
+const safeAsyncCall = async (callback, thisContext, ...rest) => {
+  try {
+    const result = callback?.call(thisContext, ...rest);
+    return await result;
+  } catch (error) {
+    console.error(error, callback);
+  }
+  return void 0;
+};
+export {
+  isEsriInternalEnv,
+  safeAsyncCall,
+  safeCall
+};

package/dist/function/index.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const identity = (value) => value;
+const debounce = (func, waitFor = 100) => {
+  let timeout;
+  return (...args) => {
+    const later = () => {
+      clearTimeout(timeout);
+      func(...args);
+    };
+    clearTimeout(timeout);
+    timeout = setTimeout(later, waitFor);
+  };
+};
+exports.debounce = debounce;
+exports.identity = identity;

package/dist/function/index.d.cts

@@ -0,0 +1,19 @@
+/**
+ * Identity function - returns back the first parameter
+ *
+ * Useful when providing a "mapping function" is required, but you have no need
+ * to change the value
+ *
+ * @privateRemarks
+ * This is a trivial function, but it helps workaround a TypeScript bug:
+ * https://devtopia.esri.com/WebGIS/arcgis-web-components/issues/2047
+ */
+export declare const identity: <T>(value: T) => T;
+/**
+ * Allows to debounce a function.
+ *
+ * @param func Function to be debounced
+ * @param waitFor Debounce time in milliseconds
+ * @returns Returns a function that can be called to debounce the original function
+ */
+export declare const debounce: <F extends (...args: Parameters<F>) => ReturnType<F>>(func: F, waitFor?: number) => ((...args: Parameters<F>) => void);

package/dist/function/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Identity function - returns back the first parameter
+ *
+ * Useful when providing a "mapping function" is required, but you have no need
+ * to change the value
+ *
+ * @privateRemarks
+ * This is a trivial function, but it helps workaround a TypeScript bug:
+ * https://devtopia.esri.com/WebGIS/arcgis-web-components/issues/2047
+ */
+export declare const identity: <T>(value: T) => T;
+/**
+ * Allows to debounce a function.
+ *
+ * @param func Function to be debounced
+ * @param waitFor Debounce time in milliseconds
+ * @returns Returns a function that can be called to debounce the original function
+ */
+export declare const debounce: <F extends (...args: Parameters<F>) => ReturnType<F>>(func: F, waitFor?: number) => ((...args: Parameters<F>) => void);

package/dist/function/index.js

@@ -0,0 +1,16 @@
+const identity = (value) => value;
+const debounce = (func, waitFor = 100) => {
+  let timeout;
+  return (...args) => {
+    const later = () => {
+      clearTimeout(timeout);
+      func(...args);
+    };
+    clearTimeout(timeout);
+    timeout = setTimeout(later, waitFor);
+  };
+};
+export {
+  debounce,
+  identity
+};