@arcgis/lumina 4.33.0-next.97 → 4.33.0-next.98

package/dist/ControllerManager-B2comd8J.js

@@ -1,310 +0,0 @@
-import { G as GenericController, j as ComponentInternals, l as retrieveComponentMembers, s as setAmbientComponent, m as elementToInstance, k as keyTrackResolve, n as devOnlySetPersistentControllerData, w as watch, h as controllerSymbol } from "./useWatch-CFtSpNnN.js";
-import { isEsriInternalEnv, Deferred, devToolsAwareTimeout, safeCall, safeAsyncCall } from "@arcgis/components-utils";
-const useControllerManager = (component) => new ControllerManager(component);
-class ControllerManager extends GenericController {
-  constructor(component) {
-    const isLit = "addController" in component;
-    const controllers = /* @__PURE__ */ new Set();
-    function addController(controller) {
-      controllers.add(controller);
-      if (!(controllerSymbol in controller) && component.renderRoot && component.el.isConnected) {
-        controller.hostConnected?.();
-      }
-    }
-    function removeController(controller) {
-      void controllers.delete(controller);
-      controller.controllerRemoved?.();
-    }
-    const controllerHost = component;
-    controllerHost.addController = addController;
-    controllerHost.removeController = removeController;
-    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
-      const stencilToLitMapping = {
-        componentDidLoad: "loaded",
-        componentDidRender: "updated",
-        componentDidUpdate: "updated",
-        componentShouldUpdate: "shouldUpdate",
-        componentWillLoad: "load",
-        componentWillRender: "willUpdate",
-        componentWillUpdate: "willUpdate"
-      };
-      Object.entries(stencilToLitMapping).forEach(([stencilMethod, litMethod]) => {
-        if (isLit && stencilMethod in component) {
-          throw new Error(
-            `Unexpected ${stencilMethod}() in a Lit component ${component.el.localName}. In Lit, you should use ${litMethod}() instead`
-          );
-        }
-      });
-      if (isLit) {
-        let i = 0;
-        let isLitElementClass = false;
-        for (let prototype = component; !isLitElementClass; i++) {
-          if (prototype === null) {
-            throw new Error("Expected controllers to be used in a LitElement class");
-          }
-          if (Object.hasOwn(prototype, "_load")) {
-            isLitElementClass = true;
-            break;
-          }
-          prototype = Object.getPrototypeOf(prototype);
-        }
-        if (i < 1) {
-          throw new Error(
-            "It looks like you are trying to call useControllerManager in a component that uses LitElement imported from 'lit'. useControllerManager should only be used in the LitElement coming from `@arcgis/lumina`"
-          );
-        }
-      }
-    }
-    super(component);
-    this.internals = new ComponentInternals(this.component);
-    this.destroyed = false;
-    this._updatePromise = new Deferred();
-    this._originalLifecycles = {};
-    this.isLit = isLit;
-    this.component.manager = this;
-    retrieveComponentMembers(component, isLit);
-    this._controllers = controllers;
-    this.exports = void 0;
-    this.hasDestroy = autoDestroyDisabledPropName in this.component && typeof this.component.destroy === "function";
-    this._bindLifecycleMethods();
-    const internals = this.internals;
-    Object.keys(internals.members).forEach((name) => {
-      internals.accessorGetter[name] = defaultGetterSetter;
-      internals.accessorSetter[name] = defaultGetterSetter;
-      internals.getSetProxy(name);
-    });
-    if (isLit) {
-      this.internals.enabledWatchers = this.internals.allWatchers;
-    } else {
-      Object.defineProperty(component, "updateComplete", {
-        get: async () => await this._updatePromise.promise
-      });
-    }
-    queueMicrotask(internals.enableReadonly);
-    setAmbientComponent(component);
-    elementToInstance.set(component.el, component);
-    elementToInstance.set(component, component);
-  }
-  _bindLifecycleMethods() {
-    const component = this.component;
-    const isLit = this.isLit;
-    const isStencilDistBuild = component.el === component;
-    this._originalLifecycles = {
-      // These component's callbacks will be called by Lit, so we don't have to
-      _connectedCallback: isLit || isStencilDistBuild ? void 0 : component.connectedCallback,
-      _disconnectedCallback: isLit || isStencilDistBuild ? void 0 : component.disconnectedCallback,
-      _load: isLit ? component.load : component.componentWillLoad,
-      _loaded: isLit ? component.loaded : component.componentDidLoad,
-      _willUpdate: isLit ? void 0 : component.componentWillUpdate,
-      _updated: isLit ? void 0 : component.componentDidUpdate,
-      _destroy: component.destroy
-    };
-    const hostConnected = this._connectedCallback.bind(this);
-    const hostDisconnected = this._disconnectedCallback.bind(this);
-    const hostUpdate = this._update.bind(this);
-    const hostUpdated = this._updated.bind(this);
-    if (isLit) {
-      component.constructor.prototype.addController.call(component, {
-        // Lit will call these callbacks
-        hostConnected,
-        hostDisconnected,
-        hostUpdate,
-        hostUpdated
-      });
-    } else {
-      component.connectedCallback = hostConnected;
-      component.disconnectedCallback = hostDisconnected;
-      component.componentWillLoad = this._load.bind(this);
-      component.componentDidLoad = this._loaded.bind(this);
-      component.componentWillUpdate = hostUpdate;
-      component.componentDidUpdate = hostUpdated;
-    }
-    if (this.hasDestroy) {
-      component.destroy = this.destroy.bind(this);
-    }
-  }
-  /**
-   * Private because this is not supposed to be called by Component directly.
-   * Instead, _bindLifecycleMethods will take care of that. Otherwise, you risk
-   * calling lifecycle methods twice.
-   *
-   * @internal
-   */
-  _connectedCallback() {
-    if (this.destroyed) {
-      const tagName = this.component.el.localName;
-      this.component.el.remove();
-      throw new Error(
-        `The ${tagName} component has already been destroyed. It cannot be used again. If you meant to disconnect and reconnect a component without automatic destroy, set the ${autoDestroyDisabledPropName} prop.`
-      );
-    }
-    if (this._autoDestroyTimeout !== void 0) {
-      clearTimeout(this._autoDestroyTimeout);
-    }
-    const internals = this.internals;
-    internals.enabledWatchers = internals.allWatchers;
-    keyTrackResolve();
-    internals.enableReadonly?.();
-    this._controllers.forEach(callConnected);
-    this._originalLifecycles._connectedCallback?.call(this.component);
-    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
-      devOnlySetPersistentControllerData?.(this, true);
-    }
-  }
-  /** @internal */
-  _disconnectedCallback() {
-    if (this.destroyed) {
-      return;
-    }
-    this._controllers.forEach(callDisconnected);
-    this._originalLifecycles._disconnectedCallback?.call(this.component);
-    if (this.hasDestroy) {
-      this._setAutoDestroyTimeout();
-    }
-  }
-  /** @internal */
-  async _load() {
-    await Promise.allSettled(Array.from(this._controllers, callLoad));
-    await this._originalLifecycles._load?.call(this.component);
-    if (this.hasDestroy) {
-      watch(this.component, autoDestroyDisabledPropName, () => this._setAutoDestroyTimeout());
-    }
-  }
-  /** @internal */
-  _loaded() {
-    this._controllers.forEach(callLoaded);
-    this._originalLifecycles._loaded?.call(this.component);
-  }
-  _update() {
-    const maybeLitComponent = this.component;
-    this._controllers.forEach(callUpdate, maybeLitComponent.$changes);
-    return this._originalLifecycles._willUpdate?.call(this.component);
-  }
-  _updated() {
-    const maybeLitComponent = this.component;
-    this._controllers.forEach(callUpdated, maybeLitComponent.$changes);
-    this._originalLifecycles._updated?.call(this.component);
-    if (this.isLit) {
-      maybeLitComponent.$changes = /* @__PURE__ */ new Map();
-    } else {
-      const updatePromise = this._updatePromise;
-      this._updatePromise = new Deferred();
-      updatePromise.resolve(true);
-    }
-  }
-  async destroy() {
-    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
-      this.ensureHasDestroy?.();
-    }
-    if (this.destroyed) {
-      return;
-    }
-    if (this.component.el.isConnected) {
-      this.hasDestroy = false;
-      try {
-        this.component.el.remove();
-      } finally {
-        this.hasDestroy = true;
-      }
-    }
-    this._autoDestroyTimeout = void 0;
-    this.destroyed = true;
-    this._controllers.forEach(callDestroy);
-    this._controllers.clear();
-    await this._originalLifecycles._destroy?.call(this.component);
-  }
-  _setAutoDestroyTimeout() {
-    if (this._autoDestroyTimeout !== void 0) {
-      clearTimeout(this._autoDestroyTimeout);
-    }
-    if (!this.component.el.isConnected && !this.component.autoDestroyDisabled) {
-      const destroy = () => void this.destroy().catch(console.error);
-      if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && autoDestroyOnDisconnectTimeout === 0) ;
-      else {
-        this._autoDestroyTimeout = devToolsAwareTimeout(destroy, autoDestroyOnDisconnectTimeout);
-      }
-    }
-  }
-}
-if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
-  ControllerManager.prototype.ensureHasDestroy = function ensureHasDestroy() {
-    if (!this.hasDestroy) {
-      throw new Error(
-        `
-          If the component uses a controller that uses destroy() method, then the
-          component must have the following properties:
-          /**
-           * If true, the component will not be destroyed automatically when it is
-           * disconnected from the document. This is useful when you want to move the
-           * component to a different place on the page, or temporarily hide it. If this
-           * is set, make sure to call the \`destroy\` method when you are done to prevent
-           * memory leaks.
-           */
-          @${this.isLit ? "property" : "Prop"}() ${autoDestroyDisabledPropName} = false;
-
-          /** Permanently destroy the component */
-          @${this.isLit ? "method" : "Method"}()
-          async destroy(): Promise<void> {
-            await this.manager.destroy();
-          }
-          `.trim().split("\n").map((line) => line.trim()).join("\n")
-      );
-    }
-  };
-}
-const autoDestroyDisabledPropName = "autoDestroyDisabled";
-let autoDestroyOnDisconnectTimeout = 1e3;
-process.env.NODE_ENV !== "production" && isEsriInternalEnv() ? {} : void 0;
-const defaultGetterSetter = (value) => value;
-function callConnected(controller) {
-  if ("triggerConnected" in controller) {
-    controller.triggerConnected();
-  } else {
-    safeCall(controller.hostConnected, controller);
-  }
-}
-function callDisconnected(controller) {
-  if ("triggerDisconnected" in controller) {
-    controller.triggerDisconnected();
-  } else {
-    safeCall(controller.hostDisconnected, controller);
-  }
-}
-async function callLoad(controller) {
-  if ("triggerLoad" in controller) {
-    await controller.triggerLoad();
-  } else {
-    await safeAsyncCall(controller.hostLoad, controller);
-  }
-}
-function callLoaded(controller) {
-  if ("triggerLoaded" in controller) {
-    controller.triggerLoaded();
-  } else {
-    safeCall(controller.hostLoaded, controller);
-  }
-}
-function callUpdate(controller) {
-  if ("triggerUpdate" in controller) {
-    controller.triggerUpdate(this);
-  } else {
-    safeCall(controller.hostUpdate, controller, this);
-  }
-}
-function callUpdated(controller) {
-  if ("triggerUpdated" in controller) {
-    controller.triggerUpdated(this);
-  } else {
-    safeCall(controller.hostUpdated, controller, this);
-  }
-}
-function callDestroy(controller) {
-  if ("triggerDestroy" in controller) {
-    controller.triggerDestroy();
-  } else {
-    safeCall(controller.hostDestroy, controller);
-  }
-}
-export {
-  useControllerManager as u
-};

