@arcgis/lumina 4.33.0-next.94 → 4.33.0-next.95

package/dist/useWatch-CFtSpNnN.js

@@ -0,0 +1,925 @@
+import { isEsriInternalEnv, safeCall, isNotUndefined, Deferred, safeAsyncCall } from "@arcgis/components-utils";
+const controllerSymbol = Symbol.for("controller");
+const name = "@arcgis/lumina";
+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 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);
+  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";
+}
+let ambientComponent;
+function setAmbientComponent(component) {
+  if (ambientComponent === component) {
+    return;
+  }
+  ambientComponent = component;
+  queueMicrotask(() => {
+    if (ambientComponent === component) {
+      ambientComponent = void 0;
+    }
+  });
+}
+function retrieveComponent(name2) {
+  if (process.env.NODE_ENV !== "production" && ambientComponent === void 0) {
+    throw new Error(
+      [
+        `Unable to find out which component ${name2 || "this"} controller `,
+        "belongs to. Possible causes:\n",
+        "- You might have multiple versions of ",
+        "@arcgis/lumina package installed\n",
+        ...isEsriInternalEnv() ? [
+          "- You tried to create controller outside the component. If so, ",
+          "please wrap your controller definition in an arrow function (like",
+          "`const myController = ()=>makeController(...);`) and call that",
+          "function inside the component (`my = myController();`), or ",
+          "define your controller using makeGenericController/GenericController ",
+          "instead.\n",
+          "- You tried to create a controller inside an async function. ",
+          "This is allowed without calling controller.use(). Make sure you ",
+          "use it like `await controller.use(useController())`."
+        ] : []
+      ].join("")
+    );
+  }
+  return ambientComponent;
+}
+let ambientControllers = [];
+function 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;
+}
+let ambientChildController;
+function setAmbientChildController(controller) {
+  if (ambientChildController === controller) {
+    return;
+  }
+  ambientChildController = controller;
+  queueMicrotask(() => {
+    if (ambientChildController === controller) {
+      ambientChildController = void 0;
+    }
+  });
+}
+function retrieveAmbientChildController() {
+  const controller = ambientChildController;
+  ambientChildController = void 0;
+  return controller;
+}
+const use = async (value, watchExports) => {
+  const controller = useRefSync(value);
+  if (controller === void 0) {
+    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && typeof watchExports === "function") {
+      throw new Error(
+        `Unable to resolve a controller from the provided value, so can't watch it's exports. The value you passed is not a controller and not a controller exports. If your controller exports a literal value, try making your controller export an object instead`
+      );
+    }
+    return value;
+  }
+  await controller.ready;
+  if (typeof watchExports === "function") {
+    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && controller.watchExports === void 0) {
+      throw new Error(`The controller must implement watchExports method to support watching exports`);
+    }
+    const unsubscribe = controller.watchExports(
+      (exports) => watchExports(exports, unsubscribe)
+    );
+  }
+  return controller.exports;
+};
+const useRef = async (value) => {
+  const controller = useRefSync(value);
+  if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && controller === void 0) {
+    throw new Error(
+      `Unable to resolve a controller from the provided value. The value you passed is not a controller and not a controller exports. If your controller exports a literal value, try making your controller export an object instead`
+    );
+  }
+  await controller.ready;
+  return controller;
+};
+const useRefSync = (value) => {
+  const component = retrieveComponent();
+  const controller = component.manager.internals.resolveExports(value);
+  if (controller !== void 0) {
+    return controller;
+  }
+  if (isController(value)) {
+    return value;
+  }
+  const ambientChildController2 = retrieveAmbientChildController();
+  if (ambientChildController2 !== void 0) {
+    return ambientChildController2;
+  }
+  return void 0;
+};
+const shouldBypass = {
+  setter: false,
+  getter: false,
+  readOnly: false
+};
+const elementToInstance = /* @__PURE__ */ new WeakMap();
+function trackPropertyKey(object, onResolved, defaultValue) {
+  const keys = Object.keys(object);
+  const keyCount = keys.length;
+  if (keyTrackMap === void 0) {
+    queueMicrotask(keyTrackResolve);
+  }
+  keyTrackMap ??= /* @__PURE__ */ new Map();
+  let pendingTrackers = keyTrackMap.get(object);
+  if (pendingTrackers === void 0) {
+    pendingTrackers = { callbacks: [], keyCount };
+    keyTrackMap.set(object, pendingTrackers);
+  }
+  if (pendingTrackers.keyCount !== keyCount) {
+    pendingTrackers.callbacks.forEach((resolve) => resolve(keys));
+    pendingTrackers.callbacks = [];
+    pendingTrackers.keyCount = keyCount;
+  }
+  pendingTrackers.callbacks.push((keys2) => {
+    const callback = (key2) => safeCall(onResolved, null, key2);
+    const key = keys2[keyCount];
+    if (key === void 0) {
+      callback(void 0);
+    } else if (object[key] === defaultValue) {
+      callback(key);
+    } else {
+      callback(void 0);
+    }
+  });
+  return defaultValue;
+}
+let keyTrackMap = void 0;
+function keyTrackResolve() {
+  Array.from(keyTrackMap?.entries() ?? []).forEach(([object, { callbacks }]) => {
+    const keys = Object.keys(object);
+    callbacks.forEach((commit) => commit(keys));
+  });
+  keyTrackMap = void 0;
+}
+var PropTypes = /* @__PURE__ */ ((PropTypes2) => {
+  PropTypes2[PropTypes2["String"] = 1] = "String";
+  PropTypes2[PropTypes2["Number"] = 2] = "Number";
+  PropTypes2[PropTypes2["Boolean"] = 4] = "Boolean";
+  PropTypes2[PropTypes2["Any"] = 8] = "Any";
+  PropTypes2[PropTypes2["Unknown"] = 16] = "Unknown";
+  PropTypes2[PropTypes2["State"] = 32] = "State";
+  PropTypes2[PropTypes2["Method"] = 64] = "Method";
+  PropTypes2[PropTypes2["Event"] = 128] = "Event";
+  PropTypes2[PropTypes2["Element"] = 256] = "Element";
+  PropTypes2[PropTypes2["ReflectAttr"] = 512] = "ReflectAttr";
+  PropTypes2[PropTypes2["Mutable"] = 1024] = "Mutable";
+  PropTypes2[PropTypes2["Prop"] = 31] = "Prop";
+  PropTypes2[PropTypes2["HasAttribute"] = 15] = "HasAttribute";
+  PropTypes2[PropTypes2["PropLike"] = 63] = "PropLike";
+  PropTypes2[PropTypes2["ReadOnly"] = 2048] = "ReadOnly";
+  return PropTypes2;
+})(PropTypes || {});
+function retrieveComponentMembers(component, isLit) {
+  if (isLit) {
+    const elementProperties = component.constructor.elementProperties;
+    component.manager.internals.members = Object.fromEntries(
+      Array.from(
+        elementProperties,
+        ([name2, descriptor]) => descriptor.noAccessor ? void 0 : [
+          name2,
+          [
+            (descriptor.readOnly ? 2048 : 0) | (descriptor.state ? 32 : 16)
+          ]
+        ]
+      ).filter(isNotUndefined)
+    );
+  } else {
+    const constructor = component.constructor;
+    const members = constructor.__registerControllers?.(component) ?? void 0;
+    constructor.__registerControllers = void 0;
+    if (typeof members !== "object") {
+      throw new Error(
+        process.env.NODE_ENV !== "production" && isEsriInternalEnv() ? "Failed to retrieve internal component meta. Make sure you have the useComponentsControllers() Rollup Plugin for Stencil Controllers configured in your Stencil config." : "Failed to retrieve component meta"
+      );
+    }
+    component.manager.internals.members = Object.fromEntries(
+      Object.entries(members).filter(([_name, [propType]]) => (propType & 63) !== 0)
+    );
+  }
+}
+function parsePropertyValue(value, type = 8) {
+  const isComplex = value == null || typeof value === "object" || typeof value === "function";
+  if (isComplex) {
+    return value;
+  }
+  if ((type & 4) !== 0) {
+    return value === "false" ? false : value === "" || !!value;
+  } else if ((type & 2) !== 0) {
+    return Number.parseFloat(value);
+  } else if ((type & 1) !== 0) {
+    return String(value);
+  } else {
+    return value;
+  }
+}
+const getMemberType = (component, name2) => component.manager.internals.members?.[name2]?.[0];
+class ComponentInternals {
+  constructor(component) {
+    this.enabledWatchers = {};
+    this.allWatchers = {};
+    this.enableReadonly = () => {
+      this.enableReadonly = void 0;
+      if (!this.component.manager.isLit) {
+        return;
+      }
+      const internals = this.component.manager.internals;
+      Object.entries(internals.members).forEach(([name2, [type]]) => {
+        const isReadOnly = type & PropTypes.ReadOnly;
+        if (isReadOnly) {
+          internals.setters[name2] ??= [];
+          internals.setters[name2].push(internals.readonlySetter);
+        }
+      });
+    };
+    this.trackedValue = nothing;
+    this.keyTrackers = [];
+    this.getters = {};
+    this.setters = {};
+    this.accessorGetter = {};
+    this.accessorSetter = {};
+    this._exports = /* @__PURE__ */ new WeakMap();
+    this.readonlySetter = (newValue, _oldValue, property) => {
+      if (shouldBypass.readOnly) {
+        return newValue;
+      }
+      throw new Error(
+        `Cannot assign to read-only property "${property}" of ${this.component.el.localName}. Trying to assign "${String(
+          newValue
+        )}"`
+      );
+    };
+    if (process.env.NODE_ENV !== "production") {
+      Object.defineProperty(this, "component", {
+        writable: false,
+        enumerable: false,
+        configurable: true,
+        value: component
+      });
+    } else {
+      this.component = component;
+    }
+  }
+  firePropTrackers(key, value) {
+    const trackers = this.keyTrackers;
+    this.trackedValue = nothing;
+    this.keyTrackers = [];
+    trackers.forEach((tracker) => tracker(key, value));
+  }
+  // REFACTOR: once Stencil is no longer supported, simplify this with Lit's getPropertyDescriptor(), or https://github.com/shoelace-style/shoelace/issues/1990
+  /**
+   * Configure a getter or setter for a given \@Prop/\@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
+   */
+  getSetProxy(property) {
+    const component = this.component;
+    const classPrototype = component.constructor.prototype;
+    this._getSetProxy(classPrototype, property, "class");
+    if (component.manager.isLit) {
+      return;
+    }
+    const htmlPrototype = component.el.constructor.prototype;
+    if (classPrototype !== htmlPrototype) {
+      this._getSetProxy(htmlPrototype, property, "html");
+    }
+  }
+  _getSetProxy(prototype, name2, type) {
+    const component = this.component;
+    const propType = getMemberType(component, name2);
+    let descriptor;
+    do {
+      descriptor = Object.getOwnPropertyDescriptor(prototype, name2);
+    } while (!descriptor && (prototype = Object.getPrototypeOf(prototype)));
+    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+      const tolerateNotFound = type === "html";
+      if (descriptor?.set === void 0 || descriptor.get === void 0) {
+        if (descriptor !== void 0 && "value" in descriptor) {
+          throw new Error(
+            `getSet() should only be used on @Prop/@property/@State/@state properties. For internal component properties, use regular get/set syntax. Tried to use it on "${name2}" in ${component.el.localName}`
+          );
+        } else if (tolerateNotFound) {
+          return;
+        } else {
+          throw new Error(`Unable to find "${name2}" property on the ${component.el.localName} component`);
+        }
+      }
+      if (propType === void 0) {
+        throw new Error("Unable to retrieve prop type");
+      }
+    } else if (!descriptor) {
+      return void 0;
+    }
+    const originalGet = descriptor.get;
+    const originalSet = descriptor.set;
+    const isGetterAlreadyOverwritten = customAccessor in originalGet;
+    const isSetterAlreadyOverwritten = customAccessor in originalSet;
+    if (isGetterAlreadyOverwritten && isSetterAlreadyOverwritten) {
+      return;
+    }
+    const shouldOverwriteGet = !isGetterAlreadyOverwritten;
+    const shouldOverwriteSet = !isSetterAlreadyOverwritten;
+    const finalGetter = shouldOverwriteGet ? function getter() {
+      let value = originalGet.call(this);
+      const component2 = elementToInstance.get(this);
+      if (shouldBypass.getter || component2 === void 0) {
+        return value;
+      }
+      const internals = component2.manager.internals;
+      value = internals.accessorGetter[name2](value, name2);
+      const getters = internals.getters[name2] ?? emptyArray;
+      for (let i = 0; i < getters.length; i++) {
+        value = getters[i](value, name2);
+      }
+      return value;
+    } : originalGet;
+    const finalSetter = shouldOverwriteSet ? function setter(rawNewValue) {
+      const oldValue = originalGet.call(this);
+      const component2 = elementToInstance.get(this);
+      if (component2 === void 0) {
+        originalSet.call(this, rawNewValue);
+        return;
+      }
+      let newValue = component2.manager.isLit ? (
+        /*
+         * Cast `null` to `undefined`.
+         * See https://devtopia.esri.com/WebGIS/arcgis-web-components/discussions/1299
+         */
+        rawNewValue ?? void 0
+      ) : parsePropertyValue(rawNewValue, propType);
+      const internals = component2.manager.internals;
+      if (newValue === oldValue) {
+        originalSet.call(this, newValue);
+      } else {
+        const setters = shouldBypass.setter ? emptyArray : internals.setters[name2] ?? emptyArray;
+        for (let i = 0; i < setters.length; i++) {
+          newValue = setters[i](newValue, oldValue, name2);
+          if (newValue === oldValue) {
+            break;
+          }
+        }
+        newValue = internals.accessorSetter[name2](newValue, oldValue, name2);
+        originalSet.call(this, newValue);
+        if (newValue !== oldValue) {
+          internals.enabledWatchers[name2]?.forEach((watcher) => watcher(newValue, oldValue, name2));
+        }
+      }
+      if (internals.keyTrackers.length > 0) {
+        internals?.firePropTrackers(name2, rawNewValue);
+      }
+    } : originalSet;
+    if (shouldOverwriteGet) {
+      finalGetter[customAccessor] = true;
+    }
+    if (shouldOverwriteSet) {
+      finalSetter[customAccessor] = true;
+    }
+    Object.defineProperty(prototype, name2, {
+      ...descriptor,
+      get: finalGetter,
+      set: finalSetter
+    });
+  }
+  /**
+   * Associate an exports object with a controller for reverse lookup in
+   * controller.use
+   */
+  markExports(controller, exports) {
+    if (typeof exports === "object" && exports !== null || typeof exports === "function") {
+      this._exports.set(exports, controller);
+    }
+  }
+  resolveExports(exports) {
+    if (typeof exports === "object" && exports !== null || typeof exports === "function") {
+      return this._exports.get(exports);
+    } else {
+      return void 0;
+    }
+  }
+}
+const emptyArray = [];
+const customAccessor = Symbol();
+const nothing = process.env.NODE_ENV !== "production" ? Symbol.for(
+  // Use Symbol.for in dev mode to make it easier to maintain state when doing HMR.
+  `${name}: nothing`
+) : (
+  // eslint-disable-next-line symbol-description
+  Symbol()
+);
+function trackPropKey(component, onResolved, defaultValue) {
+  const internals = component.manager.internals;
+  if (internals.trackedValue !== nothing && internals.trackedValue !== defaultValue) {
+    internals.firePropTrackers(void 0, void 0);
+  }
+  if (internals.keyTrackers.length === 0) {
+    queueMicrotask(() => internals.firePropTrackers(void 0, void 0));
+  }
+  internals.trackedValue = defaultValue;
+  internals.keyTrackers.push((key, value) => safeCall(onResolved, void 0, defaultValue === value ? key : void 0));
+  return defaultValue;
+}
+function trackKey(hostsCandidates = [
+  retrieveComponent(),
+  ...retrieveParentControllers()
+], onResolved, defaultValue) {
+  const candidateHosts = Array.isArray(hostsCandidates) ? hostsCandidates : [hostsCandidates];
+  let leftToResolve = candidateHosts.length + 1;
+  const resolved = (resolution) => {
+    leftToResolve -= 1;
+    if (resolution !== void 0) {
+      leftToResolve = Math.min(leftToResolve, 0);
+    }
+    if (leftToResolve === 0) {
+      onResolved(resolution);
+    }
+  };
+  candidateHosts.forEach(
+    (host) => trackPropertyKey(
+      host,
+      (key) => resolved(
+        key === void 0 ? void 0 : {
+          key,
+          host,
+          isReactive: false
+        }
+      ),
+      defaultValue
+    )
+  );
+  const component = candidateHosts.find(
+    (host) => "manager" in host && typeof host.manager === "object" && host.manager.component === host
+  );
+  if (component) {
+    trackPropKey(
+      component,
+      (key) => resolved(
+        key === void 0 ? void 0 : {
+          key,
+          host: component,
+          isReactive: true
+        }
+      ),
+      defaultValue
+    );
+  }
+  return defaultValue;
+}
+const createEventFactory = (eventName = "", options = {}, component = retrieveComponent()) => {
+  const emitter = {
+    emit: (payload) => {
+      if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && !component.el.isConnected) {
+        console.warn(`Trying to emit an ${eventName} event on a disconnected element ${component.el.localName}`);
+      }
+      if (eventName === "") {
+        keyTrackResolve();
+        if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && eventName === "") {
+          throw new Error("Unable to resolve event name from property name");
+        }
+      }
+      const event = new CustomEvent(eventName, {
+        detail: payload,
+        cancelable: true,
+        bubbles: true,
+        composed: true,
+        ...options
+      });
+      component.el.dispatchEvent(event);
+      return event;
+    }
+  };
+  if (eventName === "") {
+    trackKey(
+      void 0,
+      (resolution) => {
+        if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && resolution === void 0) {
+          throw new Error(`createEvent must be called in property default value only`);
+        }
+        eventName = resolution.key;
+      },
+      emitter
+    );
+  }
+  return emitter;
+};
+const createEvent = createEventFactory.bind(null, "");
+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.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();
+    const resolvedComponent = toControllerHost(component ?? retrieveComponent(new.target.name));
+    if (process.env.NODE_ENV !== "production") {
+      Object.defineProperty(this, "component", {
+        writable: false,
+        enumerable: false,
+        configurable: true,
+        value: resolvedComponent
+      });
+      if ("hostDestroy" in this) {
+        this.component.manager.ensureHasDestroy?.();
+      }
+    } else {
+      this.component = resolvedComponent;
+    }
+    this.component.addController(this);
+    const manager = this.component.manager;
+    const isInControllerManager = manager === void 0;
+    if (!isInControllerManager) {
+      setParentController(this);
+      queueMicrotask(() => this.catchUpLifecycle());
+    }
+  }
+  /**
+   * If controller is being added dynamically, after the component
+   * construction, then trigger connected and load right away
+   */
+  catchUpLifecycle() {
+    const { manager } = this.component;
+    const connectedWillStillHappen = !manager.connectedCalled;
+    if (!connectedWillStillHappen && !this.connectedCalled) {
+      this.triggerConnected();
+    }
+    const loadWillStillHappen = !manager._loadCalled;
+    if (loadWillStillHappen) {
+      return;
+    }
+    this.triggerLoad().then(() => {
+      const loadedWillStillHappen = !manager.loadedCalled;
+      if (loadedWillStillHappen) {
+        return;
+      }
+      this.triggerLoaded();
+    }).catch(console.error);
+  }
+  get exports() {
+    return this._exports;
+  }
+  /**
+   * Set controller's exports property (for usage with proxyExports()) and mark
+   * controller as ready (for usage in other controllers). Also, triggers
+   * re-render of the component
+   */
+  set exports(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._ready.resolve(exports);
+  }
+  setProvisionalExports(exports, proxy = true) {
+    this._exports = proxy ? makeProvisionalValue(exports) : exports;
+    this._exportWatchers.forEach(safeCall);
+  }
+  watchExports(callback) {
+    const safeCallback = () => callback(this._exports);
+    this._exportWatchers.add(safeCallback);
+    return () => void this._exportWatchers.delete(safeCallback);
+  }
+  /**
+   * A flexible utility for making sure a controller is loaded before it's used,
+   * regardless of how or where a controller was defined:
+   *
+   * @example
+   * makeGenericController(async (component, controller) => {
+   *   // Await some controller from the component:
+   *   await controller.use(component.someController);
+   *   // Initialize new controllers
+   *   await controller.use(load(importCoreReactiveUtils));
+   *   await controller.use(new ViewModelController(component,newWidgetsHomeHomeViewModel));
+   *   await controller.use(someController(component));
+   * });
+   *
+   * @remarks
+   * If your controller is not async, and you are not creating it async, then
+   * you are not required to use controller.use - you can use it directly.
+   * Similarly, accessing controllers after componentWillLoad callback does not
+   * require awaiting them as they are guaranteed to be loaded by then.
+   */
+  get use() {
+    setAmbientComponent(this.component);
+    return use;
+  }
+  /**
+   * Just like controller.use, but returns the controller itself, rather than it's
+   * exports
+   *
+   * Use cases:
+   * - You have a controller and you want to make sure it's loaded before you
+   *   try to use it
+   * - Your controller is not using exports, so you wish to access some props on
+   *   it directly
+   * - You have a controller exports only, and you want to retrieve the
+   *   controller itself. This is useful if you wish to call .watchExports() or
+   *   some other method on the controller
+   */
+  get useRef() {
+    setAmbientComponent(this.component);
+    return useRef;
+  }
+  /**
+   * Like useRef, but doesn't wait for the controller to get ready
+   *
+   * @internal
+   */
+  get useRefSync() {
+    setAmbientComponent(this.component);
+    return useRefSync;
+  }
+  controllerRemoved() {
+    if (this.component.el.isConnected) {
+      this.triggerDisconnected();
+    }
+    this.triggerDestroy();
+  }
+  // Register a lifecycle callback
+  onConnected(callback) {
+    this._callbacks.hostConnected.push(callback);
+  }
+  onDisconnected(callback) {
+    this._callbacks.hostDisconnected.push(callback);
+  }
+  onLoad(callback) {
+    this._callbacks.hostLoad.push(callback);
+  }
+  onLoaded(callback) {
+    this._callbacks.hostLoaded.push(callback);
+  }
+  onUpdate(callback) {
+    this._callbacks.hostUpdate.push(callback);
+  }
+  onUpdated(callback) {
+    this._callbacks.hostUpdated.push(callback);
+  }
+  onDestroy(callback) {
+    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+      this.component.manager.ensureHasDestroy?.();
+    }
+    this._callbacks.hostDestroy.push(callback);
+  }
+  onLifecycle(callback) {
+    this._callbacks.hostLifecycle.push(callback);
+    if (this.connectedCalled && this.component.el.isConnected) {
+      this._callLifecycle(callback);
+    }
+  }
+  // Call each lifecycle hook
+  /** @internal */
+  triggerConnected() {
+    const genericController = this;
+    if (genericController.hostConnected) {
+      safeCall(genericController.hostConnected, genericController);
+    }
+    this._callbacks.hostConnected.forEach(safeCall);
+    this.triggerLifecycle();
+    this.connectedCalled = true;
+  }
+  /** @internal */
+  triggerDisconnected() {
+    const genericController = this;
+    if (genericController.hostDisconnected) {
+      safeCall(genericController.hostDisconnected, genericController);
+    }
+    this._callbacks.hostDisconnected.forEach(safeCall);
+    this._lifecycleCleanups.forEach(safeCall);
+    this._lifecycleCleanups = [];
+  }
+  /** @internal */
+  async triggerLoad() {
+    if (this._loadCalled) {
+      return;
+    }
+    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));
+    }
+    this._ready.resolve(this._exports);
+  }
+  /** @internal */
+  triggerLoaded() {
+    if (this.loadedCalled) {
+      return;
+    }
+    const genericController = this;
+    if (genericController.hostLoaded) {
+      safeCall(genericController.hostLoaded, genericController);
+    }
+    this._callbacks.hostLoaded.forEach(safeCall);
+    this.loadedCalled = true;
+  }
+  /** @internal */
+  triggerUpdate(changes) {
+    const genericController = this;
+    if (genericController.hostUpdate) {
+      safeCall(genericController.hostUpdate, genericController, changes);
+    }
+    this._callbacks.hostUpdate.forEach(callUpdate, changes);
+  }
+  /** @internal */
+  triggerUpdated(changes) {
+    const genericController = this;
+    if (genericController.hostUpdated) {
+      safeCall(genericController.hostUpdated, genericController, changes);
+    }
+    this._callbacks.hostUpdated.forEach(callUpdate, changes);
+  }
+  /** @internal */
+  triggerDestroy() {
+    const genericController = this;
+    if (genericController.hostDestroy) {
+      safeCall(genericController.hostDestroy, genericController);
+    }
+    this._callbacks.hostDestroy.forEach(safeCall);
+  }
+  /** @internal */
+  triggerLifecycle() {
+    const genericController = this;
+    if (genericController.hostLifecycle) {
+      this._callLifecycle(() => genericController.hostLifecycle());
+    }
+    this._callbacks.hostLifecycle.forEach(this._callLifecycle, this);
+  }
+  _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);
+      } else if (typeof cleanup2 === "object" && typeof cleanup2.remove === "function") {
+        this._lifecycleCleanups.push(cleanup2.remove);
+      }
+    });
+  }
+}
+function callUpdate(callback) {
+  safeCall(callback, void 0, this);
+}
+const GenericController = Controller;
+function makeProvisionalValue(base) {
+  if (typeof base !== "object" && typeof base !== "function" || base === null) {
+    return base;
+  }
+  const proxy = new Proxy(base, {
+    get(target, prop, receiver) {
+      if (cyclical.has(prop) && prop in target && target[prop] === proxy) {
+        return void 0;
+      }
+      if (prop in target || prop in Promise.prototype || typeof prop === "symbol") {
+        return typeof target === "function" ? target[prop] : Reflect.get(target, prop, receiver);
+      }
+      if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+        if (process.env.NODE_ENV === "test" && (prop.startsWith("$$") || prop.startsWith("@@") || prop === "nodeType" || prop === "tagName" || prop === "toJSON" || prop === "hasAttribute")) {
+          return;
+        }
+        console.error(
+          `Trying to access "${prop.toString()}" on the controller before it's loaded. ${accessBeforeLoad}`
+        );
+      }
+      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);
+    }
+  });
+  return proxy;
+}
+const cyclical = /* @__PURE__ */ new Set(["exports", "_exports"]);
+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 ",
+  "componentWillLoad()/another controller without controller.use. Example correct ",
+  "usage:\n",
+  "makeController(async (component, controller)=>{ await controller.use(someOtherController); });"
+].join("") : void 0;
+function toControllerHost(component) {
+  if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+    if ("addController" in component) {
+      return component;
+    } else {
+      throw new Error(
+        "Component does not implement ControllerHost. This might be because you forgot to add 'manager: Controller<this> = useControllerManager(this);' in your component, or you tried to use some controller before that line"
+      );
+    }
+  } else {
+    return component;
+  }
+}
+function watch(component, property, callback) {
+  const genericProperty = property;
+  if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+    const type = getMemberType(component, genericProperty);
+    if (type === void 0) {
+      throw new Error(
+        component.manager.isLit ? `Trying to watch a non-@property, non-@state property "${genericProperty}". Either convert it into a @state() to be able to use watch() on it, or use the get/set syntax` : `Trying to watch a non-@Prop, non-@State property "${genericProperty}". Convert it into a @State() or @Prop property if you need to use watch() on it`
+      );
+    }
+  }
+  const internals = component.manager.internals;
+  internals.allWatchers[genericProperty] ??= [];
+  const watchers = internals.allWatchers[genericProperty];
+  const genericCallback = callback;
+  const safeCallback = (newValue, oldValue, propertyName) => safeCall(genericCallback, null, newValue, oldValue, propertyName);
+  watchers.push(safeCallback);
+  return () => {
+    const index = watchers.indexOf(safeCallback);
+    if (index !== -1) {
+      watchers.splice(index, 1);
+    }
+  };
+}
+export {
+  Controller as C,
+  GenericController as G,
+  PropTypes as P,
+  setParentController as a,
+  retrieveParentControllers as b,
+  createEvent as c,
+  createEventFactory as d,
+  trackPropertyKey as e,
+  trackPropKey as f,
+  isController as g,
+  controllerSymbol as h,
+  isPromise as i,
+  ComponentInternals as j,
+  keyTrackResolve as k,
+  retrieveComponentMembers as l,
+  elementToInstance as m,
+  devOnlySetPersistentControllerData as n,
+  devOnlyGetPersistentControllerData as o,
+  shouldBypass as p,
+  setAmbientChildController as q,
+  retrieveComponent as r,
+  setAmbientComponent as s,
+  trackKey as t,
+  watch as w
+};