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

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

@@ -1,17 +1,24 @@
-import { default as Accessor } from '@arcgis/core/core/Accessor.js';
+import type Accessor from "@arcgis/core/core/Accessor.js";
+
 /**
- * See https://webgis.esri.com/references/lumina/controllers/useAccessor#createstore-utility
+ * @param initializer
+ * @see https://webgis.esri.com/references/lumina/controllers/useAccessor#createstore-utility
  */
-export declare const createStore: <T extends object>(initializer: T | (() => T)) => Accessor & T;
-/** @deprecated Use {@link createStore} instead */
-export declare const createLegacyStore: <T extends object>(defaultState: T | (() => T)) => ObservableMap<T>;
-/** @deprecated Use {@link createStore} instead */
+export function createStore<T extends object>(initializer: T | (() => T)): Accessor & T;
+
+/**
+ * @deprecated Use [createStore()](https://developers.arcgis.com/javascript/latest/references/lumina/controllers/accessor/store/#createStore) instead
+ * @param defaultState
+ */
+export function createLegacyStore<T extends object>(defaultState: T | (() => T)): ObservableMap<T>;
+
+/** @deprecated Use [createStore()](https://developers.arcgis.com/javascript/latest/references/lumina/controllers/accessor/store/#createStore) instead */
 export type ObservableMap<T> = {
-    state: Accessor & T;
-    /** @deprecated Use state[propertyName] instead */
-    get: <P extends keyof T>(propName: P & string) => T[P];
-    /** @deprecated Use state[propertyName]=value instead */
-    set: <P extends keyof T>(propName: P & string, value: T[P]) => void;
-    /** @deprecated Use reactiveUtils.watch instead */
-    onChange: <Key extends keyof T>(propName: Key, callback: (newValue: T[Key]) => void) => () => void;
-};
+  state: Accessor & T;
+  /** @deprecated Use state[propertyName] instead */
+  get: <P extends keyof T>(propName: P & string) => T[P];
+  /** @deprecated Use state[propertyName]=value instead */
+  set: <P extends keyof T>(propName: P & string, value: T[P]) => void;
+  /** @deprecated Use reactiveUtils.watch instead */
+  onChange: <Key extends keyof T>(propName: Key, callback: (newValue: T[Key]) => void) => () => void;
+};

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

