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

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

@@ -0,0 +1,14 @@
+import { EventEmitter } from '../types';
+/**
+ * Re-emit an event from the accessor instance on the component
+ *
+ * @example
+ * ```tsx
+ * arcgisGo = reEmitEvent<__esri.HomeViewModelGoEvent>(() => this.viewModel, "go");
+ * ```
+ *
+ * @remarks
+ * `reEmitEvent()` only works in Lumina. Consult documentation for equivalent
+ * Stencil pattern.
+ */
+export declare function reEmitEvent<T>(getEventedAccessor: () => __esri.Evented, eventName: string): EventEmitter<T>;

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

@@ -0,0 +1,75 @@
+import { Controller, GenericController } from '../Controller';
+import { BaseComponent } from '../types';
+type Requires<Props, Accessor extends __esri.Accessor> = BaseComponent & 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 \@Prop 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
+     *
+     * @internal
+     */
+    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: BaseComponent, 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;
+    reEmitAccessorEvents<T>(controller: Controller<T>, instance: __esri.Accessor, prefix: string): void;
+    reCreate(instance: __esri.Accessor, component: BaseComponent): Promise<void>;
+};
+export {};

package/dist/controllers/framework.d.ts

@@ -0,0 +1,45 @@
+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/functional.d.ts

@@ -0,0 +1,19 @@
+import { GenericControllerType, Controller } from './Controller';
+import { BaseComponent, ControllerHost } from './types';
+/**
+ * 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: BaseComponent & ControllerHost, 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 BaseComponent, 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 = BaseComponent>(constructor: (component: BaseComponent & Component & ControllerHost, controller: GenericControllerType<Exports, Component>) => Exports | Promise<Exports>) => (component: BaseComponent & Component) => Exports;

package/dist/controllers/getSet.d.ts

@@ -0,0 +1,116 @@
+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/index.d.ts

@@ -0,0 +1,23 @@
+export type { GenericControllerType } from './Controller';
+export { Controller, GenericController } from './Controller';
+export type { ControllerManager } from './ControllerManager';
+export { retrieveComponent } from './ControllerInternals';
+export { useControllerManager } from './ControllerManager';
+export { trackPropertyKey, keyTrackResolve } from './trackPropertyKey';
+export { trackPropKey } from './trackPropKey';
+export { trackKey } from './trackKey';
+export { makeController, makeGenericController } from './functional';
+export { readonly, bypassReadOnly } from './readonly';
+export { getSet, dynamicGetSet, bypassGetter, bypassSetter } from './getSet';
+export { watch } from './useWatch';
+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';

package/dist/controllers/index.js

@@ -0,0 +1,283 @@
+import { C as Controller, s as setAmbientComponent, i as isPromise, a as setParentController, b as retrieveParentControllers, t as trackKey, w as watch, r as retrieveComponent, d as createEventFactory, P as PropTypes } from "../useWatch-CFtSpNnN.js";
+import { G, h, g, k, f, e } from "../useWatch-CFtSpNnN.js";
+import { u } from "../ControllerManager-B2comd8J.js";
+import { p as proxyExports } from "../proxyExports-Dl5CHmHQ.js";
+import { a, b, c, d, g as g2, r } from "../proxyExports-Dl5CHmHQ.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.onLifecycle(() => watch(componentWithOverrides, "messageOverrides", applyOverrides));
+    }
+    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 eventedComponent = component;
+  let eventEmitter = eventedComponent[eventName];
+  if (component.manager.isLit) {
+    eventEmitter = createEventFactory(eventName, void 0, component);
+    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+      if (typeof eventEmitter !== "object" || eventEmitter === null || !("emit" in eventEmitter) || typeof eventEmitter.emit !== "function") {
+        throw new Error(`Expected to find $createEvent static property on Lumina's LitElement"`);
+      }
+    }
+  }
+  if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+    if (typeof eventEmitter !== "object" || eventEmitter === null || !("emit" in eventEmitter) || typeof eventEmitter.emit !== "function") {
+      throw new Error(
+        `For consistency, usePropertyChange must be assigned to an arcgisPropertyChange property that has an @Event() decorator`
+      );
+    }
+    const allProps = new Set(
+      Object.entries(component.manager.internals.members).filter(([_name, [propType]]) => (propType & PropTypes.Prop) !== 0).map(([name]) => name)
+    );
+    toWatch.forEach((prop) => {
+      if (!allProps.has(prop)) {
+        throw new Error(
+          prop in component ? `For usePropertyChange to emit event on "${prop}" property change, you should add @${component.manager.isLit ? "property" : "Prop"}() to ${prop} in ${component.el.localName}` : `usePropertyChange can't emit event on "${prop}" property change as such property does not exist in ${component.el.localName}`
+        );
+      }
+    });
+  }
+  component.manager.onLoad(
+    () => component.manager.onLifecycle(
+      () => toWatch.map(
+        (name) => (
+          // Casting to 'el' to simplify dynamic prop name typing
+          watch(component, name, () => eventEmitter.emit({ name }))
+        )
+      )
+    )
+  );
+  if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && component.manager.isLit) {
+    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,
+  a as bypassGetter,
+  b as bypassReadOnly,
+  c as bypassSetter,
+  h as controllerSymbol,
+  d as dynamicGetSet,
+  g2 as getSet,
+  g as isController,
+  k as keyTrackResolve,
+  load,
+  makeController,
+  makeGenericController,
+  makeT9nController,
+  proxyExports,
+  r as readonly,
+  retrieveComponent,
+  toFunction,
+  trackKey,
+  f as trackPropKey,
+  e as trackPropertyKey,
+  u as useControllerManager,
+  useDirection,
+  useMedia,
+  usePropertyChange,
+  useWatchAttributes,
+  watch
+};

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" | "watchExports">) => ((...args: Parameters) => Exports);

package/dist/controllers/readonly.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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/tests/autoDestroyMock.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Mocking utility for changing auto-destroy timeout in ControllerManager to 0ms.
+ * Also, returns a convenient promise that resolves after the timeout.
+ */
+export declare function autoDestroyMock(timeout?: number): () => Promise<void>;

package/dist/controllers/tests/utils.d.ts

@@ -0,0 +1 @@
+export declare function captureConsoleErrors(): unknown[][];

package/dist/controllers/toFunction.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A tiny helper for using a class-based controller as if it's a function.
+ * Main advantage of this is that it's a bit shorter to type.
+ *
+ * This utility can be used for converting non-controller classes to functions
+ * too
+ */
+export declare const toFunction: <T, const P extends unknown[]>(Class: new (...args: P) => T) => ((...args: P) => T);

package/dist/controllers/trackKey.d.ts

@@ -0,0 +1,8 @@
+import { TrackKeyResolution } from './ComponentInternals';
+import { BaseComponent, BaseController } from './types';
+/**
+ * A combination of trackPropertyKey() and trackPropKey(). For usage when
+ * you want to track a property, but don't know if it will be defined with the
+ * \@Prop() decorator or not
+ */
+export declare function trackKey<T>(hostsCandidates: ((BaseComponent | BaseController)[] | BaseComponent | BaseController) | undefined, onResolved: (resolution: TrackKeyResolution | undefined) => void, defaultValue: T): T;