@arcgis/lumina 4.33.0-next.10 → 4.33.0-next.101

package/dist/controllers/accessor/index.js

@@ -0,0 +1,259 @@
+import { p as devOnlySetPersistentControllerData, q as devOnlyGetPersistentControllerData, G as GenericController, n as trackPropKey, h as bypassGetter, l as bypassReadOnly, t as trackKey, r as retrieveComponent, g as createEventFactory } from "../../Controller-CZ8Djohh.js";
+import { p as proxyExports } from "../../proxyExports-CK5BLFLO.js";
+import { isEsriInternalEnv } from "@arcgis/components-utils";
+import { watch, on } from "@arcgis/core/core/reactiveUtils.js";
+const makeAccessorController = (loadAccessor, _options) => (component, options) => proxy(component, loadAccessor, options);
+class AccessorController extends GenericController {
+  constructor(component, _loadAccessor, _options) {
+    super(component);
+    this._loadAccessor = _loadAccessor;
+    this._options = _options;
+    this._watchedProperties = /* @__PURE__ */ new Map();
+    this._isBinding = { value: true };
+    this.setProvisionalExports(
+      accessorSupport.makeGetterProxy(
+        component,
+        this._watchedProperties,
+        this._isBinding,
+        this.constructor.allowedPropNameMismatches
+      )
+    );
+    trackPropKey(
+      component,
+      (resolved) => {
+        if (resolved) {
+          this._instancePropName = resolved;
+        }
+      },
+      this.exports
+    );
+  }
+  hostConnected() {
+    this._isBinding.value = false;
+  }
+  async hostLoad() {
+    const component = this.component;
+    const parameters = this._gatherParameters();
+    const finalParameters = this._options?.editConstructorProperties?.call(component, parameters) ?? parameters;
+    const awaitedParameters = finalParameters instanceof Promise ? await finalParameters : finalParameters;
+    const genericComponent = component;
+    const existingInstance = typeof this._instancePropName === "string" ? genericComponent[this._instancePropName] : void 0;
+    const hasInstance = existingInstance != null && existingInstance !== this.exports;
+    if (hasInstance) {
+      this._instance = existingInstance;
+      existingInstance.set(awaitedParameters);
+    } else {
+      this._instance = await this._createInstance(awaitedParameters);
+    }
+    if (component.manager.destroyed) {
+      return;
+    }
+    accessorSupport.watchComponentUpdates(this, this._instance, this._watchedProperties);
+    accessorSupport.watchAccessorUpdates(this, this._instance, this._watchedProperties);
+    this.exports = this._instance;
+  }
+  _gatherParameters() {
+    const data = Object.fromEntries(
+      Array.from(
+        this._watchedProperties,
+        ([prop, property]) => [property, this.component[prop]]
+      ).filter(([, value]) => value !== void 0)
+    );
+    const props = process.env.NODE_ENV !== "production" && isEsriInternalEnv() ? filterWatchedProperties?.(this, data) ?? data : data;
+    return props;
+  }
+  async _createInstance(parameters) {
+    if (this._isAccessorConstructor(this._loadAccessor)) {
+      return new this._loadAccessor(parameters);
+    } else {
+      return await this._loadAccessor(parameters);
+    }
+  }
+  _isAccessorConstructor(loader) {
+    return "prototype" in loader && "declaredClass" in loader.prototype;
+  }
+  hostDestroy() {
+    if (this._instance) {
+      this._instance.destroy();
+    }
+  }
+  async reCreate() {
+    this.hostDestroy();
+    await this.hostLoad();
+  }
+}
+const proxy = proxyExports(AccessorController);
+const accessorSupport = {
+  makeGetterProxy: (component, watchedProperties, isBinding, allowedPropNameMismatches) => new Proxy(
+    {},
+    {
+      /*
+       * Without this, makeProvisionalValue() will throw on accessing
+       * non-existent prop
+       */
+      has: (target, prop) => typeof prop === "string" || prop in target,
+      get: (target, prop) => {
+        const value = Reflect.get(target, prop);
+        if (typeof prop === "symbol" || prop in Promise.prototype) {
+          return value;
+        }
+        const hasProp = prop in target;
+        const doBinding = isBinding?.value ?? true;
+        if (hasProp || !doBinding) {
+          return value;
+        }
+        if (watchedProperties.has(prop)) {
+          return;
+        }
+        return trackKey(
+          component,
+          (resolved) => {
+            if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+              if (resolved === void 0) {
+                return;
+              }
+              const isFlippingBoolean = resolved.key.toLowerCase().includes("disable");
+              const collidesWithNativeProp = prop in HTMLElement.prototype;
+              const collidesWithCustomProp = allowedPropNameMismatches?.has(prop) === true;
+              if (resolved.key !== prop && !collidesWithNativeProp && !collidesWithCustomProp && !isFlippingBoolean) {
+                throw new Error(
+                  `Tried to bind "${resolved?.key}" property to "${prop.toString()}" - property names must match`
+                );
+              }
+              if (!resolved.isReactive) {
+                throw new Error(
+                  `For two-way binding with Accessor to work, the property on your component must have @property() or @state() decorator. "${prop.toString()}" has neither`
+                );
+              }
+            }
+            if (resolved !== void 0) {
+              watchedProperties.set(resolved.key, prop);
+            }
+          },
+          value
+        );
+      }
+    }
+  ),
+  // Update Accessor on component prop change
+  watchComponentUpdates(controller, instance, watchedProperties) {
+    function getter(_value, propName) {
+      const propertyName = watchedProperties.get(propName);
+      const value = instance[propertyName];
+      const flipBoolean = typeof value === "boolean" && propertyName !== propName && propName.toLowerCase().includes("disable");
+      return flipBoolean ? !value : value;
+    }
+    const setter = (newValue, _oldValue, propName) => {
+      const propertyName = watchedProperties.get(propName);
+      const value = instance[propertyName];
+      const flipBoolean = typeof value === "boolean" && propertyName !== propName && propName.toLowerCase().includes("disable");
+      const currentValue = flipBoolean ? !value : value ?? void 0;
+      if (currentValue === newValue) {
+        return newValue;
+      }
+      instance[propertyName] = flipBoolean ? !newValue : newValue;
+      const finalValue = instance[propertyName];
+      return flipBoolean ? !finalValue : finalValue;
+    };
+    const manager = controller.component.manager;
+    watchedProperties.forEach((_propName, propertyName) => {
+      manager._accessorGetter[propertyName] = getter;
+      manager._accessorSetter[propertyName] = setter;
+    });
+  },
+  // Update component on Accessor prop change
+  watchAccessorUpdates(controller, instance, watchedProperties) {
+    const { component } = controller;
+    const genericComponent = component;
+    const genericInstance = instance;
+    const readonlyProps = findReadOnlyAccessorProps(instance);
+    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+      setReadonlyProps?.(controller, readonlyProps);
+    }
+    bypassGetter(
+      () => (
+        // Careful: Map's forEach callback arguments are (value, key), not (key, value)
+        watchedProperties.forEach((propertyName, propName) => {
+          if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && !(propertyName in instance)) {
+            throw new Error(`"${propertyName}" does not exist on the accessor instance`);
+          }
+          if (readonlyProps.has(propertyName)) {
+            return;
+          }
+          const domValue = genericComponent[propName];
+          const modelValue = genericInstance[propertyName] ?? void 0;
+          const flipBoolean = typeof domValue === "boolean" && propertyName !== propName && propName.toLowerCase().includes("disable");
+          const resolvedDomValue = flipBoolean ? !domValue : domValue;
+          if (resolvedDomValue != null && modelValue !== resolvedDomValue) {
+            genericInstance[propertyName] = resolvedDomValue;
+          }
+        })
+      )
+    );
+    controller.onLifecycle(() => {
+      if (instance.destroyed) {
+        return;
+      }
+      return Array.from(
+        watchedProperties,
+        ([propName, propertyName]) => watch(
+          () => genericInstance[propertyName],
+          () => {
+            const newValue = genericInstance[propertyName];
+            const flipBoolean = typeof newValue === "boolean" && propertyName !== propName && propName.toLowerCase().includes("disable");
+            const resolvedNewValue = flipBoolean ? !newValue : newValue;
+            bypassReadOnly(() => {
+              genericComponent[propName] = resolvedNewValue;
+            });
+          },
+          { initial: true }
+        )
+      );
+    });
+  },
+  async reCreate(instance, component) {
+    const accessorController = component.manager.useRefSync(instance);
+    if (accessorController === void 0) {
+      if (process.env.NODE_ENV !== "production") {
+        console.error("Unable to resolve the useAccessor controller from the provided value");
+      }
+      return;
+    }
+    await accessorController.reCreate();
+  }
+};
+function findReadOnlyAccessorProps(instance) {
+  const accessor = instance;
+  const properties = Object.entries(accessor.__accessor__?.metadata ?? {});
+  return new Set(
+    properties.filter(([_property, descriptor]) => descriptor?.readOnly === true).map(([property]) => property)
+  );
+}
+const setReadonlyProps = process.env.NODE_ENV !== "production" && isEsriInternalEnv() ? (controller, properties) => {
+  devOnlySetPersistentControllerData?.(controller, properties);
+} : void 0;
+const filterWatchedProperties = process.env.NODE_ENV !== "production" && isEsriInternalEnv() ? (controller, data) => {
+  const readonlyProperties = devOnlyGetPersistentControllerData?.(controller);
+  if (readonlyProperties instanceof Set) {
+    return Object.fromEntries(Object.entries(data).filter(([key]) => !readonlyProperties.has(key)));
+  }
+  return data;
+} : void 0;
+function reEmitEvent(getEventedAccessor, eventName) {
+  const component = retrieveComponent();
+  const manager = component.manager;
+  manager.onLoaded(() => manager.onLifecycle(() => on(getEventedAccessor, eventName, emitter.emit)));
+  const emitter = createEventFactory();
+  if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+    if (typeof emitter !== "object" || emitter === null || !("emit" in emitter) || typeof emitter.emit !== "function") {
+      throw new Error(`Expected to find $createEvent static property on Lumina's LitElement`);
+    }
+  }
+  return emitter;
+}
+export {
+  AccessorController,
+  accessorSupport,
+  makeAccessorController,
+  reEmitEvent
+};

