@arcgis/toolkit 4.34.0-next.61

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
+};

package/dist/intl/index.cjs

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const dom_index = require("../dom/index.cjs");
+const supportedLocalesArray = "ar,bg,bs,ca,cs,da,de,el,en,es,et,fi,fr,he,hr,hu,id,it,ja,ko,lt,lv,nl,nb,no,pl,pt-BR,pt-PT,ro,ru,sk,sl,sr,sv,th,tr,uk,vi,zh-CN,zh-HK,zh-TW".split(
+  ","
+);
+const supportedLocales = (
+  //#endregion supportedLocales
+  /* @__PURE__ */ new Set(supportedLocalesArray)
+);
+const defaultLocale = "en";
+const localeEquivalencies = {
+  //#region localeEquivalencies
+  // We use `pt-PT` as it will have the same translations as `pt`, which has no corresponding bundle
+  pt: "pt-PT",
+  // We support both 'nb' and 'no' (BCP 47) for Norwegian but only `no` has corresponding bundle
+  nb: "no",
+  // We support both 'nn' and 'no' (BCP 47) for Norwegian but only `no` has corresponding bundle
+  // See https://devtopia.esri.com/WebGIS/arcgis-web-components/issues/4667
+  nn: "no",
+  // We use `zh-CN` as base translation for chinese locales which has no corresponding bundle.
+  zh: "zh-CN"
+  //#endregion localeEquivalencies
+};
+const fetchT9nStringsBundle = async (locale, assetsPath, prefix = "") => {
+  const path = `${assetsPath}/${prefix}`;
+  const filePath = `${path}${locale}.json`;
+  t9nStringsCache[filePath] ?? (t9nStringsCache[filePath] = fetchBundle(locale, path));
+  return await t9nStringsCache[filePath];
+};
+const t9nStringsCache = {};
+const fetchBundle = async (locale, path) => {
+  const filePath = `${path}${locale}.json`;
+  try {
+    const response = await fetch(filePath);
+    if (response.ok) {
+      return await response.json();
+    }
+  } catch (error) {
+    if (process.env.NODE_ENV !== "production") {
+      const is404ViteFallback = String(error).includes(`Unexpected token '<', "<!doctype "... is not valid JSON`);
+      if (is404ViteFallback) {
+        console.error(`[404] Localization strings not found at ${filePath}`);
+      } else {
+        console.error(`Error fetching localization strings at ${filePath}`, error);
+      }
+    } else {
+      console.error(error);
+    }
+    return {};
+  }
+  if (locale === defaultLocale) {
+    return {};
+  }
+  return await fetchBundle(defaultLocale, path);
+};
+const getElementLocale = (element) => {
+  const lang = dom_index.getElementAttribute(element, "lang", globalThis.navigator?.language || defaultLocale);
+  return { lang, t9nLocale: normalizeLocale(lang) };
+};
+const normalizeLocale = (lang) => {
+  const [rawLanguageCode, regionCode] = lang.split("-");
+  const languageCode = rawLanguageCode.toLowerCase();
+  let normalizedLocale = languageCode;
+  if (regionCode) {
+    normalizedLocale = `${languageCode}-${regionCode.toUpperCase()}`;
+  }
+  normalizedLocale = localeEquivalencies[normalizedLocale] ?? normalizedLocale;
+  if (supportedLocales.has(normalizedLocale)) {
+    return normalizedLocale;
+  }
+  if (regionCode) {
+    return normalizeLocale(languageCode);
+  }
+  return defaultLocale;
+};
+const startLocaleObserver = (element, getAssetsPath, onUpdated, assetName) => {
+  let result = void 0;
+  const callback = () => updateComponentLocaleState(element, getAssetsPath(), assetName).then((newResult) => {
+    if (result?.lang !== newResult.lang || result.t9nLocale !== newResult.t9nLocale || result.t9nStrings !== newResult.t9nStrings) {
+      onUpdated(newResult);
+    }
+    result = newResult;
+  }).catch(console.error);
+  queueMicrotask(callback);
+  return dom_index.observeAncestorsMutation(element, ["lang"], callback);
+};
+const updateComponentLocaleState = async (element, assetsPath, assetName = element.localName.split("-").slice(1).join("-")) => {
+  const { lang, t9nLocale } = getElementLocale(element);
+  const t9nAssetsPath = `${assetsPath}/${assetName}/t9n`;
+  const prefix = `messages.`;
+  const t9nStrings = (
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    assetName === null ? {} : await fetchT9nStringsBundle(t9nLocale, t9nAssetsPath, prefix)
+  );
+  return { lang, t9nLocale, t9nStrings };
+};
+exports.defaultLocale = defaultLocale;
+exports.fetchT9nStringsBundle = fetchT9nStringsBundle;
+exports.getElementLocale = getElementLocale;
+exports.normalizeLocale = normalizeLocale;
+exports.startLocaleObserver = startLocaleObserver;
+exports.supportedLocales = supportedLocales;

