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

package/dist/LitElement.d.ts

@@ -1,9 +1,8 @@
-import type { CSSResultGroup, CSSResultOrNative, PropertyValues } from "lit";
-import { LitElement as OriginalLitElement } from "lit";
-import type { LuminaPropertyDeclaration } from "@arcgis/components-controllers";
-import type { Runtime } from "./runtime";
-import type { ProxyComponent } from "./lazyLoad";
-import type { ToElement } from "./jsx/types";
+import { CSSResultGroup, CSSResultOrNative, PropertyValues, LitElement as OriginalLitElement } from 'lit';
+import { LuminaPropertyDeclaration } from '@arcgis/components-controllers';
+import { Runtime } from './runtime';
+import { ProxyComponent } from './lazyLoad';
+import { ToElement } from './jsx/types';
 type ComponentLifecycle = {
     connectedCallback?: () => void;
     disconnectedCallback?: () => void;
@@ -83,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('@arcgis/components-controllers').ControllerManager<never>;
     /**
      * Map with keys for any properties that have changed since the last
      * update cycle with previous values.

package/dist/config.js

@@ -1,9 +1,16 @@
-import {
-  PropertyFlags,
-  lazyMetaGroupJoiner,
-  lazyMetaItemJoiner,
-  lazyMetaSubItemJoiner
-} from "./chunk-PGHUBTOM.js";
+const lazyMetaGroupJoiner = ";";
+const lazyMetaItemJoiner = ",";
+const lazyMetaSubItemJoiner = ":";
+var PropertyFlags = /* @__PURE__ */ ((PropertyFlags2) => {
+  PropertyFlags2[PropertyFlags2["ATTRIBUTE"] = 1] = "ATTRIBUTE";
+  PropertyFlags2[PropertyFlags2["REFLECT"] = 2] = "REFLECT";
+  PropertyFlags2[PropertyFlags2["BOOLEAN"] = 4] = "BOOLEAN";
+  PropertyFlags2[PropertyFlags2["NUMBER"] = 8] = "NUMBER";
+  PropertyFlags2[PropertyFlags2["STATE"] = 16] = "STATE";
+  PropertyFlags2[PropertyFlags2["READ_ONLY"] = 32] = "READ_ONLY";
+  PropertyFlags2[PropertyFlags2["NO_ACCESSOR"] = 64] = "NO_ACCESSOR";
+  return PropertyFlags2;
+})(PropertyFlags || {});
 export {
   PropertyFlags,
   lazyMetaGroupJoiner,

package/dist/context.d.ts

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

package/dist/createEvent.d.ts

@@ -1,4 +1,4 @@
-import type { BaseComponent, EventEmitter } from "@arcgis/components-controllers";
+import { BaseComponent, EventEmitter } from '@arcgis/components-controllers';
 /**
  * While these defaults don't match DOM defaults (all false), they match
  * Stencil and Shoelace defaults. Also, they make more sense for our

package/dist/decorators.d.ts

@@ -1,5 +1,5 @@
-import type { LuminaPropertyDeclaration } from "@arcgis/components-controllers";
-export { state } from "@lit/reactive-element/decorators/state.js";
+import { LuminaPropertyDeclaration } from '@arcgis/components-controllers';
+export { state } from '@lit/reactive-element/decorators/state.js';
 /**
  * A class field or accessor decorator which creates a reactive property that
  * reflects a corresponding attribute value. When a decorated property is set

package/dist/devOnlyDetectIncorrectLazyUsages.d.ts

@@ -1,4 +1,4 @@
-import type { LitElement } from "./LitElement";
+import { LitElement } from './LitElement';
 /**
  * When in lazy-build, the actual Lit element is never attached to the DOM.
  * Instead, a proxy element is present and should be used for all DOM actions.

package/dist/hmrSupport.d.ts

@@ -1,4 +1,4 @@
-import type { ModuleNamespace } from "vite/types/hot.js";
+import { ModuleNamespace } from 'vite/types/hot.js';
 /**
  * Update web component proxies when a module is updated.
  *

package/dist/hmrSupport.js

@@ -1,10 +1,4 @@
-import {
-  ProxyComponent,
-  noShadowRoot
-} from "./chunk-NO7HOBNA.js";
-import "./chunk-PGHUBTOM.js";
-
-// src/hmrSupport.ts
+import { n as noShadowRoot, P as ProxyComponent } from "./utils-GhKD5Lo-.js";
 import { camelToKebab } from "@arcgis/components-utils";
 function handleHmrUpdate(newModules) {
   newModules.forEach((newModule) => {

package/dist/index.d.ts

@@ -1,16 +1,17 @@
-export { useContextProvider, useContextConsumer } from "./context";
-export type { EventOptions } from "./createEvent";
-export { createEvent } from "./createEvent";
-export { state, property, method } from "./decorators";
-export type { DefineCustomElements, LazyLoadOptions, GlobalThisWithPuppeteerEnv } from "./lazyLoad";
-export { makeDefineCustomElements } from "./lazyLoad";
-export { LitElement } from "./LitElement";
-export type { PublicLitElement } from "./PublicLitElement";
-export type { Runtime, RuntimeOptions, DevOnlyGlobalRuntime, DevOnlyGlobalComponentRefCallback } from "./runtime";
-export { makeRuntime } from "./runtime";
-export type { EventHandler } from "./jsx/baseTypes";
-export * from "./jsx/types";
-export { safeClassMap, safeStyleMap, directive, live } from "./jsx/directives";
-export { nothing, noChange, setAttribute, stringOrBoolean } from "./jsx/utils";
-export { noShadowRoot } from "./utils";
-export { makeReactWrapperFactory, getReactWrapperOptions } from "./wrappersUtils";
+export { useContextProvider, useContextConsumer } from './context';
+export type { EventOptions } from './createEvent';
+export { createEvent } from './createEvent';
+export { state, property, method } from './decorators';
+export type { DefineCustomElements, LazyLoadOptions, GlobalThisWithPuppeteerEnv } from './lazyLoad';
+export { makeDefineCustomElements } from './lazyLoad';
+export { LitElement } from './LitElement';
+export type { PublicLitElement } from './PublicLitElement';
+export type { Runtime, RuntimeOptions, DevOnlyGlobalRuntime, DevOnlyGlobalComponentRefCallback } from './runtime';
+export { makeRuntime } from './runtime';
+export type { EventHandler } from './jsx/baseTypes';
+export * from './jsx/types';
+export { safeClassMap, safeStyleMap, deferLoad, deferredLoaders, directive, live } from './jsx/directives';
+export { nothing, noChange, setAttribute, stringOrBoolean } from './jsx/utils';
+export { noShadowRoot } from './utils';
+export { makeReactWrapperFactory, getReactWrapperOptions } from './wrappersUtils';
+export { renderElement } from './render';

package/dist/index.js

@@ -1,13 +1,17 @@
-import {
-  attachToAncestor,
-  makeDefineCustomElements,
-  noShadowRoot
-} from "./chunk-NO7HOBNA.js";
-import "./chunk-PGHUBTOM.js";
-
-// src/context.ts
-import { retrieveComponent } from "@arcgis/components-controllers";
-import { ContextConsumer, ContextProvider } from "@lit/context";
+import { retrieveComponent, trackKey, keyTrackResolve, useControllerManager } from "@arcgis/components-controllers";
+import { ContextProvider, ContextConsumer } from "@lit/context";
+import { isEsriInternalEnv, Deferred, camelToKebab } from "@arcgis/components-utils";
+import { state } from "@lit/reactive-element/decorators/state.js";
+import { property as property$1 } from "@lit/reactive-element/decorators/property.js";
+import { n as noShadowRoot, a as attachToAncestor } from "./utils-GhKD5Lo-.js";
+import { m } from "./utils-GhKD5Lo-.js";
+import { LitElement as LitElement$1, isServer, noChange as noChange$1 } from "lit";
+import { PropertyFlags } from "./config.js";
+import { classMap } from "lit-html/directives/class-map.js";
+import { styleMap } from "lit/directives/style-map.js";
+import { directive as directive$1, Directive } from "lit-html/directive.js";
+import { live as live$1 } from "lit-html/directives/live.js";
+import { nothing as nothing$1, noChange as noChange$2, render } from "lit-html";
 function useContextProvider(options) {
   const component = retrieveComponent();
   const controller = new ContextProvider(component.el, options);
@@ -20,17 +24,11 @@ function useContextConsumer(options) {
   component.addController(controller);
   return controller;
 }
-
-// src/createEvent.ts
-import { retrieveComponent as retrieveComponent2, keyTrackResolve, trackKey } from "@arcgis/components-controllers";
-import { isEsriInternalEnv } from "@arcgis/components-utils";
-var createEventFactory = (eventName = "", options = {}, component = retrieveComponent2()) => {
+const createEventFactory = (eventName = "", options = {}, component = retrieveComponent()) => {
   const emitter = {
     emit: (payload) => {
       if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && !component.el.isConnected) {
-        console.warn(
-          `Trying to emit an ${eventName} event on a disconnected element ${component.el.tagName.toLowerCase()}`
-        );
+        console.warn(`Trying to emit an ${eventName} event on a disconnected element ${component.el.localName}`);
       }
       if (eventName === "") {
         keyTrackResolve();
@@ -63,76 +61,33 @@ var createEventFactory = (eventName = "", options = {}, component = retrieveComp
   }
   return emitter;
 };
-var createEvent = createEventFactory.bind(null, "");
-
-// src/decorators.ts
-import { state } from "@lit/reactive-element/decorators/state.js";
-import { property as litProperty } from "@lit/reactive-element/decorators/property.js";
-var property = litProperty;
-var method = void 0;
-
-// src/LitElement.ts
-import { Deferred, camelToKebab, isEsriInternalEnv as isEsriInternalEnv2 } from "@arcgis/components-utils";
-import { LitElement as OriginalLitElement, isServer } from "lit";
-import { useControllerManager } from "@arcgis/components-controllers";
-var emptyFunction = () => void 0;
-var LitElement = class _LitElement extends OriginalLitElement {
+const createEvent = createEventFactory.bind(null, "");
+const property = property$1;
+const method = void 0;
+const emptyFunction = () => void 0;
+class LitElement extends LitElement$1 {
   constructor() {
     super();
-    /**
-     * In lazy build, the actual DOM element differs from the class instance:
-     * - "this.el" is a proxy custom element - it's physically present in the DOM
-     *   even before the Lit component is loaded.
-     * - "this" is the actual Lit component - in case of Lazy builds, it's
-     *   never directly attached to the DOM. Instead, all interactions with the
-     *   proxy are forwarded to the actual Lit component. And, when Lit wants to
-     *   render, it renders into the shadow root of the proxy.
-     *
-     * "this.el" should be used instead of "this" for all things involving the
-     * DOM (addEventListener, querySelector, children, setAttribute,
-     * MutationObserver, etc...)
-     *
-     * @example
-     * ```ts
-     * // Generally, you shouldn't have to write logic specific to lazy or non-lazy
-     * // build, but if you have to, you can detect if you are in a lazy build like so:
-     * const isLazy = this.el !== this;
-     * ```
-     */
     this.el = this.constructor.lazy ?? this;
-    /**
-     * Controller Manager orchestrates all controllers used by this component,
-     * connecting their lifecycle hooks and providing context information.
-     */
     this.manager = useControllerManager(this);
-    /** @internal */
     this._postLoad = this.constructor.lazy?._postLoad ?? new Deferred();
-    /**
-     * Direct offspring that should be awaited before loaded() is emitted.
-     *
-     * `attachToAncestor()` will add elements to this array
-     *
-     * @internal
-     */
     this._offspring = this.constructor.lazy?._offspring ?? [];
     this._postLoaded = this.constructor.lazy?._postLoaded ?? new Deferred();
     this._enableUpdating = this.enableUpdating;
     this.enableUpdating = emptyFunction;
-    const ourShouldUpdate = _LitElement.prototype.shouldUpdate;
+    const ourShouldUpdate = LitElement.prototype.shouldUpdate;
     if (this.shouldUpdate !== ourShouldUpdate) {
       this._originalShouldUpdate = this.shouldUpdate;
       this.shouldUpdate = ourShouldUpdate;
     }
     if (process.env.NODE_ENV !== "production") {
-      const isOwnComponent = globalThis.devOnly$ownTagNames?.has(
-        this.el.tagName.toLowerCase()
-      );
+      const isOwnComponent = globalThis.devOnly$ownTagNames?.has(this.el.localName);
       const constructor = this.constructor;
-      const warningsWereCustomized = constructor.enabledWarnings !== OriginalLitElement.enabledWarnings;
+      const warningsWereCustomized = constructor.enabledWarnings !== LitElement$1.enabledWarnings;
       if (!isOwnComponent && !warningsWereCustomized) {
         constructor.disableWarning?.("change-in-update");
       }
-      if (isEsriInternalEnv2()) {
+      if (isEsriInternalEnv()) {
         globalThis.devOnly$luminaComponentRefCallback?.(this);
       }
     }
@@ -171,18 +126,18 @@ var LitElement = class _LitElement extends OriginalLitElement {
        *
        * Thus, overwriting Lit's default behavior to use kebab-case:
        */
-      attribute: !!(flags & 1 /* ATTRIBUTE */) && typeof name === "string" ? camelToKebab(name) : false,
-      reflect: !!(flags & 2 /* REFLECT */),
-      type: flags & 4 /* BOOLEAN */ ? Boolean : flags & 8 /* NUMBER */ ? Number : void 0,
+      attribute: !!(flags & PropertyFlags.ATTRIBUTE) && typeof name === "string" ? camelToKebab(name) : false,
+      reflect: !!(flags & PropertyFlags.REFLECT),
+      type: flags & PropertyFlags.BOOLEAN ? Boolean : flags & PropertyFlags.NUMBER ? Number : void 0,
       /**
        * At the moment in Lit, state:true just means attribute:false, so this
        * line is technically redundant, but let's keep it here just in case Lit
        * will add more meaning to state:true in the future.
        */
-      state: !!(flags & 16 /* STATE */),
+      state: !!(flags & PropertyFlags.STATE),
       // Controllers add this option to Lit
-      readOnly: !!(flags & 32 /* READ_ONLY */),
-      noAccessor: !!(flags & 64 /* NO_ACCESSOR */),
+      readOnly: !!(flags & PropertyFlags.READ_ONLY),
+      noAccessor: !!(flags & PropertyFlags.NO_ACCESSOR),
       ...rest
     });
   }
@@ -219,13 +174,9 @@ var LitElement = class _LitElement extends OriginalLitElement {
     const options = Class.shadowRootOptions;
     const useLightDom = options === noShadowRoot;
     const renderRoot = existingShadowRoot ?? (useLightDom ? this.el : this.el.attachShadow(options));
-    Object.defineProperty(this, "shadowRoot", {
-      // Create shadow root on the proxy instance, to make Lit render content there
-      value: renderRoot
-    });
     if (existingShadowRoot) {
       if (process.env.NODE_ENV === "production") {
-        OriginalLitElement.prototype.createRenderRoot.call(this);
+        LitElement$1.prototype.createRenderRoot.call(this);
       }
       return existingShadowRoot;
     }
@@ -297,18 +248,15 @@ var LitElement = class _LitElement extends OriginalLitElement {
     await this._postLoaded.promise;
     return this;
   }
-};
+}
 LitElement.$createEvent = createEventFactory;
