@arcgis/lumina 4.33.0-next.99 → 4.34.0-next.1

package/dist/LitElement.d.ts

@@ -34,9 +34,19 @@ type ComponentLifecycle = {
  * only.
  */
 export declare class LitElement extends OriginalLitElement implements ComponentLifecycle {
+    #private;
+    /**
+     * @private
+     * @remarks
+     * We prefix private variables with double underscore to avoid collisions with
+     * subclasses. All runtime properties that start with underscore are mangled
+     * in production build, so collision avoidance is mainly important to avoid
+     * triggering TypeScript errors.
+     */
+    static __runtime: Runtime;
     /** @private */
-    static runtime: Runtime;
-    static tagName: string;
+    static __tagName: string;
+    static elementProperties: Map<PropertyKey, LuminaPropertyDeclaration>;
     /**
      * Customize Lit's default style handling to support non-shadow-root styles
      */
@@ -50,6 +60,7 @@ export declare class LitElement extends OriginalLitElement implements ComponentL
      * only to satisfy the type checker.
      */
     options?: LuminaPropertyDeclaration | number | [number, LuminaPropertyDeclaration]): void;
+    protected static getPropertyDescriptor(name: PropertyKey, key: string | symbol, options: LuminaPropertyDeclaration): PropertyDescriptor | undefined;
     /**
      * Since we can't pass arguments to web component constructor, before lazy
      * loading logic calls document.createElement(), it temporary sets this static
@@ -57,7 +68,7 @@ export declare class LitElement extends OriginalLitElement implements ComponentL
      *
      * @private
      * */
-    static lazy: ProxyComponent | undefined;
+    static __lazy: ProxyComponent | undefined;
     static readonly lumina = true;
     /**
      * In lazy build, the actual DOM element differs from the class instance:
@@ -86,15 +97,18 @@ export declare class LitElement extends OriginalLitElement implements ComponentL
      * https://lit.dev/docs/composition/controllers/
      *
      * @private
+     * @privateRemarks
+     * For most private names I tried to prefix with __ to not conflict with
+     * private names on subclasses. However, Lit already has __controllers private.
      */
-    readonly _controllers: Set<BaseController | Controller<unknown>>;
+    readonly _controllers: (BaseController | Controller<unknown>)[];
     /**
      * Controller Manager orchestrates all controllers used by this component,
      * connecting their lifecycle hooks and providing context information.
      */
     readonly manager: ControllerManager;
     /** @private */
-    _postLoad: ProxyComponent["_postLoad"];
+    __postLoadDeferred: ProxyComponent["__postLoadDeferred"];
     /**
      * Direct offspring that should be awaited before loaded() is emitted.
      *
@@ -102,19 +116,10 @@ export declare class LitElement extends OriginalLitElement implements ComponentL
      *
      * @private
      */
-    _offspring: ProxyComponent["_offspring"];
-    /**
-     * Promise that resolves once parent's load() completed. False if there is no
-     * parent
-     *
-     * @private
-     */
-    _ancestorLoad: ProxyComponent["_ancestorLoad"];
-    private _originalShouldUpdate?;
-    private _enableUpdating;
-    private _postLoaded;
+    __offspringComponents: ProxyComponent["__offspringComponents"];
     constructor();
     connectedCallback(): void;
+    disconnectedCallback(): void;
     /**
      * Overwrite Lit's default behavior of attaching shadow root to the lit
      * element, and instead use this.el to support lazy builds.
@@ -122,13 +127,12 @@ export declare class LitElement extends OriginalLitElement implements ComponentL
      * Also, support the case when component asked to not use shadow root
      */
     protected createRenderRoot(): DocumentFragment | HTMLElement;
-    /** Do asynchronous component load */
-    private _load;
     /**
      * Overwriting default shouldUpdate simply to get access to
      * "changedProperties" so that we can later provide it to ControllerManager
      */
     protected shouldUpdate(_changedProperties: PropertyValues): boolean;
+    protected update(changedProperties: PropertyValues): void;
     /**
      * A helper for setting event listener on the current component.
      *

package/dist/config.d.ts

@@ -12,12 +12,10 @@ export declare const lazyMetaSubItemJoiner = ":";
  * object, we pass it a compact number, that gets converted back to an object
  * in createProperty() at runtime.
  */
-export declare enum PropertyFlags {
-    ATTRIBUTE = 1,
-    REFLECT = 2,
-    BOOLEAN = 4,
-    NUMBER = 8,
-    STATE = 16,
-    READ_ONLY = 32,
-    NO_ACCESSOR = 64
-}
+export declare const propertyFlagAttribute: number;
+export declare const propertyFlagReflect: number;
+export declare const propertyFlagBoolean: number;
+export declare const propertyFlagNumber: number;
+export declare const propertyFlagState: number;
+export declare const propertyFlagReadOnly: number;
+export declare const propertyFlagNoAccessor: number;

package/dist/config.js

@@ -1,19 +1,22 @@
 const lazyMetaGroupJoiner = ";";
 const lazyMetaItemJoiner = ",";
 const lazyMetaSubItemJoiner = ":";
-var PropertyFlags = /* @__PURE__ */ ((PropertyFlags2) => {
-  PropertyFlags2[PropertyFlags2["ATTRIBUTE"] = 1] = "ATTRIBUTE";
-  PropertyFlags2[PropertyFlags2["REFLECT"] = 2] = "REFLECT";
-  PropertyFlags2[PropertyFlags2["BOOLEAN"] = 4] = "BOOLEAN";
-  PropertyFlags2[PropertyFlags2["NUMBER"] = 8] = "NUMBER";
-  PropertyFlags2[PropertyFlags2["STATE"] = 16] = "STATE";
-  PropertyFlags2[PropertyFlags2["READ_ONLY"] = 32] = "READ_ONLY";
-  PropertyFlags2[PropertyFlags2["NO_ACCESSOR"] = 64] = "NO_ACCESSOR";
-  return PropertyFlags2;
-})(PropertyFlags || {});
+const propertyFlagAttribute = 1 << 0;
+const propertyFlagReflect = 1 << 1;
+const propertyFlagBoolean = 1 << 2;
+const propertyFlagNumber = 1 << 3;
+const propertyFlagState = 1 << 4;
+const propertyFlagReadOnly = 1 << 5;
+const propertyFlagNoAccessor = 1 << 6;
 export {
-  PropertyFlags,
   lazyMetaGroupJoiner,
   lazyMetaItemJoiner,
-  lazyMetaSubItemJoiner
+  lazyMetaSubItemJoiner,
+  propertyFlagAttribute,
+  propertyFlagBoolean,
+  propertyFlagNoAccessor,
+  propertyFlagNumber,
+  propertyFlagReadOnly,
+  propertyFlagReflect,
+  propertyFlagState
 };

package/dist/context.d.ts

@@ -14,7 +14,7 @@ interface ContextConsumerOptions<C extends Context<unknown, unknown>> {
  *
  * @see https://lit.dev/docs/data/context/
  */
-export declare function useContextProvider<C extends Context<unknown, unknown>>(options: ContextProviderOptions<C>): ContextProvider<C>;
+export declare const useContextProvider: <C extends Context<unknown, unknown>>(options: ContextProviderOptions<C>) => ContextProvider<C>;
 /**
  * Wrapper for Lit's ContextConsumer controller to provide lazy-loading compatibility.
  *
@@ -22,7 +22,7 @@ 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, LitContextHost>;
+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.

package/dist/controllers/Controller.d.ts

@@ -12,15 +12,12 @@ import { LitElement } from '../LitElement';
  * See ./examples.tsx for many example controllers and their usages.
  */
 export declare abstract class Controller<Exports = never> implements BaseController {
-    protected _callbacks: {
-        readonly [KEY in keyof Omit<ControllerLifecycleMethods, "controllerRemoved">]-?: NonNullable<ControllerLifecycleMethods[KEY]>[];
-    };
-    protected _ready: Deferred<Exports>;
-    private _lifecycleCleanups;
+    #private;
     /** @private */
-    assignedProperty?: string | false;
+    protected __ready: Deferred<Exports>;
+    /** @private */
+    __assignedProperty?: string | false;
     connectedCalled: boolean;
-    protected _loadCalled: boolean;
     loadedCalled: boolean;
     readonly [controllerSymbol] = true;
     component: LitElement;
@@ -31,7 +28,6 @@ export declare abstract class Controller<Exports = never> implements BaseControl
      * construction, then trigger connected and load right away
      */
     catchUpLifecycle(): void;
-    private _exports;
     get exports(): Exports;
     /**
      * Set controller's exports property (for usage with proxyExports()) and mark
@@ -58,7 +54,6 @@ export declare abstract class Controller<Exports = never> implements BaseControl
     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;
-    private _exportWatchers;
     watchExports(callback: (exports: Exports) => void): () => void;
     /**
      * A flexible utility for making sure a controller is loaded before it's used,
@@ -126,7 +121,6 @@ export declare abstract class Controller<Exports = never> implements BaseControl
     triggerDestroy(): void;
     /** @private */
     triggerLifecycle(): void;
-    private _callLifecycle;
 }
 export declare abstract class GenericControllerType<Exports, Requires = LitElement> extends Controller<Exports> {
     component: LitElement & Requires;

package/dist/controllers/ControllerInternals.d.ts

@@ -1,16 +1,16 @@
 import { Controller } from './Controller';
 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;
+export declare const setAmbientComponent: (component: LitElement) => void;
+export declare const retrieveComponent: (name?: string) => LitElement;
+export declare const setParentController: (controller: BaseController | undefined) => void;
 /**
  * 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.
  */
-export declare function retrieveParentControllers(): readonly BaseController[];
-export declare function setAmbientChildController(controller: BaseController | undefined): void;
+export declare const retrieveParentControllers: () => readonly BaseController[];
+export declare const setAmbientChildController: (controller: BaseController | undefined) => void;
 /**
  * The type definition has to be duplicated due to this TypeScript error:
  * "'use' is referenced directly or indirectly in its own type annotation."
@@ -18,23 +18,17 @@ 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;
-/** @deprecated */
-export declare let shouldBypassGetter: boolean;
 export declare let shouldBypassReadOnly: boolean;
 /**
  * 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;
+export declare const 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 function bypassGetter<T = void>(callback: () => T): T | void;
+export declare const bypassSetter: <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

@@ -7,9 +7,9 @@ import { LitElement } from '../LitElement';
  * component, loads them, and forwards lifecycle events to them.
  */
 export declare class ControllerManager extends GenericController<undefined> {
+    #private;
     hasDestroy: boolean;
     destroyed: boolean;
-    private _autoDestroyTimeout?;
     constructor(component: LitElement);
     /**
      * Throws an error if component does not implement destroy() lifecycle, but
@@ -17,25 +17,23 @@ export declare class ControllerManager extends GenericController<undefined> {
      *
      * @private
      */
-    _ensureHasDestroy?: () => void;
+    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
      */
-    private _enforceReadonly;
+    _isEnforcingReadonly: boolean;
     /** @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>;
     /**
      * Map with keys for any properties that have changed since the last
      * update cycle with previous values.
@@ -46,20 +44,7 @@ export declare class ControllerManager extends GenericController<undefined> {
      *
      * @private
      */
-    _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;
+    _changedProperties?: PropertyValues;
     /**
      * Associate an exports object with a controller for reverse lookup in
      * controller.use

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

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