@arcgis/toolkit 5.2.0-next.9 → 5.2.0-next.91

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.cts → 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/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 "../dom-Bnc7oSYx.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/index.js → dom-Bnc7oSYx.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) {
@@ -207,21 +188,22 @@ const setFocus = (ref, selector = "") => {
   return false;
 };
 export {
-  classes,
-  focusElement,
-  getClosestElement,
-  getElementAttribute,
-  getSlotAssignedElements,
-  observeAncestorsMutation,
-  resolveReferenceElement,
-  setFocusOnElement,
-  slotChangeGetAssignedElements,
-  slotChangeGetAssignedNodes,
-  slotChangeGetTextContent,
-  slotChangeHasAssignedElement,
-  slotChangeHasAssignedNode,
-  slotChangeHasContent,
-  slotChangeHasTextContent,
-  unsafeGetCalciteModeName,
-  unsafeGetElementDirection
+  getClosestElement as a,
+  getSlotAssignedElements as b,
+  classes as c,
+  resolveReferenceElement as d,
+  slotChangeGetAssignedElements as e,
+  focusElement as f,
+  getElementAttribute as g,
+  slotChangeGetAssignedNodes as h,
+  slotChangeGetTextContent as i,
+  slotChangeHasAssignedElement as j,
+  slotChangeHasAssignedNode as k,
+  slotChangeHasContent as l,
+  slotChangeHasTextContent as m,
+  unsafeGetElementDirection as n,
+  observeAncestorsMutation as o,
+  resolveReferenceElement$1 as r,
+  setFocusOnElement as s,
+  unsafeGetCalciteModeName as u
 };

package/dist/dom.d.ts

@@ -0,0 +1,177 @@
+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;

package/dist/dom.js

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

package/dist/{error/index.d.cts → 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.cts → 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

package/dist/intl/dom.d.ts

@@ -0,0 +1,74 @@
+import { type GenericT9nStrings, type SupportedLocale } from "../intl.ts";
+/**
+ * Get the locale of the given element.
+ * It will look for the lang attribute on the element and its ancestors.
+ * If not lang is found, it will default to 'en'.
+ *
+ * @public
+ * @param element
+ * @returns an object with the `lang` and `t9nLocale` properties.
+ *
+ * @see [lang vs t9nLocale](https://webgis.esri.com/references/lumina/controllers/useT9n#difference-between-lang-and-t9nlocale).
+ */
+export declare const getElementLocale: (element: HTMLElement) => {
+    readonly lang: string;
+    readonly t9nLocale: SupportedLocale;
+};
+/**
+ * Start the locale observer for the given component.
+ * The callback will be called when the locale changes for the component.
+ * It will observe the lang attribute on the component and its ancestors.
+ * The callback is called once at the beginning.
+ *
+ * > Rather than using this function directly, prefer the
+ * > [useT9n()](https://webgis.esri.com/references/lumina/controllers/useT9n)
+ * > controller.
+ *
+ * @public
+ * @param element The HTML element that is doing the fetching
+ *   This is used to determine the locale to fetch, observe the `lang` attribute
+ *   changes, and is used as the default value for the `assetName` parameter.
+ * @param getAssetsPath The callback to get path to the assets folder where the
+ *   T9N strings are located.
+ * @param onUpdated The callback to call when the locale changes.
+ * @param assetName Optionally override the asset file name.
+ *   Default file name is the element tag name without the part before the
+ *   first dash (e.g. `arcgis-map` becomes `map`).
+ *
+ *   Set to null if the component has no localization strings, but you still
+ *   wish to use `startLocaleObserver` to get the locale information.
+ *
+ * @example
+ * ```ts
+ * const observer = startLocaleObserver(
+ *   element,
+ *   () => getAssetPath("./assets"),
+ *   ({ strings, lang, t9nLocale }) => console.log({ strings, lang, t9nLocale }),
+ * );
+ * // Later: cleanup
+ * observer();
+ * ```
+ */
+export declare const startLocaleObserver: <Strings extends GenericT9nStrings = GenericT9nStrings>(element: HTMLElement, getAssetsPath: () => string, onUpdated: (payload: LocaleObserverResult<Strings>) => void, assetName?: string | null) => (() => void);
+/** @public */
+export interface LocaleObserverResult<Strings extends GenericT9nStrings = GenericT9nStrings> {
+    /**
+     * The T9N strings of the component
+     *
+     * @public
+     */
+    t9nStrings: Strings;
+    /**
+     * The locale of the component set by the `lang` attribute on the component host element or one of its ancestors.
+     *
+     * @public
+     */
+    lang: string;
+    /**
+     * The locale used by the component to load the T9N strings.
+     * It may be different than the locale of the component host element that was set by the `lang` attribute.
+     *
+     * @public
+     */
+    t9nLocale: SupportedLocale;
+}