@arcgis/lumina 4.33.0-next.1 → 4.33.0-next.100

package/dist/Controller-CZ8Djohh.js

@@ -0,0 +1,627 @@
+import { isEsriInternalEnv, safeCall, Deferred, safeAsyncCall } from "@arcgis/components-utils";
+import { nothing } from "lit";
+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 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";
+}
+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._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;
+};
+let shouldBypassGetter = false;
+let shouldBypassReadOnly = false;
+function 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 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() {
+  keyTrackMap?.forEach(({ callbacks }, object) => {
+    const keys = Object.keys(object);
+    callbacks.forEach((commit) => commit(keys));
+  });
+  keyTrackMap = void 0;
+}
+function trackPropKey(component, onResolved, defaultValue) {
+  const manager = component.manager;
+  if (manager._trackedValue !== nothing && manager._trackedValue !== defaultValue) {
+    manager._firePropTrackers(void 0, void 0);
+  }
+  if (manager._keyTrackers.length === 0) {
+    queueMicrotask(() => manager._firePropTrackers(void 0, void 0));
+  }
+  manager._trackedValue = defaultValue;
+  manager._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
+    )
+  );
+  for (const host of candidateHosts) {
+    if ("manager" in host && typeof host.manager === "object" && host.manager.component === host) {
+      trackPropKey(
+        host,
+        (key) => resolved(key === void 0 ? void 0 : { key, host, isReactive: true }),
+        defaultValue
+      );
+      break;
+    }
+  }
+  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 = 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
+   *
+   * @private
+   */
+  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
+  /** @private */
+  triggerConnected() {
+    const genericController = this;
+    if (genericController.hostConnected) {
+      safeCall(genericController.hostConnected, genericController);
+    }
+    this._callbacks.hostConnected.forEach(safeCall);
+    this.triggerLifecycle();
+    this.connectedCalled = true;
+  }
+  /** @private */
+  triggerDisconnected() {
+    const genericController = this;
+    if (genericController.hostDisconnected) {
+      safeCall(genericController.hostDisconnected, genericController);
+    }
+    this._callbacks.hostDisconnected.forEach(safeCall);
+    this._lifecycleCleanups.forEach(safeCall);
+    this._lifecycleCleanups = [];
+  }
+  /** @private */
+  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);
+  }
+  /** @private */
+  triggerLoaded() {
+    if (this.loadedCalled) {
+      return;
+    }
+    const genericController = this;
+    if (genericController.hostLoaded) {
+      safeCall(genericController.hostLoaded, genericController);
+    }
+    this._callbacks.hostLoaded.forEach(safeCall);
+    this.loadedCalled = true;
+  }
+  /** @private */
+  triggerUpdate(changes) {
+    const genericController = this;
+    if (genericController.hostUpdate) {
+      safeCall(genericController.hostUpdate, genericController, changes);
+    }
+    this._callbacks.hostUpdate.forEach(callUpdate, changes);
+  }
+  /** @private */
+  triggerUpdated(changes) {
+    const genericController = this;
+    if (genericController.hostUpdated) {
+      safeCall(genericController.hostUpdated, genericController, changes);
+    }
+    this._callbacks.hostUpdated.forEach(callUpdate, changes);
+  }
+  /** @private */
+  triggerDestroy() {
+    const genericController = this;
+    if (genericController.hostDestroy) {
+      safeCall(genericController.hostDestroy, genericController);
+    }
+    this._callbacks.hostDestroy.forEach(safeCall);
+  }
+  /** @private */
+  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 ((prop === "exports" || prop === "_exports") && 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 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;
+export {
+  Controller as C,
+  GenericController as G,
+  shouldBypassGetter as a,
+  shouldBypassReadOnly as b,
+  controllerSymbol as c,
+  createEvent as d,
+  setParentController as e,
+  retrieveParentControllers as f,
+  createEventFactory as g,
+  bypassGetter as h,
+  isPromise as i,
+  bypassSetter as j,
+  keyTrackResolve as k,
+  bypassReadOnly as l,
+  trackPropertyKey as m,
+  trackPropKey as n,
+  isController as o,
+  devOnlySetPersistentControllerData as p,
+  devOnlyGetPersistentControllerData as q,
+  retrieveComponent as r,
+  setAmbientComponent as s,
+  trackKey as t,
+  setAmbientChildController as u
+};