package/dist/controllers/ComponentInternals.d.ts

@@ -1,92 +0,0 @@
-import { BaseComponent, BaseController, ControllerHost } from './types';
-export type TrackKeyResolution = {
-    readonly key: string;
-    readonly host: BaseComponent | BaseController;
-    /**
-     * True if property is decorated with `@State()` or `@Prop()` decorator
-     */
-    readonly isReactive: boolean;
-};
-/**
- * Like ControllerInternals, but specific to each instance of a component
- *
- * @internal
- */
-export declare class ComponentInternals {
-    /**
-     * When watchers are set, they are set into `allWatchers`. When watchers are
-     * read in the setter, they are read from `enabledWatchers`.
-     *
-     * In Stencil, on connectedCallback(), controller manager does
-     * `enabledWatchers=allWatchers`. Reasoning:
-     * - This disables watchers until connected callback (matches behavior of
-     *   Stencil's watchers)
-     * - This removes the need for a check in the setter for whether the watchers
-     *   were enabled already or not (as getters/setters are hot path, and should
-     *   be streamlined)
-     *
-     * In Lit, we set enabledWatchers to allWatchers in the constructor.
-     * Reasoning:
-     * - While in Stencil all user provided properties are either set before the
-     *   component constructor (this is possible since Stencil's props store is
-     *   externalized) or after connectedCallback, in Lit the properties may be
-     *   set by attributeChangedCallback before connectedCallback. Thus, we need
-     *   to enable watchers even before connectedCallback.
-     * - This means, that a watcher set for some prop before your component got
-     *   a chance to set the default value will trigger the watcher when the
-     *   default value is set - but, that is inline with Lit's willUpdate behavior
-     *   of triggering for default values AND, the only way to set a watcher
-     *   before default value is if you called watcher inside a controller. For
-     *   now, there are no controllers written outside of arcgis-map-components
-     *   package, so I was able to verify that this change would have no
-     *   negative impact.
-     *
-     * In either way, I plan to remove watchers from controllers once Stencil
-     * support is removed.
-     */
-    enabledWatchers: Watchers;
-    allWatchers: Watchers;
-    readonly component: BaseComponent & ControllerHost;
-    /**
-     * Do not use this directly as it may break on framework updates.
-     * Instead, use helpers like getPropMembers() and getPropType()
-     */
-    members: Record<string, [number, string?]>;
-    constructor(component: BaseComponent & ControllerHost);
-    /**
-     * "readOnly" is not enabled initially since we need to allow to set property
-     * default values in the constructor.
-     * For Stencil, readonly is enabled by the `readonly()` controller.
-     * For Lit, we have the following logic:
-     */
-    enableReadonly: (() => void) | undefined;
-    trackedValue: unknown;
-    keyTrackers: ((key: string | undefined, value: unknown) => void)[];
-    firePropTrackers(key: string | undefined, value: unknown): void;
-    readonly getters: Record<string, ((value: unknown, propertyName: string) => unknown)[] | undefined>;
-    readonly setters: Record<string, ((newValue: unknown, oldValue: unknown, propertyName: string) => unknown)[] | undefined>;
-    readonly accessorGetter: Record<string, (value: unknown, propertyName: string) => unknown>;
-    readonly accessorSetter: Record<string, (newValue: unknown, oldValue: unknown, propertyName: string) => unknown>;
-    /**
-     * 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: string): void;
-    private _getSetProxy;
-    private _exports;
-    /**
-     * Associate an exports object with a controller for reverse lookup in
-     * controller.use
-     */
-    markExports(controller: BaseController, exports: unknown): void;
-    resolveExports(exports: unknown): BaseController | undefined;
-    readonlySetter: <T>(newValue: T, _oldValue: T, property: string) => T;
-}
-type Watchers = Record<string, ((newValue: unknown, oldValue: unknown, propertyName: string) => void)[] | undefined>;
-export declare const nothing: symbol;
-export {};