package/dist/controllers/accessor/reEmitEvent.d.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from '../../createEvent';
+/**
+ * Re-emit an event from the accessor instance on the component
+ *
+ * @example
+ * ```tsx
+ * arcgisGo = reEmitEvent<__esri.HomeViewModelGoEvent>(() => this.viewModel, "go");
+ * ```
+ */
+export declare function reEmitEvent<T>(getEventedAccessor: () => __esri.Evented, eventName: string): EventEmitter<T>;

package/dist/controllers/accessor/useAccessor.d.ts

@@ -0,0 +1,74 @@
+import { Controller, GenericController } from '../Controller';
+import { LitElement } from '../../LitElement';
+type Requires<Props, Accessor extends __esri.Accessor> = LitElement & Pick<Accessor, keyof Accessor & keyof Props> & {
+    autoDestroyDisabled: boolean;
+    destroy: () => Promise<void>;
+};
+/**
+ * Given an Accessor class, create a controller that will do two-way binding of
+ * props between the component and the Accessor
+ *
+ * See 4.accessor.tsx for documentation & examples
+ */
+export declare const makeAccessorController: <Props, Accessor extends __esri.Accessor, OmitProps extends string = never>(loadAccessor: ((props: Props) => Accessor | Promise<Accessor>) | (new (props: Props) => Accessor), _options?: {
+    /**
+     * By default, to ensure that you didn't accidentally forget to bind any
+     * of the Accessor's properties on your component, every property that
+     * is accepted by the Accessor's constructor will be required to be bound
+     * on your component. If you do not wish to bind certain properties
+     * (or you wish to bind them but with a different type), you can omit
+     * them using this option.
+     *
+     * You can also bind the property to \@state rather than \@property if you
+     * wish to use it internally only:
+     * @example
+     * ```tsx
+     * \@State() timeZone = this.viewModel.timeZone;
+     * ```
+     *
+     * @remarks
+     * This option affects the TypeScript error checking only - it has
+     * no runtime impact. Thus, if you wish to save a few bytes in the
+     * bundle, rather than simply setting this property like
+     * `makeAccessorController(..., { omitProps: ["propName"] })`, you can
+     * set it like this:
+     * `makeAccessorController(..., {} as { omitProps: ["propName"] })`
+     */
+    omitProps: OmitProps[];
+}) => (component: Requires<Omit<Props, OmitProps>, Accessor>, options?: {
+    editConstructorProperties(props: Props): Promise<Props> | Props;
+}) => Accessor;
+export declare class AccessorController<Props, Accessor extends __esri.Accessor, ExtraRequires = Record<never, never>> extends GenericController<Accessor, ExtraRequires & Requires<Props, Accessor>> {
+    private _loadAccessor;
+    private _options?;
+    protected _instance: Accessor;
+    protected _watchedProperties: Map<string, string & keyof Props>;
+    private _instancePropName;
+    private _isBinding;
+    /**
+     * (development only) Allow these props to mismatch the name of the Accessor's property
+     * to avoid collisions
+     *
+     * @private
+     */
+    static allowedPropNameMismatches?: Set<string>;
+    constructor(component: ExtraRequires & Requires<Props, Accessor>, _loadAccessor: ((props: Props) => Accessor | Promise<Accessor>) | (new (props: Props) => Accessor), _options?: {
+        editConstructorProperties?(props: Props): Promise<Props> | Props;
+    } | undefined);
+    hostConnected(): void;
+    hostLoad(): Promise<void>;
+    private _gatherParameters;
+    private _createInstance;
+    private _isAccessorConstructor;
+    hostDestroy(): void;
+    reCreate(): Promise<void>;
+}
+export declare const accessorSupport: {
+    makeGetterProxy: (component: LitElement, watchedProperties: Map<string, string>, isBinding?: {
+        value: boolean;
+    }, allowedPropNameMismatches?: Set<string>) => unknown;
+    watchComponentUpdates<T>(controller: Controller<T>, instance: __esri.Accessor, watchedProperties: Map<string, string>): void;
+    watchAccessorUpdates<T>(controller: Controller<T>, instance: __esri.Accessor, watchedProperties: Map<string, string>): void;
+    reCreate(instance: __esri.Accessor, component: LitElement): Promise<void>;
+};
+export {};

