@arcgis/lumina 4.33.0-next.123 → 4.33.0-next.125

package/dist/{Controller-CZ8Djohh.js → Controller-B3mB4uaz.js}

@@ -1,50 +1,23 @@
 import { isEsriInternalEnv, safeCall, Deferred, safeAsyncCall } from "@arcgis/components-utils";
 import { nothing } from "lit";
 const controllerSymbol = Symbol.for("controller");
-const name = "@arcgis/lumina";
+const queueMicroTask = queueMicrotask;
 const isController = (value) => typeof value === "object" && value !== null && (controllerSymbol in value || "hostConnected" in value || "hostDisconnected" in value || "hostUpdate" in value || "hostUpdated" in value);
-const devOnlySetPersistentControllerData = process.env.NODE_ENV !== "production" && isEsriInternalEnv() ? (controller, data) => {
-  const controllers = controller.component._controllers;
-  const index = Array.from(controllers).indexOf(controller);
-  if (index === -1) {
-    return;
-  }
-  const devOnlyControllerData = Symbol.for(`${name}: devOnlyControllerData`);
-  const el = controller.component.el;
-  el[devOnlyControllerData] ??= {};
-  el[devOnlyControllerData][index] = data;
-} : void 0;
-const devOnlyGetPersistentControllerData = process.env.NODE_ENV !== "production" && isEsriInternalEnv() ? (controller) => {
-  const manager = controller.component.manager;
-  const controllers = "_controllers" in manager ? manager._controllers : void 0;
-  if (controllers === void 0) {
-    return void 0;
-  }
-  const index = Array.from(controllers).indexOf(controller);
-  const devOnlyControllerData = Symbol.for(`${name}: devOnlyControllerData`);
-  const el = controller.component.el;
-  return el[devOnlyControllerData]?.[index];
-} : void 0;
-function isPromise(arg) {
-  return typeof arg?.then === "function";
-}
+const isPromise = (arg) => typeof arg?.then === "function";
+const getControllersCount = (component) => component.M.length;
 let ambientComponent;