package/dist/controllers/framework.d.ts

@@ -1,45 +0,0 @@
-import { BaseComponent } from './types';
-/**
- * Do not consume this enum directly. Instead, consume one of the wrapper
- * functions defined in this file.
- */
-export declare enum PropTypes {
-    String = 1,
-    Number = 2,
-    Boolean = 4,
-    Any = 8,
-    Unknown = 16,
-    State = 32,
-    Method = 64,
-    Event = 128,
-    Element = 256,
-    ReflectAttr = 512,
-    Mutable = 1024,
-    Prop = 31,
-    HasAttribute = 15,
-    PropLike = 63,
-    ReadOnly = 2048
-}
-/**
- * Retrieve list of members on a Stencil/Lit component and their types
- *
- * Warning:
- * - this may break on Stencil updates
- * - component meta is not component instance specific, thus any modifications
- *   would affect all instances of that component
- */
-export declare function retrieveComponentMembers(component: BaseComponent, isLit: boolean): void;
-/**
- * This function is only expected to be called in Stencil, not Lit
- *
- * Based on https://github.com/ionic-team/stencil/blob/9c82ffb782f69bfbca28a8aced35c515e711f5fa/src/runtime/parse-property-value.ts#L31-L46
- */
-export declare function parsePropertyValue(value: unknown, type?: PropTypes): unknown;
-/**
- * Get a number representing different flags for a given prop. To get a value
- * of individual flag, use the PropTypes enum.
- *
- * @example
- * const isBoolean = (getMemberType(component, "myProp") & PropTypes.Boolean) !== 0;
- */
-export declare const getMemberType: (component: BaseComponent, name: string) => number | undefined;