package/dist/controllers/functional.d.ts

@@ -0,0 +1,19 @@
+import { LitElement } from '../LitElement';
+import { GenericControllerType, Controller } from './Controller';
+/**
+ * Controller is a function that takes a component instance and then can
+ * export some values to the component, or hook into component's lifecycle
+ *
+ * See controllers documentation for many example controllers and their usages
+ */
+export declare const makeController: <Exports>(constructor: (component: LitElement, controller: Controller<Exports>) => Exports | Promise<Exports>) => Exports;
+/**
+ * If your controller requires some specific properties to be present on the
+ * component, besides what's included in the LitElement, use
+ * makeGenericController
+ *
+ * When using a controller created using makeGenericController(), consumer must
+ * pass in "this" explicitly for proper type-checking. If controller was
+ * created using makeController(), that is not necessary
+ */
+export declare const makeGenericController: <Exports, Component = LitElement>(constructor: (component: Component & LitElement, controller: GenericControllerType<Exports, Component>) => Exports | Promise<Exports>) => (component: Component & LitElement) => Exports;

package/dist/controllers/index.d.ts

@@ -0,0 +1,24 @@
+import { EventEmitter as _EventEmitter } from '../createEvent';
+export type { GenericControllerType } from './Controller';
+export { Controller, GenericController } from './Controller';
+export type { ControllerManager } from './ControllerManager';
+export { retrieveComponent, bypassGetter, bypassSetter, bypassReadOnly } from './ControllerInternals';
+export { trackPropertyKey, keyTrackResolve } from './trackPropertyKey';
+export { trackPropKey } from './trackPropKey';
+export { trackKey } from './trackKey';
+export { makeController, makeGenericController } from './functional';
+export { useWatchAttributes } from './useWatchAttributes';
+export { load } from './load';
+export { proxyExports } from './proxyExports';
+export { toFunction } from './toFunction';
+export * from './types';
+export { useMedia } from './useMedia';
+export { useDirection } from './useDirection';
+export type { UseT9n, T9nMeta } from './useT9n';
+export { makeT9nController } from './useT9n';
+export { usePropertyChange } from './usePropertyChange';
+export { isController } from './utils';
+/**
+ * @deprecated import from "@arcgis/lumina" instead
+ */
+export type EventEmitter<T = undefined> = _EventEmitter<T>;

