@arcgis/lumina 5.0.0-next.8 → 5.0.0-next.81

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/LitElement.d.ts

@@ -1,10 +1,10 @@
 import { CSSResultGroup, CSSResultOrNative, PropertyValues, ReactiveController, LitElement as OriginalLitElement } from 'lit';
-import { Runtime } from './makeRuntime';
-import { ProxyComponent } from './lazyLoad';
-import { ToElement } from './jsx/types';
-import { BaseController, LuminaPropertyDeclaration } from './controllers/types';
-import { ControllerManager } from './controllers/ControllerManager';
-import { Controller } from './controllers/Controller';
+import { Runtime } from './makeRuntime.ts';
+import { ProxyComponent } from './lazyLoad.ts';
+import { ToElement } from './jsx/types.ts';
+import { BaseController, LuminaPropertyDeclaration } from './controllers/types.ts';
+import { ControllerManager } from './controllers/ControllerManager.ts';
+import { Controller } from './controllers/Controller.ts';
 type ComponentLifecycle = {
     connectedCallback?: () => void;
     disconnectedCallback?: () => void;

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/Controller.d.ts

@@ -1,8 +1,8 @@
 import { Deferred } from '@arcgis/toolkit/promise';
-import { BaseController, ControllerLifecycleMethods, controllerSymbol } from './types';
-import { use, useRef, useRefSync } from './ControllerInternals';
+import { BaseController, ControllerLifecycleMethods, controllerSymbol } from './types.ts';
+import { use, useRef, useRefSync } from './ControllerInternals.ts';
 import { PropertyValues } from 'lit';
-import { LitElement } from '../LitElement';
+import { LitElement } from '../LitElement.ts';
 /**
  * Base class for Controllers defined using a class rather than a function.
  * Defining controller using makeController() function is more succinct for smaller

package/dist/controllers/ControllerInternals.d.ts

@@ -1,6 +1,6 @@
-import { Controller } from './Controller';
-import { BaseController } from './types';
-import { LitElement } from '../LitElement';
+import { Controller } from './Controller.ts';
+import { BaseController } from './types.ts';
+import { LitElement } from '../LitElement.ts';
 export declare const setAmbientComponent: (component: LitElement) => void;
 export declare const retrieveComponent: (name?: string) => LitElement;
 export declare const setParentController: (controller: BaseController | undefined) => void;
@@ -22,11 +22,11 @@ export declare let shouldBypassReadOnly: boolean;
 /**
  * Permits updating read-only properties
  *
- * @see https://qawebgis.esri.com/components/lumina/properties#read-only-properties
+ * @see https://webgis.esri.com/references/lumina/properties#read-only-properties
  */
 export declare const bypassReadOnly: <T = void>(callback: () => T) => T | void;
 /**
- * @deprecated see https://qawebgis.esri.com/components/lumina/properties#get-set-properties
+ * @deprecated see https://webgis.esri.com/references/lumina/properties#get-set-properties
  */
 export declare const bypassSetter: <T = void>(callback: () => T) => T | void;
 /**

package/dist/controllers/ControllerManager.d.ts

@@ -1,7 +1,7 @@
-import { BaseController } from './types';
-import { GenericController } from './Controller';
+import { BaseController } from './types.ts';
+import { GenericController } from './Controller.ts';
 import { PropertyValues } from 'lit';
-import { LitElement } from '../LitElement';
+import { LitElement } from '../LitElement.ts';
 /**
  * A manager for all other controllers. It finds all controllers on the
  * component, loads them, and forwards lifecycle events to them.
@@ -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.d.ts

@@ -1,4 +1,4 @@
-export { reEmitEvent } from './reEmitEvent';
-export { makeAccessorController, AccessorController, reCreateAccessor, makeBinderProxy, getAccessorControllerBoundProperties, } from './useAccessor';
-export { createStore, createLegacyStore } from './store';
-export type { ObservableMap } from './store';
+export { reEmitEvent } from './reEmitEvent.ts';
+export { makeAccessorController, AccessorController, reCreateAccessor, makeBinderProxy, getAccessorControllerBoundProperties, } from './useAccessor.ts';
+export { createStore, createLegacyStore } from './store.ts';
+export type { ObservableMap } from './store.ts';

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/accessor/reEmitEvent.d.ts

@@ -1,4 +1,4 @@
-import { EventEmitter } from '../../createEvent';
+import { EventEmitter } from '../../createEvent.ts';
 /**
  * Re-emit an event from the accessor instance on the component
  *

package/dist/controllers/accessor/store.d.ts

@@ -1,6 +1,6 @@
 import { default as Accessor } from '@arcgis/core/core/Accessor.js';
 /**
- * See https://qawebgis.esri.com/components/lumina/controllers/useAccessor#createstore-utility
+ * See https://webgis.esri.com/references/lumina/controllers/useAccessor#createstore-utility
  */
 export declare const createStore: <T extends object>(initializer: T | (() => T)) => __esri.Accessor & T;
 /** @deprecated Use {@link createStore} instead */

package/dist/controllers/accessor/useAccessor.d.ts

@@ -1,5 +1,5 @@
-import { GenericController } from '../Controller';
-import { LitElement } from '../../LitElement';
+import { GenericController } from '../Controller.ts';
+import { LitElement } from '../../LitElement.ts';
 type Requires<Props, Accessor extends __esri.Accessor, OmitProps extends string = never> = LitElement & Omit<Pick<Accessor, keyof Accessor & keyof Props>, AlwaysOmit | OmitProps> & {
     autoDestroyDisabled: boolean;
     destroy: () => Promise<void>;
@@ -9,7 +9,7 @@ type AlwaysOmit = "addHandles" | "declaredClass" | "destroyed" | "hasHandles" |
  * Given an Accessor class, create a controller that will do two-way binding of
  * props between the component and the Accessor.
  *
- * See https://qawebgis.esri.com/components/lumina/controllers/useAccessor for
+ * See https://webgis.esri.com/references/lumina/controllers/useAccessor for
  * documentation & examples.
  */
 export declare const makeAccessorController: <Props, Accessor extends __esri.Accessor, OmitProps extends string = never>(createInstance: ((props?: Props) => Accessor) | (new (props?: Props) => Accessor), _options?: {

package/dist/controllers/functional.d.ts

@@ -1,5 +1,5 @@
-import { LitElement } from '../LitElement';
-import { GenericControllerType, Controller } from './Controller';
+import { LitElement } from '../LitElement.ts';
+import { GenericControllerType, Controller } from './Controller.ts';
 /**
  * Controller is a function that takes a component instance and then can
  * export some values to the component, or hook into component's lifecycle

package/dist/controllers/index.d.ts

@@ -1,23 +1,24 @@
-import { EventEmitter as _EventEmitter } from '../createEvent';
-export type { GenericControllerType } from './Controller';
-export { Controller, GenericController } from './Controller';
-export type { ControllerManager } from './ControllerManager';
-export { retrieveComponent, bypassSetter, bypassReadOnly } from './ControllerInternals';
-export { trackPropertyKey, propertyTrackResolve } from './trackPropertyKey';
-export { trackPropKey } from './trackPropKey';
-export { trackKey } from './trackKey';
-export { makeController, makeGenericController } from './functional';
-export { useWatchAttributes } from './useWatchAttributes';
-export { load } from './load';
-export { proxyExports } from './proxyExports';
-export { toFunction } from './toFunction';
-export * from './types';
-export { useMedia } from './useMedia';
-export { useDirection } from './useDirection';
-export type { UseT9n, T9nMeta } from './useT9n';
-export { makeT9nController } from './useT9n';
-export { usePropertyChange } from './usePropertyChange';
-export { isController, getControllersCount } from './utils';
+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';
+export { retrieveComponent, bypassSetter, bypassReadOnly } from './ControllerInternals.ts';
+export { trackPropertyKey, propertyTrackResolve } from './trackPropertyKey.ts';
+export { trackPropKey } from './trackPropKey.ts';
+export { trackKey } from './trackKey.ts';
+export { makeController, makeGenericController } from './functional.ts';
+export { useWatchAttributes } from './useWatchAttributes.ts';
+export { load } from './load.ts';
+export { proxyExports } from './proxyExports.ts';
+export { toFunction } from './toFunction.ts';
+export * from './types.ts';
+export { useMedia } from './useMedia.ts';
+export { useDirection } from './useDirection.ts';
+export type { UseT9n, T9nMeta } from './useT9n.ts';
+export { makeT9nController } from './useT9n.ts';
+export { usePropertyChange } from './usePropertyChange.ts';
+export { isController, getControllersCount } from './utils.ts';
 /**
  * @deprecated import from "@arcgis/lumina" instead
  */
@@ -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,
@@ -197,10 +198,12 @@ const deepMerge = (original, overwrites) => {
   }
   const merged = { ...original };
   Object.entries(overwrites).forEach(([key, value]) => {
-    if (typeof value === "object") {
-      merged[key] = deepMerge(original[key], value);
-    } else {
-      merged[key] = value ?? original[key];
+    if (original[key] !== void 0) {
+      if (typeof value === "object") {
+        merged[key] = deepMerge(original[key], value);
+      } else {
+        merged[key] = value ?? original[key];
+      }
     }
   });
   return merged;
@@ -249,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/controllers/load.d.ts

@@ -1,6 +1,6 @@
 /**
  * Load a value from a promise and provide it to the component
  *
- * Documentation: https://qawebgis.esri.com/components/lumina/controllers/load
+ * Documentation: https://webgis.esri.com/references/lumina/controllers/load
  */
 export declare const load: <T>(loader: () => Promise<T>) => T;

package/dist/controllers/proxyExports.d.ts

@@ -1,5 +1,5 @@
-import { Controller } from './Controller';
-import { ControllerLifecycleMethods } from './types';
+import { Controller } from './Controller.ts';
+import { ControllerLifecycleMethods } from './types.ts';
 /**
  * If you wish to directly expose the "exports" property of your controller,
  * rather than the entire controller class, wrap your class definition in

package/dist/controllers/trackKey.d.ts

@@ -1,5 +1,5 @@
-import { LitElement } from '../LitElement';
-import { BaseController, TrackKeyResolution } from './types';
+import { LitElement } from '../LitElement.ts';
+import { BaseController, TrackKeyResolution } from './types.ts';
 /**
  * A combination of trackPropertyKey() and trackPropKey(). For usage when
  * you want to track a property, but don't know if it will be defined with the

package/dist/controllers/trackPropKey.d.ts

@@ -1,4 +1,4 @@
-import { LitElement } from '../LitElement';
+import { LitElement } from '../LitElement.ts';
 /**
  * Like trackPropertyKey(), but for props that have \@state() or \@property()
  * decorator

package/dist/controllers/trackPropertyKey.d.ts

@@ -1,5 +1,5 @@
-import { LitElement } from '../LitElement';
-import { BaseController } from './types';
+import { LitElement } from '../LitElement.ts';
+import { BaseController } from './types.ts';
 /**
  * A magical solution to finding out what property name a given controller
  * on a given object was assigned to.

package/dist/controllers/types.d.ts

@@ -1,6 +1,6 @@
 import { IHandle } from '@arcgis/toolkit/type';
 import { ReactiveControllerHost, ReactiveController, PropertyDeclaration, PropertyValues } from 'lit';
-import { LitElement } from '../LitElement';
+import { LitElement } from '../LitElement.ts';
 export type TrackKeyResolution = {
     readonly key: string;
     readonly host: BaseController | LitElement;

package/dist/controllers/useDirection.d.ts

@@ -3,7 +3,7 @@ type Direction = "ltr" | "rtl";
  * Finds the closest "dir" attribute to current component and returns it's value.
  * Watches for changes to "dir" and will re-render your component if needed.
  *
- * Documentation: https://qawebgis.esri.com/components/lumina/controllers/useDirection
+ * Documentation: https://webgis.esri.com/references/lumina/controllers/useDirection
  *
  * Design decisions: https://devtopia.esri.com/WebGIS/arcgis-web-components/discussions/987
  */

package/dist/controllers/useMedia.d.ts

@@ -3,6 +3,6 @@
  * whether user asked to use reduced motion, or whether the screen size is above
  * certain threshold).
  *
- * Documentation: https://qawebgis.esri.com/components/lumina/controllers/useMedia
+ * Documentation: https://webgis.esri.com/references/lumina/controllers/useMedia
  */
 export declare const useMedia: (query: string) => boolean;

package/dist/controllers/usePropertyChange.d.ts

@@ -1,12 +1,12 @@
-import { EventEmitter } from '../createEvent';
-import { LitElement } from '../LitElement';
+import { EventEmitter } from '../createEvent.ts';
+import { LitElement } from '../LitElement.ts';
 type PropertyChangeController<Component extends LitElement> = <ToWatch extends keyof Component>(...toWatch: ToWatch[]) => EventEmitter<{
     name: ToWatch & string;
 }>;
 /**
  * Let user easily set watchers for component properties.
  *
- * Documentation: https://qawebgis.esri.com/components/lumina/controllers/usePropertyChange
+ * Documentation: https://webgis.esri.com/references/lumina/controllers/usePropertyChange
  */
 export declare const usePropertyChange: <Component extends LitElement>(
 /** Needed for typings only */

package/dist/controllers/useT9n.d.ts

@@ -38,7 +38,7 @@ export interface UseT9n {
 /**
  * Load component's localization strings.
  *
- * Documentation: https://qawebgis.esri.com/components/lumina/controllers/useT9n
+ * Documentation: https://webgis.esri.com/references/lumina/controllers/useT9n
  *
  * Design decisions:
  * - https://devtopia.esri.com/WebGIS/arcgis-web-components/discussions/969

package/dist/controllers/useWatchAttributes.d.ts

@@ -1,7 +1,7 @@
-import { Controller } from './Controller';
+import { Controller } from './Controller.ts';
 /**
  * Watch when given attributes change on the component element.
  *
- * Documentation: https://qawebgis.esri.com/components/lumina/controllers/useWatchAttributes
+ * Documentation: https://webgis.esri.com/references/lumina/controllers/useWatchAttributes
  */
 export declare const useWatchAttributes: <T extends string>(attributes: readonly T[], callback: (newValue: string | null, oldValue: string | null, attribute: T) => void) => Controller;

package/dist/controllers/utils.d.ts

@@ -1,5 +1,5 @@
-import { LitElement } from '../LitElement';
-import { ControllerLifecycleMethods } from './types';
+import { LitElement } from '../LitElement.ts';
+import { ControllerLifecycleMethods } from './types.ts';
 export declare const isController: (value: unknown) => value is ControllerLifecycleMethods;
 /**
  * Checks if the argument is a promise by checking if it has a `then` method.

package/dist/createEvent.d.ts

@@ -32,7 +32,7 @@ export type EventOptions = {
      */
     composed?: boolean;
 };
-export declare const createEventFactory: <T = void>(eventName?: string, options?: EventOptions, component?: import('./LitElement').LitElement) => EventEmitter<T>;
+export declare const createEventFactory: <T = void>(eventName?: string, options?: EventOptions, component?: import('./LitElement.ts').LitElement) => EventEmitter<T>;
 /**
  * Creates an event emitter.
  * Events emitted by your component will be included in the documentation.

package/dist/decorators.d.ts

@@ -1,4 +1,4 @@
-import { LuminaPropertyDeclaration } from './controllers/types';
+import { LuminaPropertyDeclaration } from './controllers/types.ts';
 export { state } from 'lit/decorators/state.js';
 /**
  * A class field or accessor decorator which creates a reactive property that

package/dist/devOnlyDetectIncorrectLazyUsages.d.ts

@@ -1,4 +1,4 @@
-import { LitElement } from './LitElement';
+import { LitElement } from './LitElement.ts';
 /**
  * When in lazy-build, the actual Lit element is never attached to the DOM.
  * Instead, a proxy element is present and should be used for all DOM actions.

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) => {