package/dist/controllers/getSet.d.ts

@@ -1,116 +0,0 @@
-import { BaseComponent } from './types';
-/**
- * Listen for any component's @State()/@Prop() change, and mutate it's
- * value before it is set.
- * This is necessary because Stencil's Compiler does not support get/set for
- * @State()/@Prop().
- * For private component properties, you should use regular get/set syntax.
- *
- * @example
- * ```tsx
- * @Prop() exampleProp = getSet(defaultValue,{get,set})
- * @Prop() someProp = getSet(
- *   undefined as string | undefined,
- *   {
- *     get: (value)=>value.trim(),
- *     set: (newValue,oldValue) => newValue.trim() ?? oldValue
- *   }
- * )
- * ```
- *
- * @remarks
- * Unlike a native get/set, the get function receives the current attribute
- * value, and can modify it before returning it (or can disregard the current
- * value and get it from elsewhere instead).
- * Similarly, setter is called with the new and old value, and is expected to
- * return the final new value (or return the old value to undo the change)
- *
- * @deprecated see https://qawebgis.esri.com/components/lumina/properties#get-set-properties
- */
-export declare function getSet<T>(
-/**
- * Default value is used only if user did not set a value in the DOM before
- * component was loaded
- */
-defaultValue: T, getSet: {
-    get?(newValue: T, propertyName: string): T;
-    set(newValue: T, oldValue: T, propertyName: string): T;
-} | {
-    get(newValue: T, propertyName: string): T;
-    set?(newValue: T, oldValue: T, propertyName: string): T;
-} | {
-    get(newValue: T, propertyName: string): T;
-    set: "ignore";
-}): T;
-/**
- * Like getSet(), but can be called on any component's
- * state/prop from anywhere, rather than just from the default value
- *
- * @deprecated see https://qawebgis.esri.com/components/lumina/properties#get-set-properties
- */
-export declare const dynamicGetSet: <Component extends BaseComponent, Property extends keyof (BaseComponent & Component)>(component: Component, property: Property, getSet: {
-    get?(newValue: (BaseComponent & Component)[Property], propertyName: Property): (BaseComponent & Component)[Property];
-    set(newValue: (BaseComponent & Component)[Property], oldValue: (BaseComponent & Component)[Property], propertyName: Property): (BaseComponent & Component)[Property];
-} | {
-    get(newValue: (BaseComponent & Component)[Property], propertyName: Property): (BaseComponent & Component)[Property];
-    set?(newValue: (BaseComponent & Component)[Property], oldValue: (BaseComponent & Component)[Property], propertyName: Property): (BaseComponent & Component)[Property];
-}) => void;
-/**
- * If you need to set a prop/state without triggering the custom setter you
- * defined with getSet()/dynamicGetSet()/readonly(), set the value inside
- * of this function
- *
- * @example
- * ```tsx
- * @Prop() readOnly = readOnly(true);
- *
- * someAction(): void {
- *   bypassSetter(()=>{
- *     this.readOnly = false;
- *   });
- * }
- * ```
- *
- * @deprecated see https://qawebgis.esri.com/components/lumina/properties#get-set-properties
- */
-export declare function bypassSetter<T = void>(callback: () => T): T | void;
-/**
- * Property reads inside of this function will bypass any custom getter you
- * may have, and read the value directly from what's stored in Stencil/Lit.
- *
- * This also bypasses reactiveUtils integration - reading a property inside of
- * bypassGetter won't make that property tracked.
- *
- * @example
- * ```tsx
- * reactiveUtils.watch(
- *   ()=>{
- *     bypassGetter(()=>{
- *       console.log(this.someProp);
- *     });
- *     return this.prop;
- *   },
- *   console.log
- * );
- * ```
- *
- * @deprecated see https://qawebgis.esri.com/components/lumina/properties#get-set-properties
- */
-export declare function bypassGetter<T = void>(callback: () => T): T | void;
-/**
- * Like dynamicGetSet, but less type-safe. Useful in cases when trying to set
- * getters/setters in place where property names & types are not known
- * statically
- *
- * @deprecated see https://qawebgis.esri.com/components/lumina/properties#get-set-properties
- */
-export declare function genericGetSet<Type>(component: BaseComponent, property: string, getSet: {
-    get?(newValue: Type, propertyName: string): Type;
-    set(newValue: Type, oldValue: Type, propertyName: string): Type;
-} | {
-    get(newValue: Type, propertyName: string): Type;
-    set?(newValue: Type, oldValue: Type, propertyName: string): Type;
-} | {
-    get(newValue: Type, propertyName: string): Type;
-    set: "ignore";
-}): void;