package/dist/controllers/index.js

@@ -0,0 +1,263 @@
+import { C as Controller, s as setAmbientComponent, i as isPromise, e as setParentController, f as retrieveParentControllers, t as trackKey, r as retrieveComponent, g as createEventFactory } from "../Controller-CZ8Djohh.js";
+import { G, h, l, j, c, o, k, n, m } from "../Controller-CZ8Djohh.js";
+import { p as proxyExports } from "../proxyExports-CK5BLFLO.js";
+import { observeAncestorsMutation, isEsriInternalEnv, getElementAttribute, getElementLocales, startLocaleObserver } from "@arcgis/components-utils";
+const makeController = (constructor) => proxy(void 0, constructor);
+const makeGenericController = (constructor) => (component) => proxy(
+  component,
+  /**
+   * GenericController is identical to Controller, in all except for typing.
+   * So dying a type-cast here so as not to needlessly add one more object
+   * to the prototype chain
+   */
+  constructor
+);
+class FunctionalController extends Controller {
+  constructor(component, constructor) {
+    super(component);
+    const originalExports = this.exports;
+    try {
+      setAmbientComponent(this.component);
+      const value = constructor(this.component, this);
+      const constructorChangedExports = this.exports !== originalExports;
+      if (isPromise(value)) {
+        if (!constructorChangedExports) {
+          this.setProvisionalExports(value);
+        }
+        const resolved = value.then((result) => {
+          this.exports = result;
+          super.catchUpLifecycle();
+        }).catch((error) => {
+          this._ready.reject(error);
+          console.error(error);
+        });
+        this.onLoad(async () => await resolved);
+      } else {
+        if (!constructorChangedExports || value !== void 0) {
+          this.exports = value;
+        }
+        queueMicrotask(() => super.catchUpLifecycle());
+      }
+    } catch (error) {
+      this._ready.reject(error);
+      console.error(error);
+    }
+  }
+  /** Noop - will be called in the constructor instead */
+  catchUpLifecycle() {
+    return;
+  }
+}
+const proxy = proxyExports(FunctionalController);
+const useWatchAttributes = (attributes, callback) => new AttributeWatchController(attributes, callback);
+class AttributeWatchController extends Controller {
+  constructor(_attributes, _callback) {
+    super();
+    this._attributes = _attributes;
+    this._callback = _callback;
+    this._observer = new MutationObserver((mutations) => {
+      mutations.forEach((mutation) => {
+        if (_attributes.includes(mutation.attributeName)) {
+          _callback.call(
+            this.component,
+            this.component.el.getAttribute(mutation.attributeName),
+            mutation.oldValue,
+            mutation.attributeName
+          );
+        }
+      });
+    });
+  }
+  hostConnected() {
+    this._attributes.forEach((attribute) => {
+      if (this.component.el.hasAttribute(attribute)) {
+        this._callback.call(this.component, null, this.component.el.getAttribute(attribute), attribute);
+      }
+    });
+    this._observer.observe(this.component.el, {
+      attributes: true,
+      attributeOldValue: true,
+      attributeFilter: this._attributes
+    });
+  }
+  hostDisconnected() {
+    this._observer.disconnect();
+  }
+}
+const load = makeController;
+const toFunction = (Class) => (...args) => {
+  const ambientControllers = retrieveParentControllers();
+  const instance = new Class(...args);
+  setParentController(ambientControllers.at(-1));
+  return instance;
+};
+const useMedia = (query) => makeController((_component, controller) => {
+  const media = globalThis.matchMedia(query);
+  function changed() {
+    controller.exports = media.matches;
+  }
+  changed();
+  controller.onLifecycle(() => {
+    media.addEventListener("change", changed);
+    return () => media.removeEventListener("change", changed);
+  });
+  return void 0;
+});
+const defaultDirection = "ltr";
+const useDirection = () => makeController((component, controller) => {
+  controller.exports = defaultDirection;
+  controller.onLifecycle(() => {
+    function callback() {
+      const dir = getElementAttribute(component.el, "dir", defaultDirection);
+      controller.exports = dir === "rtl" ? "rtl" : "ltr";
+    }
+    callback();
+    return observeAncestorsMutation(component.el, ["dir"], callback);
+  });
+  if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+    trackKey(
+      component,
+      (resolved) => {
+        if (resolved?.key === "dir") {
+          throw new Error(
+            `Do not assign this controller to a prop called \`dir\` as that will overwrite the \`dir\` attribute on the host element - component should not be setting the \`dir\` attribute on itself. Instead, assign this controller to a property called \`direction\`.`
+          );
+        }
+      },
+      controller.exports
+    );
+  }
+  return void 0;
+});
+const makeT9nController = (getAssetPath) => (options = {}) => (
+  // eslint-disable-next-line @typescript-eslint/promise-function-async
+  makeController((component, controller) => {
+    const locale = getElementLocales(component.el);
+    const pending = { _lang: locale.lang, _t9nLocale: locale.t9nLocale, _loading: true };
+    const componentWithOverrides = component;
+    controller.onLifecycle(
+      () => startLocaleObserver(
+        component.el,
+        () => getAssetPath("./assets"),
+        ({ t9nLocale, t9nStrings, lang }) => {
+          const withoutOverrides = {
+            ...t9nStrings,
+            _lang: lang,
+            _t9nLocale: t9nLocale,
+            _loading: false
+          };
+          controller.exports = withoutOverrides;
+          const label = t9nStrings.componentLabel;
+          if (typeof label === "string" && "label" in component && component.label == null) {
+            component.label ??= label;
+          }
+          applyOverrides(componentWithOverrides.messageOverrides);
+        },
+        options.name
+      )
+    );
+    function applyOverrides(messageOverrides) {
+      const currentValue = controller.exports;
+      const rawMessages = currentValue._original ?? currentValue;
+      const updated = deepMerge(rawMessages, messageOverrides);
+      if (messageOverrides) {
+        updated._original = rawMessages;
+      }
+      controller.exports = updated;
+    }
+    if ("messageOverrides" in componentWithOverrides) {
+      controller.onUpdate((changes) => {
+        if (changes.has("messageOverrides")) {
+          applyOverrides(componentWithOverrides.messageOverrides);
+        }
+      });
+    }
+    if (options.blocking) {
+      controller.setProvisionalExports(pending, false);
+      return controller.ready;
+    } else {
+      return pending;
+    }
+  })
+);
+function deepMerge(original, overwrites) {
+  if (!overwrites) {
+    return original;
+  }
+  const merged = { ...original };
+  Object.entries(overwrites).forEach(([key, value]) => {
+    if (typeof value === "object") {
+      merged[key] = deepMerge(original[key], value);
+    } else {
+      merged[key] = value ?? original[key];
+    }
+  });
+  return merged;
+}
+const usePropertyChange = (_component) => propertyChangeController;
+const eventName = "arcgisPropertyChange";
+function propertyChangeController(...toWatch) {
+  const component = retrieveComponent();
+  const eventEmitter = createEventFactory(eventName, void 0, component);
+  if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+    toWatch.forEach((prop) => {
+      const descriptor = component.constructor.elementProperties.get(prop);
+      const isProp = descriptor !== void 0 && descriptor.state !== true;
+      if (!isProp) {
+        throw new Error(
+          `For usePropertyChange to emit event on "${prop}" property change, you should add @property() to ${prop} in ${component.el.localName}`
+        );
+      }
+    });
+  }
+  let isFirst = true;
+  component.manager.onUpdated((changes) => {
+    if (isFirst || !component.el.isConnected) {
+      isFirst = false;
+      return;
+    }
+    for (const name of toWatch) {
+      if (changes.has(name)) {
+        eventEmitter.emit({ name });
+      }
+    }
+  });
+  if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+    trackKey(
+      component,
+      (resolution) => {
+        if (resolution === void 0 || resolution.isReactive || resolution.key !== eventName) {
+          throw new Error(
+            `For consistency, usePropertyChange must be assigned to an arcgisPropertyChange property and that property should not have @property() or @state() decorators: arcgisPropertyChange = usePropertyChange<this>()("prop1", "prop2");`
+          );
+        }
+      },
+      eventEmitter
+    );
+  }
+  return eventEmitter;
+}
+export {
+  Controller,
+  G as GenericController,
+  h as bypassGetter,
+  l as bypassReadOnly,
+  j as bypassSetter,
+  c as controllerSymbol,
+  o as isController,
+  k as keyTrackResolve,
+  load,
+  makeController,
+  makeGenericController,
+  makeT9nController,
+  proxyExports,
+  retrieveComponent,
+  toFunction,
+  trackKey,
+  n as trackPropKey,
+  m as trackPropertyKey,
+  useDirection,
+  useMedia,
+  usePropertyChange,
+  useWatchAttributes
+};

