@arcgis/lumina 5.2.0-next.2 → 5.2.0-next.21

package/dist/context.d.ts

@@ -1,36 +1,36 @@
-import { ContextConsumer, ContextProvider, Context, ContextType } from '@lit/context';
-import { ReactiveControllerHost } from 'lit';
-interface ContextProviderOptions<C extends Context<unknown, unknown>> {
-    context: C;
-    initialValue?: ContextType<C>;
+import type { ContextConsumer, ContextProvider, Context, ContextType } from "@lit/context";
+import type { ReactiveControllerHost } from "lit";
+
+export interface ContextProviderOptions<C extends Context<unknown, unknown>> {
+  context: C;
+  initialValue?: ContextType<C>;
 }
-interface ContextConsumerOptions<C extends Context<unknown, unknown>> {
-    context: C;
-    callback?: (value: ContextType<C>, dispose?: () => void) => void;
-    subscribe?: boolean;
+
+export interface ContextConsumerOptions<C extends Context<unknown, unknown>> {
+  context: C;
+  /**
+   * @param value
+   * @param dispose
+   */
+  callback?(value: ContextType<C>, dispose?: () => void): void;
+  subscribe?: boolean;
 }
+
 /**
  * Wrapper for Lit's ContextProvider controller to provide lazy-loading compatibility.
  *
+ * @param options
  * @see https://lit.dev/docs/data/context/
  */
-export declare const useContextProvider: <C extends Context<unknown, unknown>>(options: ContextProviderOptions<C>) => ContextProvider<C>;
+export function useContextProvider<C extends Context<unknown, unknown>>(options: ContextProviderOptions<C>): ContextProvider<C>;
+
 /**
  * Wrapper for Lit's ContextConsumer controller to provide lazy-loading compatibility.
  *
+ * @param options
  * @see https://lit.dev/docs/data/context/
- *
- * FEATURE: wrap this in proxyExports to improve DX, or keep it simple?
- */
-export declare const useContextConsumer: <C extends Context<unknown, unknown>>(options: ContextConsumerOptions<C>) => ContextConsumer<C, LitContextHost>;
-/**
- * Lit context wasn't written with lazy loading proxy in mind. For it to
- * work correctly, we must provide the DOM-attached element as the host element.
- * Events will be fired/listened on it.
- *
- * At the same time, .addController() and .requestUpdate() methods will be
- * called on it. We had to implement these on the lazy proxy to redirect the
- * calls to the actual LitElement.
  */
-type LitContextHost = HTMLElement & ReactiveControllerHost;
-export {};
+export function useContextConsumer<C extends Context<unknown, unknown>>(options: ContextConsumerOptions<C>): ContextConsumer<C, LitContextHost>;
+
+export type LitContextHost = HTMLElement
+  & ReactiveControllerHost;

package/dist/controllers/Controller.d.ts

@@ -1,145 +1,112 @@
-import { Deferred } from '@arcgis/toolkit/promise';
-import { BaseController, ControllerLifecycleMethods, controllerSymbol } from './types.ts';
-import { use, useRef, useRefSync } from './ControllerInternals.ts';
-import { PropertyValues } from 'lit';
-import { LitElement } from '../LitElement.ts';
+import type { ControllerLifecycleMethods } from "./types.js";
+import type { NotNever, InferController } from "./ControllerInternals.js";
+import type { LitElement } from "../LitElement.js";
+
 /**
  * Base class for Controllers defined using a class rather than a function.
  * Defining controller using makeController() function is more succinct for smaller
  * controllers. For controllers that need to declare several methods, or need
  * more flexibility, this class may be used
  */
-export declare abstract class Controller<Exports = never> implements BaseController {
-    #private;
-    /** @private */
-    protected __ready: Deferred<Exports>;
-    /** @private */
-    __assignedProperty?: string | false;
-    connectedCalled: boolean;
-    loadedCalled: boolean;
-    readonly [controllerSymbol] = true;
-    component: LitElement;
-    ready: Promise<Exports>;
-    constructor(component?: LitElement);
-    /**
-     * If controller is being added dynamically, after the component
-     * construction, then trigger connected and load right away
-     */
-    catchUpLifecycle(): void;
-    get exports(): Exports;
-    /**
-     * Set controller's exports property (for usage with proxyExports()) and mark
-     * controller as ready (for usage in other controllers). Also, triggers
-     * re-render of the component
-     */
-    set exports(exports: Exports);
-    /**
-     * If controller needs to await a promise before it's exports are fully ready
-     * but it wishes to make some limited exports available before then,
-     * this method can be used.
-     *
-     * This is useful for permitting a limited usage of the controller in default
-     * values of properties or in component constructor.
-     *
-     * In order to help detect bugs, trying to access a prop on the exports value
-     * that does not exist will throw an error (in development only). This is
-     * useful to detect usages of controller that forgot to await it's exports.
-     * (the "value in this.myController" check won't cause an exception though)
-     *
-     * @param proxy [true] - whether to throw an error if unknown property is
-     *   accessed before the controller is loaded.
-     */
-    setProvisionalExports(exports: Exports, proxy?: boolean): void;
-    setProvisionalExports(exports: Exports extends object ? Partial<Exports> : Exports, proxy?: boolean): void;
-    setProvisionalExports<Props extends keyof Exports>(exports: Pick<Exports, Props>, proxy?: boolean): void;
-    watchExports(callback: (exports: Exports) => void): () => void;
-    /**
-     * A flexible utility for making sure a controller is loaded before it's used,
-     * regardless of how or where a controller was defined:
-     *
-     * @example
-     * makeGenericController(async (component, controller) => {
-     *   // Await some controller from the component:
-     *   await controller.use(component.someController);
-     *   // Initialize new controllers
-     *   await controller.use(load(importCoreReactiveUtils));
-     *   await controller.use(new ViewModelController(component,newWidgetsHomeHomeViewModel));
-     *   await controller.use(someController(component));
-     * });
-     *
-     * @remarks
-     * If your controller is not async, and you are not creating it async, then
-     * you are not required to use controller.use - you can use it directly.
-     * Similarly, accessing controllers after componentWillLoad callback does not
-     * require awaiting them as they are guaranteed to be loaded by then.
-     */
-    get use(): typeof use;
-    /**
-     * Just like controller.use, but returns the controller itself, rather than it's
-     * exports
-     *
-     * Use cases:
-     * - You have a controller and you want to make sure it's loaded before you
-     *   try to use it
-     * - Your controller is not using exports, so you wish to access some props on
-     *   it directly
-     * - You have a controller exports only, and you want to retrieve the
-     *   controller itself. This is useful if you wish to call .watchExports() or
-     *   some other method on the controller
-     */
-    get useRef(): typeof useRef;
-    /**
-     * Like useRef, but doesn't wait for the controller to get ready
-     *
-     * @private
-     */
-    get useRefSync(): typeof useRefSync;
-    controllerRemoved(): void;
-    onConnected(callback: NonNullable<ControllerLifecycleMethods["hostConnected"]>): void;
-    onDisconnected(callback: NonNullable<ControllerLifecycleMethods["hostDisconnected"]>): void;
-    onLoad(callback: NonNullable<ControllerLifecycleMethods["hostLoad"]>): void;
-    onLoaded(callback: NonNullable<ControllerLifecycleMethods["hostLoaded"]>): void;
-    onUpdate(callback: NonNullable<ControllerLifecycleMethods["hostUpdate"]>): void;
-    onUpdated(callback: NonNullable<ControllerLifecycleMethods["hostUpdated"]>): void;
-    onDestroy(callback: NonNullable<ControllerLifecycleMethods["hostDestroy"]>): void;
-    onLifecycle(callback: NonNullable<ControllerLifecycleMethods["hostLifecycle"]>): void;
-    /** @private */
-    triggerConnected(): void;
-    /** @private */
-    triggerDisconnected(): void;
-    /** @private */
-    triggerLoad(): Promise<void>;
-    /** @private */
-    triggerLoaded(): void;
-    /** @private */
-    triggerUpdate(changes: PropertyValues): void;
-    /** @private */
-    triggerUpdated(changes: PropertyValues): void;
-    /** @private */
-    triggerDestroy(): void;
-    /** @private */
-    triggerLifecycle(): void;
-}
-export declare abstract class GenericControllerType<Exports, Requires = LitElement> extends Controller<Exports> {
-    component: LitElement & Requires;
-    constructor(component: LitElement & Requires);
-}
-/**
- * If your controller requires some specific properties to be present on the
- * component, besides what's included in LitElement, use
- * GenericController over the usual Controller. Use the 2nd generic argument
- * on this class for specifying what properties your controller expects on the
- * component
- *
- * When using a controller created using GenericController, consumer must
- * pass in "this" explicitly to the constructor. If controller was
- * created using Controller, that is not necessary
- *
- * @remarks
- * GenericController class is identical to Controller class in all but typing.
- * That is why, at runtime GenericController is actually equal to Controller
- * class.
- * You can use GenericControllerType type if you wish to reference generic
- * controller instance type.
- */
-export declare const GenericController: typeof GenericControllerType;
+export abstract class Controller<Exports = never> {
+  constructor(component?: LitElement);
+  component: LitElement;
+  /** @default false */
+  connectedCalled: boolean;
+  /**
+   * Setting .exports set controller's exports property for usage with
+   * proxyExports() and marks the controller as ready for usage in other
+   * controllers. Also, this triggers re-render of the component.
+   */
+  accessor exports: Exports;
+  /** @default false */
+  loadedCalled: boolean;
+  ready: Promise<Exports>;
+  /**
+   * A flexible utility for making sure a controller is loaded before it's used,
+   * regardless of how or where a controller was defined:
+   *
+   * If your controller is not async, and you are not creating it inside async
+   * function, then you are not required to use controller.use - you can create
+   * controller directly. Similarly, accessing controllers after
+   * componentWillLoad callback does not require awaiting them as they are
+   * guaranteed to be loaded by then.
+   *
+   * @example
+   * makeGenericController(async (component, controller) => {
+   *   // Await some controller from the component:
+   *   await controller.use(component.someController);
+   *   // Initialize new controllers
+   *   await controller.use(load(importCoreReactiveUtils));
+   *   await controller.use(new ViewModelController(component,newWidgetsHomeHomeViewModel));
+   *   await controller.use(someController(component));
+   * });
+   */
+  get use(): <Value>(value: Value, watchExports?: (value: NotNever<InferController<Value>>, unsubscribe: () => void) => void) => Promise<NotNever<InferController<Value>>>;
+  /**
+   * Just like controller.use, but returns the controller itself, rather than it's
+   * exports
+   *
+   * Use cases:
+   * - You have a controller and you want to make sure it's loaded before you
+   *   try to use it
+   * - Your controller is not using exports, so you wish to access some props on
+   *   it directly
+   * - You have a controller exports only, and you want to retrieve the
+   *   controller itself. This is useful if you wish to call .watchExports() or
+   *   some other method on the controller
+   */
+  get useRef(): <Value>(value: Value) => Promise<InferController<Value>>;
+  /** @internal */
+  controllerRemoved(): void;
+  /**
+   * Register a connected lifecycle callback
+   *
+   * @param callback
+   */
+  onConnected(callback: NonNullable<ControllerLifecycleMethods["hostConnected"]>): void;
+  /** @param callback */
+  onDestroy(callback: NonNullable<ControllerLifecycleMethods["hostDestroy"]>): void;
+  /** @param callback */
+  onDisconnected(callback: NonNullable<ControllerLifecycleMethods["hostDisconnected"]>): void;
+  /** @param callback */
+  onLifecycle(callback: NonNullable<ControllerLifecycleMethods["hostLifecycle"]>): void;
+  /** @param callback */
+  onLoad(callback: NonNullable<ControllerLifecycleMethods["hostLoad"]>): void;
+  /** @param callback */
+  onLoaded(callback: NonNullable<ControllerLifecycleMethods["hostLoaded"]>): void;
+  /** @param callback */
+  onUpdate(callback: NonNullable<ControllerLifecycleMethods["hostUpdate"]>): void;
+  /** @param callback */
+  onUpdated(callback: NonNullable<ControllerLifecycleMethods["hostUpdated"]>): void;
+  /**
+   * If controller needs to await a promise before it's exports are fully ready
+   * but it wishes to make some limited exports available before then,
+   * this method can be used.
+   *
+   * This is useful for permitting a limited usage of the controller in default
+   * values of properties or in component constructor.
+   *
+   * In order to help detect bugs, trying to access a prop on the exports value
+   * that does not exist will throw an error (in development only). This is
+   * useful to detect usages of controller that forgot to await it's exports.
+   * (the "value in this.myController" check won't cause an exception though)
+   *
+   * @param exports
+   * @param proxy - whether to throw an error if unknown property is
+   *   accessed before the controller is loaded.
+   */
+  setProvisionalExports(exports: Exports, proxy?: boolean): void;
+  /**
+   * @param exports
+   * @param proxy
+   */
+  setProvisionalExports(exports: Exports extends object ? Partial<Exports> : Exports, proxy?: boolean): void;
+  /**
+   * @param exports
+   * @param proxy
+   */
+  setProvisionalExports<Props extends keyof Exports>(exports: Pick<Exports, Props>, proxy?: boolean): void;
+  /** @param callback */
+  watchExports(callback: (exports: Exports) => void): () => void;
+}

package/dist/controllers/ControllerInternals.d.ts

@@ -1,30 +1,42 @@
-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;
+import type { Controller } from "./Controller.js";
+import type { BaseController } from "./types.js";
+import type { LitElement } from "../LitElement.js";
+
 /**
- * Get references to controllers this nested controller might have been called
- * from. The list may include extra controllers, but at least one of them or
- * the component itself is the parent for this controller.
+ * Allow controllers to implicitly retrieve which component they are in, to
+ * improve DX (avoids the need to pass "this" explicitly for each controller)
+ *
+ * All controllers on the page share a single instance of ControllerInternals
+ * class. However, this does not cause a conflict. This variable is set at
+ * the very beginning of a component constructor, and is unset at the very
+ * next microtask. This way, when controllers are being initialized in the
+ * component constructor, this is pointing to the correct component. And, on
+ * the very next tick the reference to the component is cleared, to prevent
+ * memory leaks and to prevent anyone from accessing this value when they
+ * are not supposed to.
+ *
+ * @param component
+ * @internal
  */
-export declare const retrieveParentControllers: () => readonly BaseController[];
-export declare const setAmbientChildController: (controller: BaseController | undefined) => void;
+export function setAmbientComponent(component: LitElement): void;
+
 /**
- * The type definition has to be duplicated due to this TypeScript error:
- * "'use' is referenced directly or indirectly in its own type annotation."
+ * Get a reference to a custom element. This is only reliably available during
+ * component's constructor execution. Controllers are invoked during that
+ * stage.
+ *
+ * @param name
  */
-export declare const use: <Value>(value: Value, watchExports?: (value: NotNever<InferController<Value>>, unsubscribe: () => void) => void) => Promise<NotNever<InferController<Value>>>;
-export declare const useRef: <Value>(value: Value) => Promise<InferController<Value>>;
-export declare const useRefSync: <Value>(value: Value) => InferController<Value> | undefined;
-export declare let shouldBypassReadOnly: boolean;
+export function retrieveComponent(name?: string): LitElement;
+
 /**
  * Permits updating read-only properties
  *
+ * @param callback
  * @see https://webgis.esri.com/references/lumina/properties#read-only-properties
  */
-export declare const bypassReadOnly: <T = void>(callback: () => T) => T | void;
+export function bypassReadOnly<T = void>(callback: () => T): T | void;
+
 /**
  * If passed value is a controller, then return it. Otherwise, assume it's a
  * proxyExports() result and wrap it into a controller
@@ -32,18 +44,14 @@ export declare const bypassReadOnly: <T = void>(callback: () => T) => T | void;
  * This won't type correctly if a proxyExports() controller is exporting a
  * non-proxyExports() controller
  */
-type InferController<ControllerOrExports> = ControllerOrExports extends BaseController ? ControllerOrExports & {
+export type InferController<ControllerOrExports> = ControllerOrExports extends BaseController ? ControllerOrExports & {
     exports?: unknown;
     ready?: Promise<void>;
     watchExports?: Controller["watchExports"];
 } : Controller<ControllerOrExports>;
+
 /**
  * If controller never sets its exports, then its default exports is "this".
  * This allows usage of controller.use with controllers that don't have exports
  */
-type NotNever<T extends {
-    exports?: any;
-}> = T extends {
-    exports: never;
-} ? T : T["exports"];
-export {};
+export type NotNever<T extends { exports?: any; }> = T extends { exports: never; } ? T : T["exports"];

package/dist/controllers/ControllerManager.d.ts

@@ -1,66 +1,45 @@
-import { BaseController } from './types.ts';
-import { GenericController } from './Controller.ts';
-import { PropertyValues } from 'lit';
-import { LitElement } from '../LitElement.ts';
+import type { PropertyValues } from "lit";
+import type { LitElement } from "../LitElement.js";
+import type { GenericController } from "./GenericController.js";
+
 /**
  * A manager for all other controllers. It finds all controllers on the
  * component, loads them, and forwards lifecycle events to them.
  */
-export declare class ControllerManager extends GenericController<undefined> {
-    #private;
-    hasDestroy: boolean;
-    destroyed: boolean;
-    constructor(component: LitElement);
-    /**
-     * Throws an error if component does not implement destroy() lifecycle, but
-     * tries to use it. This check is only present in development mode
-     *
-     * @private
-     */
-    devOnly$ensureHasDestroy?: () => void;
-    destroy(): Promise<void>;
-    /** @private */
-    _setAutoDestroyTimeout(): void;
-    /**
-     * "readOnly" is not enabled initially since we need to allow to set property
-     * default values in the constructor.
-     *
-     * @private
-     */
-    _isEnforcingReadonly: boolean;
-    /** @private */
-    _trackedValue: unknown;
-    /** @private */
-    _keyTrackers: ((key: string | undefined, value: unknown) => void)[];
-    /** @private */
-    _firePropTrackers(key: string | undefined, value: unknown): void;
-    /**
-     * Map with keys for any properties that have changed since the last
-     * update cycle with previous values.
-     *
-     * Do not access this directly as this value is only set during the update
-     * lifecycle. Instead, use the `changes` property that is provided
-     * to the shouldUpdate(), willUpdate() and updated() lifecycle hooks.
-     *
-     * @private
-     */
-    _changedProperties?: PropertyValues;
-    /**
-     * Associate an exports object with a controller for reverse lookup in
-     * controller.use
-     *
-     * @private
-     */
-    _markExports(controller: BaseController, exports: unknown): void;
-    /** @private */
-    _resolveExports(exports: unknown): BaseController | undefined;
+export class ControllerManager extends GenericController<undefined> {
+  constructor(component: LitElement);
+  /**
+   * Map with keys for any properties that have changed since the last
+   * update cycle with previous values.
+   *
+   * Do not access this directly as this value is only set during the update
+   * lifecycle. Instead, use the `changes` property that is provided
+   * to the shouldUpdate(), willUpdate() and updated() lifecycle hooks.
+   *
+   * @internal
+   */
+  _changedProperties?: PropertyValues;
+  /** @default false */
+  destroyed: boolean;
+  /**
+   * Throws an error if component does not implement destroy() lifecycle, but
+   * tries to use it. This check is only present in development mode
+   *
+   * @internal
+   */
+  devOnly$ensureHasDestroy?: () => void;
+  hasDestroy: boolean;
+  destroy(): Promise<void>;
 }
-export declare let autoDestroyOnDisconnectTimeout: number;
-export declare const autoDestroyDisabledPropName = "autoDestroyDisabled";
-export declare function setAutoDestroyOnDisconnectTimeout(timeout: number): void;
-export type LuminaLifecycles = {
-    connectedCallback?: LitElement["connectedCallback"];
-    disconnectedCallback?: LitElement["disconnectedCallback"];
-    load?: () => Promise<void> | void;
-    loaded?: () => void;
-};
+
+/**
+ * @default 1000
+ * @internal
+ */
+export const autoDestroyOnDisconnectTimeout: number;
+
+/**
+ * @param timeout
+ * @internal
+ */
+export function setAutoDestroyOnDisconnectTimeout(timeout: number): void;

package/dist/controllers/GenericController.d.ts

@@ -0,0 +1,26 @@
+import type { LitElement } from "../LitElement.js";
+import type { Controller } from "./Controller.js";
+
+export abstract class GenericControllerType<Exports, Requires = LitElement> extends Controller<Exports> {
+  constructor(component: LitElement & Requires);
+  component: LitElement & Requires;
+}
+
+/**
+ * If your controller requires some specific properties to be present on the
+ * component, besides what's included in LitElement, use
+ * GenericController over the usual Controller. Use the 2nd generic argument
+ * on this class for specifying what properties your controller expects on the
+ * component
+ *
+ * When using a controller created using GenericController, consumer must
+ * pass in "this" explicitly to the constructor. If controller was
+ * created using Controller, that is not necessary
+ *
+ * GenericController class is identical to Controller class in all but typing.
+ * That is why, at runtime GenericController is actually equal to Controller
+ * class.
+ * You can use GenericControllerType type if you wish to reference generic
+ * controller instance type.
+ */
+export const GenericController: typeof GenericControllerType;

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

@@ -1,4 +1,6 @@
-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';
+export { reEmitEvent } from "./reEmitEvent.js";
+export { makeAccessorController, AccessorController, reCreateAccessor, makeBinderProxy, getAccessorControllerBoundProperties } from "./useAccessor.js";
+export { type AccessorControllerRequires } from "./useAccessor.js";
+export { createStore, createLegacyStore } from "./store.js";
+export { type ObservableMap } from "./store.js";
+

package/dist/controllers/accessor/index.js

@@ -1,8 +1,8 @@
 import { isEsriInternalEnv } from "@arcgis/toolkit/error";
 import { r as retrieveComponent } from "../../ControllerInternals-CeDntN3G.js";
 import { on, watch } from "@arcgis/core/core/reactiveUtils.js";
-import { a as createEventFactory, G as GenericController, b as trackPropKey, t as trackKey } from "../../Controller-Cer_6Z29.js";
-import { p as proxyExports } from "../../proxyExports-BkN6hND0.js";
+import { a as createEventFactory, G as GenericController, b as trackPropKey, t as trackKey } from "../../GenericController-C8NSb50b.js";
+import { p as proxyExports } from "../../proxyExports-ZRLty8oJ.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";
@@ -20,6 +20,11 @@ const reEmitEvent = (getEventedAccessor, eventName) => {
 };
 const makeAccessorController = (createInstance, _options) => (component) => proxy(component, createInstance);
 class AccessorController extends GenericController {
+  /**
+   * @public
+   * @param component
+   * @param createInstance
+   */
   constructor(component, createInstance) {
     super(component);
     this.Y = /* @__PURE__ */ new Map();
@@ -73,6 +78,7 @@ class AccessorController extends GenericController {
   #isInstanceOwner;
   #exportsObservable;
   #createInstance;
+  /** @public */
   get exports() {
     trackAccess(this.#exportsObservable);
     return super.exports;
@@ -81,17 +87,29 @@ class AccessorController extends GenericController {
     super.exports = value;
     this.#exportsObservable.notify();
   }
-  /** @private */
   Z() {
     const that = this;
     that.instance = "prototype" in that.#createInstance && "declaredClass" in that.#createInstance.prototype ? new that.#createInstance() : that.#createInstance();
     that.#isInstanceOwner = true;
   }
+  /**
+   * If you subclass this controller and override this method, make sure to call
+   * super.hostConnected();
+   * @public
+   * @privateRemarks
+   * We expose this only so that subclasses remember to call `super`.
+   */
   hostConnected() {
     this.exports = this.instance;
   }
-  // FEATURE: is there a way to detect that accessor does not need to be destroyed?
-  //   Is it possible to write accessors that don't need to be destroyed?
+  /**
+   * If you subclass this controller and override this method, make sure to call
+   * super.hostDestroy();
+   * @public
+   * @privateRemarks
+   * FEATURE: is there a way to detect that accessor does not need to be destroyed?
+   * Is it possible to write accessors that don't need to be destroyed?
+   */
   hostDestroy() {
     if (this.#isInstanceOwner) {
       this.instance.destroy?.();

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

@@ -1,11 +1,14 @@
-import { EventEmitter } from '../../createEvent.ts';
-import { Evented } from '@arcgis/core/core/Evented.js';
+import type { EventEmitter } from "../../createEvent.js";
+import type { Evented } from "@arcgis/core/core/Evented.js";
+
 /**
  * Re-emit an event from the accessor instance on the component
  *
+ * @param getEventedAccessor
+ * @param eventName
  * @example
  * ```tsx
  * arcgisGo = reEmitEvent<HomeViewModelGoEvent>(() => this.viewModel, "go");
  * ```
  */
-export declare const reEmitEvent: <T>(getEventedAccessor: () => Evented, eventName: string) => EventEmitter<T>;
+export function reEmitEvent<T>(getEventedAccessor: () => Evented, eventName: string): EventEmitter<T>;