@arcgis/lumina 5.1.0-next.9 → 5.1.0-next.91

package/dist/{Controller-DQnXLHsP.js → Controller-Cer_6Z29.js}

@@ -1,5 +1,5 @@
 import { safeCall, isEsriInternalEnv, safeAsyncCall } from "@arcgis/toolkit/error";
-import { r as retrieveComponent, d as retrieveParentControllers, b as setParentController, a as setAmbientComponent, u as use, k as useRef, l as useRefSync, c as controllerSymbol } from "./ControllerInternals-By6dhpY-.js";
+import { r as retrieveComponent, d as retrieveParentControllers, b as setParentController, a as setAmbientComponent, u as use, j as useRef, k as useRefSync, c as controllerSymbol } from "./ControllerInternals-CeDntN3G.js";
 import { nothing } from "lit";
 import { Deferred } from "@arcgis/toolkit/promise";
 import { rethrowError } from "@arcgis/toolkit/log";
@@ -211,19 +211,19 @@ class Controller {
    * controller as ready (for usage in other controllers). Also, triggers
    * re-render of the component
    */
-  set exports(exports) {
+  set exports(exports$1) {
     const oldExports = this.#exports;
-    if (oldExports !== exports) {
-      this.#exports = exports;
+    if (oldExports !== exports$1) {
+      this.#exports = exports$1;
       this.#exportWatchers.forEach(safeCall);
       if (this.connectedCalled && this.O !== false) {
         this.#component.requestUpdate(this.O, oldExports);
       }
     }
-    this.P.resolve(exports);
+    this.P.resolve(exports$1);
   }
-  setProvisionalExports(exports, proxy = true) {
-    this.#exports = proxy ? makeProvisionalValue(exports) : exports;
+  setProvisionalExports(exports$1, proxy = true) {
+    this.#exports = proxy ? makeProvisionalValue(exports$1) : exports$1;
     this.#exportWatchers.forEach(safeCall);
   }
   #exportWatchers;
@@ -454,9 +454,9 @@ export {
   Controller as C,
   GenericController as G,
   createEventFactory as a,
-  trackPropertyKey as b,
+  trackPropKey as b,
   createEvent as c,
-  trackPropKey as d,
+  trackPropertyKey as d,
   propertyTrackResolve as p,
   trackKey as t
 };

package/dist/{ControllerInternals-By6dhpY-.js → ControllerInternals-CeDntN3G.js}

@@ -1,5 +1,5 @@
 import { isEsriInternalEnv } from "@arcgis/toolkit/error";
-const controllerSymbol = Symbol.for("controller");
+const controllerSymbol = /* @__PURE__ */ Symbol.for("controller");
 const isController = (value) => typeof value === "object" && value !== null && (controllerSymbol in value || "hostConnected" in value || "hostDisconnected" in value || "hostUpdate" in value || "hostUpdated" in value);
 const isPromise = (arg) => typeof arg?.then === "function";
 const getControllersCount = (component) => component.M.length;
@@ -74,7 +74,7 @@ const use = async (value, watchExports) => {
       throw new Error(`The controller must implement watchExports method to support watching exports`);
     }
     const unsubscribe = controller.watchExports(
-      (exports) => watchExports(exports, unsubscribe)
+      (exports$1) => watchExports(exports$1, unsubscribe)
     );
   }
   return controller.exports;
@@ -113,20 +113,18 @@ const bypassReadOnly = (callback) => {
     shouldBypassReadOnly = false;
   }
 };
-const bypassSetter = bypassReadOnly;
 export {
   setAmbientComponent as a,
   setParentController as b,
   controllerSymbol as c,
   retrieveParentControllers as d,
-  bypassSetter as e,
-  bypassReadOnly as f,
-  isController as g,
-  getControllersCount as h,
+  bypassReadOnly as e,
+  isController as f,
+  getControllersCount as g,
+  setAmbientChildController as h,
   isPromise as i,
-  setAmbientChildController as j,
-  useRef as k,
-  useRefSync as l,
+  useRef as j,
+  useRefSync as k,
   retrieveComponent as r,
   shouldBypassReadOnly as s,
   use as u

package/dist/{ControllerManager-eFkqujn9.js → ControllerManager-DpJfvft9.js}

@@ -1,8 +1,8 @@
 import { safeCall, isEsriInternalEnv } from "@arcgis/toolkit/error";
-import { G as GenericController, p as propertyTrackResolve } from "./Controller-DQnXLHsP.js";
+import { G as GenericController, p as propertyTrackResolve } from "./Controller-Cer_6Z29.js";
 import { nothing, LitElement as LitElement$1 } from "lit";
 import { devToolsAwareTimeout } from "@arcgis/toolkit/promise";
-import { a as setAmbientComponent } from "./ControllerInternals-By6dhpY-.js";
+import { a as setAmbientComponent } from "./ControllerInternals-CeDntN3G.js";
 class ControllerManager extends GenericController {
   constructor(component) {
     super(component);
@@ -83,12 +83,12 @@ class ControllerManager extends GenericController {
   // would need to make it async in the future
   // eslint-disable-next-line @typescript-eslint/require-await
   async destroy() {
-    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
-      this.devOnly$ensureHasDestroy?.();
-    }
     if (this.destroyed) {
       return;
     }
+    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+      this.devOnly$ensureHasDestroy?.();
+    }
     if (this.#component.el.isConnected) {
       this.hasDestroy = false;
       this.#component.el.remove();
@@ -132,15 +132,15 @@ class ControllerManager extends GenericController {
    *
    * @private
    */
-  W(controller, exports) {
-    if (typeof exports === "object" && exports !== null || typeof exports === "function") {
-      this.#exportsStore.set(exports, controller);
+  W(controller, exports$1) {
+    if (typeof exports$1 === "object" && exports$1 !== null || typeof exports$1 === "function") {
+      this.#exportsStore.set(exports$1, controller);
     }
   }
   /** @private */
-  X(exports) {
-    if (typeof exports === "object" && exports !== null || typeof exports === "function") {
-      return this.#exportsStore.get(exports);
+  X(exports$1) {
+    if (typeof exports$1 === "object" && exports$1 !== null || typeof exports$1 === "function") {
+      return this.#exportsStore.get(exports$1);
     } else {
       return void 0;
     }

package/dist/LitElement.d.ts

@@ -5,6 +5,7 @@ import { ToElement } from './jsx/types.ts';
 import { BaseController, LuminaPropertyDeclaration } from './controllers/types.ts';
 import { ControllerManager } from './controllers/ControllerManager.ts';
 import { Controller } from './controllers/Controller.ts';
+import { FormAssociatedEvents } from './formAssociatedUtils.ts';
 type ComponentLifecycle = {
     connectedCallback?: () => void;
     disconnectedCallback?: () => void;
@@ -117,6 +118,19 @@ export declare class LitElement extends OriginalLitElement implements ComponentL
      * @private
      */
     __offspringComponents: ProxyComponent["__offspringComponents"];
+    /**
+     * For HMR, if the .elementInternals was created, preserve that element
+     * internals instance across hot reloads. This method lets HMR get a reference
+     * to element internals in a side-effect free way and without adding production
+     * bytes.
+     *
+     * @private
+     */
+    devOnly$PureGetElementInternals?: () => ElementInternals | undefined;
+    /**
+     * @see [MDN ElementInternals](https://developer.mozilla.org/en-US/docs/Web/API/ElementInternals)
+     */
+    get elementInternals(): ElementInternals;
     constructor();
     connectedCallback(): void;
     disconnectedCallback(): void;
@@ -157,6 +171,7 @@ export declare class LitElement extends OriginalLitElement implements ComponentL
      * ```
      */
     listen<K extends keyof HTMLElementEventMap>(name: K, listener: (this: this, event: HTMLElementEventMap[K]) => unknown, options?: AddEventListenerOptions | boolean): void;
+    listen<K extends keyof FormAssociatedEvents>(name: K, listener: (this: this, event: FormAssociatedEvents[K]) => unknown, options?: Omit<AddEventListenerOptions, "capture" | "passive"> | boolean): void;
     listen(name: string, listener: (this: this, event: Event) => unknown, options?: AddEventListenerOptions | boolean): void;
     listen<EventType extends Event = CustomEvent<"Provide type like this.listenOn<ToEvents<ArcgisCounter>['arcgisClick']>() to get type-checked payload type">>(name: string, 
     /**

package/dist/config.d.ts

@@ -19,3 +19,4 @@ export declare const propertyFlagNumber: number;
 export declare const propertyFlagState: number;
 export declare const propertyFlagReadOnly: number;
 export declare const propertyFlagNoAccessor: number;
+export declare const propertyFlagUseDefault: number;

package/dist/config.js

@@ -8,6 +8,7 @@ const propertyFlagNumber = 1 << 3;
 const propertyFlagState = 1 << 4;
 const propertyFlagReadOnly = 1 << 5;
 const propertyFlagNoAccessor = 1 << 6;
+const propertyFlagUseDefault = 1 << 7;
 export {
   lazyMetaGroupJoiner,
   lazyMetaItemJoiner,
@@ -18,5 +19,6 @@ export {
   propertyFlagNumber,
   propertyFlagReadOnly,
   propertyFlagReflect,
-  propertyFlagState
+  propertyFlagState,
+  propertyFlagUseDefault
 };

package/dist/context.js

@@ -1,5 +1,5 @@
-import { ContextProvider, ContextConsumer } from "@lit/context";
-import { r as retrieveComponent } from "./ControllerInternals-By6dhpY-.js";
+import { ContextConsumer, ContextProvider } from "@lit/context";
+import { r as retrieveComponent } from "./ControllerInternals-CeDntN3G.js";
 const useContextProvider = (options) => {
   const component = retrieveComponent();
   const controller = new ContextProvider(component.el, options);

package/dist/controllers/ControllerInternals.d.ts

@@ -25,10 +25,6 @@ export declare let shouldBypassReadOnly: boolean;
  * @see https://webgis.esri.com/references/lumina/properties#read-only-properties
  */
 export declare const bypassReadOnly: <T = void>(callback: () => T) => T | void;
-/**
- * @deprecated see https://webgis.esri.com/references/lumina/properties#get-set-properties
- */
-export declare const bypassSetter: <T = void>(callback: () => T) => T | void;
 /**
  * If passed value is a controller, then return it. Otherwise, assume it's a
  * proxyExports() result and wrap it into a controller

package/dist/controllers/accessor/index.js

@@ -1,8 +1,8 @@
 import { isEsriInternalEnv } from "@arcgis/toolkit/error";
-import { r as retrieveComponent } from "../../ControllerInternals-By6dhpY-.js";
+import { r as retrieveComponent } from "../../ControllerInternals-CeDntN3G.js";
 import { on, watch } from "@arcgis/core/core/reactiveUtils.js";
-import { a as createEventFactory, G as GenericController, d as trackPropKey, t as trackKey } from "../../Controller-DQnXLHsP.js";
-import { p as proxyExports } from "../../proxyExports-CXEnG2Az.js";
+import { a as createEventFactory, G as GenericController, b as trackPropKey, t as trackKey } from "../../Controller-Cer_6Z29.js";
+import { p as proxyExports } from "../../proxyExports-BkN6hND0.js";
 import { createObservable, trackAccess } from "@arcgis/core/applications/Components/reactiveUtils.js";
 import { property, subclass } from "@arcgis/core/core/accessorSupport/decorators.js";
 import Accessor from "@arcgis/core/core/Accessor.js";

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

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

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

@@ -2,7 +2,7 @@ import { default as Accessor } from '@arcgis/core/core/Accessor.js';
 /**
  * See https://webgis.esri.com/references/lumina/controllers/useAccessor#createstore-utility
  */
-export declare const createStore: <T extends object>(initializer: T | (() => T)) => __esri.Accessor & T;
+export declare const createStore: <T extends object>(initializer: T | (() => T)) => Accessor & T;
 /** @deprecated Use {@link createStore} instead */
 export declare const createLegacyStore: <T extends object>(defaultState: T | (() => T)) => ObservableMap<T>;
 /** @deprecated Use {@link createStore} instead */

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

@@ -1,6 +1,7 @@
 import { GenericController } from '../Controller.ts';
 import { LitElement } from '../../LitElement.ts';
-type Requires<Props, Accessor extends __esri.Accessor, OmitProps extends string = never> = LitElement & Omit<Pick<Accessor, keyof Accessor & keyof Props>, AlwaysOmit | OmitProps> & {
+import { default as coreAccessor } from '@arcgis/core/core/Accessor.js';
+type Requires<Props, Accessor extends coreAccessor, OmitProps extends string = never> = LitElement & Omit<Pick<Accessor, keyof Accessor & keyof Props>, AlwaysOmit | OmitProps> & {
     autoDestroyDisabled: boolean;
     destroy: () => Promise<void>;
 };
@@ -12,7 +13,7 @@ type AlwaysOmit = "addHandles" | "declaredClass" | "destroyed" | "hasHandles" |
  * See https://webgis.esri.com/references/lumina/controllers/useAccessor for
  * documentation & examples.
  */
-export declare const makeAccessorController: <Props, Accessor extends __esri.Accessor, OmitProps extends string = never>(createInstance: ((props?: Props) => Accessor) | (new (props?: Props) => Accessor), _options?: {
+export declare const makeAccessorController: <Props, Accessor extends coreAccessor, OmitProps extends string = never>(createInstance: ((props?: Props) => 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
@@ -38,7 +39,7 @@ export declare const makeAccessorController: <Props, Accessor extends __esri.Acc
      */
     omitProps: OmitProps[];
 }) => (component: Requires<Props, Accessor, OmitProps>) => Accessor;
-export declare class AccessorController<Props, Accessor extends __esri.Accessor, ExtraRequires = Record<never, never>> extends GenericController<Accessor, ExtraRequires & Requires<Props, Accessor>> {
+export declare class AccessorController<Props, Accessor extends coreAccessor, ExtraRequires = Record<never, never>> extends GenericController<Accessor, ExtraRequires & Requires<Props, Accessor>> {
     #private;
     protected instance: Accessor;
     /**
@@ -63,14 +64,14 @@ export declare class AccessorController<Props, Accessor extends __esri.Accessor,
     hostConnected(): void;
     hostDestroy(): void;
 }
-type MinimalAccessorController = Pick<AccessorController<never, __esri.Accessor>, "_currentlyBindingPropertyName" | "exports"> & {
+type MinimalAccessorController = Pick<AccessorController<never, coreAccessor>, "_currentlyBindingPropertyName" | "exports"> & {
     component: LitElement;
 };
 export declare const makeBinderProxy: (component: LitElement, accessorControllerRef: WeakRef<MinimalAccessorController & {
     constructor: MinimalAccessorController["constructor"] & {
         devOnly$allowedPropNameMismatches?: ReadonlySet<string>;
     };
-}>, accessorControllerIndex: number, instance: __esri.Accessor, boundProperties: Map<string, string>) => unknown;
-export declare const getAccessorControllerBoundProperties: <Accessor extends __esri.Accessor>(controller: AccessorController<unknown, Accessor>) => Map<string & keyof Accessor, string>;
-export declare const reCreateAccessor: (instance: __esri.Accessor, component: LitElement) => void;
+}>, accessorControllerIndex: number, instance: coreAccessor, boundProperties: Map<string, string>) => unknown;
+export declare const getAccessorControllerBoundProperties: <Accessor extends coreAccessor>(controller: AccessorController<unknown, Accessor>) => Map<string & keyof Accessor, string>;
+export declare const reCreateAccessor: (instance: coreAccessor, component: LitElement) => void;
 export {};

package/dist/controllers/index.d.ts

@@ -3,7 +3,7 @@ import { setAutoDestroyOnDisconnectTimeout } from './ControllerManager.ts';
 export type { GenericControllerType } from './Controller.ts';
 export { Controller, GenericController } from './Controller.ts';
 export type { ControllerManager } from './ControllerManager.ts';
-export { retrieveComponent, bypassSetter, bypassReadOnly } from './ControllerInternals.ts';
+export { retrieveComponent, bypassReadOnly } from './ControllerInternals.ts';
 export { trackPropertyKey, propertyTrackResolve } from './trackPropertyKey.ts';
 export { trackPropKey } from './trackPropKey.ts';
 export { trackKey } from './trackKey.ts';
@@ -12,6 +12,7 @@ export { useWatchAttributes } from './useWatchAttributes.ts';
 export { load } from './load.ts';
 export { proxyExports } from './proxyExports.ts';
 export { toFunction } from './toFunction.ts';
+export { useSlottableRequest } from './useSlottableRequest.ts';
 export * from './types.ts';
 export { useMedia } from './useMedia.ts';
 export { useDirection } from './useDirection.ts';

package/dist/controllers/index.js

@@ -1,13 +1,13 @@
-import { C as Controller, t as trackKey, a as createEventFactory, p as propertyTrackResolve } from "../Controller-DQnXLHsP.js";
-import { G, d, b } from "../Controller-DQnXLHsP.js";
-import { a as setAmbientComponent, i as isPromise, b as setParentController, d as retrieveParentControllers, r as retrieveComponent } from "../ControllerInternals-By6dhpY-.js";
-import { f, e, c, h, g } from "../ControllerInternals-By6dhpY-.js";
-import { p as proxyExports } from "../proxyExports-CXEnG2Az.js";
+import { C as Controller, c as createEvent, t as trackKey, a as createEventFactory, p as propertyTrackResolve } from "../Controller-Cer_6Z29.js";
+import { G, b, d } from "../Controller-Cer_6Z29.js";
+import { a as setAmbientComponent, i as isPromise, b as setParentController, d as retrieveParentControllers, r as retrieveComponent } from "../ControllerInternals-CeDntN3G.js";
+import { e, c, g, f } from "../ControllerInternals-CeDntN3G.js";
+import { p as proxyExports } from "../proxyExports-BkN6hND0.js";
 import { isServer } from "lit";
 import { isEsriInternalEnv } from "@arcgis/toolkit/error";
 import { observeAncestorsMutation, getElementAttribute } from "@arcgis/toolkit/dom";
 import { getElementLocale, startLocaleObserver } from "@arcgis/toolkit/intl";
-import { s as setAutoDestroyOnDisconnectTimeout, b as autoDestroyOnDisconnectTimeout } from "../ControllerManager-eFkqujn9.js";
+import { s as setAutoDestroyOnDisconnectTimeout, b as autoDestroyOnDisconnectTimeout } from "../ControllerManager-DpJfvft9.js";
 const makeController = (constructor) => proxy(void 0, constructor);
 const makeGenericController = (constructor) => (component) => proxy(
   component,
@@ -101,6 +101,53 @@ const toFunction = (Class) => (...args) => {
   setParentController(ambientControllers.at(-1));
   return instance;
 };
+const useSlottableRequest = (component, watch, getDetailsBySlotName) => makeController((_component, controller) => {
+  const watchedProps = watch;
+  const slottableRequestController = createEvent({ bubbles: false, composed: false });
+  controller.onUpdated((changes) => {
+    if (!watchedProps.some((prop) => changes.has(prop))) {
+      return;
+    }
+    const previousDetails = getDetailsBySlotName(getWatchedProps(component, watchedProps, changes));
+    const currentDetails = getDetailsBySlotName(getWatchedProps(component, watchedProps));
+    previousDetails.forEach((previousDetail, slotName) => {
+      if (!currentDetails.has(slotName)) {
+        slottableRequestController.emit({ ...previousDetail, data: void 0 });
+      }
+    });
+    currentDetails.forEach((currentDetail, slotName) => {
+      const previousDetail = previousDetails.get(slotName);
+      if (!previousDetail || !isEqualValue(previousDetail, currentDetail)) {
+        slottableRequestController.emit(currentDetail);
+      }
+    });
+  });
+  return slottableRequestController;
+});
+function getWatchedProps(component, watchedProps, changes) {
+  const values = {};
+  watchedProps.forEach((prop) => {
+    values[prop] = changes?.has(prop) ? changes.get(prop) : component[prop];
+  });
+  return values;
+}
+function isEqualValue(previous, current) {
+  if (previous === current) {
+    return true;
+  }
+  if (!previous || !current || typeof previous !== "object" || typeof current !== "object") {
+    return false;
+  }
+  if (Array.isArray(previous) || Array.isArray(current)) {
+    return false;
+  }
+  const previousEntries = Object.entries(previous);
+  const currentEntries = Object.entries(current);
+  if (previousEntries.length !== currentEntries.length) {
+    return false;
+  }
+  return previousEntries.every(([key, value]) => isEqualValue(value, current[key]));
+}
 const useMedia = (query) => makeController((_component, controller) => {
   const media = globalThis.matchMedia(query);
   const changed = () => {
@@ -258,12 +305,11 @@ const exportsForTests = {
 export {
   Controller,
   G as GenericController,
-  f as bypassReadOnly,
-  e as bypassSetter,
+  e as bypassReadOnly,
   c as controllerSymbol,
   exportsForTests,
-  h as getControllersCount,
-  g as isController,
+  g as getControllersCount,
+  f as isController,
   keyTrackResolve,
   load,
   makeController,
@@ -274,10 +320,11 @@ export {
   retrieveComponent,
   toFunction,
   trackKey,
-  d as trackPropKey,
-  b as trackPropertyKey,
+  b as trackPropKey,
+  d as trackPropertyKey,
   useDirection,
   useMedia,
   usePropertyChange,
+  useSlottableRequest,
   useWatchAttributes
 };

package/dist/controllers/useSlottableRequest.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter } from '../createEvent.ts';
+import { LitElement } from '../LitElement.ts';
+type SlottableRequestDetail = {
+    name: string;
+    slotName: string;
+    data: unknown;
+};
+type WatchedProps<Component extends LitElement, ToWatch extends readonly (keyof Component)[]> = Pick<Component, ToWatch[number]>;
+/**
+ * Watches host properties and emits slottable request details when the
+ * requested slot details are added, removed, or changed.
+ *
+ * @example
+ * ```ts
+ * const slottableRequest = useSlottableRequest(this, ["item"], ({ item }) => {
+ *  const details = new Map<string, Detail>();
+ *  details.set("item-slot", { name: "item", slotName: "item-slot", data: item });
+ *  return details;
+ * });
+ */
+export declare const useSlottableRequest: <Component extends LitElement, const ToWatch extends readonly (keyof Component)[], Detail extends SlottableRequestDetail>(component: Component, watch: ToWatch, getDetailsBySlotName: (component: WatchedProps<Component, ToWatch>) => ReadonlyMap<string, Detail>) => EventEmitter<Detail>;
+export {};

package/dist/formAssociatedUtils.d.ts

@@ -0,0 +1,48 @@
+import { ProxyComponent } from './lazyLoad.ts';
+import { LitElement } from './LitElement.ts';
+/**
+ * Web platform allows custom elements to define these methods to handle the
+ * corresponding form events. For performance reasons, the engines require that
+ * these methods are present when the customElements.define() is called - it
+ * means that we need to include them in the lazy proxy as well.
+ *
+ * The lazy proxy today only creates the methods proxies the first time a proxy
+ * element of that tag name is created, which is too late.
+ *
+ * We could update the proxy to define the method proxies right away. Some cons
+ * with that:
+ * - In lazy builds, most components are never loaded, so I want to keep the
+ *   per-proxy overhead minimal.
+ * - To handle this form event, the component would need to define a
+ *   corresponding method with a \@method() decorator (to ensure it is present
+ *   on the proxy), and the method needs to be async (so that the lazy proxy
+ *   knows to await component loading before calling the method)
+ *   - If you forget to add \@method(), lazy proxy won't proxy this method. If
+ *     you forget to make it async, lazy proxy will error if the component is
+ *     not loaded yet. These are not obvious constraints from lazy-loading, and
+ *     do not match the examples online/copilot. We may need lint rules about
+ *     this.
+ * - Such API is not composable - if the method needs to be present on the
+ *   component, it is hard for a controller to handle it, creating wiring
+ *   boilerplate.
+ *
+ * To address these concerns, the proxy does the following:
+ * - Always define these methods on the prototype (harmless for
+ *   non-form-associated components). The methods are created once, so no
+ *   per-proxy overhead.
+ * - The proxy waits for component to be loaded. This avoids a race condition of
+ *   event being emitted before the constructor is lazy-loaded, and keeps timing
+ *   consistent with non-lazy builds.
+ * - The proxy will emit a corresponding event on itself. The component or any
+ *   controller can choose to listen to these events. The event does not bubble
+ *   and does not compose, so will have minimum visibility outside the component.
+ * - To keep the non-lazy behavior aligned, we also emit such events on itself
+ *   in non-lazy builds.
+ */
+export interface FormAssociatedEvents {
+    luminaFormAssociatedCallback: CustomEvent<readonly [form: HTMLFormElement | null]>;
+    luminaFormDisabledCallback: CustomEvent<readonly [disabled: boolean]>;
+    luminaFormResetCallback: CustomEvent<readonly []>;
+    luminaFormStateRestoreCallback: CustomEvent<readonly [state: unknown, mode: "autocomplete" | "restore"]>;
+}
+export declare function proxyFormMethodsToEvents(constructor: typeof LitElement | typeof ProxyComponent): void;

package/dist/hmrSupport.d.ts

@@ -21,6 +21,7 @@ export type HmrComponentMeta = {
     readonly properties: (readonly [property: string, attribute: string] | readonly [property: string])[];
     readonly asyncMethods: readonly string[];
     readonly syncMethods: readonly string[];
+    readonly formAssociated: boolean;
 };
 /**
  * Update lazy component meta

package/dist/hmrSupport.js

@@ -1,4 +1,4 @@
-import { n as noShadowRoot, P as ProxyComponent } from "./lazyLoad-DJM-hmfq.js";
+import { P as ProxyComponent, n as noShadowRoot } from "./lazyLoad-B5Rj3U_I.js";
 import { camelToKebab } from "@arcgis/toolkit/string";
 function handleHmrUpdate(newModules) {
   newModules.forEach((newModule) => {
@@ -56,6 +56,8 @@ function reInitialize(instance, newModule) {
     ([propertyName, descriptor]) => typeof propertyName === "string" && (instance.devOnly$hmrSetProps.has(propertyName) || typeof descriptor.attribute === "string" && instance.devOnly$hmrSetAttributes.has(descriptor.attribute))
   ).map(([key]) => [key, instance[key]]);
   instance.devOnly$hmrResetStore(Object.fromEntries(preservedProperties));
+  const elementInternals = instance.$component.devOnly$PureGetElementInternals();
+  instance.devOnly$elementInternals = elementInternals;
   if (instance.isConnected) {
     instance.$component.disconnectedCallback();
   }
@@ -91,7 +93,7 @@ function handleComponentMetaUpdate(meta) {
   ProxyClass.observedAttributes = attributes;
 }
 function initializeAttributeObserver() {
-  const observedAttributesSymbol = Symbol.for("@arcgis/lumina:observedAttributes");
+  const observedAttributesSymbol = /* @__PURE__ */ Symbol.for("@arcgis/lumina:observedAttributes");
   const globalThisWithObservedAttributes = globalThis;
   const alreadyHadObservers = observedAttributesSymbol in globalThisWithObservedAttributes;
   globalThisWithObservedAttributes[observedAttributesSymbol] ??= {};