package/dist/controllers/load.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Load a value from a promise and provide it to the component
+ *
+ * Documentation: https://qawebgis.esri.com/components/lumina/controllers/load
+ */
+export declare const load: <T>(loader: () => Promise<T>) => T;

package/dist/controllers/proxyExports.d.ts

@@ -0,0 +1,27 @@
+import { Controller } from './Controller';
+import { ControllerLifecycleMethods } from './types';
+/**
+ * If you wish to directly expose the "exports" property of your controller,
+ * rather than the entire controller class, wrap your class definition in
+ * "proxyExports".
+ *
+ * This is especially convenient when your exports is not an object, or it is a
+ * dynamically created object, and so you don't want your Controller's methods
+ * interfering with the keys on the exported value.
+ *
+ * "proxyExports" is the default behavior for all controllers declared using
+ * the makeController()/makeGenericController() function
+ *
+ * @remarks
+ * If using readonly(), and controller updates its exports, the readonly prop
+ * will still get updated
+ *
+ * @remarks
+ * (Advanced) If you wish to use proxyExports() in a class that does not
+ * extend Controller class and does not have a useControllerManager(), then your
+ * class must subclass a class with the following constructor:
+ * `constructor() { setAmbientController(this); }`. This
+ * is necessary for proxyExports() to receive a reference to your object
+ * implicitly, and before any of your default values are assigned.
+ */
+export declare const proxyExports: <Exports, const Parameters extends unknown[]>(Class: new (...args: Parameters) => ControllerLifecycleMethods & Pick<Controller<Exports>, "component" | "exports" | "onUpdate" | "watchExports">) => ((...args: Parameters) => Exports);