@arcgis/lumina 4.33.0-next.124 → 4.33.0-next.126

package/dist/controllers/index.js

@@ -1,6 +1,6 @@
-import { C as Controller, s as setAmbientComponent, i as isPromise, e as setParentController, f as retrieveParentControllers, t as trackKey, r as retrieveComponent, g as createEventFactory } from "../Controller-CZ8Djohh.js";
-import { G, h, l, j, c, o, k, n, m } from "../Controller-CZ8Djohh.js";
-import { p as proxyExports } from "../proxyExports-CK5BLFLO.js";
+import { C as Controller, s as setAmbientComponent, i as isPromise, q as queueMicroTask, d as setParentController, e as retrieveParentControllers, t as trackKey, r as retrieveComponent, f as createEventFactory } from "../Controller-B3mB4uaz.js";
+import { G, h, g, c, n, m, k, l, j } from "../Controller-B3mB4uaz.js";
+import { p as proxyExports } from "../proxyExports-DQobuu44.js";
 import { isServer } from "lit";
 import { observeAncestorsMutation, isEsriInternalEnv, getElementAttribute, getElementLocales, startLocaleObserver } from "@arcgis/components-utils";
 const makeController = (constructor) => proxy(void 0, constructor);
@@ -29,7 +29,7 @@ class FunctionalController extends Controller {
           this.exports = result;
           super.catchUpLifecycle();
         }).catch((error) => {
-          this._ready.reject(error);
+          this.P.reject(error);
           console.error(error);
         });
         this.onLoad(async () => await resolved);
@@ -37,10 +37,10 @@ class FunctionalController extends Controller {
         if (!constructorChangedExports || value !== void 0) {
           this.exports = value;
         }
-        queueMicrotask(() => super.catchUpLifecycle());
+        queueMicroTask(() => super.catchUpLifecycle());
       }
     } catch (error) {
-      this._ready.reject(error);
+      this.P.reject(error);
       console.error(error);
     }
   }