package/dist/controllers/readonly.d.ts

@@ -1,29 +0,0 @@
-/**
- * Make a @Prop() or @State() readonly (prevent overwriting default value).
- *
- * For internal properties, prefer TypeScript's "readonly" modifier instead.
- *
- * @example
- * ```ts
- * // Defining readonly prop
- * @Prop({ reflect: true }) prop = readonly('a');
- * ```
- *
- * @example
- * ```ts
- * // Overwriting readonly prop internally
- * bypassReadOnly(()=>{
- *   this.prop = 'b';
- * });
- * ```
- *
- * @deprecated see https://qawebgis.esri.com/components/lumina/properties#read-only-properties
- */
-export declare function readonly<T>(value: T): T;
-/**
- * Like bypassSetter(), but only bypasses readonly(), rather that
- * all setters set using getSet()
- *
- * @deprecated see https://qawebgis.esri.com/components/lumina/properties#read-only-properties
- */
-export declare function bypassReadOnly<T = void>(callback: () => T): T | void;

package/dist/controllers/useWatch.d.ts

@@ -1,27 +0,0 @@
-import { BaseComponent } from './types';
-/**
- * Dynamically set a watcher for any reactive property
- *
- * @example
- * ```ts
- * this.manager.onLifecycle(()=>
- *   watch(this, "myProp", (newValue,oldValue)=>console.log(newValue,oldValue))
- * )
- * ```
- *
- * @remarks
- * If you are in Lit, you should prefer the willUpdate() lifecycle method
- * over watch(). willUpdate() is going to be more memory-efficient, and more
- * flexible (can watch multiple props at once or provide dynamic prop name)
- *
- * ```ts
- * willUpdate(changes: PropertyValues<this>) {
- *   if (changes.has('firstName') || changes.has('lastName')) {
- *     this.sha = computeSHA(`${this.firstName} ${this.lastName}`);
- *   }
- * }
- * ```
- *
- * @deprecated see https://qawebgis.esri.com/components/lumina/lifecycle#willupdate and https://qawebgis.esri.com/components/lumina/controllers/lifecycle
- */
-export declare function watch<Component extends BaseComponent, Property extends keyof Component>(component: Component, property: Property, callback: (newValue: Component[Property], oldValue: Component[Property], property: Property) => void): () => void;