@arcgis/lumina 5.0.0-next.73 → 5.0.0-next.75

package/dist/{Controller-ftAEcdmI.js → Controller-DDyB41GY.js}

@@ -1,5 +1,5 @@
 import { safeCall, isEsriInternalEnv, safeAsyncCall } from "@arcgis/toolkit/error";
-import { r as retrieveComponent, d as retrieveParentControllers, b as setParentController, s as setAmbientComponent, u as use, k as useRef, l as useRefSync, c as controllerSymbol } from "./ControllerInternals-CWQrfEA8.js";
+import { r as retrieveComponent, d as retrieveParentControllers, b as setParentController, a as setAmbientComponent, u as use, k as useRef, l as useRefSync, c as controllerSymbol } from "./ControllerInternals-By6dhpY-.js";
 import { nothing } from "lit";
 import { Deferred } from "@arcgis/toolkit/promise";
 const trackPropertyKey = (object, onResolved, defaultValue) => {

package/dist/{ControllerInternals-CWQrfEA8.js → ControllerInternals-By6dhpY-.js}

@@ -115,7 +115,7 @@ const bypassReadOnly = (callback) => {
 };
 const bypassSetter = bypassReadOnly;
 export {
-  shouldBypassReadOnly as a,
+  setAmbientComponent as a,
   setParentController as b,
   controllerSymbol as c,
   retrieveParentControllers as d,
@@ -128,6 +128,6 @@ export {
   useRef as k,
   useRefSync as l,
   retrieveComponent as r,
-  setAmbientComponent as s,
+  shouldBypassReadOnly as s,
   use as u
 };

package/dist/ControllerManager-LzfJtMG7.js

@@ -0,0 +1,185 @@
+import { safeCall, isEsriInternalEnv } from "@arcgis/toolkit/error";
+import { G as GenericController, p as propertyTrackResolve } from "./Controller-DDyB41GY.js";
+import { nothing, LitElement as LitElement$1 } from "lit";
+import { devToolsAwareTimeout } from "@arcgis/toolkit/promise";
+import { a as setAmbientComponent } from "./ControllerInternals-By6dhpY-.js";
+class ControllerManager extends GenericController {
+  constructor(component) {
+    super(component);
+    this.destroyed = false;
+    this.R = false;
+    this.V = nothing;
+    this.T = [];
+    this.#exportsStore = /* @__PURE__ */ new WeakMap();
+    this.#component = component;
+    this.exports = void 0;
+    this.hasDestroy = autoDestroyDisabledPropName in component && typeof component.destroy === "function";
+    LitElement$1.prototype.addController.call(component, {
+      // Lit will call these callbacks
+      // We do not directly implement hostConnected and etc on ControllerManager
+      // because ControllerManager is also included in the list of controllers
+      // we manage - and for each controller we manage we call hostConnected
+      // (from inside of .triggerConnected). So there would be an infinite
+      // loop if Lit calls hostConnected which in turn calls
+      // triggerConnected which calls hostConnected again.
+      hostConnected: () => {
+        if (this.destroyed) {
+          const tagName = component.el.localName;
+          component.el.remove();
+          throw new Error(
+            `The ${tagName} component has already been destroyed. It cannot be used again. If you meant to disconnect and reconnect a component without automatic destroy, set the ${autoDestroyDisabledPropName} prop.`
+          );
+        }
+        if (this.#autoDestroyTimeout !== void 0) {
+          clearTimeout(this.#autoDestroyTimeout);
+        }
+        propertyTrackResolve();
+        for (const controller of component.M) {
+          if ("triggerConnected" in controller) {
+            controller.triggerConnected();
+          } else {
+            safeCall(controller.hostConnected, controller);
+          }
+        }
+      },
+      hostDisconnected: () => {
+        for (const controller of component.M) {
+          if ("triggerDisconnected" in controller) {
+            controller.triggerDisconnected();
+          } else {
+            safeCall(controller.hostDisconnected, controller);
+          }
+        }
+        if (this.hasDestroy && !this.destroyed) {
+          this.U();
+        }
+      },
+      hostUpdate: () => {
+        for (const controller of component.M) {
+          if ("triggerUpdate" in controller) {
+            controller.triggerUpdate(this.Q);
+          } else {
+            safeCall(controller.hostUpdate, controller, this.Q);
+          }
+        }
+      },
+      hostUpdated: () => {
+        for (const controller of component.M) {
+          if ("triggerUpdated" in controller) {
+            controller.triggerUpdated(this.Q);
+          } else {
+            safeCall(controller.hostUpdated, controller, this.Q);
+          }
+        }
+        this.Q = void 0;
+      }
+    });
+    queueMicrotask(() => this.R = true);
+    setAmbientComponent(component);
+  }
+  #autoDestroyTimeout;
+  #component;
+  // Keep this method async needlessly for now to avoid a breaking change if we
+  // would need to make it async in the future
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async destroy() {
+    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+      this.devOnly$ensureHasDestroy?.();
+    }
+    if (this.destroyed) {
+      return;
+    }
+    if (this.#component.el.isConnected) {
+      this.hasDestroy = false;
+      this.#component.el.remove();
+    }
+    this.#autoDestroyTimeout = void 0;
+    this.destroyed = true;
+    for (const controller of this.#component.M) {
+      if ("triggerDestroy" in controller) {
+        controller.triggerDestroy();
+      } else {
+        safeCall(controller.hostDestroy, controller);
+      }
+    }
+    this.#component.M.splice(0);
+  }
+  /** @private */
+  U() {
+    if (this.#autoDestroyTimeout !== void 0) {
+      clearTimeout(this.#autoDestroyTimeout);
+    }
+    if (!this.#component.el.isConnected && !this.#component.autoDestroyDisabled) {
+      const destroy = () => void this.#component.destroy();
+      if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && autoDestroyOnDisconnectTimeout === 0) {
+        queueMicrotask(destroy);
+      } else {
+        this.#autoDestroyTimeout = devToolsAwareTimeout(destroy, autoDestroyOnDisconnectTimeout);
+      }
+    }
+  }
+  /** @private */
+  S(key, value) {
+    const trackers = this.T;
+    this.V = nothing;
+    this.T = [];
+    trackers.forEach((tracker) => tracker(key, value));
+  }
+  #exportsStore;
+  /**
+   * Associate an exports object with a controller for reverse lookup in
+   * controller.use
+   *
+   * @private
+   */
+  W(controller, exports) {
+    if (typeof exports === "object" && exports !== null || typeof exports === "function") {
+      this.#exportsStore.set(exports, controller);
+    }
+  }
+  /** @private */
+  X(exports) {
+    if (typeof exports === "object" && exports !== null || typeof exports === "function") {
+      return this.#exportsStore.get(exports);
+    } else {
+      return void 0;
+    }
+  }
+}
+if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+  ControllerManager.prototype.devOnly$ensureHasDestroy = function ensureHasDestroy() {
+    if (!this.hasDestroy) {
+      throw new Error(
+        `
+          If the component uses a controller that uses destroy() method, then the
+          component must have the following properties:
+          /**
+           * If true, the component will not be destroyed automatically when it is
+           * disconnected from the document. This is useful when you want to move the
+           * component to a different place on the page, or temporarily hide it. If this
+           * is set, make sure to call the \`destroy\` method when you are done to prevent
+           * memory leaks.
+           */
+          @property() ${autoDestroyDisabledPropName} = false;
+
+          /** Permanently destroy the component */
+          @method()
+          async destroy(): Promise<void> {
+            await this.manager.destroy();
+          }
+          `.trim().split("\n").map((line) => line.trim()).join("\n")
+      );
+    }
+  };
+}
+let autoDestroyOnDisconnectTimeout = 1e3;
+const autoDestroyDisabledPropName = "autoDestroyDisabled";
+function setAutoDestroyOnDisconnectTimeout(timeout) {
+  autoDestroyOnDisconnectTimeout = timeout;
+}
+export {
+  ControllerManager as C,
+  autoDestroyDisabledPropName as a,
+  autoDestroyOnDisconnectTimeout as b,
+  setAutoDestroyOnDisconnectTimeout as s
+};

package/dist/context.js

@@ -1,5 +1,5 @@
 import { ContextProvider, ContextConsumer } from "@lit/context";
-import { r as retrieveComponent } from "./ControllerInternals-CWQrfEA8.js";
+import { r as retrieveComponent } from "./ControllerInternals-By6dhpY-.js";
 const useContextProvider = (options) => {
   const component = retrieveComponent();
   const controller = new ContextProvider(component.el, options);

package/dist/controllers/ControllerManager.d.ts

@@ -57,9 +57,7 @@ export declare class ControllerManager extends GenericController<undefined> {
 }
 export declare let autoDestroyOnDisconnectTimeout: number;
 export declare const autoDestroyDisabledPropName = "autoDestroyDisabled";
-export declare const exportsForTests: {
-    setAutoDestroyOnDisconnectTimeout: (timeout: number) => void;
-} | undefined;
+export declare function setAutoDestroyOnDisconnectTimeout(timeout: number): void;
 export type LuminaLifecycles = {
     connectedCallback?: LitElement["connectedCallback"];
     disconnectedCallback?: LitElement["disconnectedCallback"];

package/dist/controllers/accessor/index.js

@@ -1,8 +1,8 @@
 import { isEsriInternalEnv } from "@arcgis/toolkit/error";
-import { r as retrieveComponent } from "../../ControllerInternals-CWQrfEA8.js";
+import { r as retrieveComponent } from "../../ControllerInternals-By6dhpY-.js";
 import { on, watch } from "@arcgis/core/core/reactiveUtils.js";
-import { a as createEventFactory, G as GenericController, d as trackPropKey, t as trackKey } from "../../Controller-ftAEcdmI.js";
-import { p as proxyExports } from "../../proxyExports-D906TEtL.js";
+import { a as createEventFactory, G as GenericController, d as trackPropKey, t as trackKey } from "../../Controller-DDyB41GY.js";
+import { p as proxyExports } from "../../proxyExports-BH_3cSmm.js";
 import { createObservable, trackAccess } from "@arcgis/core/applications/Components/reactiveUtils.js";
 import { property, subclass } from "@arcgis/core/core/accessorSupport/decorators.js";
 import Accessor from "@arcgis/core/core/Accessor.js";

package/dist/controllers/index.d.ts

@@ -1,4 +1,5 @@
 import { EventEmitter as _EventEmitter } from '../createEvent.ts';
+import { setAutoDestroyOnDisconnectTimeout } from './ControllerManager.ts';
 export type { GenericControllerType } from './Controller.ts';
 export { Controller, GenericController } from './Controller.ts';
 export type { ControllerManager } from './ControllerManager.ts';
@@ -26,3 +27,11 @@ export type EventEmitter<T = undefined> = _EventEmitter<T>;
  * @deprecated Let us know if someone is using this
  */
 export declare const keyTrackResolve: () => void;
+/**
+ * @private
+ */
+export declare const exportsForTests: {
+    setAmbientComponent: (component: import('../LitElement.ts').LitElement) => void;
+    autoDestroyOnDisconnectTimeout: number;
+    setAutoDestroyOnDisconnectTimeout: typeof setAutoDestroyOnDisconnectTimeout;
+};

package/dist/controllers/index.js

@@ -1,12 +1,13 @@
-import { C as Controller, t as trackKey, a as createEventFactory, p as propertyTrackResolve } from "../Controller-ftAEcdmI.js";
-import { G, d, b } from "../Controller-ftAEcdmI.js";
-import { s as setAmbientComponent, i as isPromise, b as setParentController, d as retrieveParentControllers, r as retrieveComponent } from "../ControllerInternals-CWQrfEA8.js";
-import { f, e, c, h, g } from "../ControllerInternals-CWQrfEA8.js";
-import { p as proxyExports } from "../proxyExports-D906TEtL.js";
+import { C as Controller, t as trackKey, a as createEventFactory, p as propertyTrackResolve } from "../Controller-DDyB41GY.js";
+import { G, d, b } from "../Controller-DDyB41GY.js";
+import { a as setAmbientComponent, i as isPromise, b as setParentController, d as retrieveParentControllers, r as retrieveComponent } from "../ControllerInternals-By6dhpY-.js";
+import { f, e, c, h, g } from "../ControllerInternals-By6dhpY-.js";
+import { p as proxyExports } from "../proxyExports-BH_3cSmm.js";
 import { isServer } from "lit";
 import { isEsriInternalEnv } from "@arcgis/toolkit/error";
 import { observeAncestorsMutation, getElementAttribute } from "@arcgis/toolkit/dom";
 import { getElementLocale, startLocaleObserver } from "@arcgis/toolkit/intl";
+import { s as setAutoDestroyOnDisconnectTimeout, b as autoDestroyOnDisconnectTimeout } from "../ControllerManager-LzfJtMG7.js";
 const makeController = (constructor) => proxy(void 0, constructor);
 const makeGenericController = (constructor) => (component) => proxy(
   component,
@@ -251,12 +252,18 @@ const propertyChangeController = (...toWatch) => {
   return eventEmitter;
 };
 const keyTrackResolve = propertyTrackResolve;
+const exportsForTests = {
+  setAmbientComponent,
+  autoDestroyOnDisconnectTimeout,
+  setAutoDestroyOnDisconnectTimeout
+};
 export {
   Controller,
   G as GenericController,
   f as bypassReadOnly,
   e as bypassSetter,
   c as controllerSymbol,
+  exportsForTests,
   h as getControllersCount,
   g as isController,
   keyTrackResolve,

package/dist/hmrSupport.js

@@ -1,4 +1,4 @@
-import { n as noShadowRoot, P as ProxyComponent } from "./lazyLoad-BlK67lvm.js";
+import { n as noShadowRoot, P as ProxyComponent } from "./lazyLoad-DjHR4rq8.js";
 import { camelToKebab } from "@arcgis/toolkit/string";
 function handleHmrUpdate(newModules) {
   newModules.forEach((newModule) => {

package/dist/index.js

@@ -1,14 +1,15 @@
-import { G as GenericController, p as propertyTrackResolve } from "./Controller-ftAEcdmI.js";
-import { c } from "./Controller-ftAEcdmI.js";
+import { p as propertyTrackResolve } from "./Controller-DDyB41GY.js";
+import { c } from "./Controller-DDyB41GY.js";
 import { state } from "lit/decorators/state.js";
 import { property as property$1 } from "lit/decorators/property.js";
-import { e as emptyFunction, n as noShadowRoot, a as attachToAncestor } from "./lazyLoad-BlK67lvm.js";
-import { d, m } from "./lazyLoad-BlK67lvm.js";
-import { safeCall, isEsriInternalEnv, safeAsyncCall } from "@arcgis/toolkit/error";
+import { e as emptyFunction, n as noShadowRoot, a as attachToAncestor } from "./lazyLoad-DjHR4rq8.js";
+import { d, m } from "./lazyLoad-DjHR4rq8.js";
+import { isEsriInternalEnv, safeAsyncCall, safeCall } from "@arcgis/toolkit/error";
 import { camelToKebab } from "@arcgis/toolkit/string";
-import { devToolsAwareTimeout, Deferred } from "@arcgis/toolkit/promise";
-import { nothing as nothing$1, LitElement as LitElement$1, isServer, notEqual, noChange as noChange$1, render } from "lit";
-import { s as setAmbientComponent, c as controllerSymbol, a as shouldBypassReadOnly } from "./ControllerInternals-CWQrfEA8.js";
+import { Deferred } from "@arcgis/toolkit/promise";
+import { LitElement as LitElement$1, isServer, notEqual, noChange as noChange$1, nothing as nothing$1, render } from "lit";
+import { c as controllerSymbol, s as shouldBypassReadOnly } from "./ControllerInternals-By6dhpY-.js";
+import { C as ControllerManager, a as autoDestroyDisabledPropName } from "./ControllerManager-LzfJtMG7.js";
 import { propertyFlagAttribute, propertyFlagNoAccessor, propertyFlagReadOnly, propertyFlagState, propertyFlagBoolean, propertyFlagNumber, propertyFlagReflect } from "./config.js";
 import { classMap } from "lit/directives/class-map.js";
 import { styleMap } from "lit/directives/style-map.js";
@@ -17,177 +18,6 @@ import { live as live$1 } from "lit/directives/live.js";
 import { ref } from "lit/directives/ref.js";
 const property = property$1;
 const method = void 0;
-class ControllerManager extends GenericController {
-  constructor(component) {
-    super(component);
-    this.destroyed = false;
-    this.R = false;
-    this.V = nothing$1;
-    this.T = [];
-    this.#exportsStore = /* @__PURE__ */ new WeakMap();
-    this.#component = component;
-    this.exports = void 0;
-    this.hasDestroy = autoDestroyDisabledPropName in component && typeof component.destroy === "function";
-    LitElement$1.prototype.addController.call(component, {
-      // Lit will call these callbacks
-      // We do not directly implement hostConnected and etc on ControllerManager
-      // because ControllerManager is also included in the list of controllers
-      // we manage - and for each controller we manage we call hostConnected
-      // (from inside of .triggerConnected). So there would be an infinite
-      // loop if Lit calls hostConnected which in turn calls
-      // triggerConnected which calls hostConnected again.
-      hostConnected: () => {
-        if (this.destroyed) {
-          const tagName = component.el.localName;
-          component.el.remove();
-          throw new Error(
-            `The ${tagName} component has already been destroyed. It cannot be used again. If you meant to disconnect and reconnect a component without automatic destroy, set the ${autoDestroyDisabledPropName} prop.`
-          );
-        }
-        if (this.#autoDestroyTimeout !== void 0) {
-          clearTimeout(this.#autoDestroyTimeout);
-        }
-        propertyTrackResolve();
-        for (const controller of component.M) {
-          if ("triggerConnected" in controller) {
-            controller.triggerConnected();
-          } else {
-            safeCall(controller.hostConnected, controller);
-          }
-        }
-      },
-      hostDisconnected: () => {
-        for (const controller of component.M) {
-          if ("triggerDisconnected" in controller) {
-            controller.triggerDisconnected();
-          } else {
-            safeCall(controller.hostDisconnected, controller);
-          }
-        }
-        if (this.hasDestroy && !this.destroyed) {
-          this.U();
-        }
-      },
-      hostUpdate: () => {
-        for (const controller of component.M) {
-          if ("triggerUpdate" in controller) {
-            controller.triggerUpdate(this.Q);
-          } else {
-            safeCall(controller.hostUpdate, controller, this.Q);
-          }
-        }
-      },
-      hostUpdated: () => {
-        for (const controller of component.M) {
-          if ("triggerUpdated" in controller) {
-            controller.triggerUpdated(this.Q);
-          } else {
-            safeCall(controller.hostUpdated, controller, this.Q);
-          }
-        }
-        this.Q = void 0;
-      }
-    });
-    queueMicrotask(() => this.R = true);
-    setAmbientComponent(component);
-  }
-  #autoDestroyTimeout;
-  #component;
-  // Keep this method async needlessly for now to avoid a breaking change if we
-  // would need to make it async in the future
-  // eslint-disable-next-line @typescript-eslint/require-await
-  async destroy() {
-    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
-      this.devOnly$ensureHasDestroy?.();
-    }
-    if (this.destroyed) {
-      return;
-    }
-    if (this.#component.el.isConnected) {
-      this.hasDestroy = false;
-      this.#component.el.remove();
-    }
-    this.#autoDestroyTimeout = void 0;
-    this.destroyed = true;
-    for (const controller of this.#component.M) {
-      if ("triggerDestroy" in controller) {
-        controller.triggerDestroy();
-      } else {
-        safeCall(controller.hostDestroy, controller);
-      }
-    }
-    this.#component.M.splice(0);
-  }
-  /** @private */
-  U() {
-    if (this.#autoDestroyTimeout !== void 0) {
-      clearTimeout(this.#autoDestroyTimeout);
-    }
-    if (!this.#component.el.isConnected && !this.#component.autoDestroyDisabled) {
-      const destroy = () => void this.#component.destroy();
-      if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && autoDestroyOnDisconnectTimeout === 0) ;
-      else {
-        this.#autoDestroyTimeout = devToolsAwareTimeout(destroy, autoDestroyOnDisconnectTimeout);
-      }
-    }
-  }
-  /** @private */
-  S(key, value) {
-    const trackers = this.T;
-    this.V = nothing$1;
-    this.T = [];
-    trackers.forEach((tracker) => tracker(key, value));
-  }
-  #exportsStore;
-  /**
-   * Associate an exports object with a controller for reverse lookup in
-   * controller.use
-   *
-   * @private
-   */
-  W(controller, exports) {
-    if (typeof exports === "object" && exports !== null || typeof exports === "function") {
-      this.#exportsStore.set(exports, controller);
-    }
-  }
-  /** @private */
-  X(exports) {
-    if (typeof exports === "object" && exports !== null || typeof exports === "function") {
-      return this.#exportsStore.get(exports);
-    } else {
-      return void 0;
-    }
-  }
-}
-if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
-  ControllerManager.prototype.devOnly$ensureHasDestroy = function ensureHasDestroy() {
-    if (!this.hasDestroy) {
-      throw new Error(
-        `
-          If the component uses a controller that uses destroy() method, then the
-          component must have the following properties:
-          /**
-           * If true, the component will not be destroyed automatically when it is
-           * disconnected from the document. This is useful when you want to move the
-           * component to a different place on the page, or temporarily hide it. If this
-           * is set, make sure to call the \`destroy\` method when you are done to prevent
-           * memory leaks.
-           */
-          @property() ${autoDestroyDisabledPropName} = false;
-
-          /** Permanently destroy the component */
-          @method()
-          async destroy(): Promise<void> {
-            await this.manager.destroy();
-          }
-          `.trim().split("\n").map((line) => line.trim()).join("\n")
-      );
-    }
-  };
-}
-let autoDestroyOnDisconnectTimeout = 1e3;
-const autoDestroyDisabledPropName = "autoDestroyDisabled";
-process.env.NODE_ENV !== "production" && isEsriInternalEnv() ? {} : void 0;
 class LitElement extends LitElement$1 {
   constructor() {
     super();

package/dist/{lazyLoad-BlK67lvm.js → lazyLoad-DjHR4rq8.js}

@@ -96,10 +96,16 @@ if (process.env.NODE_ENV !== "production") {
 const noShadowRoot = {};
 function emptyFunction() {
 }
-const devOnly$getLitElementTagNameAndRuntime = process.env.NODE_ENV !== "production" && isEsriInternalEnv() ? (componentClass) => ({
-  tagName: componentClass.L,
-  runtime: componentClass.K
-}) : void 0;
+const devOnly$getLitElementTagNameAndRuntime = process.env.NODE_ENV !== "production" && isEsriInternalEnv() ? (componentClass) => {
+  const prototype = Object.getPrototypeOf(componentClass);
+  if (prototype.L !== void 0 && prototype.L === componentClass.L) {
+    return { tagName: void 0, runtime: void 0 };
+  }
+  return {
+    tagName: componentClass.L,
+    runtime: componentClass.K
+  };
+} : void 0;
 const makeDefineCustomElements = (runtime, structure) => function defineCustomElements(windowOrOptions, options) {
   if (!globalThis.customElements) {
     return;

package/dist/{proxyExports-D906TEtL.js → proxyExports-BH_3cSmm.js}

@@ -1,5 +1,5 @@
-import { b as setParentController, d as retrieveParentControllers, j as setAmbientChildController, f as bypassReadOnly } from "./ControllerInternals-CWQrfEA8.js";
-import { t as trackKey } from "./Controller-ftAEcdmI.js";
+import { b as setParentController, d as retrieveParentControllers, j as setAmbientChildController, f as bypassReadOnly } from "./ControllerInternals-By6dhpY-.js";
+import { t as trackKey } from "./Controller-DDyB41GY.js";
 const proxyExports = (Class) => (...args) => {
   const ambientControllers = retrieveParentControllers();
   const instance = new Class(...args);

package/dist/tests/wrappersUtils.typeTest.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils.d.ts

@@ -28,6 +28,6 @@ export declare function emptyFunction(): undefined;
  * @private
  */
 export declare const devOnly$getLitElementTagNameAndRuntime: ((componentClass: typeof LitElement) => {
-    tagName: string;
-    runtime: Runtime;
+    tagName: string | undefined;
+    runtime: Runtime | undefined;
 }) | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcgis/lumina",
-  "version": "5.0.0-next.73",
+  "version": "5.0.0-next.75",
   "sideEffects": false,
   "type": "module",
   "main": "dist/index.cjs",
@@ -23,7 +23,7 @@
   ],
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@arcgis/toolkit": "~5.0.0-next.73",
+    "@arcgis/toolkit": "~5.0.0-next.75",
     "csstype": "^3.1.3",
     "tslib": "^2.8.1"
   },

package/dist/controllers/tests/autoDestroyMock.d.ts

@@ -1,5 +0,0 @@
-/**
- * Mocking utility for changing auto-destroy timeout in ControllerManager to 0ms.
- * Also, returns a convenient promise that resolves after the timeout.
- */
-export declare function autoDestroyMock(timeout?: number): () => Promise<void>;

package/dist/controllers/tests/utils.d.ts

@@ -1 +0,0 @@
-export declare function captureConsoleErrors(): unknown[][];

package/dist/runtime.d.ts

@@ -1,6 +0,0 @@
-export declare const runtime: import('./makeRuntime.ts').Runtime;
-/**
- * "customElement" needs to be exported - it will be used by the build system.
- * You should not call it directly.
- */
-export declare const customElement: (tagName: string, component: typeof import('./LitElement.ts').LitElement) => void;