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

package/dist/ControllerManager-B2comd8J.js

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

@@ -1,8 +1,8 @@
 import { CSSResultGroup, CSSResultOrNative, PropertyValues, LitElement as OriginalLitElement } from 'lit';
-import { LuminaPropertyDeclaration } from '@arcgis/components-controllers';
-import { Runtime } from './runtime';
+import { Runtime } from './makeRuntime';
 import { ProxyComponent } from './lazyLoad';
 import { ToElement } from './jsx/types';
+import { LuminaPropertyDeclaration } from './controllers/types';
 type ComponentLifecycle = {
     connectedCallback?: () => void;
     disconnectedCallback?: () => void;
@@ -82,7 +82,7 @@ export declare class LitElement extends OriginalLitElement implements ComponentL
      * Controller Manager orchestrates all controllers used by this component,
      * connecting their lifecycle hooks and providing context information.
      */
-    manager: import('@arcgis/components-controllers').ControllerManager<never>;
+    manager: import('./controllers').ControllerManager;
     /**
      * Map with keys for any properties that have changed since the last
      * update cycle with previous values.

package/dist/context.d.ts

@@ -1,5 +1,5 @@
-import { ControllerHost } from '@arcgis/components-controllers';
 import { ContextConsumer, ContextProvider, Context, ContextType } from '@lit/context';
+import { ControllerHost } from './controllers/types';
 interface ContextProviderOptions<C extends Context<unknown, unknown>> {
     context: C;
     initialValue?: ContextType<C>;

package/dist/controllers/ComponentInternals.d.ts

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

@@ -0,0 +1,152 @@
+import { Deferred } from '@arcgis/components-utils';
+import { BaseComponent, BaseController, ControllerHost, ControllerLifecycleMethods, controllerSymbol } from './types';
+import { use, useRef, useRefSync } from './ControllerInternals';
+import { PropertyValues } from 'lit';
+/**
+ * Base class for Controllers defined using a class rather than a function.
+ * Defining controller using makeController() function is more succinct for smaller
+ * controllers. For controllers that need to declare several methods, or need
+ * more flexibility, this class may be used
+ *
+ * See ./examples.tsx for many example controllers and their usages.
+ */
+export declare abstract class Controller<Exports = never> implements BaseController {
+    protected _callbacks: {
+        readonly [KEY in keyof Omit<ControllerLifecycleMethods, "controllerRemoved">]-?: NonNullable<ControllerLifecycleMethods[KEY]>[];
+    };
+    protected _ready: Deferred<Exports>;
+    private _lifecycleCleanups;
+    /** @internal */
+    assignedProperty?: string | false;
+    connectedCalled: boolean;
+    protected _loadCalled: boolean;
+    loadedCalled: boolean;
+    readonly [controllerSymbol] = true;
+    component: BaseComponent & ControllerHost;
+    ready: Promise<Exports>;
+    constructor(component?: BaseComponent);
+    /**
+     * If controller is being added dynamically, after the component
+     * construction, then trigger connected and load right away
+     */
+    catchUpLifecycle(): void;
+    private _exports;
+    get exports(): Exports;
+    /**
+     * Set controller's exports property (for usage with proxyExports()) and mark
+     * controller as ready (for usage in other controllers). Also, triggers
+     * re-render of the component
+     */
+    set exports(exports: Exports);
+    /**
+     * If controller needs to await a promise before it's exports are fully ready
+     * but it wishes to make some limited exports available before then,
+     * this method can be used.
+     *
+     * This is useful for permitting a limited usage of the controller in default
+     * values of properties or in component constructor.
+     *
+     * In order to help detect bugs, trying to access a prop on the exports value
+     * that does not exist will throw an error (in development only). This is
+     * useful to detect usages of controller that forgot to await it's exports.
+     * (the "value in this.myController" check won't cause an exception though)
+     *
+     * @param proxy [true] - whether to throw an error if unknown property is
+     *   accessed before the controller is loaded.
+     */
+    setProvisionalExports(exports: Exports, proxy?: boolean): void;
+    setProvisionalExports(exports: Exports extends object ? Partial<Exports> : Exports, proxy?: boolean): void;
+    setProvisionalExports<Props extends keyof Exports>(exports: Pick<Exports, Props>, proxy?: boolean): void;
+    private _exportWatchers;
+    watchExports(callback: (exports: Exports) => void): () => void;
+    /**
+     * A flexible utility for making sure a controller is loaded before it's used,
+     * regardless of how or where a controller was defined:
+     *
+     * @example
+     * makeGenericController(async (component, controller) => {
+     *   // Await some controller from the component:
+     *   await controller.use(component.someController);
+     *   // Initialize new controllers
+     *   await controller.use(load(importCoreReactiveUtils));
+     *   await controller.use(new ViewModelController(component,newWidgetsHomeHomeViewModel));
+     *   await controller.use(someController(component));
+     * });
+     *
+     * @remarks
+     * If your controller is not async, and you are not creating it async, then
+     * you are not required to use controller.use - you can use it directly.
+     * Similarly, accessing controllers after componentWillLoad callback does not
+     * require awaiting them as they are guaranteed to be loaded by then.
+     */
+    get use(): typeof use;
+    /**
+     * Just like controller.use, but returns the controller itself, rather than it's
+     * exports
+     *
+     * Use cases:
+     * - You have a controller and you want to make sure it's loaded before you
+     *   try to use it
+     * - Your controller is not using exports, so you wish to access some props on
+     *   it directly
+     * - You have a controller exports only, and you want to retrieve the
+     *   controller itself. This is useful if you wish to call .watchExports() or
+     *   some other method on the controller
+     */
+    get useRef(): typeof useRef;
+    /**
+     * Like useRef, but doesn't wait for the controller to get ready
+     *
+     * @internal
+     */
+    get useRefSync(): typeof useRefSync;
+    controllerRemoved(): void;
+    onConnected(callback: NonNullable<ControllerLifecycleMethods["hostConnected"]>): void;
+    onDisconnected(callback: NonNullable<ControllerLifecycleMethods["hostDisconnected"]>): void;
+    onLoad(callback: NonNullable<ControllerLifecycleMethods["hostLoad"]>): void;
+    onLoaded(callback: NonNullable<ControllerLifecycleMethods["hostLoaded"]>): void;
+    onUpdate(callback: NonNullable<ControllerLifecycleMethods["hostUpdate"]>): void;
+    onUpdated(callback: NonNullable<ControllerLifecycleMethods["hostUpdated"]>): void;
+    onDestroy(callback: NonNullable<ControllerLifecycleMethods["hostDestroy"]>): void;
+    onLifecycle(callback: NonNullable<ControllerLifecycleMethods["hostLifecycle"]>): void;
+    /** @internal */
+    triggerConnected(): void;
+    /** @internal */
+    triggerDisconnected(): void;
+    /** @internal */
+    triggerLoad(): Promise<void>;
+    /** @internal */
+    triggerLoaded(): void;
+    /** @internal */
+    triggerUpdate(changes: PropertyValues): void;
+    /** @internal */
+    triggerUpdated(changes: PropertyValues): void;
+    /** @internal */
+    triggerDestroy(): void;
+    /** @internal */
+    triggerLifecycle(): void;
+    private _callLifecycle;
+}
+export declare abstract class GenericControllerType<Exports, Requires = BaseComponent> extends Controller<Exports> {
+    component: BaseComponent & ControllerHost & Requires;
+    constructor(component: BaseComponent & Requires);
+}
+/**
+ * If your controller requires some specific properties to be present on the
+ * component, besides what's included in the BaseComponent, use
+ * GenericController over the usual Controller. Use the 2nd generic argument
+ * on this class for specifying what properties your controller expects on the
+ * component
+ *
+ * When using a controller created using GenericController, consumer must
+ * pass in "this" explicitly to the constructor. If controller was
+ * created using Controller, that is not necessary
+ *
+ * @remarks
+ * GenericController class is identical to Controller class in all but typing.
+ * That is why, at runtime GenericController is actually equal to Controller
+ * class.
+ * You can use GenericControllerType type if you wish to reference generic
+ * controller instance type.
+ */
+export declare const GenericController: typeof GenericControllerType;

package/dist/controllers/ControllerInternals.d.ts

@@ -0,0 +1,52 @@
+import { Controller } from './Controller';
+import { BaseComponent, BaseController, ControllerHost } from './types';
+export declare function setAmbientComponent(component: BaseComponent & ControllerHost): void;
+export declare function retrieveComponent(name?: string): BaseComponent & ControllerHost;
+export declare function setParentController(controller: BaseController | undefined): void;
+/**
+ * Get references to controllers this nested controller might have been called
+ * from. The list may include extra controllers, but at least one of them or
+ * the component itself is the parent for this controller.
+ */
+export declare function retrieveParentControllers(): readonly BaseController[];
+export declare function setAmbientChildController(controller: BaseController | undefined): void;
+/**
+ * The type definition has to be duplicated due to this TypeScript error:
+ * "'use' is referenced directly or indirectly in its own type annotation."
+ */
+export declare const use: <Value>(value: Value, watchExports?: (value: NotNever<InferController<Value>>, unsubscribe: () => void) => void) => Promise<NotNever<InferController<Value>>>;
+export declare const useRef: <Value>(value: Value) => Promise<InferController<Value>>;
+export declare const useRefSync: <Value>(value: Value) => InferController<Value> | undefined;
+export declare const shouldBypass: {
+    setter: boolean;
+    getter: boolean;
+    readOnly: boolean;
+};
+/**
+ * A map from component instance or component element to component instance.
+ * To get from component instance or component element to component element,
+ * you can just use the .el property
+ */
+export declare const elementToInstance: WeakMap<HTMLElement | BaseComponent, BaseComponent>;
+/**
+ * If passed value is a controller, then return it. Otherwise, assume it's a
+ * proxyExports() result and wrap it into a controller
+ *
+ * This won't type correctly if a proxyExports() controller is exporting a
+ * non-proxyExports() controller
+ */
+type InferController<ControllerOrExports> = ControllerOrExports extends BaseController ? ControllerOrExports & {
+    exports?: unknown;
+    ready?: Promise<void>;
+    watchExports?: Controller["watchExports"];
+} : Controller<ControllerOrExports>;
+/**
+ * If controller never sets it's exports, then it's default exports is "this".
+ * This allows usage of controller.use with controllers that don't have exports
+ */
+type NotNever<T extends {
+    exports?: any;
+}> = T extends {
+    exports: never;
+} ? T : T["exports"];
+export {};