@arcgis/toolkit 5.2.0-next.14 → 5.2.0-next.141

package/LICENSE.md

@@ -1,12 +1,14 @@
 # Licensing
 
-COPYRIGHT © Esri
+COPYRIGHT Esri
 
 All rights reserved under the copyright laws of the United States and applicable international laws, treaties, and conventions.
 
-This material is licensed for use under the [Esri Master License Agreement (MLA)](https://www.esri.com/content/dam/esrisites/en-us/media/legal/ma-full/ma-full.pdf), and is bound by the terms of that agreement.
+This material is licensed for use under the Esri Master License Agreement (MLA), and is bound by the terms of that agreement.
 You may redistribute and use this code without modification, provided you adhere to the terms of the MLA and include this copyright notice.
 
+See use restrictions at https://www.esri.com/content/dam/esrisites/en-us/media/legal/ma-full/ma-full.pdf.
+
 For additional information, contact:
 Environmental Systems Research Institute, Inc.
 Attn: Contracts and Legal Services Department

package/README.md

@@ -8,5 +8,5 @@ It is not intended to be used directly, but rather used as a dependency by other
 
 ## License
 
-This package is licensed under the terms described in the `LICENSE.md` file, located in the root of the package, and at https://js.arcgis.com/5.1/LICENSE.txt.
-For third party notices, see https://js.arcgis.com/5.1/third-party-notices.txt.
+This package is licensed under the terms described in the `LICENSE.md` file, located in the root of the package, and at https://js.arcgis.com/5.2/LICENSE.txt.
+For third party notices, see https://js.arcgis.com/5.2/third-party-notices.txt.

package/dist/{array/index.d.ts → array.d.ts}

@@ -1,8 +1,11 @@
-import { nil } from '../type/index.ts';
+import type { nil } from "./type.ts";
 /**
  * A combination of map and find.
  * Find a value in an array, and return its mapped variant.
  *
+ * @public
+ * @param array
+ * @param callback
  * @example
  * ```ts
  * // Given array of url strings, return the first valid URL object.

package/dist/{dom/index.js → chunks/dom.js}

@@ -1,35 +1,7 @@
-import { log } from "../log/index.js";
-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;
-}
+import { getSlotAssignedElements as getSlotAssignedElements$1, slotChangeGetAssignedElements as slotChangeGetAssignedElements$1, slotChangeGetAssignedNodes as slotChangeGetAssignedNodes$1, slotChangeGetTextContent as slotChangeGetTextContent$1, slotChangeHasAssignedElement as slotChangeHasAssignedElement$1, slotChangeHasAssignedNode as slotChangeHasAssignedNode$1, slotChangeHasContent as slotChangeHasContent$1, slotChangeHasTextContent as slotChangeHasTextContent$1 } from "../dom/slots.js";
+import { log } from "../log.js";
 const allowedTags = ["arcgis-map", "arcgis-scene", "arcgis-link-chart"];
-function resolveReferenceElement(component, referenceElementString) {
+function resolveReferenceElement$1(component, referenceElementString) {
   const referenceElement = referenceElementString ?? component.referenceElement;
   if (typeof referenceElement !== "string") {
     return referenceElement ?? void 0;
@@ -55,6 +27,15 @@ function resolveReferenceElement(component, referenceElementString) {
   }
   return resolved ?? void 0;
 }
+const slotChangeHasContent = slotChangeHasContent$1;
+const slotChangeGetTextContent = slotChangeGetTextContent$1;
+const slotChangeHasTextContent = slotChangeHasTextContent$1;
+const slotChangeHasAssignedNode = slotChangeHasAssignedNode$1;
+const slotChangeGetAssignedNodes = slotChangeGetAssignedNodes$1;
+const slotChangeHasAssignedElement = slotChangeHasAssignedElement$1;
+const slotChangeGetAssignedElements = slotChangeGetAssignedElements$1;
+const getSlotAssignedElements = getSlotAssignedElements$1;
+const resolveReferenceElement = resolveReferenceElement$1;
 const classes = (...classes2) => {
   const effectiveClasses = [];
   for (let i = 0; i < classes2.length; ++i) {
@@ -206,22 +187,27 @@ const setFocus = (ref, selector = "") => {
   }
   return false;
 };
+function getElementWindow(element) {
+  return element.ownerDocument.defaultView || window;
+}
 export {
-  classes,
-  focusElement,
-  getClosestElement,
-  getElementAttribute,
-  getSlotAssignedElements,
-  observeAncestorsMutation,
-  resolveReferenceElement,
-  setFocusOnElement,
-  slotChangeGetAssignedElements,
-  slotChangeGetAssignedNodes,
-  slotChangeGetTextContent,
-  slotChangeHasAssignedElement,
-  slotChangeHasAssignedNode,
-  slotChangeHasContent,
-  slotChangeHasTextContent,
-  unsafeGetCalciteModeName,
-  unsafeGetElementDirection
+  getElementAttribute as a,
+  getClosestElement as b,
+  classes as c,
+  getSlotAssignedElements as d,
+  resolveReferenceElement as e,
+  focusElement as f,
+  getElementWindow as g,
+  slotChangeGetAssignedElements as h,
+  slotChangeGetAssignedNodes as i,
+  slotChangeGetTextContent as j,
+  slotChangeHasAssignedElement as k,
+  slotChangeHasAssignedNode as l,
+  slotChangeHasContent as m,
+  slotChangeHasTextContent as n,
+  observeAncestorsMutation as o,
+  unsafeGetElementDirection as p,
+  resolveReferenceElement$1 as r,
+  setFocusOnElement as s,
+  unsafeGetCalciteModeName as u
 };

package/dist/dom/color.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Get the resolved color from a CSS custom property on an element.
+ *
+ * Resolves `light-dark()` values using the element's inherited color scheme,
+ * including styles in its shadow root. Returns `undefined` if the property is
+ * missing. The returned value is a CSS color string, not a parsed color.
+ *
+ * @public
+ * @param element The element on which to read the custom property.
+ * @param propertyName The CSS custom property containing a color.
+ * @returns The resolved CSS color, or `undefined` if the property is missing.
+ *
+ * @example
+ * ```ts
+ * const textColor = getCssColor(element, "--app-text-color");
+ * const fallbackColor = getCssColor(element, "--optional-color") ?? "black";
+ * ```
+ *
+ * @example
+ * ```css
+ * .panel {
+ *   color-scheme: dark;
+ *   --panel-color: light-dark(#ffffff, #202020);
+ * }
+ * ```
+ * ```ts
+ * // Resolves to the dark color in the context of the panel.
+ * const panelColor = getCssColor(panel, "--panel-color");
+ * ```
+ */
+export declare function getCssColor(element: Element, propertyName: string): string | undefined;
+/**
+ * Get the effective light or dark color scheme for an element.
+ *
+ * A computed `color-scheme` containing only `light` or only `dark` takes
+ * precedence. If both or neither are allowed, the system color preference
+ * determines the result. This is a snapshot; call again after styles or the
+ * system preference change.
+ *
+ * @public
+ * @param element The element whose computed color scheme is used.
+ * @returns The effective color scheme.
+ *
+ * @example
+ * ```ts
+ * // An element with `color-scheme: dark` returns "dark".
+ * const scheme = getEffectiveColorScheme(element);
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With `color-scheme: light dark`, the preferred system scheme is returned.
+ * const preferredScheme = getEffectiveColorScheme(element);
+ * ```
+ */
+export declare function getEffectiveColorScheme(element: Element): "dark" | "light";

package/dist/dom/color.js

@@ -0,0 +1,37 @@
+import { g as getElementWindow } from "../chunks/dom.js";
+function getCssColor(element, propertyName) {
+  const elWindow = getElementWindow(element);
+  const cssColor = elWindow.getComputedStyle(element).getPropertyValue(propertyName).trim();
+  if (!cssColor) {
+    return void 0;
+  }
+  if (!/light-dark\(/iu.test(cssColor)) {
+    return cssColor;
+  }
+  const sampleElement = element.ownerDocument.createElement("test");
+  Object.assign(sampleElement.style, {
+    color: cssColor,
+    display: "none"
+  });
+  if (!sampleElement.style.color) {
+    return cssColor;
+  }
+  (element.shadowRoot ?? element).append(sampleElement);
+  const color = elWindow.getComputedStyle(sampleElement).color || cssColor;
+  sampleElement.remove();
+  return color;
+}
+function getEffectiveColorScheme(element) {
+  const elWindow = getElementWindow(element);
+  const colorSchemes = elWindow.getComputedStyle(element).colorScheme.split(/\s+/u);
+  const hasDark = colorSchemes.includes("dark");
+  const hasLight = colorSchemes.includes("light");
+  if (hasDark !== hasLight) {
+    return hasDark ? "dark" : "light";
+  }
+  return elWindow.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+}
+export {
+  getCssColor,
+  getEffectiveColorScheme
+};

package/dist/dom/referenceElement.d.ts

@@ -0,0 +1,17 @@
+/** @public */
+interface ArcgisComponentBase<T> {
+    /** @public */
+    el: HTMLElement;
+    /** @public */
+    referenceElement?: T | string | null | undefined;
+}
+/**
+ * Resolves a reference element (arcgis-map, arcgis-scene, arcgis-link-chart)
+ * from a component's `referenceElement` property or attribute.
+ *
+ * @public
+ * @param component
+ * @param referenceElementString
+ */
+export declare function resolveReferenceElement<T extends Element>(component: ArcgisComponentBase<T>, referenceElementString?: ArcgisComponentBase<T>["referenceElement"] | string): T | undefined;
+export {};

package/dist/dom/referenceElement.js

@@ -0,0 +1,5 @@
+import { r } from "../chunks/dom.js";
+import "../log.js";
+export {
+  r as resolveReferenceElement
+};

package/dist/dom/slots.d.ts

@@ -1,6 +1,7 @@
 /**
  * Returns `true` if the target `slot` element from the `onSlotchange` event has any content (text or elements).
  *
+ * @public
  * @param event The event.
  * @returns Whether the slot has any content.
  *
@@ -13,6 +14,7 @@ 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.
  *
+ * @public
  * @param event The event.
  * @returns The slots text.
  *
@@ -25,6 +27,7 @@ export declare function slotChangeGetTextContent(event: Event): string;
 /**
  * Returns `true` if the target `slot` element from the `onSlotchange` event has any text content.
  *
+ * @public
  * @param event The event.
  * @returns Whether the slot has any text content.
  *
@@ -37,6 +40,7 @@ export declare function slotChangeHasTextContent(event: Event): boolean;
 /**
  * Returns `true` if the target `slot` element from the `onSlotchange` event has an assigned node.
  *
+ * @public
  * @param event The event.
  * @returns Whether the slot has any assigned nodes.
  *
@@ -49,6 +53,7 @@ export declare function slotChangeHasAssignedNode(event: Event): boolean;
 /**
  * Returns the assigned nodes on a `slot` element from the `onSlotchange` event.
  *
+ * @public
  * @param event The event.
  * @returns Whether the slot has any assigned nodes.
  *
@@ -61,6 +66,7 @@ export declare function slotChangeGetAssignedNodes(event: Event): Node[];
 /**
  * Returns `true` if the target `slot` element from the `onSlotchange` event has an assigned element.
  *
+ * @public
  * @param event The event.
  * @returns Whether the slot has any assigned elements.
  *
@@ -73,6 +79,7 @@ export declare function slotChangeHasAssignedElement(event: Event): boolean;
 /**
  * Returns the assigned elements on a `slot` element from the `onSlotchange` event.
  *
+ * @public
  * @param event The event.
  * @param selector The CSS selector string to filter the returned elements by.
  * @returns An array of elements.
@@ -86,6 +93,7 @@ export declare function slotChangeGetAssignedElements<T extends Element>(event:
 /**
  * Returns the assigned elements on a `slot` element, filtered by an optional css selector.
  *
+ * @public
  * @param slot The slot element.
  * @param selector CSS selector string to filter the returned elements by.
  * @returns An array of elements.

package/dist/dom/slots.js

@@ -0,0 +1,39 @@
+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;
+}
+export {
+  getSlotAssignedElements,
+  slotChangeGetAssignedElements,
+  slotChangeGetAssignedNodes,
+  slotChangeGetTextContent,
+  slotChangeHasAssignedElement,
+  slotChangeHasAssignedNode,
+  slotChangeHasContent,
+  slotChangeHasTextContent
+};

package/dist/dom.d.ts

@@ -0,0 +1,186 @@
+import type { nil } from "./type.ts";
+import { slotChangeHasContent as slotChangeHasContentAlias, slotChangeGetTextContent as slotChangeGetTextContentAlias, slotChangeHasTextContent as slotChangeHasTextContentAlias, slotChangeHasAssignedNode as slotChangeHasAssignedNodeAlias, slotChangeGetAssignedNodes as slotChangeGetAssignedNodesAlias, slotChangeHasAssignedElement as slotChangeHasAssignedElementAlias, slotChangeGetAssignedElements as slotChangeGetAssignedElementsAlias, getSlotAssignedElements as getSlotAssignedElementsAlias } from "./dom/slots.ts";
+/**
+ * @public
+ * @deprecated import { slotChangeHasContent } from "@arcgis/toolkit/dom/slots"; instead
+ * */
+export declare const slotChangeHasContent: typeof slotChangeHasContentAlias;
+/**
+ * @public
+ * @deprecated import { slotChangeGetTextContent } from "@arcgis/toolkit/dom/slots"; instead
+ */
+export declare const slotChangeGetTextContent: typeof slotChangeGetTextContentAlias;
+/**
+ * @public
+ * @deprecated import { slotChangeHasTextContent } from "@arcgis/toolkit/dom/slots"; instead
+ */
+export declare const slotChangeHasTextContent: typeof slotChangeHasTextContentAlias;
+/**
+ * @public
+ * @deprecated import { slotChangeHasAssignedNode } from "@arcgis/toolkit/dom/slots"; instead
+ */
+export declare const slotChangeHasAssignedNode: typeof slotChangeHasAssignedNodeAlias;
+/**
+ * @public
+ * @deprecated import { slotChangeGetAssignedNodes } from "@arcgis/toolkit/dom/slots"; instead
+ */
+export declare const slotChangeGetAssignedNodes: typeof slotChangeGetAssignedNodesAlias;
+/**
+ * @public
+ * @deprecated import { slotChangeHasAssignedElement } from "@arcgis/toolkit/dom/slots"; instead
+ */
+export declare const slotChangeHasAssignedElement: typeof slotChangeHasAssignedElementAlias;
+/**
+ * @public
+ * @deprecated import { slotChangeGetAssignedElements } from "@arcgis/toolkit/dom/slots"; instead
+ */
+export declare const slotChangeGetAssignedElements: typeof slotChangeGetAssignedElementsAlias;
+/**
+ * @public
+ * @deprecated import { getSlotAssignedElements } from "@arcgis/toolkit/dom/slots"; instead
+ */
+export declare const getSlotAssignedElements: typeof getSlotAssignedElementsAlias;
+import { resolveReferenceElement as resolveReferenceElementAlias } from "./dom/referenceElement.ts";
+/**
+ * @public
+ * @deprecated import { resolveReferenceElement } from "@arcgis/toolkit/dom/reference-element"; instead
+ */
+export declare const resolveReferenceElement: typeof resolveReferenceElementAlias;
+/**
+ * Combine multiple class names into a single string.
+ *
+ * > This function is less necessary in Lumina packages as the `class` JSX prop
+ * > accepts `Record<string, boolean>` objects.
+ *
+ * @public
+ * @param classes
+ */
+export declare const classes: (...classes: (nil | Record<string, boolean> | string[] | string | false)[]) => string;
+/**
+ * Observe the element and its ancestors for attribute mutations.
+ * If the attributes have been changed in the ancestor tree then the callback
+ * will be invoked.
+ *
+ * @public
+ * @param element The element on which to observe the attribute mutations.
+ * @param attributeFilter The list of attributes to observe.
+ * @param callback The callback to invoke when the attributes have been changed.
+ * @returns A callback to unsubscribe from the observer.
+ *
+ * @example
+ * ```ts
+ * observeAncestorsMutation(
+ *   element,
+ *   ["dir", "lang"],
+ *   () => console.log(getElementAttribute(element, "dir", "ltr"))
+ * );
+ * ```
+ */
+export declare const observeAncestorsMutation: (element: Node, attributeFilter: string[], callback: () => void) => (() => void);
+/**
+ * Find the closest element that matches the selector.
+ * It will traverse the element's ancestors to find the target element.
+ * Shadow DOM boundaries are also taken into account.
+ *
+ * > This is similar to [Element.closest()](https://developer.mozilla.org/docs/Web/API/Element/closest),
+ * > but the DOM's utility only looks up until the first shadow boundary.
+ *
+ * @public
+ * @param base The element to start the search from.
+ * @param selector The selector to match.
+ * @returns The closest element that matches the selector or null if not found.
+ *
+ * @example
+ * ```ts
+ * const hostElement = getClosestElement(element, "arcgis-map, arcgis-scene");
+ * ```
+ */
+export declare const getClosestElement: <T = Element>(base: Element, selector: string) => T | undefined;
+/**
+ * Use the closest Calcite mode class name to determine the
+ * theme of the element. It will traverse the element's
+ * ancestors to find the theme. Shadow DOM boundaries are also
+ * taken into account.
+ *
+ * > It is advised to consider alternative solutions before using this utility:
+ * > - Calcite CSS variables. Benefits: makes styles more consistent,
+ * >   and variables are updated automatically to match dark/light theme.
+ * > - Detect dark mode using CSS selectors and apply styles in CSS.
+ * >   Benefit: styles update automatically when the theme changes.
+ *
+ * @public
+ * @param el The element to start the search from.
+ * @returns The theme of the element ("light" or "dark"). "light" is the default.
+ *
+ */
+export declare function unsafeGetCalciteModeName(el: HTMLElement): "dark" | "light";
+/**
+ * Get direction property of the closest element.
+ *
+ * > Do not set the `dir` property on the element itself. Do not set the `dir`
+ * > attribute on the components you are rendering. The `dir` attribute is only
+ * > meant to be set by the consumers of your component. Your component is
+ * > expected to respect what was set by the consumer.
+ *
+ * > Prefer [useDirection()](https://webgis.esri.com/references/lumina/controllers/useDirection)
+ * > to ensure your component is responsive to direction changes.
+ *
+ * @public
+ * @param el The element to start the search from.
+ * @returns The direction of the element ("ltr" | "rtl"). "ltr" is the default.
+ */
+export declare const unsafeGetElementDirection: (el: HTMLElement) => "ltr" | "rtl";
+/**
+ * Get the attribute value from the element or closest ancestor.
+ * Shadow DOM boundaries are also taken into account.
+ * If the attribute is not found then the fallback value is returned.
+ *
+ * @public
+ * @param el
+ * @param attributeName
+ * @param fallbackValue
+ * @example
+ * ```ts
+ * const dir = getElementAttribute(element, "dir", "ltr");
+ * ```
+ */
+export declare const getElementAttribute: (el: Element, attributeName: string, fallbackValue: string) => string;
+/**
+ * Focus the element if it is focusable.
+ *
+ * @public
+ * @param el
+ * @returns A promise that resolves once the focus is set.
+ */
+export declare const focusElement: (el: FocusableElement | undefined) => Promise<void>;
+/** @public */
+export interface FocusableElement extends HTMLElement {
+    /** @public */
+    setFocus?: () => Promise<void>;
+}
+/**
+ * Set the focus on the element that matches the selector.
+ * It will traverse the element's ancestors to find the target element.
+ * Shadow DOM boundaries are also taken into account.
+ * If the element is not found then the focus is not set.
+ * Example: `setFocusOnElement(element, "[role='menuitem']");`
+ *
+ * @public
+ * @param ref The element to start the search from.
+ * @param selector The selector to match.
+ * @returns Returns true if the focus is set on the element.
+ *
+ * @deprecated This function is doing too much. Import from `focusElement(getClosestElement())` from `@arcgis/toolkit/dom` instead.
+ */
+export declare const setFocusOnElement: (ref: (Element & {
+    componentOnReady?: () => Promise<void>;
+}) | null | undefined, selector: string) => void;
+/**
+ * Get the window associated with an element's document.
+ * Falls back to the current global window if the document has no associated window.
+ *
+ * @public
+ * @param element The element whose document determines the window.
+ * @returns The element's document window, or the current global window as a fallback.
+ */
+export declare function getElementWindow(element: Element): Window;

package/dist/dom.js

@@ -0,0 +1,22 @@
+import "./dom/slots.js";
+import { c, f, b, a, g, d, o, e, s, h, i, j, k, l, m, n, u, p } from "./chunks/dom.js";
+export {
+  c as classes,
+  f as focusElement,
+  b as getClosestElement,
+  a as getElementAttribute,
+  g as getElementWindow,
+  d as getSlotAssignedElements,
+  o as observeAncestorsMutation,
+  e as resolveReferenceElement,
+  s as setFocusOnElement,
+  h as slotChangeGetAssignedElements,
+  i as slotChangeGetAssignedNodes,
+  j as slotChangeGetTextContent,
+  k as slotChangeHasAssignedElement,
+  l as slotChangeHasAssignedNode,
+  m as slotChangeHasContent,
+  n as slotChangeHasTextContent,
+  u as unsafeGetCalciteModeName,
+  p as unsafeGetElementDirection
+};

package/dist/{error/index.d.ts → error.d.ts}

@@ -10,23 +10,34 @@
  * - `process.env.NODE_ENV === "development"`
  * - `process.env.NODE_ENV === "test"`
  *
+ * > This function is primary for usage in support packages. In Lumina component
+ * > packages, simpler alternatives are provided:
+ * > https://webgis.esri.com/references/lumina/publishing#bundling-code-conditionally
+ *
  * [Documentation](https://webgis.esri.com/references/lumina/publishing#internal-esri-environment)
  *
- * @remarks
- * This function is primary for usage in support packages. In Lumina component
- * packages, simpler alternatives are provided:
- * https://webgis.esri.com/references/lumina/publishing#bundling-code-conditionally
+ * @public
  */
 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
+ *
+ * @public
+ * @param callback
+ * @param thisContext
+ * @param rest
  */
 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
+ *
+ * @public
+ * @param callback
+ * @param thisContext
+ * @param rest
  */
 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 → error.js}

@@ -8,7 +8,7 @@ const isEsriInternalEnv = () => (
    * 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
+   * See https://devtopia.esri.com/WebGIS/webgis-sdk/pull/2087#issuecomment-5152454
    */
   typeof globalThis.process === "object" && !!process.env.ESRI_INTERNAL
 );

package/dist/{function/index.d.ts → function.d.ts}

@@ -4,14 +4,17 @@
  * Useful when providing a "mapping function" is required, but you have no need
  * to change the value
  *
+ * @public
+ * @param value
  * @privateRemarks
  * This is a trivial function, but it helps workaround a TypeScript bug:
- * https://devtopia.esri.com/WebGIS/arcgis-web-components/issues/2047
+ * https://devtopia.esri.com/WebGIS/webgis-sdk/issues/2047
  */
 export declare const identity: <T>(value: T) => T;
 /**
  * Allows to debounce a function.
  *
+ * @public
  * @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