@@ -1,77 +1,95 @@
-import { GenericController } from '../Controller.ts';
-import { LitElement } from '../../LitElement.ts';
-import { default as coreAccessor } from '@arcgis/core/core/Accessor.js';
-type Requires<Props, Accessor extends coreAccessor, OmitProps extends string = never> = LitElement & Omit<Pick<Accessor, keyof Accessor & keyof Props>, AlwaysOmit | OmitProps> & {
-    autoDestroyDisabled: boolean;
-    destroy: () => Promise<void>;
+import type coreAccessor from "@arcgis/core/core/Accessor.js";
+import type { GenericController } from "../GenericController.js";
+import type { LitElement } from "../../LitElement.js";
+
+export type AccessorControllerRequires<Props, Accessor extends coreAccessor, OmitProps extends string = never> = LitElement
+  & Omit<Pick<Accessor, keyof Accessor & keyof Props>, AlwaysOmit | OmitProps>
+  & {
+  /** This must be present for the accessor instance to be garbage collected correctly */
+  autoDestroyDisabled: boolean;
+  /** This must be present for the accessor instance to be garbage collected correctly */
+  destroy: () => Promise<void>;
 };
-type AlwaysOmit = "addHandles" | "declaredClass" | "destroyed" | "hasHandles" | "initialized" | "removeHandles" | "set" | "watch";
+
+/**
+ * If Accessor class does not override constructor, constructor parameter will
+ * be "any". In such cases, all accessor properties are assumed to be required
+ * for binding. We add a few exceptions for well known built-in properties
+ */
+export type AlwaysOmit = "addHandles" | "declaredClass" | "destroyed" | "hasHandles" | "initialized" | "removeHandles" | "set" | "watch";
+
 /**
  * Given an Accessor class, create a controller that will do two-way binding of
  * props between the component and the Accessor.
  *
  * See https://webgis.esri.com/references/lumina/controllers/useAccessor for
  * documentation & examples.
+ *
+ * @param createInstance
+ * @param options
  */
-export declare const makeAccessorController: <Props, Accessor extends coreAccessor, OmitProps extends string = never>(createInstance: ((props?: Props) => Accessor) | (new (props?: Props) => Accessor), _options?: {
-    /**
-     * By default, to ensure that you didn't accidentally forget to bind any
-     * of the Accessor's properties on your component, every property that
-     * is accepted by the Accessor's constructor will be required to be bound
-     * on your component. If you do not wish to bind certain properties
-     * (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 \@property if you
-     * wish to use it internally only:
-     * @example
-     * ```tsx
-     * \@State() timeZone = this.viewModel.timeZone;
-     * ```
-     *
-     * @remarks
-     * This option affects the TypeScript error checking only - it has
-     * no runtime impact. Thus, if you wish to save a few bytes in the
-     * bundle, rather than simply setting this property like
-     * `makeAccessorController(..., { omitProps: ["propName"] })`, you can
-     * set it like this:
-     * `makeAccessorController(..., {} as { omitProps: ["propName"] })`
-     */
-    omitProps: OmitProps[];
-}) => (component: Requires<Props, Accessor, OmitProps>) => Accessor;
-export declare class AccessorController<Props, Accessor extends coreAccessor, ExtraRequires = Record<never, never>> extends GenericController<Accessor, ExtraRequires & Requires<Props, Accessor>> {
-    #private;
-    protected instance: Accessor;
-    /**
-     * Use getAccessorControllerBoundProperties() helper to get access to this map
-     * @private
-     */
-    _boundAccessorProperties: Map<string & keyof Accessor, string>;
-    /** @private */
-    _currentlyBindingPropertyName?: string;
-    /**
-     * (development only) Allow these props to mismatch the name of the Accessor's
-     * property to avoid collisions
-     *
-     * @private
-     */
-    static devOnly$allowedPropNameMismatches?: ReadonlySet<string>;
-    get exports(): Accessor;
-    set exports(value: Accessor);
-    constructor(component: ExtraRequires & Requires<Props, Accessor>, createInstance: ((props?: Props) => Accessor) | (new (props?: Props) => Accessor));
-    /** @private */
-    _createAccessorInstance(): void;
-    hostConnected(): void;
-    hostDestroy(): void;
+export function makeAccessorController<Props, Accessor extends coreAccessor, OmitProps extends string = never>(createInstance: ((props?: Props) => Accessor) | (new (props?: Props) => Accessor), options?: MakeAccessorControllerOptions<OmitProps>): ((component: AccessorControllerRequires<Props, Accessor, OmitProps>) => Accessor);
+
+export interface MakeAccessorControllerOptions<OmitProps extends string> {
+  /**
+   * By default, to ensure that you didn't accidentally forget to bind any
+   * of the Accessor's properties on your component, every property that
+   * is accepted by the Accessor's constructor will be required to be bound
+   * on your component. If you do not wish to bind certain properties
+   * (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 \@property if you
+   * wish to use it internally only:
+   *
+   * @example
+   * ```tsx
+   * \@State() timeZone = this.viewModel.timeZone;
+   * ```
+   */
+  omitProps: OmitProps[];
 }
-type MinimalAccessorController = Pick<AccessorController<never, coreAccessor>, "_currentlyBindingPropertyName" | "exports"> & {
-    component: LitElement;
-};
-export declare const makeBinderProxy: (component: LitElement, accessorControllerRef: WeakRef<MinimalAccessorController & {
-    constructor: MinimalAccessorController["constructor"] & {
-        devOnly$allowedPropNameMismatches?: ReadonlySet<string>;
-    };
-}>, accessorControllerIndex: number, instance: coreAccessor, boundProperties: Map<string, string>) => unknown;
-export declare const getAccessorControllerBoundProperties: <Accessor extends coreAccessor>(controller: AccessorController<unknown, Accessor>) => Map<string & keyof Accessor, string>;
-export declare const reCreateAccessor: (instance: coreAccessor, component: LitElement) => void;
-export {};
+
+export class AccessorController<Props, Accessor extends coreAccessor, ExtraRequires = Record<never, never>> extends GenericController<Accessor, AccessorControllerRequires<Props, Accessor> & ExtraRequires> {
+  static devOnly$allowedPropNameMismatches?: ReadonlySet<string>;
+  constructor(component: AccessorControllerRequires<Props, Accessor> & ExtraRequires, createInstance: ((props?: Props) => Accessor) | (new (props?: Props) => Accessor));
+  /**
+   * 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: Accessor;
+  protected instance: Accessor;
+  /**
+   * If you subclass this controller and override this method, make sure to call
+   * super.hostConnected();
+   */
+  hostConnected(): void;
+  /**
+   * If you subclass this controller and override this method, make sure to call
+   * super.hostDestroy();
+   */
+  hostDestroy(): void;
+}
+
+export interface MinimalAccessorController extends Pick<AccessorController<never, coreAccessor>, "exports"> {
+  component: LitElement;
+}
+
+/**
+ * @param component
+ * @param accessorControllerRef
+ * @param accessorControllerIndex
+ * @param instance
+ * @param boundProperties
+ */
+export function makeBinderProxy(component: LitElement, accessorControllerRef: WeakRef<MinimalAccessorController & { constructor: MinimalAccessorController["constructor"] & { devOnly$allowedPropNameMismatches?: ReadonlySet<string>; }; }>, accessorControllerIndex: number, instance: coreAccessor, boundProperties: Map<string, string>): unknown;
+
+/** @param controller */
+export function getAccessorControllerBoundProperties<Accessor extends coreAccessor>(controller: AccessorController<unknown, Accessor>): Map<string & keyof Accessor, string>;
+
+/**
+ * @param instance
+ * @param component
+ */
+export function reCreateAccessor(instance: coreAccessor, component: LitElement): void;

package/dist/controllers/functional.d.ts

@@ -1,12 +1,17 @@
-import { LitElement } from '../LitElement.ts';
-import { GenericControllerType, Controller } from './Controller.ts';
+import type { LitElement } from "../LitElement.js";
+import type { GenericControllerType } from "./GenericController.js";
+import type { Controller } from "./Controller.js";
+
 /**
  * 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
+ *
+ * @param constructor
  */
-export declare const makeController: <Exports>(constructor: (component: LitElement, controller: Controller<Exports>) => Exports | Promise<Exports>) => Exports;
+export function 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 LitElement, use
@@ -15,5 +20,7 @@ export declare const makeController: <Exports>(constructor: (component: LitEleme
  * 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
+ *
+ * @param constructor
  */
-export declare const makeGenericController: <Exports, Component = LitElement>(constructor: (component: Component & LitElement, controller: GenericControllerType<Exports, Component>) => Exports | Promise<Exports>) => (component: Component & LitElement) => Exports;
+export function 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,38 +1,37 @@
-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, 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 { useSlottableRequest } from './useSlottableRequest.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
- */
+import type { EventEmitter as _EventEmitter } from "../createEvent.js";
+import type { setAmbientComponent } from "./ControllerInternals.js";
+import type { autoDestroyOnDisconnectTimeout, setAutoDestroyOnDisconnectTimeout } from "./ControllerManager.js";
+
+export { type GenericControllerType } from "./GenericController.js";
+export { GenericController } from "./GenericController.js";
+export { Controller } from "./Controller.js";
+export { type ControllerManager } from "./ControllerManager.js";
+export { retrieveComponent, bypassReadOnly } from "./ControllerInternals.js";
+export { trackPropertyKey, propertyTrackResolve } from "./trackPropertyKey.js";
+export { trackPropKey } from "./trackPropKey.js";
+export { trackKey } from "./trackKey.js";
+export { makeController, makeGenericController } from "./functional.js";
+export { useWatchAttributes } from "./useWatchAttributes.js";
+export { load } from "./load.js";
+export { proxyExports } from "./proxyExports.js";
+export { toFunction } from "./toFunction.js";
+export { useSlottableRequest } from "./useSlottableRequest.js";
+export { controllerSymbol } from "./types.js";
+export { type TrackKeyResolution, type Use, type ControllerLifecycleMethods, type BaseController, type LuminaPropertyDeclaration } from "./types.js";
+export { useMedia } from "./useMedia.js";
+export { useDirection } from "./useDirection.js";
+export { type Direction } from "./useDirection.js";
+export { type UseT9n, type T9nMeta } from "./useT9n.js";
+export { makeT9nController } from "./useT9n.js";
+export { usePropertyChange } from "./usePropertyChange.js";
+export { isController, getControllersCount } from "./utils.js";
+
+/** @deprecated import from "@arcgis/lumina" instead */
 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;
+
+/** @internal */
+export const exportsForTests: {
+    setAmbientComponent: typeof setAmbientComponent;
+    autoDestroyOnDisconnectTimeout: typeof autoDestroyOnDisconnectTimeout;
     setAutoDestroyOnDisconnectTimeout: typeof setAutoDestroyOnDisconnectTimeout;
-};
+};

package/dist/controllers/index.js

@@ -1,13 +1,13 @@
-import { C as Controller, c as createEvent, t as trackKey, a as createEventFactory, p as propertyTrackResolve } from "../Controller-Cer_6Z29.js";
-import { G, b, d } from "../Controller-Cer_6Z29.js";
+import { C as Controller, c as createEvent, t as trackKey, a as createEventFactory } from "../GenericController-C8NSb50b.js";
+import { G, p, b, d } from "../GenericController-C8NSb50b.js";
 import { a as setAmbientComponent, i as isPromise, b as setParentController, d as retrieveParentControllers, r as retrieveComponent } from "../ControllerInternals-CeDntN3G.js";
 import { e, c, g, f } from "../ControllerInternals-CeDntN3G.js";
-import { p as proxyExports } from "../proxyExports-BkN6hND0.js";
+import { p as proxyExports } from "../proxyExports-ZRLty8oJ.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-DpJfvft9.js";
+import { s as setAutoDestroyOnDisconnectTimeout, b as autoDestroyOnDisconnectTimeout } from "../ControllerManager-4cSEnB5Y.js";
 const makeController = (constructor) => proxy(void 0, constructor);
 const makeGenericController = (constructor) => (component) => proxy(
   component,
@@ -296,7 +296,6 @@ const propertyChangeController = (...toWatch) => {
   }
   return eventEmitter;
 };
-const keyTrackResolve = propertyTrackResolve;
 const exportsForTests = {
   setAmbientComponent,
   autoDestroyOnDisconnectTimeout,
@@ -310,12 +309,11 @@ export {
   exportsForTests,
   g as getControllersCount,
   f as isController,
-  keyTrackResolve,
   load,
   makeController,
   makeGenericController,
   makeT9nController,
-  propertyTrackResolve,
+  p as propertyTrackResolve,
   proxyExports,
   retrieveComponent,
   toFunction,

package/dist/controllers/load.d.ts

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

package/dist/controllers/proxyExports.d.ts

@@ -1,5 +1,6 @@
-import { Controller } from './Controller.ts';
-import { ControllerLifecycleMethods } from './types.ts';
+import type { Controller } from "./Controller.js";
+import type { ControllerLifecycleMethods } from "./types.js";
+
 /**
  * If you wish to directly expose the "exports" property of your controller,
  * rather than the entire controller class, wrap your class definition in
@@ -12,16 +13,16 @@ import { ControllerLifecycleMethods } from './types.ts';
  * "proxyExports" is the default behavior for all controllers declared using
  * the makeController()/makeGenericController() function
  *
- * @remarks
  * If using readonly(), and controller updates its exports, the readonly prop
  * will still get updated
  *
- * @remarks
  * (Advanced) If you wish to use proxyExports() in a class that does not
  * extend Controller class and does not have a useControllerManager(), then your
  * class must subclass a class with the following constructor:
  * `constructor() { setAmbientController(this); }`. This
  * is necessary for proxyExports() to receive a reference to your object
  * implicitly, and before any of your default values are assigned.
+ *
+ * @param Class
  */
-export declare const proxyExports: <Exports, const Parameters extends unknown[]>(Class: new (...args: Parameters) => ControllerLifecycleMethods & Pick<Controller<Exports>, "component" | "exports" | "onUpdate" | "watchExports">) => ((...args: Parameters) => Exports);
+export function proxyExports<Exports, const Parameters extends unknown[]>(Class: new (...args: Parameters) => ControllerLifecycleMethods & Pick<Controller<Exports>, "component" | "exports" | "onUpdate" | "watchExports">): ((...args: Parameters) => Exports);

package/dist/controllers/toFunction.d.ts

@@ -3,6 +3,8 @@
  * Main advantage of this is that it's a bit shorter to type.
  *
  * This utility can be used for converting non-controller classes to functions
- * too
+ * too.
+ *
+ * @param Class
  */
-export declare const toFunction: <T, const P extends unknown[]>(Class: new (...args: P) => T) => ((...args: P) => T);
+export function toFunction<T, const P extends unknown[]>(Class: new (...args: P) => T): ((...args: P) => T);

package/dist/controllers/trackKey.d.ts

@@ -1,8 +1,13 @@
-import { LitElement } from '../LitElement.ts';
-import { BaseController, TrackKeyResolution } from './types.ts';
+import type { LitElement } from "../LitElement.js";
+import type { BaseController, TrackKeyResolution } from "./types.js";
+
 /**
  * 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
- * \@property() decorator or not
+ * \@property() decorator or not.
+ *
+ * @param hostsCandidates
+ * @param onResolved
+ * @param defaultValue
  */
-export declare const trackKey: <T>(hostsCandidates: ((BaseController | LitElement)[] | BaseController | LitElement) | undefined, onResolved: (resolution: TrackKeyResolution | undefined) => void, defaultValue: T) => T;
+export function trackKey<T>(hostsCandidates: (BaseController | LitElement)[] | BaseController | LitElement | undefined, onResolved: (resolution: TrackKeyResolution | undefined) => void, defaultValue: T): T;

package/dist/controllers/trackPropKey.d.ts

@@ -1,9 +1,14 @@
-import { LitElement } from '../LitElement.ts';
+import type { LitElement } from "../LitElement.js";
+
 /**
  * Like trackPropertyKey(), but for props that have \@state() or \@property()
  * decorator
  *
+ * @param component
+ * @param onResolved
+ * @param defaultValue
  * @example
+ * ```ts
  * function trackMe() {
  *   const component = retrieveComponent();
  *   const defaultValue = 'some value';
@@ -17,5 +22,6 @@ import { LitElement } from '../LitElement.ts';
  *   // Will console log "myState"
  *   \@state() myState = trackMe();
  * }
+ * ```
  */
-export declare const trackPropKey: <T>(component: LitElement, onResolved: (key: string | undefined) => void, defaultValue: T) => T;
+export function trackPropKey<T>(component: LitElement, onResolved: (key: string | undefined) => void, defaultValue: T): T;

package/dist/controllers/trackPropertyKey.d.ts

@@ -1,14 +1,18 @@
-import { LitElement } from '../LitElement.ts';
-import { BaseController } from './types.ts';
+import type { LitElement } from "../LitElement.js";
+import type { BaseController } from "./types.js";
+
 /**
  * A magical solution to finding out what property name a given controller
  * on a given object was assigned to.
  *
- * @remarks
  * This does not work for properties that have \@property() or \@state()
  * decorator - for those, use trackPropKey() instead.
  *
+ * @param object
+ * @param onResolved
+ * @param defaultValue
  * @example
+ * ```ts
  * function trackMe<T>(defaultValue: T, component: LitElement):T {
  *   trackPropertyKey(component, (key)=>console.log(key), defaultValue);
  *   return defaultValue;
@@ -18,12 +22,13 @@ import { BaseController } from './types.ts';
  *   // Will console log "myProp"
  *   myProp = trackMe('a', this);
  * }
- *
+ * ```
  */
-export declare const trackPropertyKey: <T>(object: BaseController | LitElement, onResolved: (key: string | undefined) => void, defaultValue: T) => T;
+export function trackPropertyKey<T>(object: BaseController | LitElement, onResolved: (key: string | undefined) => void, defaultValue: T): T;
+
 /**
  * Resolve all pending trackPropertyKey() calls. This must be called after a
  * property you are trying to resolve had it's default value set, thus after
  * constructor. At the start of connectedCallback is a perfect place.
  */
-export declare const propertyTrackResolve: () => void;
+export function propertyTrackResolve(): void;