package/dist/intl/index.d.cts

@@ -0,0 +1,121 @@
+declare const supportedLocalesArray: ["ar", "bg", "bs", "ca", "cs", "da", "de", "el", "en", "es", "et", "fi", "fr", "he", "hr", "hu", "id", "it", "ja", "ko", "lt", "lv", "nl", "nb", "no", "pl", "pt-BR", "pt-PT", "ro", "ru", "sk", "sl", "sr", "sv", "th", "tr", "uk", "vi", "zh-CN", "zh-HK", "zh-TW"];
+/**
+ * The list of supported locales for ArcGIS Maps SDK for JavaScript components.
+ */
+export declare const supportedLocales: Set<"hr" | "th" | "tr" | "ar" | "bg" | "bs" | "ca" | "cs" | "da" | "de" | "el" | "en" | "es" | "et" | "fi" | "fr" | "he" | "hu" | "id" | "it" | "ja" | "ko" | "lt" | "lv" | "nl" | "nb" | "no" | "pl" | "pt-BR" | "pt-PT" | "ro" | "ru" | "sk" | "sl" | "sr" | "sv" | "uk" | "vi" | "zh-CN" | "zh-HK" | "zh-TW">;
+/**
+ * TypeScript union type for each locale supported by WebGIS SDK
+ */
+export type SupportedLocale = (typeof supportedLocalesArray)[number];
+/**
+ * The default locale for WebGIS SDK.
+ */
+export declare const defaultLocale = "en";
+/**
+ * Fetch the T9N strings bundle for the given locale, assets path and prefix.
+ * The locale must be one of the supported locales.
+ * If the locale is not supported, it will default to 'en'.
+ * If the T9N strings bundle cannot be found, it will default to 'en'.
+ *
+ * @param locale The locale for which to fetch the T9N strings
+ * @param assetsPath The path to the assets folder where the T9N strings are located
+ * @param prefix The prefix to use for the T9N strings file name.
+ *
+ * @remarks
+ * Rather than using this function directly, prefer the
+ * [useT9n()](https://qawebgis.esri.com/components/lumina/controllers/useT9n)
+ * controller.
+ *
+ * @remarks
+ * The function implements cache. Frequent calls are safe.
+ *
+ * @example
+ * ```ts
+ * // Will make a request for ./assets/coding-editor/t9n/messages.en.json
+ * const t9nStrings = await fetchT9nStringsBundle(
+ *   "en",
+ *   getAssetPath("./assets/coding-editor/t9n"),
+ *   "messages."
+ * );
+ * ```
+ *
+ * @see [Lumina asset handling](https://qawebgis.esri.com/components/lumina/assets)
+ */
+export declare const fetchT9nStringsBundle: <Strings extends GenericT9nStrings>(locale: string, assetsPath: string, prefix?: string) => Promise<Strings>;
+/**
+ * The interface for translated strings.
+ */
+export interface GenericT9nStrings {
+    [key: string]: GenericT9nStrings | string;
+}
+/**
+ * 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'.
+ *
+ * @returns an object with the `lang` and `t9nLocale` properties.
+ *
+ * @see [lang vs t9nLocale](https://qawebgis.esri.com/components/lumina/controllers/useT9n#difference-between-lang-and-t9nlocale).
+ */
+export declare const getElementLocale: (element: HTMLElement) => {
+    readonly lang: string;
+    readonly t9nLocale: SupportedLocale;
+};
+/**
+ * Try to parse any language string into one of the locales supported by WebGIS SDK.
+ *
+ * @remarks
+ * If language includes a region code, but we don't have a bundle for it, the
+ * language is normalized to the language code only.
+ */
+export declare const normalizeLocale: (lang: string) => SupportedLocale;
+export interface LocaleObserverResult<Strings extends GenericT9nStrings = GenericT9nStrings> {
+    /** The T9N strings of the component */
+    t9nStrings: Strings;
+    /**
+     * The locale of the component set by the `lang` attribute on the component host element or one of its ancestors.
+     */
+    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.
+     */
+    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.
+ *
+ * @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.
+ *
+ * @remarks
+ * Rather than using this function directly, prefer the
+ * [useT9n()](https://qawebgis.esri.com/components/lumina/controllers/useT9n)
+ * controller.
+ *
+ * @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);
+export {};

package/dist/intl/index.d.ts

@@ -0,0 +1,121 @@
+declare const supportedLocalesArray: ["ar", "bg", "bs", "ca", "cs", "da", "de", "el", "en", "es", "et", "fi", "fr", "he", "hr", "hu", "id", "it", "ja", "ko", "lt", "lv", "nl", "nb", "no", "pl", "pt-BR", "pt-PT", "ro", "ru", "sk", "sl", "sr", "sv", "th", "tr", "uk", "vi", "zh-CN", "zh-HK", "zh-TW"];
+/**
+ * The list of supported locales for ArcGIS Maps SDK for JavaScript components.
+ */
+export declare const supportedLocales: Set<"hr" | "th" | "tr" | "ar" | "bg" | "bs" | "ca" | "cs" | "da" | "de" | "el" | "en" | "es" | "et" | "fi" | "fr" | "he" | "hu" | "id" | "it" | "ja" | "ko" | "lt" | "lv" | "nl" | "nb" | "no" | "pl" | "pt-BR" | "pt-PT" | "ro" | "ru" | "sk" | "sl" | "sr" | "sv" | "uk" | "vi" | "zh-CN" | "zh-HK" | "zh-TW">;
+/**
+ * TypeScript union type for each locale supported by WebGIS SDK
+ */
+export type SupportedLocale = (typeof supportedLocalesArray)[number];
+/**
+ * The default locale for WebGIS SDK.
+ */
+export declare const defaultLocale = "en";
+/**
+ * Fetch the T9N strings bundle for the given locale, assets path and prefix.
+ * The locale must be one of the supported locales.
+ * If the locale is not supported, it will default to 'en'.
+ * If the T9N strings bundle cannot be found, it will default to 'en'.
+ *
+ * @param locale The locale for which to fetch the T9N strings
+ * @param assetsPath The path to the assets folder where the T9N strings are located
+ * @param prefix The prefix to use for the T9N strings file name.
+ *
+ * @remarks
+ * Rather than using this function directly, prefer the
+ * [useT9n()](https://qawebgis.esri.com/components/lumina/controllers/useT9n)
+ * controller.
+ *
+ * @remarks
+ * The function implements cache. Frequent calls are safe.
+ *
+ * @example
+ * ```ts
+ * // Will make a request for ./assets/coding-editor/t9n/messages.en.json
+ * const t9nStrings = await fetchT9nStringsBundle(
+ *   "en",
+ *   getAssetPath("./assets/coding-editor/t9n"),
+ *   "messages."
+ * );
+ * ```
+ *
+ * @see [Lumina asset handling](https://qawebgis.esri.com/components/lumina/assets)
+ */
+export declare const fetchT9nStringsBundle: <Strings extends GenericT9nStrings>(locale: string, assetsPath: string, prefix?: string) => Promise<Strings>;
+/**
+ * The interface for translated strings.
+ */
+export interface GenericT9nStrings {
+    [key: string]: GenericT9nStrings | string;
+}
+/**
+ * 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'.
+ *
+ * @returns an object with the `lang` and `t9nLocale` properties.
+ *
+ * @see [lang vs t9nLocale](https://qawebgis.esri.com/components/lumina/controllers/useT9n#difference-between-lang-and-t9nlocale).
+ */
+export declare const getElementLocale: (element: HTMLElement) => {
+    readonly lang: string;
+    readonly t9nLocale: SupportedLocale;
+};
+/**
+ * Try to parse any language string into one of the locales supported by WebGIS SDK.
+ *
+ * @remarks
+ * If language includes a region code, but we don't have a bundle for it, the
+ * language is normalized to the language code only.
+ */
+export declare const normalizeLocale: (lang: string) => SupportedLocale;
+export interface LocaleObserverResult<Strings extends GenericT9nStrings = GenericT9nStrings> {
+    /** The T9N strings of the component */
+    t9nStrings: Strings;
+    /**
+     * The locale of the component set by the `lang` attribute on the component host element or one of its ancestors.
+     */
+    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.
+     */
+    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.
+ *
+ * @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.
+ *
+ * @remarks
+ * Rather than using this function directly, prefer the
+ * [useT9n()](https://qawebgis.esri.com/components/lumina/controllers/useT9n)
+ * controller.
+ *
+ * @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);
+export {};

package/dist/intl/index.js

@@ -0,0 +1,103 @@
+import { getElementAttribute, observeAncestorsMutation } from "../dom/index.js";
+const supportedLocalesArray = "ar,bg,bs,ca,cs,da,de,el,en,es,et,fi,fr,he,hr,hu,id,it,ja,ko,lt,lv,nl,nb,no,pl,pt-BR,pt-PT,ro,ru,sk,sl,sr,sv,th,tr,uk,vi,zh-CN,zh-HK,zh-TW".split(
+  ","
+);
+const supportedLocales = (
+  //#endregion supportedLocales
+  /* @__PURE__ */ new Set(supportedLocalesArray)
+);
+const defaultLocale = "en";
+const localeEquivalencies = {
+  //#region localeEquivalencies
+  // We use `pt-PT` as it will have the same translations as `pt`, which has no corresponding bundle
+  pt: "pt-PT",
+  // We support both 'nb' and 'no' (BCP 47) for Norwegian but only `no` has corresponding bundle
+  nb: "no",
+  // We support both 'nn' and 'no' (BCP 47) for Norwegian but only `no` has corresponding bundle
+  // See https://devtopia.esri.com/WebGIS/arcgis-web-components/issues/4667
+  nn: "no",
+  // We use `zh-CN` as base translation for chinese locales which has no corresponding bundle.
+  zh: "zh-CN"
+  //#endregion localeEquivalencies
+};
+const fetchT9nStringsBundle = async (locale, assetsPath, prefix = "") => {
+  const path = `${assetsPath}/${prefix}`;
+  const filePath = `${path}${locale}.json`;
+  t9nStringsCache[filePath] ?? (t9nStringsCache[filePath] = fetchBundle(locale, path));
+  return await t9nStringsCache[filePath];
+};
+const t9nStringsCache = {};
+const fetchBundle = async (locale, path) => {
+  const filePath = `${path}${locale}.json`;
+  try {
+    const response = await fetch(filePath);
+    if (response.ok) {
+      return await response.json();
+    }
+  } catch (error) {
+    if (process.env.NODE_ENV !== "production") {
+      const is404ViteFallback = String(error).includes(`Unexpected token '<', "<!doctype "... is not valid JSON`);
+      if (is404ViteFallback) {
+        console.error(`[404] Localization strings not found at ${filePath}`);
+      } else {
+        console.error(`Error fetching localization strings at ${filePath}`, error);
+      }
+    } else {
+      console.error(error);
+    }
+    return {};
+  }
+  if (locale === defaultLocale) {
+    return {};
+  }
+  return await fetchBundle(defaultLocale, path);
+};
+const getElementLocale = (element) => {
+  const lang = getElementAttribute(element, "lang", globalThis.navigator?.language || defaultLocale);
+  return { lang, t9nLocale: normalizeLocale(lang) };
+};
+const normalizeLocale = (lang) => {
+  const [rawLanguageCode, regionCode] = lang.split("-");
+  const languageCode = rawLanguageCode.toLowerCase();
+  let normalizedLocale = languageCode;
+  if (regionCode) {
+    normalizedLocale = `${languageCode}-${regionCode.toUpperCase()}`;
+  }
+  normalizedLocale = localeEquivalencies[normalizedLocale] ?? normalizedLocale;
+  if (supportedLocales.has(normalizedLocale)) {
+    return normalizedLocale;
+  }
+  if (regionCode) {
+    return normalizeLocale(languageCode);
+  }
+  return defaultLocale;
+};
+const startLocaleObserver = (element, getAssetsPath, onUpdated, assetName) => {
+  let result = void 0;
+  const callback = () => updateComponentLocaleState(element, getAssetsPath(), assetName).then((newResult) => {
+    if (result?.lang !== newResult.lang || result.t9nLocale !== newResult.t9nLocale || result.t9nStrings !== newResult.t9nStrings) {
+      onUpdated(newResult);
+    }
+    result = newResult;
+  }).catch(console.error);
+  queueMicrotask(callback);
+  return observeAncestorsMutation(element, ["lang"], callback);
+};
+const updateComponentLocaleState = async (element, assetsPath, assetName = element.localName.split("-").slice(1).join("-")) => {
+  const { lang, t9nLocale } = getElementLocale(element);
+  const t9nAssetsPath = `${assetsPath}/${assetName}/t9n`;
+  const prefix = `messages.`;
+  const t9nStrings = (
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    assetName === null ? {} : await fetchT9nStringsBundle(t9nLocale, t9nAssetsPath, prefix)
+  );
+  return { lang, t9nLocale, t9nStrings };
+};
+export {
+  defaultLocale,
+  fetchT9nStringsBundle,
+  getElementLocale,
+  normalizeLocale,
+  startLocaleObserver,
+  supportedLocales
+};

package/dist/predicate/index.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isNotUndefined = (item) => item !== void 0;
+const isNotNull = (item) => item !== null;
+const isNotNil = (x) => x != null;
+exports.isNotNil = isNotNil;
+exports.isNotNull = isNotNull;
+exports.isNotUndefined = isNotUndefined;

package/dist/predicate/index.d.cts

@@ -0,0 +1,24 @@
+import { nil } from '../type';
+/**
+ * Safeguard to ensure that an item is not undefined.
+ * @param item The item to check.
+ * @returns Returns true if the item is not undefined.
+ * @example
+ * ```ts
+ * const arr = [1, undefined, 3];
+ * const result = arr.filter(isNotUndefined);
+ * ```
+ */
+export declare const isNotUndefined: <T>(item: T | undefined) => item is T;
+/**
+ * Safeguard to ensure that an item is not null.
+ * @param item The item to check.
+ * @returns Returns true if the item is not null.
+ */
+export declare const isNotNull: <T>(item: T | null) => item is T;
+/**
+ * Safeguard to ensure that an item is not null.
+ * @param item The item to check.
+ * @returns Returns true if the item is not and not undefined and not null.
+ */
+export declare const isNotNil: <T>(x: nil | T) => x is T;