@@ -52,17 +52,20 @@ class FunctionalController extends Controller {
 const proxy = proxyExports(FunctionalController);
 const useWatchAttributes = (attributes, callback) => new AttributeWatchController(attributes, callback);
 class AttributeWatchController extends Controller {
-  constructor(_attributes, _callback) {
+  #observer;
+  #attributes;
+  #callback;
+  constructor(attributes, callback) {
     super();
-    this._attributes = _attributes;
-    this._callback = _callback;
     if (isServer) {
       return;
     }
-    this._observer = new MutationObserver((mutations) => {
+    this.#attributes = attributes;
+    this.#callback = callback;
+    this.#observer = new MutationObserver((mutations) => {
       mutations.forEach((mutation) => {
-        if (_attributes.includes(mutation.attributeName)) {
-          _callback.call(
+        if (attributes.includes(mutation.attributeName)) {
+          callback.call(
             this.component,
             this.component.el.getAttribute(mutation.attributeName),
             mutation.oldValue,
@@ -73,19 +76,19 @@ class AttributeWatchController extends Controller {
     });
   }
   hostConnected() {
-    this._attributes.forEach((attribute) => {
+    this.#attributes.forEach((attribute) => {
       if (this.component.el.hasAttribute(attribute)) {
-        this._callback.call(this.component, null, this.component.el.getAttribute(attribute), attribute);
+        this.#callback.call(this.component, null, this.component.el.getAttribute(attribute), attribute);
       }
     });
-    this._observer.observe(this.component.el, {
+    this.#observer.observe(this.component.el, {
       attributes: true,
       attributeOldValue: true,
-      attributeFilter: this._attributes
+      attributeFilter: this.#attributes
     });
   }
   hostDisconnected() {
-    this._observer.disconnect();
+    this.#observer.disconnect();
   }
 }
 const load = makeController;
@@ -97,9 +100,9 @@ const toFunction = (Class) => (...args) => {
 };
 const useMedia = (query) => makeController((_component, controller) => {
   const media = globalThis.matchMedia(query);
-  function changed() {
+  const changed = () => {
     controller.exports = media.matches;
-  }
+  };
   changed();
   controller.onLifecycle(() => {
     media.addEventListener("change", changed);
@@ -111,10 +114,10 @@ const defaultDirection = "ltr";
 const useDirection = () => makeController((component, controller) => {
   controller.exports = defaultDirection;
   controller.onLifecycle(() => {
-    function callback() {
+    const callback = () => {
       const dir = getElementAttribute(component.el, "dir", defaultDirection);
       controller.exports = dir === "rtl" ? "rtl" : "ltr";
-    }
+    };
     callback();
     return observeAncestorsMutation(component.el, ["dir"], callback);
   });
@@ -137,7 +140,7 @@ const makeT9nController = (getAssetPath) => (options = {}) => (
   // eslint-disable-next-line @typescript-eslint/promise-function-async
   makeController((component, controller) => {
     const locale = getElementLocales(component.el);
-    const pending = { _lang: locale.lang, _t9nLocale: locale.t9nLocale, _loading: true };
+    const pending = { ["_lang"]: locale.lang, ["_t9nLocale"]: locale.t9nLocale, ["_loading"]: true };
     const componentWithOverrides = component;
     controller.onLifecycle(
       () => startLocaleObserver(
@@ -146,9 +149,9 @@ const makeT9nController = (getAssetPath) => (options = {}) => (
         ({ t9nLocale, t9nStrings, lang }) => {
           const withoutOverrides = {
             ...t9nStrings,
-            _lang: lang,
-            _t9nLocale: t9nLocale,
-            _loading: false
+            ["_lang"]: lang,
+            ["_t9nLocale"]: t9nLocale,
+            ["_loading"]: false
           };
           controller.exports = withoutOverrides;
           const label = t9nStrings.componentLabel;
@@ -160,15 +163,15 @@ const makeT9nController = (getAssetPath) => (options = {}) => (
         options.name
       )
     );
-    function applyOverrides(messageOverrides) {
+    const applyOverrides = (messageOverrides) => {
       const currentValue = controller.exports;
-      const rawMessages = currentValue._original ?? currentValue;
+      const rawMessages = currentValue["_original"] ?? currentValue;
       const updated = deepMerge(rawMessages, messageOverrides);
       if (messageOverrides) {
-        updated._original = rawMessages;
+        updated["_original"] = rawMessages;
       }
       controller.exports = updated;
-    }
+    };
     if ("messageOverrides" in componentWithOverrides) {
       controller.onUpdate((changes) => {
         if (changes.has("messageOverrides")) {
@@ -184,7 +187,7 @@ const makeT9nController = (getAssetPath) => (options = {}) => (
     }
   })
 );
-function deepMerge(original, overwrites) {
+const deepMerge = (original, overwrites) => {
   if (!overwrites) {
     return original;
   }
@@ -197,10 +200,10 @@ function deepMerge(original, overwrites) {
     }
   });
   return merged;
-}
+};
 const usePropertyChange = (_component) => propertyChangeController;
 const eventName = "arcgisPropertyChange";
-function propertyChangeController(...toWatch) {
+const propertyChangeController = (...toWatch) => {
   const component = retrieveComponent();
   const eventEmitter = createEventFactory(eventName, void 0, component);
   if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
@@ -240,15 +243,15 @@ function propertyChangeController(...toWatch) {
     );
   }
   return eventEmitter;
-}
+};
 export {
   Controller,
   G as GenericController,
-  h as bypassGetter,
-  l as bypassReadOnly,
-  j as bypassSetter,
+  h as bypassReadOnly,
+  g as bypassSetter,
   c as controllerSymbol,
-  o as isController,
+  n as getControllersCount,
+  m as isController,
   k as keyTrackResolve,
   load,
   makeController,
@@ -258,8 +261,8 @@ export {
   retrieveComponent,
   toFunction,
   trackKey,
-  n as trackPropKey,
-  m as trackPropertyKey,
+  l as trackPropKey,
+  j as trackPropertyKey,
   useDirection,
   useMedia,
   usePropertyChange,

package/dist/controllers/trackKey.d.ts

@@ -5,4 +5,4 @@ import { BaseController, TrackKeyResolution } from './types';
  * you want to track a property, but don't know if it will be defined with the
  * \@property() decorator or not
  */
-export declare function trackKey<T>(hostsCandidates: ((BaseController | LitElement)[] | BaseController | LitElement) | undefined, onResolved: (resolution: TrackKeyResolution | undefined) => void, defaultValue: T): T;
+export declare const trackKey: <T>(hostsCandidates: ((BaseController | LitElement)[] | BaseController | LitElement) | undefined, onResolved: (resolution: TrackKeyResolution | undefined) => void, defaultValue: T) => T;

package/dist/controllers/trackPropKey.d.ts

@@ -18,4 +18,4 @@ import { LitElement } from '../LitElement';
  *   \@state() myState = trackMe();
  * }
  */
-export declare function trackPropKey<T>(component: LitElement, onResolved: (key: string | undefined) => void, defaultValue: T): T;
+export declare const trackPropKey: <T>(component: LitElement, onResolved: (key: string | undefined) => void, defaultValue: T) => T;

package/dist/controllers/trackPropertyKey.d.ts

@@ -20,10 +20,10 @@ import { BaseController } from './types';
  * }
  *
  */
-export declare function trackPropertyKey<T>(object: BaseController | LitElement, onResolved: (key: string | undefined) => void, defaultValue: T): T;
+export declare const 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 function keyTrackResolve(): void;
+export declare const keyTrackResolve: () => void;

package/dist/controllers/types.d.ts

@@ -149,4 +149,39 @@ export type LuminaPropertyDeclaration = PropertyDeclaration & {
      * ```
      */
     readonly readOnly?: boolean;
+    /**
+     * Short for "changed"
+     *
+     * Temporary set during a setter to track whether property is considered
+     * changed.
+     * @private
+     */
+    c?: boolean;
+    /**
+     * Short for "descriptor"
+     *
+     * Stores a reference to the property getter and setter. This is overwritten
+     * in useAccessor to proxy the get/set through the Accessor instance.
+     * @private
+     */
+    d?: PropertyDescriptor;
+    /**
+     * The positional index of the Accessor controller to which this property is
+     * bound.
+     * @private
+     */
+    i?: number;
+};
+/** @private */
+export type AccessorObservableLike = {
+    /**
+     * A callback that will be called in the setter if the value hasChanged to
+     * integrate with Accessor's reactivity notification system.
+     */
+    notify: () => void;
+};
+/** @private */
+export type ReactiveTrackingTarget = {
+    clear: () => void;
+    destroy: () => void;
 };

package/dist/controllers/utils.d.ts

@@ -1,15 +1,13 @@
-import { Controller } from './Controller';
+import { LitElement } from '../LitElement';
 import { ControllerLifecycleMethods } from './types';
+export declare const queueMicroTask: typeof queueMicrotask;
 export declare const isController: (value: unknown) => value is ControllerLifecycleMethods;
 /**
- * In development, on hot module reload, controller would be re-initialized
- * with all Props and State values persistent, but properties lost. This unsafe
- * development-only API lets you set or get data for a controller that would
- * persist across hot reloads.
+ * Checks if the argument is a promise by checking if it has a `then` method.
  */
-export declare const devOnlySetPersistentControllerData: ((controller: Controller<unknown>, data: unknown) => void) | undefined;
-export declare const devOnlyGetPersistentControllerData: (<T>(controller: Controller<unknown>) => T | undefined) | undefined;
+export declare const isPromise: <T>(arg: Promise<T> | T) => arg is Promise<T>;
 /**
- * Checks if the argument is a promise by checking if it has a `then` method.
+ * Get the number of controllers current component has. Can be used to get a
+ * unique id for each controller.
  */
-export declare function isPromise<T>(arg: Promise<T> | T): arg is Promise<T>;
+export declare const getControllersCount: (component: LitElement) => number;

package/dist/hmrSupport.js

@@ -1,4 +1,4 @@
-import { n as noShadowRoot, P as ProxyComponent } from "./utils-BdB9g3GU.js";
+import { n as noShadowRoot, P as ProxyComponent } from "./lazyLoad-ByH-FaBP.js";
 import { camelToKebab } from "@arcgis/components-utils";
 function handleHmrUpdate(newModules) {
   newModules.forEach((newModule) => {
@@ -6,26 +6,26 @@ function handleHmrUpdate(newModules) {
       return;
     }
     Object.values(newModule).forEach((exported) => {
-      if (typeof exported !== "function" || typeof exported.tagName !== "string") {
+      if (typeof exported !== "function" || typeof exported.L !== "string") {
         return;
       }
       const LitConstructor = exported;
-      const ProxyClass = customElements.get(LitConstructor.tagName);
+      const ProxyClass = customElements.get(LitConstructor.L);
       if (ProxyClass === void 0) {
-        throw new Error(`Failed to find custom element proxy for tag name: ${LitConstructor.tagName}`);
+        throw new Error(`Failed to find custom element proxy for tag name: ${LitConstructor.L}`);
       }
-      ProxyClass._LitConstructor = void 0;
-      ProxyClass._loadPromise = void 0;
-      ProxyClass._hmrIndex ??= 0;
-      ProxyClass._hmrIndex += 1;
-      ProxyClass._initializePrototype();
-      ProxyClass._hmrInstances?.forEach((instanceWeakRef) => {
+      ProxyClass.A = void 0;
+      ProxyClass.B = void 0;
+      ProxyClass.devOnly$hmrIndex ??= 0;
+      ProxyClass.devOnly$hmrIndex += 1;
+      ProxyClass.F();
+      ProxyClass.devOnly$hmrInstances?.forEach((instanceWeakRef) => {
         const instance = instanceWeakRef.deref();
         if (instance === void 0) {
           return;
         }
-        if (instance._litElement === void 0) {
-          void ProxyClass._loadPromise.then(() => reInitialize(instance, newModule));
+        if (instance.$component === void 0) {
+          void ProxyClass.B.then(() => reInitialize(instance, newModule));
         } else {
           reInitialize(instance, newModule);
         }
@@ -35,7 +35,7 @@ function handleHmrUpdate(newModules) {
   });
 }
 function reInitialize(instance, newModule) {
-  const PreviousLitConstructor = instance._litElement.constructor;
+  const PreviousLitConstructor = instance.$component.constructor;
   const isShadowRoot = PreviousLitConstructor.shadowRootOptions !== noShadowRoot;
   if (!isShadowRoot) {
     const root = instance.getRootNode() ?? document;
@@ -53,20 +53,20 @@ function reInitialize(instance, newModule) {
   }
   const properties = PreviousLitConstructor.elementProperties;
   const preservedProperties = Array.from(properties.entries()).filter(
-    ([propertyName, descriptor]) => typeof propertyName === "string" && (instance._hmrSetProps.has(propertyName) || typeof descriptor.attribute === "string" && instance._hmrSetAttributes.has(descriptor.attribute))
+    ([propertyName, descriptor]) => typeof propertyName === "string" && (instance.devOnly$hmrSetProps.has(propertyName) || typeof descriptor.attribute === "string" && instance.devOnly$hmrSetAttributes.has(descriptor.attribute))
   ).map(([key]) => [key, instance[key]]);
-  instance._store = Object.fromEntries(preservedProperties);
+  instance.devOnly$hmrResetStore(Object.fromEntries(preservedProperties));
   if (instance.isConnected) {
-    instance._litElement.disconnectedCallback();
+    instance.$component.disconnectedCallback();
   }
-  const renderRoot = instance._litElement?.renderRoot;
+  const renderRoot = instance.$component?.renderRoot;
   if (renderRoot) {
-    renderRoot._$litPart$ = void 0;
+    renderRoot["_$litPart$"] = void 0;
     while (renderRoot.firstChild) {
       renderRoot.removeChild(renderRoot.firstChild);
     }
   }
-  instance._initializeComponent(newModule);
+  instance.devOnly$InitializeComponent(newModule);
 }
 function handleComponentMetaUpdate(meta) {
   const ProxyClass = customElements.get(meta.tagName);
@@ -85,9 +85,9 @@ function handleComponentMetaUpdate(meta) {
      */
     attributes.filter((attribute) => !originallyObserved.has(attribute))
   );
-  ProxyClass._asyncMethods = meta.asyncMethods;
-  ProxyClass._syncMethods = meta.syncMethods;
-  ProxyClass._properties = meta.properties.map(([name]) => name);
+  ProxyClass.E = meta.asyncMethods;
+  ProxyClass.D = meta.syncMethods;
+  ProxyClass.C = meta.properties.map(([name]) => name);
   ProxyClass.observedAttributes = attributes;
 }
 function initializeAttributeObserver() {

package/dist/index.d.ts

@@ -12,6 +12,6 @@ export type { EventHandler } from './jsx/baseTypes';
 export * from './jsx/types';
 export { safeClassMap, safeStyleMap, deferLoad, deferredLoaders, directive, live } from './jsx/directives';
 export { nothing, noChange, setAttribute, stringOrBoolean } from './jsx/utils';
-export { noShadowRoot } from './utils';
+export { noShadowRoot, devOnly$getLitElementTagNameAndRuntime } from './utils';
 export { makeReactWrapperFactory, getReactWrapperOptions } from './wrappersUtils';
 export { renderElement } from './render';