-function setAmbientComponent(component) {
+const setAmbientComponent = (component) => {
   if (ambientComponent === component) {
     return;
   }
   ambientComponent = component;
-  queueMicrotask(() => {
-    if (ambientComponent === component) {
-      ambientComponent = void 0;
-    }
-  });
-}
-function retrieveComponent(name2) {
+  queueMicroTask(() => ambientComponent === component ? ambientComponent = void 0 : 0);
+};
+const retrieveComponent = (name) => {
   if (process.env.NODE_ENV !== "production" && ambientComponent === void 0) {
     throw new Error(
       [
-        `Unable to find out which component ${name2 || "this"} controller `,
+        `Unable to find out which component ${name || "this"} controller `,
         "belongs to. Possible causes:\n",
         "- You might have multiple versions of ",
         "@arcgis/lumina package installed\n",
@@ -63,39 +36,31 @@ function retrieveComponent(name2) {
     );
   }
   return ambientComponent;
-}
+};
 let ambientControllers = [];
-function setParentController(controller) {
+const setParentController = (controller) => {
   if (controller === void 0) {
     ambientControllers = [];
     return;
   }
   const index = ambientControllers.indexOf(controller);
   ambientControllers = index === -1 ? [...ambientControllers, controller] : ambientControllers.slice(0, index + 1);
-  queueMicrotask(() => {
-    ambientControllers = [];
-  });
-}
-function retrieveParentControllers() {
-  return ambientControllers;
-}
+  queueMicroTask(() => ambientControllers = []);
+};
+const retrieveParentControllers = () => ambientControllers;
 let ambientChildController;
-function setAmbientChildController(controller) {
+const setAmbientChildController = (controller) => {
   if (ambientChildController === controller) {
     return;
   }
   ambientChildController = controller;
-  queueMicrotask(() => {
-    if (ambientChildController === controller) {
-      ambientChildController = void 0;
-    }
-  });
-}
-function retrieveAmbientChildController() {
+  queueMicroTask(() => ambientChildController === controller ? ambientChildController = void 0 : 0);
+};
+const retrieveAmbientChildController = () => {
   const controller = ambientChildController;
   ambientChildController = void 0;
   return controller;
-}
+};
 const use = async (value, watchExports) => {
   const controller = useRefSync(value);
   if (controller === void 0) {
@@ -129,7 +94,7 @@ const useRef = async (value) => {
 };
 const useRefSync = (value) => {
   const component = retrieveComponent();
-  const controller = component.manager._resolveExports(value);
+  const controller = component.manager.X(value);
   if (controller !== void 0) {
     return controller;
   }
@@ -142,30 +107,21 @@ const useRefSync = (value) => {
   }
   return void 0;
 };
-let shouldBypassGetter = false;
 let shouldBypassReadOnly = false;
-function bypassReadOnly(callback) {
+const bypassReadOnly = (callback) => {
   shouldBypassReadOnly = true;
   try {
     return callback();
   } finally {
     shouldBypassReadOnly = false;
   }
-}
+};
 const bypassSetter = bypassReadOnly;
-function bypassGetter(callback) {
-  shouldBypassGetter = true;
-  try {
-    return callback();
-  } finally {
-    shouldBypassGetter = false;
-  }
-}
-function trackPropertyKey(object, onResolved, defaultValue) {
+const trackPropertyKey = (object, onResolved, defaultValue) => {
   const keys = Object.keys(object);
   const keyCount = keys.length;
   if (keyTrackMap === void 0) {
-    queueMicrotask(keyTrackResolve);
+    queueMicroTask(keyTrackResolve);
   }
   keyTrackMap ??= /* @__PURE__ */ new Map();
   let pendingTrackers = keyTrackMap.get(object);
@@ -190,31 +146,31 @@ function trackPropertyKey(object, onResolved, defaultValue) {
     }
   });
   return defaultValue;
-}
+};
 let keyTrackMap = void 0;
-function keyTrackResolve() {
+const keyTrackResolve = () => {
   keyTrackMap?.forEach(({ callbacks }, object) => {
     const keys = Object.keys(object);
     callbacks.forEach((commit) => commit(keys));
   });
   keyTrackMap = void 0;
-}
-function trackPropKey(component, onResolved, defaultValue) {
+};
+const trackPropKey = (component, onResolved, defaultValue) => {
   const manager = component.manager;
-  if (manager._trackedValue !== nothing && manager._trackedValue !== defaultValue) {
-    manager._firePropTrackers(void 0, void 0);
+  if (manager.V !== nothing && manager.V !== defaultValue) {
+    manager.S(void 0, void 0);
   }
-  if (manager._keyTrackers.length === 0) {
-    queueMicrotask(() => manager._firePropTrackers(void 0, void 0));
+  if (manager.T.length === 0) {
+    queueMicroTask(() => manager.S(void 0, void 0));
   }
-  manager._trackedValue = defaultValue;
-  manager._keyTrackers.push((key, value) => safeCall(onResolved, void 0, defaultValue === value ? key : void 0));
+  manager.V = defaultValue;
+  manager.T.push((key, value) => safeCall(onResolved, void 0, defaultValue === value ? key : void 0));
   return defaultValue;
-}
-function trackKey(hostsCandidates = [
+};
+const trackKey = (hostsCandidates = [
   retrieveComponent(),
   ...retrieveParentControllers()
-], onResolved, defaultValue) {
+], onResolved, defaultValue) => {
   const candidateHosts = Array.isArray(hostsCandidates) ? hostsCandidates : [hostsCandidates];
   let leftToResolve = candidateHosts.length + 1;
   const resolved = (resolution) => {
@@ -234,7 +190,7 @@ function trackKey(hostsCandidates = [
     )
   );
   for (const host of candidateHosts) {
-    if ("manager" in host && typeof host.manager === "object" && host.manager.component === host) {
+    if ("manager" in host && host.manager.component === host) {
       trackPropKey(
         host,
         (key) => resolved(key === void 0 ? void 0 : { key, host, isReactive: true }),
@@ -244,7 +200,7 @@ function trackKey(hostsCandidates = [
     }
   }
   return defaultValue;
-}
+};
 const createEventFactory = (eventName = "", options = {}, component = retrieveComponent()) => {
   const emitter = {
     emit: (payload) => {
@@ -271,12 +227,12 @@ const createEventFactory = (eventName = "", options = {}, component = retrieveCo
   if (eventName === "") {
     trackKey(
       void 0,
-      (resolution) => {
-        if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && resolution === void 0) {
+      process.env.NODE_ENV !== "production" && isEsriInternalEnv() ? (resolution) => {
+        if (resolution === void 0) {
           throw new Error(`createEvent must be called in property default value only`);
         }
         eventName = resolution.key;
-      },
+      } : (resolution) => eventName = resolution.key,
       emitter
     );
   }
@@ -287,26 +243,26 @@ var _a;
 _a = controllerSymbol;
 class Controller {
   constructor(component) {
-    this._callbacks = {
-      hostConnected: [],
-      hostDisconnected: [],
-      hostLoad: [],
-      hostLoaded: [],
-      hostUpdate: [],
-      hostUpdated: [],
-      hostDestroy: [],
-      hostLifecycle: []
-    };
-    this._ready = new Deferred();
-    this._lifecycleCleanups = [];
+    this.#hostConnected = [];
+    this.#hostDisconnected = [];
+    this.#hostLoad = [];
+    this.#hostLoaded = [];
+    this.#hostUpdate = [];
+    this.#hostUpdated = [];
+    this.#hostDestroy = [];
+    this.#hostLifecycle = [];
+    this.#lifecycleCleanups = [];
+    this.#loadCalled = false;
+    this.P = new Deferred();
     this.connectedCalled = false;
-    this._loadCalled = false;
     this.loadedCalled = false;
     this[_a] = true;
-    this.ready = this._ready.promise;
-    this._exports = makeProvisionalValue(this);
-    this._exportWatchers = /* @__PURE__ */ new Set();
+    this.#exportWatchers = [];
+    const that = this;
     const resolvedComponent = component ?? retrieveComponent(new.target.name);
+    that.#component = resolvedComponent;
+    that.ready = that.P.promise;
+    that.#exports = makeProvisionalValue(that);
     if (process.env.NODE_ENV !== "production") {
       Object.defineProperty(this, "component", {
         writable: false,
@@ -315,43 +271,54 @@ class Controller {
         value: resolvedComponent
       });
       if ("hostDestroy" in this) {
-        this.component.manager._ensureHasDestroy?.();
+        that.#component.manager.devOnly$ensureHasDestroy?.();
       }
     } else {
-      this.component = resolvedComponent;
+      that.component = resolvedComponent;
     }
-    this.component.addController(this);
-    const manager = this.component.manager;
+    that.#component.addController(that);
+    const manager = that.#component.manager;
     const isInControllerManager = manager === void 0;
     if (!isInControllerManager) {
-      setParentController(this);
-      queueMicrotask(() => this.catchUpLifecycle());
+      setParentController(that);
+      queueMicroTask(() => that.catchUpLifecycle());
     }
   }
+  #hostConnected;
+  #hostDisconnected;
+  #hostLoad;
+  #hostLoaded;
+  #hostUpdate;
+  #hostUpdated;
+  #hostDestroy;
+  #hostLifecycle;
+  #lifecycleCleanups;
+  #loadCalled;
+  #component;
   /**
    * If controller is being added dynamically, after the component
    * construction, then trigger connected and load right away
    */
   catchUpLifecycle() {
-    const { manager } = this.component;
+    const { manager } = this.#component;
     const connectedWillStillHappen = !manager.connectedCalled;
     if (!connectedWillStillHappen && !this.connectedCalled) {
       this.triggerConnected();
     }
-    const loadWillStillHappen = !manager._loadCalled;
+    const loadWillStillHappen = !manager.#loadCalled;
     if (loadWillStillHappen) {
       return;
     }
-    this.triggerLoad().then(() => {
-      const loadedWillStillHappen = !manager.loadedCalled;
-      if (loadedWillStillHappen) {
-        return;
-      }
-      this.triggerLoaded();
-    }).catch(console.error);
-  }
+    this.triggerLoad().then(
+      () => (
+        // Call loaded ourself, unless manager is going to do it
+        manager.loadedCalled && this.triggerLoaded()
+      )
+    ).catch(console.error);
+  }
+  #exports;
   get exports() {
-    return this._exports;
+    return this.#exports;
   }
   /**
    * Set controller's exports property (for usage with proxyExports()) and mark
@@ -359,24 +326,25 @@ class Controller {
    * re-render of the component
    */
   set exports(exports) {
-    const oldExports = this._exports;
+    const oldExports = this.#exports;
     if (oldExports !== exports) {
-      this._exports = exports;
-      this._exportWatchers.forEach(safeCall);
-      if (this.connectedCalled && this.assignedProperty !== false) {
-        this.component.requestUpdate(this.assignedProperty, oldExports);
+      this.#exports = exports;
+      this.#exportWatchers.forEach(safeCall);
+      if (this.connectedCalled && this.O !== false) {
+        this.#component.requestUpdate(this.O, oldExports);
       }
     }
-    this._ready.resolve(exports);
+    this.P.resolve(exports);
   }
   setProvisionalExports(exports, proxy = true) {
-    this._exports = proxy ? makeProvisionalValue(exports) : exports;
-    this._exportWatchers.forEach(safeCall);
+    this.#exports = proxy ? makeProvisionalValue(exports) : exports;
+    this.#exportWatchers.forEach(safeCall);
   }
+  #exportWatchers;
   watchExports(callback) {
-    const safeCallback = () => callback(this._exports);
-    this._exportWatchers.add(safeCallback);
-    return () => void this._exportWatchers.delete(safeCallback);
+    const safeCallback = () => callback(this.#exports);
+    this.#exportWatchers.push(safeCallback);
+    return () => void this.#exportWatchers.splice(this.#exportWatchers.indexOf(safeCallback), 1);
   }
   /**
    * A flexible utility for making sure a controller is loaded before it's used,
@@ -399,7 +367,7 @@ class Controller {
    * require awaiting them as they are guaranteed to be loaded by then.
    */
   get use() {
-    setAmbientComponent(this.component);
+    setAmbientComponent(this.#component);
     return use;
   }
   /**
@@ -416,7 +384,7 @@ class Controller {
    *   some other method on the controller
    */
   get useRef() {
-    setAmbientComponent(this.component);
+    setAmbientComponent(this.#component);
     return useRef;
   }
   /**
@@ -425,135 +393,130 @@ class Controller {
    * @private
    */
   get useRefSync() {
-    setAmbientComponent(this.component);
+    setAmbientComponent(this.#component);
     return useRefSync;
   }
   controllerRemoved() {
-    if (this.component.el.isConnected) {
+    if (this.#component.el.isConnected) {
       this.triggerDisconnected();
     }
     this.triggerDestroy();
   }
   // Register a lifecycle callback
   onConnected(callback) {
-    this._callbacks.hostConnected.push(callback);
+    this.#hostConnected.push(callback);
   }
   onDisconnected(callback) {
-    this._callbacks.hostDisconnected.push(callback);
+    this.#hostDisconnected.push(callback);
   }
   onLoad(callback) {
-    this._callbacks.hostLoad.push(callback);
+    this.#hostLoad.push(callback);
   }
   onLoaded(callback) {
-    this._callbacks.hostLoaded.push(callback);
+    this.#hostLoaded.push(callback);
   }
   onUpdate(callback) {
-    this._callbacks.hostUpdate.push(callback);
+    this.#hostUpdate.push(callback);
   }
   onUpdated(callback) {
-    this._callbacks.hostUpdated.push(callback);
+    this.#hostUpdated.push(callback);
   }
   onDestroy(callback) {
     if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
-      this.component.manager._ensureHasDestroy?.();
+      this.#component.manager.devOnly$ensureHasDestroy?.();
     }
-    this._callbacks.hostDestroy.push(callback);
+    this.#hostDestroy.push(callback);
   }
   onLifecycle(callback) {
-    this._callbacks.hostLifecycle.push(callback);
-    if (this.connectedCalled && this.component.el.isConnected) {
-      this._callLifecycle(callback);
+    this.#hostLifecycle.push(callback);
+    if (this.connectedCalled && this.#component.el.isConnected) {
+      this.#callLifecycle(callback);
     }
   }
   // Call each lifecycle hook
   /** @private */
   triggerConnected() {
-    const genericController = this;
-    if (genericController.hostConnected) {
-      safeCall(genericController.hostConnected, genericController);
+    const that = this;
+    if (that.hostConnected) {
+      safeCall(that.hostConnected, that);
     }
-    this._callbacks.hostConnected.forEach(safeCall);
-    this.triggerLifecycle();
-    this.connectedCalled = true;
+    that.#hostConnected.forEach(safeCall);
+    that.triggerLifecycle();
+    that.connectedCalled = true;
   }
   /** @private */
   triggerDisconnected() {
-    const genericController = this;
-    if (genericController.hostDisconnected) {
-      safeCall(genericController.hostDisconnected, genericController);
+    const that = this;
+    if (that.hostDisconnected) {
+      safeCall(that.hostDisconnected, that);
     }
-    this._callbacks.hostDisconnected.forEach(safeCall);
-    this._lifecycleCleanups.forEach(safeCall);
-    this._lifecycleCleanups = [];
+    that.#hostDisconnected.forEach(safeCall);
+    that.#lifecycleCleanups.forEach(safeCall);
+    that.#lifecycleCleanups = [];
   }
   /** @private */
   async triggerLoad() {
-    if (this._loadCalled) {
+    if (this.#loadCalled) {
       return;
     }
-    this._loadCalled = true;
+    this.#loadCalled = true;
     const genericController = this;
     if (genericController.hostLoad) {
       await safeAsyncCall(genericController.hostLoad, genericController);
     }
-    if (this._callbacks.hostLoad.length > 0) {
-      await Promise.allSettled(this._callbacks.hostLoad.map(safeAsyncCall));
+    if (this.#hostLoad.length > 0) {
+      await Promise.allSettled(this.#hostLoad.map(safeAsyncCall));
     }
-    this._ready.resolve(this._exports);
+    this.P.resolve(this.#exports);
   }
   /** @private */
   triggerLoaded() {
     if (this.loadedCalled) {
       return;
     }
-    const genericController = this;
-    if (genericController.hostLoaded) {
-      safeCall(genericController.hostLoaded, genericController);
+    if (this.hostLoaded) {
+      safeCall(this.hostLoaded, this);
     }
-    this._callbacks.hostLoaded.forEach(safeCall);
+    this.#hostLoaded.forEach(safeCall);
     this.loadedCalled = true;
   }
   /** @private */
   triggerUpdate(changes) {
-    const genericController = this;
-    if (genericController.hostUpdate) {
-      safeCall(genericController.hostUpdate, genericController, changes);
+    if (this.hostUpdate) {
+      safeCall(this.hostUpdate, this, changes);
     }
-    this._callbacks.hostUpdate.forEach(callUpdate, changes);
+    this.#hostUpdate.forEach(callUpdate, changes);
   }
   /** @private */
   triggerUpdated(changes) {
-    const genericController = this;
-    if (genericController.hostUpdated) {
-      safeCall(genericController.hostUpdated, genericController, changes);
+    if (this.hostUpdated) {
+      safeCall(this.hostUpdated, this, changes);
     }
-    this._callbacks.hostUpdated.forEach(callUpdate, changes);
+    this.#hostUpdated.forEach(callUpdate, changes);
   }
   /** @private */
   triggerDestroy() {
-    const genericController = this;
-    if (genericController.hostDestroy) {
-      safeCall(genericController.hostDestroy, genericController);
+    if (this.hostDestroy) {
+      safeCall(this.hostDestroy, this);
     }
-    this._callbacks.hostDestroy.forEach(safeCall);
+    this.#hostDestroy.forEach(safeCall);
   }
   /** @private */
   triggerLifecycle() {
-    const genericController = this;
-    if (genericController.hostLifecycle) {
-      this._callLifecycle(() => genericController.hostLifecycle());
+    if (this.hostLifecycle) {
+      this.#callLifecycle(() => this.hostLifecycle());
     }
-    this._callbacks.hostLifecycle.forEach(this._callLifecycle, this);
+    this.#hostLifecycle.forEach(this.#callLifecycle, this);
   }
-  _callLifecycle(callback) {
-    setAmbientComponent(this.component);
+  #callLifecycle(callback) {
+    setAmbientComponent(this.#component);
     const cleanupRaw = safeCall(callback);
     const cleanup = Array.isArray(cleanupRaw) ? cleanupRaw : [cleanupRaw];
     cleanup.forEach((cleanup2) => {
       if (typeof cleanup2 === "function") {
-        this._lifecycleCleanups.push(cleanup2);
+        this.#lifecycleCleanups.push(cleanup2);
       } else if (typeof cleanup2 === "object" && typeof cleanup2.remove === "function") {
-        this._lifecycleCleanups.push(cleanup2.remove);
+        this.#lifecycleCleanups.push(cleanup2.remove);
       }
     });
   }
@@ -562,11 +525,11 @@ function callUpdate(callback) {
   safeCall(callback, void 0, this);
 }
 const GenericController = Controller;
-function makeProvisionalValue(base) {
+const makeProvisionalValue = (base) => {
   if (typeof base !== "object" && typeof base !== "function" || base === null) {
     return base;
   }
-  const proxy = new Proxy(base, {
+  const proxyDefinition = {
     get(target, prop, receiver) {
       if ((prop === "exports" || prop === "_exports") && prop in target && target[prop] === proxy) {
         return void 0;
@@ -583,16 +546,17 @@ function makeProvisionalValue(base) {
         );
       }
       return void 0;
-    },
-    set: (target, prop, newValue, receiver) => {
-      if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
-        console.error(`Trying to set "${prop.toString()}" on the controller before it's loaded. ${accessBeforeLoad}`);
-      }
-      return Reflect.set(target, prop, newValue, receiver);
     }
-  });
+  };
+  if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+    proxyDefinition.set = (target, prop, newValue, receiver) => {
+      console.error(`Trying to set "${prop.toString()}" on the controller before it's loaded. ${accessBeforeLoad}`);
+      return Reflect.set(target, prop, newValue, receiver);
+    };
+  }
+  const proxy = new Proxy(base, proxyDefinition);
   return proxy;
-}
+};
 const accessBeforeLoad = process.env.NODE_ENV !== "production" && isEsriInternalEnv() ? [
   "This might be the case if you are trying to access an async controller in ",
   "connectedCallback(). Or, if you are using it inside of ",
@@ -603,25 +567,23 @@ const accessBeforeLoad = process.env.NODE_ENV !== "production" && isEsriInternal
 export {
   Controller as C,
   GenericController as G,
-  shouldBypassGetter as a,
-  shouldBypassReadOnly as b,
+  shouldBypassReadOnly as a,
+  createEvent as b,
   controllerSymbol as c,
-  createEvent as d,
-  setParentController as e,
-  retrieveParentControllers as f,
-  createEventFactory as g,
-  bypassGetter as h,
+  setParentController as d,
+  retrieveParentControllers as e,
+  createEventFactory as f,
+  bypassSetter as g,
+  bypassReadOnly as h,
   isPromise as i,
-  bypassSetter as j,
+  trackPropertyKey as j,
   keyTrackResolve as k,
-  bypassReadOnly as l,
-  trackPropertyKey as m,
-  trackPropKey as n,
-  isController as o,
-  devOnlySetPersistentControllerData as p,
-  devOnlyGetPersistentControllerData as q,
+  trackPropKey as l,
+  isController as m,
+  getControllersCount as n,
+  setAmbientChildController as o,
+  queueMicroTask as q,
   retrieveComponent as r,
   setAmbientComponent as s,
-  trackKey as t,
-  setAmbientChildController as u
+  trackKey as t
 };