@arcgis/components-utils 4.33.0-next.99 → 4.34.0-next.1

package/dist/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-function mappedFind(array, callback) {
+const mappedFind = (array, callback) => {
   for (let i = 0; i < array.length; i++) {
     const value = callback(array[i], i);
     if (value != null) {
@@ -8,8 +8,8 @@ function mappedFind(array, callback) {
     }
   }
   return;
-}
-function classes(...classes2) {
+};
+const classes = (...classes2) => {
   const effectiveClasses = [];
   for (let i = 0; i < classes2.length; i++) {
     const arg = classes2[i];
@@ -28,19 +28,8 @@ function classes(...classes2) {
   const className = effectiveClasses.join(" ");
   effectiveClasses.length = 0;
   return className;
-}
+};
 class Deferred {
-  /**
-   * Resolves the promise.
-   * @param value The value to resolve the promise with.
-   */
-  resolve(_value) {
-  }
-  /**
-   * Rejects the promise.
-   */
-  reject(_error) {
-  }
   /**
    * Creates a new deferred promise.
    */
@@ -51,7 +40,7 @@ class Deferred {
     });
   }
 }
-function inTargetElement(element, targetElement) {
+const inTargetElement = (element, targetElement) => {
   let currentElement = element;
   while (currentElement) {
     if (currentElement === targetElement) {
@@ -67,18 +56,18 @@ function inTargetElement(element, targetElement) {
     }
   }
   return false;
-}
-function observeAncestorsMutation(element, attributeFilter, callback) {
-  const { subscribe } = observe(attributeFilter);
+};
+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 = {};
-function observe(attributeFilter) {
+const observe = (attributeFilter) => {
   const attributes = attributeFilter.join(",");
   const previousObserver = observers[attributes];
   if (previousObserver !== void 0) {
@@ -94,7 +83,7 @@ function observe(attributeFilter) {
     });
   }
   const observer = {
-    subscribe(callback) {
+    subscribe: (callback) => {
       subscribers.add(callback);
       return () => {
         subscribers.delete(callback);
@@ -107,8 +96,8 @@ function observe(attributeFilter) {
   };
   observers[attributes] = observer;
   return observer;
-}
-function closestElement(base, selector) {
+};
+const closestElement = (base, selector) => {
   let currentElement = base;
   while (currentElement) {
     const element = currentElement.closest?.(selector);
@@ -122,25 +111,19 @@ function closestElement(base, selector) {
     currentElement = rootElement.host;
   }
   return null;
-}
-function getElementTheme(base) {
+};
+const getElementTheme = (base) => {
   const themeElement = closestElement(base, ":is(.calcite-mode-light, .calcite-mode-dark)");
   return themeElement?.classList.contains("calcite-mode-dark") ? "dark" : "light";
-}
-function getElementDir(el) {
-  return getElementAttribute(el, "dir", "ltr");
-}
-function getElementAttribute(el, prop, fallbackValue) {
+};
+const getElementDir = (el) => getElementAttribute(el, "dir", "ltr");
+const getElementAttribute = (el, prop, fallbackValue) => {
   const closest = closestElement(el, `[${prop}]`);
   return closest?.getAttribute(prop) ?? fallbackValue;
-}
-function isElement(ref) {
-  return ref.nodeType === Node.ELEMENT_NODE;
-}
-function hasSetFocus(ref) {
-  return typeof ref.setFocus === "function";
-}
-function setFocus(ref, selector = "") {
+};
+const isElement = (ref) => ref.nodeType === Node.ELEMENT_NODE;
+const hasSetFocus = (ref) => typeof ref.setFocus === "function";
+const setFocus = (ref, selector = "") => {
   if (!isElement(ref)) {
     return false;
   }
@@ -164,8 +147,8 @@ function setFocus(ref, selector = "") {
     }
   }
   return false;
-}
-async function focusElement(el) {
+};
+const focusElement = async (el) => {
   if (el == null) {
     return;
   }
@@ -174,8 +157,8 @@ async function focusElement(el) {
   } else {
     el.focus();
   }
-}
-function setFocusOnElement(ref, selector) {
+};
+const setFocusOnElement = (ref, selector) => {
   if (!ref?.shadowRoot) {
     return;
   }
@@ -184,19 +167,29 @@ function setFocusOnElement(ref, selector) {
     return;
   }
   void Promise.resolve(ref.componentOnReady?.()).then(() => setFocus(ref, selector));
-}
-function isEsriInternalEnv() {
-  return typeof globalThis.process === "object" && !!process.env.ESRI_INTERNAL;
-}
-function safeCall(callback, thisContext, ...rest) {
+};
+const 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;
-}
-async function safeAsyncCall(callback, thisContext, ...rest) {
+};
+const safeAsyncCall = async (callback, thisContext, ...rest) => {
   try {
     const result = callback?.call(thisContext, ...rest);
     return await result;
@@ -204,60 +197,18 @@ async function safeAsyncCall(callback, thisContext, ...rest) {
     console.error(error, callback);
   }
   return void 0;
-}
-function gen(count) {
+};
+const gen = (count) => {
   let out = "";
   for (let i = 0; i < count; i++) {
     out += ((1 + Math.random()) * 65536 | 0).toString(16).substring(1);
   }
   return out;
-}
-function generateGuid() {
-  return [gen(2), gen(1), gen(1), gen(1), gen(3)].join("-");
-}
-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"
-];
+};
+const generateGuid = () => [gen(2), gen(1), gen(1), gen(1), gen(3)].join("-");
+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 = /* @__PURE__ */ new Set(supportedLocalesArray);
 const defaultLocale = "en";
 const localeEquivalencies = {
@@ -271,14 +222,14 @@ const localeEquivalencies = {
   // We use `zh-CN` as base translation for chinese locales which has no corresponding bundle.
   zh: "zh-CN"
 };
-async function fetchT9nStringsBundle(locale, assetsPath, prefix = "") {
+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 = {};
-async function fetchBundle(locale, path) {
+const fetchBundle = async (locale, path) => {
   const filePath = `${path}${locale}.json`;
   try {
     const response = await fetch(filePath);
@@ -302,12 +253,12 @@ async function fetchBundle(locale, path) {
     return {};
   }
   return await fetchBundle(defaultLocale, path);
-}
-function getElementLocales(element) {
+};
+const getElementLocales = (element) => {
   const lang = getElementAttribute(element, "lang", globalThis.navigator?.language || defaultLocale);
   return { lang, t9nLocale: normalizeLocale(lang) };
-}
-function normalizeLocale(locale) {
+};
+const normalizeLocale = (locale) => {
   const [rawLanguageCode, regionCode] = locale.split("-");
   const languageCode = rawLanguageCode.toLowerCase();
   let normalizedLocale = languageCode;
@@ -322,10 +273,10 @@ function normalizeLocale(locale) {
     return normalizeLocale(languageCode);
   }
   return defaultLocale;
-}
-function startLocaleObserver(element, getAssetsPath, onUpdated, assetName) {
+};
+const startLocaleObserver = (element, getAssetsPath, onUpdated, assetName) => {
   let result = void 0;
-  const callback = () => void updateComponentLocaleState(element, getAssetsPath(), assetName).then((newResult) => {
+  const callback = () => updateComponentLocaleState(element, getAssetsPath(), assetName).then((newResult) => {
     if (result?.lang !== newResult.lang || result.t9nLocale !== newResult.t9nLocale || result.t9nStrings !== newResult.t9nStrings) {
       onUpdated(newResult);
     }
@@ -333,8 +284,8 @@ function startLocaleObserver(element, getAssetsPath, onUpdated, assetName) {
   }).catch(console.error);
   queueMicrotask(callback);
   return observeAncestorsMutation(element, ["lang"], callback);
-}
-async function updateComponentLocaleState(element, assetsPath, assetName = element.localName.split("-").slice(1).join("-")) {
+};
+const updateComponentLocaleState = async (element, assetsPath, assetName = element.localName.split("-").slice(1).join("-")) => {
   const { lang, t9nLocale } = getElementLocales(element);
   const t9nAssetsPath = `${assetsPath}/${assetName}/t9n`;
   const prefix = `messages.`;
@@ -343,7 +294,7 @@ async function updateComponentLocaleState(element, assetsPath, assetName = eleme
     assetName === null ? {} : await fetchT9nStringsBundle(t9nLocale, t9nAssetsPath, prefix)
   );
   return { lang, t9nLocale, t9nStrings };
-}
+};
 const blurb = "All material copyright Esri, All Rights Reserved, unless otherwise specified.\nSee https://js.arcgis.com/{minorVersion}/esri/copyright.txt for details.\nv{version}";
 const extractMinorVersion = (version) => {
   const [major, minor] = version.split(".");
@@ -352,10 +303,8 @@ const extractMinorVersion = (version) => {
 const getPreamble = (version) => blurb.replace("{minorVersion}", extractMinorVersion(version)).replace("{version}", version);
 const doubleQuote = '"';
 const singleQuote = "'";
-function repeatString(value, n) {
-  return new Array(n + 1).join(value);
-}
-function quoteString(value) {
+const repeatString = (value, n) => new Array(n + 1).join(value);
+const quoteString = (value) => {
   let quote = doubleQuote;
   let alternateQuote = singleQuote;
   const avoidEscape = value.includes(quote) && !value.includes(alternateQuote);
@@ -377,24 +326,23 @@ function quoteString(value) {
     (_, boundaryChar, leadingEscapedSlashes, quoteChars) => boundaryChar + leadingEscapedSlashes + repeatString(`\\${quote}`, quoteChars.length)
   );
   return quote + value + quote;
-}
-function createFilterExpression(filterWord) {
+};
+const createFilterExpression = (filterWord) => {
   const sanitizedWord = filterWord ? filterWord.replaceAll(/[-[\]/{}()*+?.\\^$|]/gu, "\\$&") : "^.*$";
   return new RegExp(sanitizedWord, "i");
-}
-function setValuesInString(message, values = {}) {
-  return (message ?? "").replace(/\{(?<valueName>.*?)\}/gu, (match, valueName) => values[valueName] ?? match);
-}
-function addLTRMark(value) {
-  return `‎${value ?? ""}‎`;
-}
+};
+const setValuesInString = (message, values = {}) => (message ?? "").replace(/\{(?<valueName>.*?)\}/gu, (match, valueName) => values[valueName] ?? match);
+const addLTRMark = (value) => (
+  // Make sure the string value is LTR. This prevent issues with RTL language used in LTR containers.
+  `‎${value ?? ""}‎`
+);
 const kebabToPascal = (string) => string.split("-").map(capitalize).join("");
 const camelToKebab = (string) => string.replace(upperBeforeLower, (upper, remainder) => `${remainder === 0 ? "" : "-"}${upper.toLowerCase()}`);
 const upperBeforeLower = /[A-Z]+(?![a-z])|[A-Z]/gu;
 const capitalize = (string) => string.charAt(0).toUpperCase() + string.slice(1);
 const uncapitalize = (string) => string.charAt(0).toLowerCase() + string.slice(1);
 const camelToHuman = (string) => capitalize(string.replace(upperBeforeLower, (upper, remainder) => `${remainder === 0 ? "" : " "}${upper}`));
-function devToolsAwareTimeout(callback, timeout) {
+const devToolsAwareTimeout = (callback, timeout) => {
   const interval = timeout > longTimeoutThreshold ? longTimeoutInterval : timeout / shortTimeoutIntervals;
   let elapsed = 0;
   const reference = setInterval(() => {
@@ -405,18 +353,14 @@ function devToolsAwareTimeout(callback, timeout) {
     }
   }, interval);
   return reference;
-}
+};
 const longTimeoutThreshold = 4e3;
 const longTimeoutInterval = 2e3;
 const shortTimeoutIntervals = 4;
-function isNotNull(item) {
-  return item !== null;
-}
-function isNotUndefined(item) {
-  return item !== void 0;
-}
+const isNotNull = (item) => item !== null;
+const isNotUndefined = (item) => item !== void 0;
 const identity = (value) => value;
-function debounce(func, waitFor = 100) {
+const debounce = (func, waitFor = 100) => {
   let timeout;
   return (...args) => {
     const later = () => {
@@ -426,8 +370,8 @@ function debounce(func, waitFor = 100) {
     clearTimeout(timeout);
     timeout = setTimeout(later, waitFor);
   };
-}
-function hasSameOrigin(url1, url2, ignoreProtocol = false) {
+};
+const hasSameOrigin = (url1, url2, ignoreProtocol = false) => {
   if (!url1 || !url2) {
     return false;
   }
@@ -440,15 +384,15 @@ function hasSameOrigin(url1, url2, ignoreProtocol = false) {
     return false;
   }
   return url1Obj.host.toLowerCase() === url2Obj.host.toLowerCase() && url1Obj.port === url2Obj.port;
-}
-function isURL(url) {
+};
+const isURL = (url) => {
   try {
     new URL(url);
     return true;
   } catch (e) {
     return false;
   }
-}
+};
 exports.Deferred = Deferred;
 exports.addLTRMark = addLTRMark;
 exports.camelToHuman = camelToHuman;