@arcgis/toolkit 5.2.0-next.1 → 5.2.0-next.10

package/dist/intl/index.cjs

@@ -1,110 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const dom_index = require("../dom/index.cjs");
-const log_index = require("../log/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
-  // Locale equivalencies aligned with ArcGIS Maps SDK for JavaScript:
-  // https://developers.arcgis.com/javascript/latest/localization/#locale-support
-  // We resolve to `pt-BR` as it will have the same translations as `pt`, which has no corresponding bundle
-  pt: "pt-BR",
-  // 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) {
-        log_index.log("error", "intl", `Localization strings not found at ${filePath}`);
-      } else {
-        log_index.log("error", "intl", `Error fetching localization strings at ${filePath}`, { detail: { error } });
-      }
-    } else {
-      log_index.log("error", "intl", `An unknown error occurred while fetching localization strings at ${filePath}`, {
-        detail: { 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((error) => {
-    log_index.log("error", "intl", "Error updating component locale state", { detail: { 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

@@ -1,124 +0,0 @@
-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" | "el" | "ar" | "bg" | "bs" | "ca" | "cs" | "da" | "de" | "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://webgis.esri.com/references/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://webgis.esri.com/references/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://webgis.esri.com/references/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
- * Follows the ArcGIS Maps SDK for JavaScript locale support:
- * https://developers.arcgis.com/javascript/latest/localization/#locale-support
- *
- * 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://webgis.esri.com/references/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/log/index.cjs

@@ -1,81 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const loggedMessages = /* @__PURE__ */ new Set();
-let esriConfig;
-const setEsriConfig = (config) => {
-  esriConfig = config;
-};
-const getContextString = (context) => {
-  if (typeof context === "string") {
-    return context;
-  }
-  if ("el" in context) {
-    return context.el.localName;
-  }
-  if ("localName" in context) {
-    return context.localName;
-  }
-  return context.declaredClass;
-};
-const log = (level, context, message, options) => {
-  const contextString = getContextString(context);
-  if (options?.once) {
-    const key = `${level}${contextString}${message}`;
-    if (loggedMessages.has(key)) {
-      return;
-    }
-    loggedMessages.add(key);
-  }
-  let memorySafeDetail;
-  if (options?.detail) {
-    memorySafeDetail = {};
-    for (const [key, value] of Object.entries(options.detail)) {
-      if ((typeof value === "object" || typeof value === "function") && value !== null) {
-        const weakRefValue = new WeakRef(value);
-        Object.defineProperty(memorySafeDetail, key, {
-          enumerable: true,
-          get() {
-            return weakRefValue.deref();
-          }
-        });
-      } else {
-        memorySafeDetail[key] = value;
-      }
-    }
-    esriConfig?.log.interceptors?.forEach(
-      (interceptor) => interceptor(level, contextString, message, memorySafeDetail)
-    );
-    console[level](`[${contextString}]: ${message}`, memorySafeDetail);
-  } else {
-    esriConfig?.log.interceptors?.forEach((interceptor) => interceptor(level, contextString, message));
-    console[level](`[${contextString}]: ${message}`);
-  }
-};
-const rethrowError = (context) => {
-  const prefix = `[${getContextString(context)}] `;
-  return (error) => {
-    const errorToRethrow = error instanceof Error && error.message ? error : new Error(String(error));
-    errorToRethrow.message = `${prefix}${errorToRethrow.message}`;
-    setTimeout(() => {
-      throw error;
-    });
-  };
-};
-const composeMissingPropertyMessage = (property) => (
-  //#endregion composeMissingPropertyMessage
-  `The property \`${property.toString()}\` is required but missing.`
-);
-const composeEmptyPropertyMessage = (property) => (
-  //#endregion composeEmptyPropertyMessage
-  `The property \`${property.toString()}\` is empty but must have at least one element.`
-);
-const logDeprecatedProperty = (context, oldName, newName, options) => (
-  //#endregion logDeprecatedProperty
-  log("warn", context, `\`${oldName.toString()}\` is deprecated. Use \`${newName.toString()}\` instead.`, options)
-);
-exports.composeEmptyPropertyMessage = composeEmptyPropertyMessage;
-exports.composeMissingPropertyMessage = composeMissingPropertyMessage;
-exports.log = log;
-exports.logDeprecatedProperty = logDeprecatedProperty;
-exports.rethrowError = rethrowError;
-exports.setEsriConfig = setEsriConfig;

package/dist/log/index.d.cts

@@ -1,128 +0,0 @@
-export type LogLevel = "error" | "info" | "warn";
-type CustomElementLike = {
-    el: {
-        localName: string;
-    };
-} | {
-    localName: string;
-};
-type AccessorLike = {
-    declaredClass: string;
-};
-export type LogContext = AccessorLike | CustomElementLike | string;
-type LogOptions = {
-    /** Whether the message should only be logged once. */
-    once?: boolean;
-    /** Additional objects to log after `message`. Use this to avoid memory leaks when logging objects to the console. Each object value will be automatically wrapped in a `WeakRef` before logging so it can be garbage-collected. */
-    detail?: Record<string, unknown>;
-};
-type EsriConfig = {
-    log: {
-        /**
-         * @link {https://developers.arcgis.com/javascript/latest/references/core/config/#LogInterceptor}
-         */
-        interceptors?: ((level: LogLevel | "none", module: string, ...args: any[]) => void)[];
-    };
-};
-/**
- * Workaround for setting {@link https://developers.arcgis.com/javascript/latest/references/core/config/#log log interceptors} and maintaining compatibility with {@link https://devtopia.esri.com/WebGIS/arcgis-websceneviewer-app/blob/8f0a1bbcf12d1193134d94589d9e187f0afa72fa/src/js/support/ApiLoggerInstrumentation.ts#L17 js-api's interceptor usage}.
- * @see {@link https://devtopia.esri.com/WebGIS/arcgis-js-api/discussions/74935}
- * @param config {@link https://developers.arcgis.com/javascript/latest/references/core/config/}
- * @example
- * ```ts
- * // IMPORTANT: do this only in config.ts or another early-loaded module
- * import esriConfig from "@arcgis/core/config.js";
- * import { setEsriConfig } from "@arcgis/toolkit/log";
- *
- * setEsriConfig(esriConfig);
- *
- * // either here or in another file, you can add your interceptors
- * // and they will be respected when log is called later on
- * esriConfig.log.interceptors?.push(yourInterceptor);
- * ```
- */
-export declare const setEsriConfig: (config: EsriConfig) => void;
-/**
- * Helper utility for logging messages in a consistent manner.
- *
- * @param level The log level
- * @param context The context of the log message (e.g., `this` inside a Lit-like component, or just a custom string)
- * @param message A custom message to log
- * @param options Additional options for logging, such as to provide a context object
- *
- * @see [setEsriConfig](#setEsriConfig)
- *
- * @example
- * ```ts
- * // Basic usage
- * log("error", this, "message to log");
- * ```
- *
- * @example
- * ```ts
- * // Optional usage
- * log("warn", this, "message to log", {
- *   once: true,
- *   detail: { object1, object2 }
- * });
- */
-export declare const log: (level: LogLevel, context: LogContext, message: string, options?: LogOptions) => void;
-/**
- * Rethrows an error and prepends context information to the error message. The error is
- * thrown asynchronously to avoid interrupting the current execution stack, so it cannot be caught
- * with `try/catch` and will bubble to the global object.
- * @param context From where the error is being thrown (e.g., `this` inside a Lit-like component, or just a custom string)
- * @returns A function that can be used in `try-catch`/`.catch` to rethrow an error
- *
- * @example
- * ```ts
- * try {
- *   functionThatMightThrow();
- * } catch (error) {
- *   rethrowError(this)(error);
- * }
- * ```
- *
- * @example
- * ```ts
- * promise.then().catch(rethrowError("context string"));
- * ```
- */
-export declare const rethrowError: (context: LogContext) => ((error: unknown) => void);
-type LogContextOrObject = Exclude<LogContext, string> | object;
-type InferPropertyType<T extends LogContextOrObject> = [object] extends [T] ? string : keyof T;
-/**
- * Returns a string that can be used in log messages for missing required properties.
- * @param property The name of the required property
- * @example
- * ```ts
- * // returns "The property `x` is required but missing."
- * composeMissingPropertyMessage<YourClass>("x");
- * // you don't need to provide a generic type argument if you don't have one
- * composeMissingPropertyMessage("object.sub.property");
- * ```
- */
-export declare const composeMissingPropertyMessage: <T extends LogContextOrObject = object>(property: InferPropertyType<T>) => string;
-/**
- * Returns a string that can be used in log messages for empty required arrays.
- * @param property The name of the required property
- * @example
- * ```ts
- * // returns "The property `x` is empty but must have at least one element."
- * composeEmptyPropertyMessage<YourClass>("x");
- * // you don't need to provide a generic type argument if you don't have one
- * composeEmptyPropertyMessage("object.sub.property");
- * ```
- */
-export declare const composeEmptyPropertyMessage: <T extends LogContextOrObject = object>(property: InferPropertyType<T>) => string;
-/**
- * Logs a warning message for deprecated object properties.
- * @example
- * ```ts
- * logDeprecatedProperty(this, "oldName", "newName", {
- *   once: true,
- * });
- * ```
- */
-export declare const logDeprecatedProperty: <T extends LogContext>(context: T, oldName: keyof T, newName: keyof T, options?: LogOptions) => ReturnType<typeof log>;
-export {};

package/dist/number/index.cjs

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-function clamp(value, min, max) {
-  return Math.max(min, Math.min(max, value));
-}
-function lerp(min, max, t) {
-  return min + (max - min) * t;
-}
-exports.clamp = clamp;
-exports.lerp = lerp;

package/dist/number/index.d.cts

@@ -1,19 +0,0 @@
-/**
- * Clamps a value between a minimum and maximum value.
- *
- * @param value The number to clamp.
- * @param min The minimum value.
- * @param max The maximum value.
- *
- * @returns The clamped value.
- */
-export declare function clamp(value: number, min: number, max: number): number;
-/**
- * Linearly interpolates between two numbers.
- *
- * @param min - The start value.
- * @param max - The end value.
- * @param t - The interpolation factor, typically between 0 and 1.
- * @returns The interpolated value between `min` and `max` based on `t`.
- */
-export declare function lerp(min: number, max: number, t: number): number;

package/dist/predicate/index.cjs

@@ -1,8 +0,0 @@
-"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

@@ -1,24 +0,0 @@
-import { nil } from '../type/index.ts';
-/**
- * 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;

package/dist/promise/index.cjs

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-class Deferred {
-  /**
-   * Creates a new deferred promise.
-   */
-  constructor() {
-    this.promise = new Promise((resolve, reject) => {
-      this.resolve = resolve;
-      this.reject = reject;
-    });
-  }
-}
-async function forEachWithConcurrency(items, concurrency, callback) {
-  if (items.length === 0) {
-    return;
-  }
-  let index = 0;
-  async function consumeItems() {
-    while (index < items.length) {
-      const item = items[index];
-      index += 1;
-      await callback(item);
-    }
-  }
-  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, async () => await consumeItems()));
-}
-const devToolsAwareTimeout = (callback, timeout) => {
-  const interval = timeout > longTimeoutThreshold ? longTimeoutInterval : timeout / shortTimeoutIntervals;
-  let elapsed = 0;
-  const reference = setInterval(() => {
-    elapsed += interval;
-    if (elapsed >= timeout) {
-      clearInterval(reference);
-      callback();
-    }
-  }, interval);
-  return reference;
-};
-const longTimeoutThreshold = 4e3;
-const longTimeoutInterval = 2e3;
-const shortTimeoutIntervals = 4;
-exports.Deferred = Deferred;
-exports.devToolsAwareTimeout = devToolsAwareTimeout;
-exports.forEachWithConcurrency = forEachWithConcurrency;

package/dist/promise/index.d.cts

@@ -1,60 +0,0 @@
-/**
- * A deferred promise.
- * Useful for when you want to return a promise but don't have the value yet.
- *
- * @example
- * ```ts
- * const deferred = new Deferred<string>();
- * setTimeout(() => deferred.resolve("Hello World"), 1000);
- * return deferred.promise;
- * ```
- *
- * @deprecated
- * If browser support permits, prefer using
- * [Promise.withResolvers()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers)
- */
-export declare class Deferred<T> {
-    /**
-     * The promise that can be awaited.
-     */
-    promise: Promise<T>;
-    /**
-     * Creates a new deferred promise.
-     */
-    constructor();
-}
-export interface Deferred<T> {
-    /**
-     * Resolves the promise.
-     * @param value The value to resolve the promise with.
-     *
-     * @privateRemarks
-     * Defined as a method to disable covariance checks. Overridden in constructor.
-     */
-    resolve(_value: PromiseLike<T> | T): void;
-    /**
-     * Rejects the promise.
-     */
-    reject(_error: unknown): void;
-}
-/**
- * Execute async callbacks against a list with a fixed number of in-flight
- * operations.
- * Useful for rate-limiting or to avoid overwhelming resources with too many concurrent operations.
- *
- * @example
- * ```ts
- * const items = [...lotsOfItems];
- * await forEachWithConcurrency(items, 5, async (item) => {
- *   await doSomethingAsync(item);
- * });
- * ```
- */
-export declare function forEachWithConcurrency<T>(items: readonly T[], concurrency: number, callback: (item: T) => Promise<void>): Promise<void>;
-/**
- * Like setTimeout(), but does not advance the clock if the program is
- * stopped on a debugger breakpoint.
- *
- * @see https://devtopia.esri.com/WebGIS/arcgis-js-api/discussions/60405
- */
-export declare const devToolsAwareTimeout: (callback: () => void, timeout: number) => ReturnType<typeof setInterval>;