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

package/dist/controllers/ControllerManager.d.ts

@@ -0,0 +1,63 @@
+import { BaseComponent } from './types';
+import { GenericController } from './Controller';
+import { ComponentInternals } from './ComponentInternals';
+/**
+ * Using "new ControllerManager(this)" inside a component causes this TypeScript
+ * error:
+ * 'manager' implicitly has type 'any' because it does not have a type
+ * annotation and is referenced directly or indirectly in its own initializer.
+ *
+ * This function fixes that, and it's also a bit shorter to type
+ *
+ * @deprecated Lumina packages should not need to call this directly
+ */
+export declare const useControllerManager: (component: BaseComponent) => ControllerManager;
+/**
+ * A manager for all other controllers. It finds all controllers on the
+ * component, loads them, and forwards lifecycle events to them.
+ */
+export declare class ControllerManager extends GenericController<undefined> {
+    private readonly _controllers;
+    /** @internal */
+    readonly internals: ComponentInternals;
+    hasDestroy: boolean;
+    destroyed: boolean;
+    private _updatePromise;
+    private _autoDestroyTimeout?;
+    /**
+     * If true, indicates that ControllerManager is running against a Lit component.
+     * Otherwise, means we are running against a Stencil component.
+     */
+    readonly isLit: boolean;
+    constructor(component: BaseComponent);
+    private _originalLifecycles;
+    private _bindLifecycleMethods;
+    /**
+     * Throws an error if component does not implement destroy() lifecycle, but
+     * tries to use it. This check is only present in development mode
+     */
+    ensureHasDestroy?: () => void;
+    /**
+     * 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(): void;
+    /** @internal */
+    _disconnectedCallback(): void;
+    /** @internal */
+    _load(): Promise<void>;
+    /** @internal */
+    _loaded(): void;
+    private _update;
+    private _updated;
+    destroy(): Promise<void>;
+    private _setAutoDestroyTimeout;
+}
+export declare let autoDestroyOnDisconnectTimeout: number;
+export declare const exportsForTests: {
+    setAutoDestroyOnDisconnectTimeout: (timeout: number) => void;
+} | undefined;
+export declare const defaultGetterSetter: (value: unknown) => unknown;

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

@@ -0,0 +1,2 @@
+export { makeAccessorController, AccessorController, accessorSupport } from './useAccessor';
+export { reEmitEvent } from './reEmitEvent';

package/dist/controllers/accessor/index.js

@@ -0,0 +1,307 @@
+import { n as devOnlySetPersistentControllerData, o as devOnlyGetPersistentControllerData, G as GenericController, f as trackPropKey, t as trackKey, r as retrieveComponent, d as createEventFactory } from "../../useWatch-CFtSpNnN.js";
+import { p as proxyExports, a as bypassGetter, c as bypassSetter } from "../../proxyExports-Dl5CHmHQ.js";
+import { isEsriInternalEnv, camelToKebab, isNotUndefined } from "@arcgis/components-utils";
+import { on, watch } 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)) {
+          if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && !component.manager.isLit) {
+            throw new Error(
+              `Tried to bind "${prop.toString()}" prop twice. This might also happen if you are trying to access the accessor instance before ${component.manager.isLit ? "load" : "componentWillLoad"}()`
+            );
+          }
+          return;
+        }
+        return trackKey(
+          component,
+          (resolved) => {
+            if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+              if (resolved === void 0) {
+                if (component.manager.isLit) {
+                  return;
+                }
+                throw new Error(
+                  `Unable to resolve what property is "${prop.toString()}" being bound too. Check documentation for useAccessor to ensure proper usage. Make sure you are not trying to access the accessor instance before ${component.manager.isLit ? "load" : "componentWillLoad"}()`
+                );
+              }
+              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(
+                  component.manager.isLit ? `For two-way binding with Accessor to work, the property on your component must have @property() or @state() decorator. "${prop.toString()}" has neither` : `For two-way binding with Accessor to work, the property on your component must have @Prop() 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 : component.manager.isLit ? value ?? void 0 : value;
+      if (currentValue === newValue) {
+        return newValue;
+      }
+      instance[propertyName] = flipBoolean ? !newValue : newValue;
+      const finalValue = instance[propertyName];
+      return flipBoolean ? !finalValue : finalValue;
+    };
+    const component = controller.component;
+    const internals = component.manager.internals;
+    watchedProperties.forEach((_propName, propertyName) => {
+      internals.accessorGetter[propertyName] = getter;
+      internals.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];
+          let modelValue = genericInstance[propertyName];
+          if (component.manager.isLit) {
+            modelValue ??= 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;
+            bypassSetter(() => {
+              genericComponent[propName] = resolvedNewValue;
+            });
+          },
+          { initial: true }
+        )
+      );
+    });
+  },
+  // REFACTOR: remove this once Stencil is no longer supported
+  reEmitAccessorEvents(controller, instance, prefix) {
+    const isEvented = "on" in instance && typeof instance.on === "function";
+    if (!isEvented) {
+      return;
+    }
+    const toListen = Object.entries(controller.component).map(([key, unknown]) => {
+      const value = unknown;
+      if (!key.startsWith(prefix) || key === prefix || typeof value !== "object" || value === null || !("emit" in value) || typeof value.emit !== "function") {
+        return void 0;
+      }
+      const emit = value.emit;
+      const trimmedEventName = key.slice(prefix.length);
+      const camelCaseEventName = camelToKebab(trimmedEventName);
+      const eventName = camelCaseEventName.toLowerCase();
+      return [eventName, emit];
+    }).filter(isNotUndefined);
+    if (toListen.length === 0) {
+      return;
+    }
+    const eventTarget = instance;
+    const getEventTarget = () => eventTarget;
+    controller.onLifecycle(() => {
+      if (instance.destroyed) {
+        return;
+      }
+      return toListen.map(([eventName, emit]) => on(getEventTarget, eventName, emit));
+    });
+  },
+  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();
+  if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && !component.manager.isLit) {
+    throw new Error(
+      "reEmitEvent is only supported in Lumina components. Consult documentation for equivalent Stencil pattern."
+    );
+  }
+  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,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';