@arcgis/lumina 4.33.0-next.96 → 4.33.0-next.98

package/dist/LitElement.d.ts

@@ -1,8 +1,10 @@
-import { CSSResultGroup, CSSResultOrNative, PropertyValues, LitElement as OriginalLitElement } from 'lit';
+import { CSSResultGroup, CSSResultOrNative, PropertyValues, ReactiveController, LitElement as OriginalLitElement } from 'lit';
 import { Runtime } from './makeRuntime';
 import { ProxyComponent } from './lazyLoad';
 import { ToElement } from './jsx/types';
-import { LuminaPropertyDeclaration } from './controllers/types';
+import { BaseController, LuminaPropertyDeclaration } from './controllers/types';
+import { ControllerManager } from './controllers/ControllerManager';
+import { Controller } from './controllers/Controller';
 type ComponentLifecycle = {
     connectedCallback?: () => void;
     disconnectedCallback?: () => void;
@@ -32,7 +34,7 @@ type ComponentLifecycle = {
  * only.
  */
 export declare class LitElement extends OriginalLitElement implements ComponentLifecycle {
-    /** @internal */
+    /** @private */
     static runtime: Runtime;
     static tagName: string;
     /**
@@ -53,7 +55,7 @@ export declare class LitElement extends OriginalLitElement implements ComponentL
      * loading logic calls document.createElement(), it temporary sets this static
      * property.
      *
-     * @internal
+     * @private
      * */
     static lazy: ProxyComponent | undefined;
     static readonly lumina = true;
@@ -77,43 +79,35 @@ export declare class LitElement extends OriginalLitElement implements ComponentL
      * const isLazy = this.el !== this;
      * ```
      */
-    el: ToElement<this>;
+    readonly el: ToElement<this>;
     /**
-     * Controller Manager orchestrates all controllers used by this component,
-     * connecting their lifecycle hooks and providing context information.
+     * Controller does not need to be an instance of the Controller class. Any
+     * Lit's Reactive controller will work as well. See examples:
+     * https://lit.dev/docs/composition/controllers/
+     *
+     * @private
      */
-    manager: import('./controllers').ControllerManager;
+    readonly _controllers: Set<BaseController | Controller<unknown>>;
     /**
-     * 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 didUpdate() lifecycle hooks.
-     *
-     * @internal
-     *
-     * @remarks
-     * The name does not start with `_` because in the future we may configure the
-     * minifier to mangle such properties - but this property is accessed from
-     * outside this package, so should not be mangled.
+     * Controller Manager orchestrates all controllers used by this component,
+     * connecting their lifecycle hooks and providing context information.
      */
-    $changes: PropertyValues;
-    /** @internal */
+    readonly manager: ControllerManager;
+    /** @private */
     _postLoad: ProxyComponent["_postLoad"];
     /**
      * Direct offspring that should be awaited before loaded() is emitted.
      *
      * `attachToAncestor()` will add elements to this array
      *
-     * @internal
+     * @private
      */
     _offspring: ProxyComponent["_offspring"];
     /**
      * Promise that resolves once parent's load() completed. False if there is no
      * parent
      *
-     * @internal
+     * @private
      */
     _ancestorLoad: ProxyComponent["_ancestorLoad"];
     private _originalShouldUpdate?;
@@ -228,6 +222,20 @@ export declare class LitElement extends OriginalLitElement implements ComponentL
      * });
      */
     componentOnReady(): Promise<this>;
+    /**
+     * Adds a controller to the host, which connects the controller's lifecycle
+     * methods to the host's lifecycle.
+     *
+     * @remarks
+     * Even though Lit's LitElement already has addController,
+     * we overwrite it with a compatible version to have more control over
+     * timing, and to add support for load/loaded lifecycle hooks.
+     */
+    addController(controller: BaseController | ReactiveController): void;
+    /**
+     * Removes a controller from the host.
+     */
+    removeController(controller: BaseController | ReactiveController): void;
 }
 type Listener<ThisType, EventType> = ((this: ThisType, event: EventType) => unknown) | {
     handleEvent(event: EventType): unknown;

package/dist/context.d.ts

@@ -1,5 +1,5 @@
 import { ContextConsumer, ContextProvider, Context, ContextType } from '@lit/context';
-import { ControllerHost } from './controllers/types';
+import { ReactiveControllerHost } from 'lit';
 interface ContextProviderOptions<C extends Context<unknown, unknown>> {
     context: C;
     initialValue?: ContextType<C>;
@@ -22,5 +22,15 @@ export declare function useContextProvider<C extends Context<unknown, unknown>>(
  *
  * FEATURE: wrap this in proxyExports to improve DX, or keep it simple?
  */
-export declare function useContextConsumer<C extends Context<unknown, unknown>>(options: ContextConsumerOptions<C>): ContextConsumer<C, ControllerHost & HTMLElement>;
+export declare function 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 {};

package/dist/controllers/Controller.d.ts

@@ -1,7 +1,8 @@
 import { Deferred } from '@arcgis/components-utils';
-import { BaseComponent, BaseController, ControllerHost, ControllerLifecycleMethods, controllerSymbol } from './types';
+import { BaseController, ControllerLifecycleMethods, controllerSymbol } from './types';
 import { use, useRef, useRefSync } from './ControllerInternals';
 import { PropertyValues } from 'lit';
+import { LitElement } from '../LitElement';
 /**
  * Base class for Controllers defined using a class rather than a function.
  * Defining controller using makeController() function is more succinct for smaller
@@ -16,15 +17,15 @@ export declare abstract class Controller<Exports = never> implements BaseControl
     };
     protected _ready: Deferred<Exports>;
     private _lifecycleCleanups;
-    /** @internal */
+    /** @private */
     assignedProperty?: string | false;
     connectedCalled: boolean;
     protected _loadCalled: boolean;
     loadedCalled: boolean;
     readonly [controllerSymbol] = true;
-    component: BaseComponent & ControllerHost;
+    component: LitElement;
     ready: Promise<Exports>;
-    constructor(component?: BaseComponent);
+    constructor(component?: LitElement);
     /**
      * If controller is being added dynamically, after the component
      * construction, then trigger connected and load right away
@@ -97,7 +98,7 @@ export declare abstract class Controller<Exports = never> implements BaseControl
     /**
      * Like useRef, but doesn't wait for the controller to get ready
      *
-     * @internal
+     * @private
      */
     get useRefSync(): typeof useRefSync;
     controllerRemoved(): void;
@@ -109,31 +110,31 @@ export declare abstract class Controller<Exports = never> implements BaseControl
     onUpdated(callback: NonNullable<ControllerLifecycleMethods["hostUpdated"]>): void;
     onDestroy(callback: NonNullable<ControllerLifecycleMethods["hostDestroy"]>): void;
     onLifecycle(callback: NonNullable<ControllerLifecycleMethods["hostLifecycle"]>): void;
-    /** @internal */
+    /** @private */
     triggerConnected(): void;
-    /** @internal */
+    /** @private */
     triggerDisconnected(): void;
-    /** @internal */
+    /** @private */
     triggerLoad(): Promise<void>;
-    /** @internal */
+    /** @private */
     triggerLoaded(): void;
-    /** @internal */
+    /** @private */
     triggerUpdate(changes: PropertyValues): void;
-    /** @internal */
+    /** @private */
     triggerUpdated(changes: PropertyValues): void;
-    /** @internal */
+    /** @private */
     triggerDestroy(): void;
-    /** @internal */
+    /** @private */
     triggerLifecycle(): void;
     private _callLifecycle;
 }
-export declare abstract class GenericControllerType<Exports, Requires = BaseComponent> extends Controller<Exports> {
-    component: BaseComponent & ControllerHost & Requires;
-    constructor(component: BaseComponent & Requires);
+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 the BaseComponent, use
+ * 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

package/dist/controllers/ControllerInternals.d.ts

@@ -1,7 +1,8 @@
 import { Controller } from './Controller';
-import { BaseComponent, BaseController, ControllerHost } from './types';
-export declare function setAmbientComponent(component: BaseComponent & ControllerHost): void;
-export declare function retrieveComponent(name?: string): BaseComponent & ControllerHost;
+import { BaseController } from './types';
+import { LitElement } from '../LitElement';
+export declare function setAmbientComponent(component: LitElement): void;
+export declare function retrieveComponent(name?: string): LitElement;
 export declare function setParentController(controller: BaseController | undefined): void;
 /**
  * Get references to controllers this nested controller might have been called
@@ -17,17 +18,23 @@ export declare function setAmbientChildController(controller: BaseController | u
 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 const shouldBypass: {
-    setter: boolean;
-    getter: boolean;
-    readOnly: boolean;
-};
+/** @deprecated */
+export declare let shouldBypassGetter: boolean;
+export declare let shouldBypassReadOnly: boolean;
 /**
- * A map from component instance or component element to component instance.
- * To get from component instance or component element to component element,
- * you can just use the .el property
+ * Permits updating read-only properties
+ *
+ * @see https://qawebgis.esri.com/components/lumina/properties#read-only-properties
+ */
+export declare function bypassReadOnly<T = void>(callback: () => T): T | void;
+/**
+ * @deprecated see https://qawebgis.esri.com/components/lumina/properties#get-set-properties
+ */
+export declare const bypassSetter: typeof bypassReadOnly;
+/**
+ * @deprecated see https://qawebgis.esri.com/components/lumina/properties#get-set-properties
  */
-export declare const elementToInstance: WeakMap<HTMLElement | BaseComponent, BaseComponent>;
+export declare function bypassGetter<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

package/dist/controllers/ControllerManager.d.ts

@@ -1,63 +1,83 @@
-import { BaseComponent } from './types';
+import { BaseController } from './types';
 import { GenericController } from './Controller';
-import { ComponentInternals } from './ComponentInternals';
-/**
- * Using "new ControllerManager(this)" inside a component causes this TypeScript
- * error:
- * 'manager' implicitly has type 'any' because it does not have a type
- * annotation and is referenced directly or indirectly in its own initializer.
- *
- * This function fixes that, and it's also a bit shorter to type
- *
- * @deprecated Lumina packages should not need to call this directly
- */
-export declare const useControllerManager: (component: BaseComponent) => ControllerManager;
+import { PropertyValues } from 'lit';
+import { LitElement } from '../LitElement';
 /**
  * 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 readonly _controllers;
-    /** @internal */
-    readonly internals: ComponentInternals;
     hasDestroy: boolean;
     destroyed: boolean;
-    private _updatePromise;
     private _autoDestroyTimeout?;
-    /**
-     * If true, indicates that ControllerManager is running against a Lit component.
-     * Otherwise, means we are running against a Stencil component.
-     */
-    readonly isLit: boolean;
-    constructor(component: BaseComponent);
-    private _originalLifecycles;
-    private _bindLifecycleMethods;
+    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
      */
-    ensureHasDestroy?: () => void;
+    _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 _enforceReadonly;
+    /** @private */
+    _trackedValue: unknown;
+    /** @private */
+    _keyTrackers: ((key: string | undefined, value: unknown) => void)[];
+    /** @private */
+    _firePropTrackers(key: string | undefined, value: unknown): void;
+    /** @private */
+    readonly _accessorGetter: Record<string, (value: unknown, propertyName: string) => unknown>;
+    /** @private */
+    readonly _accessorSetter: Record<string, (newValue: unknown, oldValue: unknown, propertyName: string) => unknown>;
     /**
-     * Private because this is not supposed to be called by Component directly.
-     * Instead, _bindLifecycleMethods will take care of that. Otherwise, you risk
-     * calling lifecycle methods twice.
+     * 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
+     * @private
      */
-    _connectedCallback(): void;
-    /** @internal */
-    _disconnectedCallback(): void;
-    /** @internal */
-    _load(): Promise<void>;
-    /** @internal */
-    _loaded(): void;
-    private _update;
-    private _updated;
-    destroy(): Promise<void>;
-    private _setAutoDestroyTimeout;
+    _changes?: PropertyValues;
+    /**
+     * Configure a getter or setter for a given \@property/\@state
+     *
+     * Since props are defined on the prototype, they are shared between all
+     * instances of a component. Thus, instead of passing a reference to the
+     * getter/setter function, you should update the
+     * ComponentInternals.getters/setters properties, and then call getSetProxy
+     * to apply the changes to the prototype
+     *
+     * @deprecated
+     */
+    private _getSetProxy;
+    private _exportsStore;
+    /**
+     * 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 declare let autoDestroyOnDisconnectTimeout: number;
+export declare const autoDestroyDisabledPropName = "autoDestroyDisabled";
 export declare const exportsForTests: {
     setAutoDestroyOnDisconnectTimeout: (timeout: number) => void;
 } | undefined;
-export declare const defaultGetterSetter: (value: unknown) => unknown;
+export type LuminaLifecycles = {
+    connectedCallback?: LitElement["connectedCallback"];
+    disconnectedCallback?: LitElement["disconnectedCallback"];
+    load?: () => Promise<void> | void;
+    loaded?: () => void;
+};

package/dist/controllers/accessor/index.js

@@ -1,7 +1,7 @@
-import { n as devOnlySetPersistentControllerData, o as devOnlyGetPersistentControllerData, G as GenericController, f as trackPropKey, t as trackKey, r as retrieveComponent, d as createEventFactory } from "../../useWatch-CFtSpNnN.js";
-import { p as proxyExports, a as bypassGetter, c as bypassSetter } from "../../proxyExports-Dl5CHmHQ.js";
-import { isEsriInternalEnv, camelToKebab, isNotUndefined } from "@arcgis/components-utils";
-import { on, watch } from "@arcgis/core/core/reactiveUtils.js";
+import { p as devOnlySetPersistentControllerData, q as devOnlyGetPersistentControllerData, G as GenericController, n as trackPropKey, h as bypassGetter, l as bypassReadOnly, t as trackKey, r as retrieveComponent, g as createEventFactory } from "../../Controller-CZ8Djohh.js";
+import { p as proxyExports } from "../../proxyExports-CK5BLFLO.js";
+import { isEsriInternalEnv } from "@arcgis/components-utils";
+import { watch, on } from "@arcgis/core/core/reactiveUtils.js";
 const makeAccessorController = (loadAccessor, _options) => (component, options) => proxy(component, loadAccessor, options);
 class AccessorController extends GenericController {
   constructor(component, _loadAccessor, _options) {
@@ -103,11 +103,6 @@ const accessorSupport = {
           return value;
         }
         if (watchedProperties.has(prop)) {
-          if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && !component.manager.isLit) {
-            throw new Error(
-              `Tried to bind "${prop.toString()}" prop twice. This might also happen if you are trying to access the accessor instance before ${component.manager.isLit ? "load" : "componentWillLoad"}()`
-            );
-          }
           return;
         }
         return trackKey(
@@ -115,12 +110,7 @@ const accessorSupport = {
           (resolved) => {
             if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
               if (resolved === void 0) {
-                if (component.manager.isLit) {
-                  return;
-                }
-                throw new Error(
-                  `Unable to resolve what property is "${prop.toString()}" being bound too. Check documentation for useAccessor to ensure proper usage. Make sure you are not trying to access the accessor instance before ${component.manager.isLit ? "load" : "componentWillLoad"}()`
-                );
+                return;
               }
               const isFlippingBoolean = resolved.key.toLowerCase().includes("disable");
               const collidesWithNativeProp = prop in HTMLElement.prototype;
@@ -132,7 +122,7 @@ const accessorSupport = {
               }
               if (!resolved.isReactive) {
                 throw new Error(
-                  component.manager.isLit ? `For two-way binding with Accessor to work, the property on your component must have @property() or @state() decorator. "${prop.toString()}" has neither` : `For two-way binding with Accessor to work, the property on your component must have @Prop() or @State() decorator. "${prop.toString()}" has neither`
+                  `For two-way binding with Accessor to work, the property on your component must have @property() or @state() decorator. "${prop.toString()}" has neither`
                 );
               }
             }
@@ -157,7 +147,7 @@ const accessorSupport = {
       const propertyName = watchedProperties.get(propName);
       const value = instance[propertyName];
       const flipBoolean = typeof value === "boolean" && propertyName !== propName && propName.toLowerCase().includes("disable");
-      const currentValue = flipBoolean ? !value : component.manager.isLit ? value ?? void 0 : value;
+      const currentValue = flipBoolean ? !value : value ?? void 0;
       if (currentValue === newValue) {
         return newValue;
       }
@@ -165,11 +155,10 @@ const accessorSupport = {
       const finalValue = instance[propertyName];
       return flipBoolean ? !finalValue : finalValue;
     };
-    const component = controller.component;
-    const internals = component.manager.internals;
+    const manager = controller.component.manager;
     watchedProperties.forEach((_propName, propertyName) => {
-      internals.accessorGetter[propertyName] = getter;
-      internals.accessorSetter[propertyName] = setter;
+      manager._accessorGetter[propertyName] = getter;
+      manager._accessorSetter[propertyName] = setter;
     });
   },
   // Update component on Accessor prop change
@@ -192,10 +181,7 @@ const accessorSupport = {
             return;
           }
           const domValue = genericComponent[propName];
-          let modelValue = genericInstance[propertyName];
-          if (component.manager.isLit) {
-            modelValue ??= void 0;
-          }
+          const modelValue = genericInstance[propertyName] ?? void 0;
           const flipBoolean = typeof domValue === "boolean" && propertyName !== propName && propName.toLowerCase().includes("disable");
           const resolvedDomValue = flipBoolean ? !domValue : domValue;
           if (resolvedDomValue != null && modelValue !== resolvedDomValue) {
@@ -216,7 +202,7 @@ const accessorSupport = {
             const newValue = genericInstance[propertyName];
             const flipBoolean = typeof newValue === "boolean" && propertyName !== propName && propName.toLowerCase().includes("disable");
             const resolvedNewValue = flipBoolean ? !newValue : newValue;
-            bypassSetter(() => {
+            bypassReadOnly(() => {
               genericComponent[propName] = resolvedNewValue;
             });
           },
@@ -225,35 +211,6 @@ const accessorSupport = {
       );
     });
   },
-  // REFACTOR: remove this once Stencil is no longer supported
-  reEmitAccessorEvents(controller, instance, prefix) {
-    const isEvented = "on" in instance && typeof instance.on === "function";
-    if (!isEvented) {
-      return;
-    }
-    const toListen = Object.entries(controller.component).map(([key, unknown]) => {
-      const value = unknown;
-      if (!key.startsWith(prefix) || key === prefix || typeof value !== "object" || value === null || !("emit" in value) || typeof value.emit !== "function") {
-        return void 0;
-      }
-      const emit = value.emit;
-      const trimmedEventName = key.slice(prefix.length);
-      const camelCaseEventName = camelToKebab(trimmedEventName);
-      const eventName = camelCaseEventName.toLowerCase();
-      return [eventName, emit];
-    }).filter(isNotUndefined);
-    if (toListen.length === 0) {
-      return;
-    }
-    const eventTarget = instance;
-    const getEventTarget = () => eventTarget;
-    controller.onLifecycle(() => {
-      if (instance.destroyed) {
-        return;
-      }
-      return toListen.map(([eventName, emit]) => on(getEventTarget, eventName, emit));
-    });
-  },
   async reCreate(instance, component) {
     const accessorController = component.manager.useRefSync(instance);
     if (accessorController === void 0) {
@@ -284,11 +241,6 @@ const filterWatchedProperties = process.env.NODE_ENV !== "production" && isEsriI
 } : void 0;
 function reEmitEvent(getEventedAccessor, eventName) {
   const component = retrieveComponent();
-  if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && !component.manager.isLit) {
-    throw new Error(
-      "reEmitEvent is only supported in Lumina components. Consult documentation for equivalent Stencil pattern."
-    );
-  }
   const manager = component.manager;
   manager.onLoaded(() => manager.onLifecycle(() => on(getEventedAccessor, eventName, emitter.emit)));
   const emitter = createEventFactory();

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

@@ -1,4 +1,4 @@
-import { EventEmitter } from '../types';
+import { EventEmitter } from '../../createEvent';
 /**
  * Re-emit an event from the accessor instance on the component
  *
@@ -6,9 +6,5 @@ import { EventEmitter } from '../types';
  * ```tsx
  * arcgisGo = reEmitEvent<__esri.HomeViewModelGoEvent>(() => this.viewModel, "go");
  * ```
- *
- * @remarks
- * `reEmitEvent()` only works in Lumina. Consult documentation for equivalent
- * Stencil pattern.
  */
 export declare function reEmitEvent<T>(getEventedAccessor: () => __esri.Evented, eventName: string): EventEmitter<T>;

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

@@ -1,6 +1,6 @@
 import { Controller, GenericController } from '../Controller';
-import { BaseComponent } from '../types';
-type Requires<Props, Accessor extends __esri.Accessor> = BaseComponent & Pick<Accessor, keyof Accessor & keyof Props> & {
+import { LitElement } from '../../LitElement';
+type Requires<Props, Accessor extends __esri.Accessor> = LitElement & Pick<Accessor, keyof Accessor & keyof Props> & {
     autoDestroyDisabled: boolean;
     destroy: () => Promise<void>;
 };
@@ -19,7 +19,7 @@ export declare const makeAccessorController: <Props, Accessor extends __esri.Acc
      * (or you wish to bind them but with a different type), you can omit
      * them using this option.
      *
-     * You can also bind the property to \@State rather than \@Prop if you
+     * You can also bind the property to \@state rather than \@property if you
      * wish to use it internally only:
      * @example
      * ```tsx
@@ -49,7 +49,7 @@ export declare class AccessorController<Props, Accessor extends __esri.Accessor,
      * (development only) Allow these props to mismatch the name of the Accessor's property
      * to avoid collisions
      *
-     * @internal
+     * @private
      */
     static allowedPropNameMismatches?: Set<string>;
     constructor(component: ExtraRequires & Requires<Props, Accessor>, _loadAccessor: ((props: Props) => Accessor | Promise<Accessor>) | (new (props: Props) => Accessor), _options?: {
@@ -64,12 +64,11 @@ export declare class AccessorController<Props, Accessor extends __esri.Accessor,
     reCreate(): Promise<void>;
 }
 export declare const accessorSupport: {
-    makeGetterProxy: (component: BaseComponent, watchedProperties: Map<string, string>, isBinding?: {
+    makeGetterProxy: (component: LitElement, watchedProperties: Map<string, string>, isBinding?: {
         value: boolean;
     }, allowedPropNameMismatches?: Set<string>) => unknown;
     watchComponentUpdates<T>(controller: Controller<T>, instance: __esri.Accessor, watchedProperties: Map<string, string>): void;
     watchAccessorUpdates<T>(controller: Controller<T>, instance: __esri.Accessor, watchedProperties: Map<string, string>): void;
-    reEmitAccessorEvents<T>(controller: Controller<T>, instance: __esri.Accessor, prefix: string): void;
-    reCreate(instance: __esri.Accessor, component: BaseComponent): Promise<void>;
+    reCreate(instance: __esri.Accessor, component: LitElement): Promise<void>;
 };
 export {};

package/dist/controllers/functional.d.ts

@@ -1,19 +1,19 @@
+import { LitElement } from '../LitElement';
 import { GenericControllerType, Controller } from './Controller';
-import { BaseComponent, ControllerHost } from './types';
 /**
  * Controller is a function that takes a component instance and then can
  * export some values to the component, or hook into component's lifecycle
  *
  * See controllers documentation for many example controllers and their usages
  */
-export declare const makeController: <Exports>(constructor: (component: BaseComponent & ControllerHost, controller: Controller<Exports>) => Exports | Promise<Exports>) => Exports;
+export declare const makeController: <Exports>(constructor: (component: LitElement, controller: Controller<Exports>) => Exports | Promise<Exports>) => Exports;
 /**
  * If your controller requires some specific properties to be present on the
- * component, besides what's included in the BaseComponent, use
+ * component, besides what's included in the LitElement, use
  * makeGenericController
  *
  * When using a controller created using makeGenericController(), consumer must
  * pass in "this" explicitly for proper type-checking. If controller was
  * created using makeController(), that is not necessary
  */
-export declare const makeGenericController: <Exports, Component = BaseComponent>(constructor: (component: BaseComponent & Component & ControllerHost, controller: GenericControllerType<Exports, Component>) => Exports | Promise<Exports>) => (component: BaseComponent & Component) => Exports;
+export declare const makeGenericController: <Exports, Component = LitElement>(constructor: (component: Component & LitElement, controller: GenericControllerType<Exports, Component>) => Exports | Promise<Exports>) => (component: Component & LitElement) => Exports;

package/dist/controllers/index.d.ts

@@ -1,15 +1,12 @@
+import { EventEmitter as _EventEmitter } from '../createEvent';
 export type { GenericControllerType } from './Controller';
 export { Controller, GenericController } from './Controller';
 export type { ControllerManager } from './ControllerManager';
-export { retrieveComponent } from './ControllerInternals';
-export { useControllerManager } from './ControllerManager';
+export { retrieveComponent, bypassGetter, bypassSetter, bypassReadOnly } from './ControllerInternals';
 export { trackPropertyKey, keyTrackResolve } from './trackPropertyKey';
 export { trackPropKey } from './trackPropKey';
 export { trackKey } from './trackKey';
 export { makeController, makeGenericController } from './functional';
-export { readonly, bypassReadOnly } from './readonly';
-export { getSet, dynamicGetSet, bypassGetter, bypassSetter } from './getSet';
-export { watch } from './useWatch';
 export { useWatchAttributes } from './useWatchAttributes';
 export { load } from './load';
 export { proxyExports } from './proxyExports';
@@ -21,3 +18,7 @@ export type { UseT9n, T9nMeta } from './useT9n';
 export { makeT9nController } from './useT9n';
 export { usePropertyChange } from './usePropertyChange';
 export { isController } from './utils';
+/**
+ * @deprecated import from "@arcgis/lumina" instead
+ */
+export type EventEmitter<T = undefined> = _EventEmitter<T>;