-if (process.env.NODE_ENV !== "production" && isEsriInternalEnv2()) {
+if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
   const globalWithLit = globalThis;
   globalWithLit.litIssuedWarnings ??= /* @__PURE__ */ new Set();
   globalWithLit.litIssuedWarnings.add(
     "Overriding ReactiveElement.createProperty() is deprecated. The override will not be called with standard decorators See https://lit.dev/msg/no-override-create-property for more information."
   );
 }
-
-// src/runtime.ts
-import { isEsriInternalEnv as isEsriInternalEnv3 } from "@arcgis/components-utils";
 function makeRuntime(options) {
   let assetPath;
   const setAssetPath = (path) => {
@@ -351,33 +299,35 @@ function makeRuntime(options) {
     }
   };
   setAssetPath(options.defaultAssetPath);
-  if (process.env.NODE_ENV !== "production" && isEsriInternalEnv3()) {
+  if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
     globalThis.devOnly$luminaRuntime = runtime;
   }
   return runtime;
 }
-
-// src/jsx/types.ts
-var Fragment = void 0;
-var bindAttribute = void 0;
-var bindBooleanAttribute = void 0;
-var bindProperty = void 0;
-var bindEvent = void 0;
-
-// src/jsx/directives.ts
-import { classMap } from "lit-html/directives/class-map.js";
-import { styleMap } from "lit/directives/style-map.js";
-import { directive as litDirective } from "lit-html/directive.js";
-import { live as litLive } from "lit-html/directives/live.js";
-var safeClassMap = (parameters) => typeof parameters === "object" && parameters != null ? classMap(parameters) : parameters;
-var safeStyleMap = (parameters) => typeof parameters === "object" && parameters != null ? styleMap(parameters) : parameters;
-var directive = litDirective;
-var live = litLive;
-
-// src/jsx/utils.ts
-import { noChange as litNoChange, nothing as litNothing } from "lit-html";
-var nothing = litNothing;
-var noChange = litNoChange;
+const Fragment = void 0;
+const bindAttribute = void 0;
+const bindBooleanAttribute = void 0;
+const bindProperty = void 0;
+const bindEvent = void 0;
+const safeClassMap = (parameters) => typeof parameters === "object" && parameters != null ? classMap(parameters) : parameters;
+const safeStyleMap = (parameters) => typeof parameters === "object" && parameters != null ? styleMap(parameters) : parameters;
+class DeferLoad extends Directive {
+  update(part) {
+    const tagName = part.element.localName;
+    if (!customElements.get(tagName)) {
+      void deferredLoaders.get(tagName)?.();
+    }
+  }
+  render() {
+    return noChange$1;
+  }
+}
+const deferLoad = /* @__PURE__ */ directive$1(DeferLoad)();
+const deferredLoaders = /* @__PURE__ */ new Map();
+const directive = directive$1;
+const live = live$1;
+const nothing = nothing$1;
+const noChange = noChange$2;
 function setAttribute(element, attributeName, value) {
   if (value == null) {
     element.removeAttribute(attributeName);
@@ -385,13 +335,11 @@ function setAttribute(element, attributeName, value) {
     element.setAttribute(attributeName, value);
   }
 }
-var stringOrBoolean = {
+const stringOrBoolean = {
   toAttribute: (value) => value === true ? "" : value === false ? null : value
 };
-
-// src/wrappersUtils.ts
-var emptyObject = {};
-var makeReactWrapperFactory = (react, createComponent) => (options) => {
+const emptyObject = {};
+const makeReactWrapperFactory = (react, createComponent) => (options) => {
   const tagName = options.tagName;
   let customElementPrototype = emptyObject;
   const elementClass = {
@@ -429,7 +377,12 @@ var makeReactWrapperFactory = (react, createComponent) => (options) => {
   customElementPrototype = void 0;
   return result;
 };
-var getReactWrapperOptions = (tagNameAndElement, events) => ({ tagName: tagNameAndElement, events });
+const getReactWrapperOptions = (tagNameAndElement, events) => ({ tagName: tagNameAndElement, events });
+function renderElement(element) {
+  const container = document.createElement("div");
+  render(element, container);
+  return container.firstElementChild;
+}
 export {
   Fragment,
   LitElement,
@@ -438,10 +391,12 @@ export {
   bindEvent,
   bindProperty,
   createEvent,
+  deferLoad,
+  deferredLoaders,
   directive,
   getReactWrapperOptions,
   live,
-  makeDefineCustomElements,
+  m as makeDefineCustomElements,
   makeReactWrapperFactory,
   makeRuntime,
   method,
@@ -449,6 +404,7 @@ export {
   noShadowRoot,
   nothing,
   property,
+  renderElement,
   safeClassMap,
   safeStyleMap,
   setAttribute,

package/dist/jsx/baseTypes.d.ts

@@ -1,5 +1,5 @@
-import type { DirectiveResult } from "lit-html/directive.js";
-import type { Ref } from "lit-html/directives/ref.js";
+import { DirectiveResult } from 'lit-html/directive.js';
+import { Ref } from 'lit-html/directives/ref.js';
 export type EventHandlerUnion<T, E extends Event> = (e: E & {
     currentTarget: T;
     target: Element;
@@ -21,15 +21,19 @@ export type EventHandler<E> = {
 }["bivarianceHack"];
 export interface CustomAttributes<T = HTMLElement> {
     /**
-     * The `key` is a special attribute that can be set on any element.
-     *
-     * At build-time it is translated into the `keyed()` directive:
-     * https://lit.dev/docs/templates/directives/#keyed
-     *
-     * @remarks
-     * Unlike in React or Stencil, any JavaScript value is acceptable as a key
+     * [Documentation](https://qawebgis.esri.com/components/lumina/jsx#key-prop)
      */
     key?: unknown;
+    /**
+     * [Documentation](https://qawebgis.esri.com/components/lumina/jsx#refs)
+     */
     ref?: EventHandler<T | undefined> | Ref<T>;
+    /**
+     * [Documentation](https://qawebgis.esri.com/components/lumina/jsx#lit-directives)
+     */
     directives?: readonly DirectiveResult[];
+    /**
+     * [Documentation](https://qawebgis.esri.com/components/lumina/jsx#deferring-web-component-load)
+     */
+    deferLoad?: true;
 }

package/dist/jsx/directives.d.ts

@@ -1,10 +1,11 @@
-import type { Nil } from "@arcgis/components-utils";
-import type { Properties as CssProperties } from "csstype";
-import type { ClassInfo } from "lit-html/directives/class-map.js";
-import type { DirectiveResult } from "lit/directive.js";
-import type { ClassMapDirective } from "lit/directives/class-map.js";
-import type { StyleMapDirective } from "lit/directives/style-map.js";
-import type { DirectiveClass } from "lit-html/directive.js";
+import { Nil } from '@arcgis/components-utils';
+import { Properties as CssProperties } from 'csstype';
+import { ClassInfo } from 'lit-html/directives/class-map.js';
+import { DirectiveResult } from 'lit/directive.js';
+import { ClassMapDirective } from 'lit/directives/class-map.js';
+import { StyleMapDirective } from 'lit/directives/style-map.js';
+import { DirectiveClass, ElementPart, Directive } from 'lit-html/directive.js';
+import { noChange } from 'lit';
 /**
  * You likely won't have to import this directly. It will be added during
  * _JSX to lit-html_ conversion.
@@ -55,6 +56,22 @@ export declare const safeClassMap: (parameters: ClassInfo | Nil | string) => Dir
  * @private
  */
 export declare const safeStyleMap: (parameters: CssProperties | Nil | string) => DirectiveResult<typeof StyleMapDirective> | Nil | string;
+declare class DeferLoad extends Directive {
+    update(part: ElementPart): void;
+    render(): typeof noChange;
+}
+/**
+ * @private
+ * Do not use this directive directly. Use the `deferLoad` JSX prop instead.
+ * [Documentation](https://qawebgis.esri.com/components/lumina/jsx#deferring-web-component-load)
+ */
+export declare const deferLoad: DirectiveResult<typeof DeferLoad>;
+/**
+ * @private
+ * Do not use this directly. Use the `deferLoad` JSX prop instead.
+ * [Documentation](https://qawebgis.esri.com/components/lumina/jsx#deferring-web-component-load)
+ */
+export declare const deferredLoaders: Map<string, () => Promise<unknown>>;
 /**
  * Creates a user-facing directive function from a Directive class. This
  * function has the same parameters as the directive's render() method.
@@ -75,3 +92,4 @@ export declare const directive: <C extends DirectiveClass>(c: C) => (...values:
  * "never" to allow it be set as a value for any JSX attribute.
  */
 export declare const live: (value: unknown) => never;
+export {};

package/dist/jsx/generatedTypes.d.ts

@@ -1,13 +1,9 @@
-/**
- * Parts of this file are auto-generated or auto-updated by the `generate-jsx-types`
- * script.
- */
-import type { DirectiveResult } from "lit/directive.js";
-import type { ClassInfo, ClassMapDirective } from "lit/directives/class-map.js";
-import type { StyleMapDirective } from "lit/directives/style-map.js";
-import type { ChangeEventHandlerUnion, CustomAttributes, EventHandlerUnion, FocusEventHandlerUnion, InputEventHandlerUnion } from "./baseTypes";
-import type { JsxNode } from "./types";
-import type { Properties as CssProperties } from "csstype";
+import { DirectiveResult } from 'lit/directive.js';
+import { ClassInfo, ClassMapDirective } from 'lit/directives/class-map.js';
+import { StyleMapDirective } from 'lit/directives/style-map.js';
+import { ChangeEventHandlerUnion, CustomAttributes, EventHandlerUnion, FocusEventHandlerUnion, InputEventHandlerUnion } from './baseTypes';
+import { JsxNode } from './types';
+import { Properties as CssProperties } from 'csstype';
 /**
  * Some attributes accepts numbers as a number or as a string, while also
  * accepting "inherit". Define the type as `number | string | "inherit"` rather

package/dist/jsx/types.d.ts

@@ -1,15 +1,7 @@
-/**
- * This reference directive is removed by tsup at compile time. It is only
- * needed to correctly type-check this package. For consumers of this package,
- * they should have an `./src/lumina.ts` file like so:
- * ```ts
- * /// <reference types="@arcgis/lumina/typings" />
- * ```
- */
-import type { TemplateResult } from "lit-html";
-import type { DirectiveResult } from "lit-html/directive.js";
-import type { HTMLElementTags, HTMLAttributes, GlobalEventHandlersCamelCase, SvgElementTags, DOMAttributes, AriaAttributes } from "./generatedTypes";
-import type { CustomAttributes } from "./baseTypes";
+import { TemplateResult } from 'lit-html';
+import { DirectiveResult } from 'lit-html/directive.js';
+import { HTMLElementTags, HTMLAttributes, GlobalEventHandlersCamelCase, SvgElementTags, DOMAttributes, AriaAttributes } from './generatedTypes';
+import { CustomAttributes } from './baseTypes';
 /**
  * The "h" namespace is used to import JSX types for elements and attributes.
  * It is imported in order to avoid conflicting global JSX issues.
@@ -372,27 +364,8 @@ type FixupStencilEventCasing<PropertyName extends PropertyKey> = PropertyName ex
  * https://www.typescriptlang.org/docs/handbook/jsx.html
  */
 export declare namespace LuminaJsx {
-    /**
-     * Whether to pick TemplateResult or JsxNode here is a compromise.
-     *
-     * - If I tell it Lit JSX type is JsxNode, then even <a /> expression will
-     *   have a very broad JsxNode type (union of template results, null,
-     *   undefined, false, and more). This may slow down type-checking and may be
-     *   too-broad for certain use cases.
-     *   - Since <a /> would be typed very broad, you won't be able to declare
-     *     your function as receiving just TemplateResult
-     *   - Also, this makes TypeScript not allow you to return undefined from
-     *     your functional component
-     *   - This is what React did and what I am going with
-     * - If I tell TypeScript that JSX type is TemplateResult, then my function
-     *   component is no longer allowed to return undefined or string or etc.
-     *
-     * This is mainly a TypeScript limitation. Issues tracking this:
-     * - https://github.com/microsoft/TypeScript/issues/21699
-     * - https://github.com/DefinitelyTyped/DefinitelyTyped/issues/18912
-     *
-     */
     export type Element = TemplateResult;
+    export type ElementType = JsxNode;
     export interface ElementClass {
     }
     export interface ElementAttributesProperty {

package/dist/lazyLoad.d.ts

@@ -1,7 +1,7 @@
-import { Deferred } from "@arcgis/components-utils";
-import type { LitElement } from "./LitElement";
-import type { Runtime } from "./runtime";
-import type { ControllerManager } from "@arcgis/components-controllers";
+import { Deferred } from '@arcgis/components-utils';
+import { LitElement } from './LitElement';
+import { Runtime } from './runtime';
+import { ControllerManager } from '@arcgis/components-controllers';
 /**
  * Defines lazy-loading proxy components for all web components in this package.
  *

package/dist/lifecycleSupport.d.ts

@@ -1,4 +1,4 @@
-import type { ProxyComponent } from "./lazyLoad";
+import { ProxyComponent } from './lazyLoad';
 /**
  * If there is a parent component, tell it to await it's loaded() until we
  * completed load().

package/dist/render.d.ts

@@ -0,0 +1,5 @@
+import { JsxNode } from './jsx/types';
+/**
+ * Retrieve an HTML element to be manually appended to an existing component.
+ */
+export declare function renderElement<Element extends HTMLElement = HTMLElement>(element: JsxNode): Element;

package/dist/runtime.d.ts

@@ -1,5 +1,5 @@
-import type { CSSResult } from "lit";
-import type { LitElement } from "./LitElement";
+import { CSSResult } from 'lit';
+import { LitElement } from './LitElement';
 /**
  * `@arcgis/lumina` package may be bundled once but used by multiple packages with
  * different configuration options. For that reason, the configuration options

package/dist/stencilSsrCompatibility/index.d.ts

@@ -1,9 +1,5 @@
-/**
- * Lots of silencing of ESLint in this file to be compatible with Stencil's
- * unsafe typings.
- */
-import { type RenderInfo } from "@lit-labs/ssr/lib/render.js";
-import type { Readable } from "node:stream";
+import { RenderInfo } from '@lit-labs/ssr/lib/render.js';
+import { Readable } from 'node:stream';
 /**
  * @deprecated
  * Use `render` from `@lit-labs/ssr` instead.

package/dist/stencilSsrCompatibility/index.js

@@ -1,11 +1,10 @@
-// src/stencilSsrCompatibility/index.ts
 import { getWindow } from "@lit-labs/ssr/lib/dom-shim.js";
 import { render } from "@lit-labs/ssr/lib/render.js";
 import { html } from "@lit-labs/ssr/lib/server-template.js";
-import { unsafeStatic, withStatic } from "lit-html/static.js";
+import { withStatic, unsafeStatic } from "lit-html/static.js";
 import { collectResult } from "@lit-labs/ssr/lib/render-result.js";
 import { RenderResultReadable } from "@lit-labs/ssr/lib/render-result-readable.js";
-var staticHtml = withStatic(html);
+const staticHtml = withStatic(html);
 function createWindowFromHtml(templateHtml, uniqueId = Math.random().toString()) {
   const window = getWindow({ includeJSBuiltIns: true });
   window.document.defaultView = window;

package/dist/typings/importMeta.d.ts

@@ -7,7 +7,7 @@ interface ImportMetaEnv {
 }
 interface ImportMeta {
     url: string;
-    readonly hot?: import("vite/types/hot.d.ts").ViteHotContext;
+    readonly hot?: import('vite/types/hot.d.ts').ViteHotContext;
     readonly env: ImportMetaEnv;
-    glob: import("vite/types/importGlob.d.ts").ImportGlobFunction;
+    glob: import('vite/types/importGlob.d.ts').ImportGlobFunction;
 }

package/dist/{chunk-NO7HOBNA.js → utils-GhKD5Lo-.js}

@@ -1,17 +1,9 @@
-import {
-  lazyMetaGroupJoiner,
-  lazyMetaItemJoiner,
-  lazyMetaSubItemJoiner
-} from "./chunk-PGHUBTOM.js";
-
-// src/lazyLoad.ts
-import { Deferred, camelToKebab, isEsriInternalEnv } from "@arcgis/components-utils";
-
-// src/devOnlyDetectIncorrectLazyUsages.ts
+import { Deferred, isEsriInternalEnv, camelToKebab } from "@arcgis/components-utils";
+import { lazyMetaSubItemJoiner, lazyMetaGroupJoiner, lazyMetaItemJoiner } from "./config.js";
 function devOnlyDetectIncorrectLazyUsages(LitClass) {
   const genericPrototype = LitClass.prototype;
   const descriptor = Object.getOwnPropertyDescriptor(genericPrototype, "innerText");
-  if (descriptor !== void 0 && descriptor.get === descriptor.set) {
+  if (descriptor !== void 0 && descriptor.set?.name === "setWrapper") {
     return;
   }
   const allowList = /* @__PURE__ */ new Set([
@@ -41,23 +33,40 @@ function devOnlyDetectIncorrectLazyUsages(LitClass) {
     if (allowList.has(key)) {
       return;
     }
-    const callback = (...args) => {
+    function validateUsage(...args) {
+      const isDynamicallyCreatedComponentInTest = this === this.el;
+      if (isDynamicallyCreatedComponentInTest) {
+        return;
+      }
       if (key === "hasAttribute" && args[0] === "defer-hydration") {
         return false;
       }
       throw new Error(
         `You should not be trying to access this.${key} directly as it won't work correctly in lazy-builds. Instead, ${customErrorMessages[key] ?? `use this.el.${key}`}`
       );
-    };
+    }
     if (typeof value.value === "function") {
-      genericPrototype[key] = callback;
+      genericPrototype[key] = function functionWrapper(...args) {
+        return validateUsage.call(this, ...args) ?? value.value.call(this, ...args);
+      };
+    } else if (typeof value.get === "function") {
+      Object.defineProperty(genericPrototype, key, {
+        get() {
+          validateUsage.call(this);
+          return value.get.call(this);
+        },
+        set: typeof value.set === "function" ? function setWrapper(setValue) {
+          validateUsage.call(this);
+          value.set.call(this, setValue);
+        } : void 0
+      });
+    } else if (key === key.toUpperCase() && typeof value.value === "number") {
+      return;
     } else {
-      Object.defineProperty(genericPrototype, key, { get: callback, set: callback });
+      throw new Error(`Unexpected value type for ${key}: ${value}`);
     }
   });
 }
-
-// src/lifecycleSupport.ts
 function attachToAncestor(child) {
   let ancestor = child;
   while (ancestor = ancestor.parentNode ?? ancestor.host) {
@@ -71,9 +80,7 @@ function attachToAncestor(child) {
   }
   return false;
 }
-
-// src/lazyLoad.ts
-var makeDefineCustomElements = (runtime, structure) => function defineCustomElements(windowOrOptions, options) {
+const makeDefineCustomElements = (runtime, structure) => function defineCustomElements(windowOrOptions, options) {
   if (!globalThis.customElements) {
     return;
   }
@@ -121,35 +128,19 @@ function createLazyElement([tagName, [load, compactMeta = ""]]) {
     globalThis.devOnly$ownTagNames?.add(tagName);
   }
 }
-var defineProperty = Object.defineProperty;
+const defineProperty = Object.defineProperty;
 function parseCondensedProp(propAndAttribute) {
   const name = propAndAttribute.split(lazyMetaSubItemJoiner);
   return name.length === 1 ? [name[0], camelToKebab(name[0])] : name;
 }
-var HtmlElement = globalThis.HTMLElement ?? parseCondensedProp;
-var ProxyComponent = class extends HtmlElement {
+const HtmlElement = globalThis.HTMLElement ?? parseCondensedProp;
+class ProxyComponent extends HtmlElement {
   constructor() {
     super();
-    /** @internal */
     this._store = {};
-    /**
-     * If attributeChangedCallback() is called before the LitElement is loaded,
-     * store the attributes here, and replay later
-     */
     this._pendingAttributes = [];
-    /**
-     * Resolved once LitElement's load() is complete.
-     * Not read inside of this class, but needed for LitElement to determine if
-     * it's closest ancestor finished load()
-     */
     this._postLoad = new Deferred();
-    /**
-     * Resolved once LitElement's loaded() is complete
-     */
     this._postLoaded = new Deferred();
-    /**
-     * Direct offspring that should be awaited before loaded() is emitted
-     */
     this._offspring = [];
     if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
       this._hmrSetProps = /* @__PURE__ */ new Set();
@@ -162,7 +153,7 @@ var ProxyComponent = class extends HtmlElement {
     if (ProxyClass._LitConstructor) {
       this._initializeComponent({ a: ProxyClass._LitConstructor });
     } else {
-      void ProxyClass._loadPromise.then(this._initializeComponent.bind(this)).catch((error) => {
+      void ProxyClass._loadPromise.then(awaitTopLevelPolyfill).then(this._initializeComponent.bind(this)).catch((error) => {
         this._postLoaded.reject(error);
         setTimeout(() => {
           throw error;
@@ -384,7 +375,7 @@ var ProxyComponent = class extends HtmlElement {
   requestUpdate() {
     this._litElement?.requestUpdate();
   }
-};
+}
 function syncLitElement([key, value]) {
   this[key] = value;
 }
@@ -409,13 +400,14 @@ function patchLitElement(parentClass) {
     devOnlyDetectIncorrectLazyUsages(parentClass);
   }
 }
-
-// src/utils.ts
-var noShadowRoot = {};
-
+const awaitTopLevelPolyfill = async (module) => {
+  await module.$$;
+  return module;
+};
+const noShadowRoot = {};
 export {
-  attachToAncestor,
-  makeDefineCustomElements,
-  ProxyComponent,
-  noShadowRoot
+  ProxyComponent as P,
+  attachToAncestor as a,
+  makeDefineCustomElements as m,
+  noShadowRoot as n
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcgis/lumina",
-  "version": "4.33.0-next.9",
+  "version": "4.33.0-next.91",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
@@ -20,8 +20,8 @@
   ],
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@arcgis/components-controllers": "4.33.0-next.9",
-    "@arcgis/components-utils": "4.33.0-next.9",
+    "@arcgis/components-controllers": "4.33.0-next.91",
+    "@arcgis/components-utils": "4.33.0-next.91",
     "@lit-labs/ssr": "^3.2.2",
     "@lit-labs/ssr-client": "^1.1.7",
     "@lit/context": "^1.1.3",

package/dist/chunk-PGHUBTOM.js

@@ -1,21 +0,0 @@
-// src/config.ts
-var lazyMetaGroupJoiner = ";";
-var lazyMetaItemJoiner = ",";
-var lazyMetaSubItemJoiner = ":";
-var PropertyFlags = /* @__PURE__ */ ((PropertyFlags2) => {
-  PropertyFlags2[PropertyFlags2["ATTRIBUTE"] = 1] = "ATTRIBUTE";
-  PropertyFlags2[PropertyFlags2["REFLECT"] = 2] = "REFLECT";
-  PropertyFlags2[PropertyFlags2["BOOLEAN"] = 4] = "BOOLEAN";
-  PropertyFlags2[PropertyFlags2["NUMBER"] = 8] = "NUMBER";
-  PropertyFlags2[PropertyFlags2["STATE"] = 16] = "STATE";
-  PropertyFlags2[PropertyFlags2["READ_ONLY"] = 32] = "READ_ONLY";
-  PropertyFlags2[PropertyFlags2["NO_ACCESSOR"] = 64] = "NO_ACCESSOR";
-  return PropertyFlags2;
-})(PropertyFlags || {});
-
-export {
-  lazyMetaGroupJoiner,
-  lazyMetaItemJoiner,
-  lazyMetaSubItemJoiner,
-  PropertyFlags
-};

package/dist/wrappersUtils.test.d.ts

@@ -1 +0,0 @@
-export {};