@arcgis/lumina 5.2.0-next.2 → 5.2.0-next.21

package/dist/formAssociatedUtils.d.ts

@@ -1,48 +1,6 @@
-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;
+  luminaFormAssociatedCallback: CustomEvent<readonly [form: HTMLFormElement | null]>;
+  luminaFormDisabledCallback: CustomEvent<readonly [disabled: boolean]>;
+  luminaFormResetCallback: CustomEvent<readonly []>;
+  luminaFormStateRestoreCallback: CustomEvent<readonly [state: unknown, mode: "autocomplete" | "restore"]>;
+}

package/dist/globalTypes/importMeta.d.ts

@@ -1,13 +1,21 @@
-interface ImportMetaEnv {
-    [key: string]: any;
-    BASE_URL: string;
-    MODE: string;
-    DEV: boolean;
-    PROD: boolean;
-}
-interface ImportMeta {
+
+
+/** @public */
+declare global {
+  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;
+  }
 }
+
+export type ImportMetaEnv = { [key: string]: any; } & {
+  BASE_URL: string;
+  MODE: string;
+  DEV: boolean;
+  PROD: boolean;
+};

package/dist/globalTypes/index.d.ts

@@ -1,4 +1,6 @@
-/// <reference path="jsxGlobals.d.ts" preserve="true" />
-/// <reference path="loadLitCss.d.ts" preserve="true" />
-/// <reference path="viteEnv.d.ts" preserve="true" />
-/// <reference path="importMeta.d.ts" preserve="true" />
+/// <reference path="./loadLitCss.d.ts" preserve="true" />
+/// <reference path="./viteEnv.d.ts" preserve="true" />
+/// <reference path="./importMeta.d.ts" preserve="true" />
+
+export type * from "./jsxGlobals.js";
+

package/dist/globalTypes/jsxGlobals.d.ts

@@ -3,30 +3,42 @@
  * referenced in public types of your package to not pollute the global types
  * namespace
  */
+
+/**
+ * This file is used for internal type checking only. It should not be
+ * referenced in public types of your package to not pollute the global types
+ * namespace
+ *
+ * @public
+ */
 declare global {
-    /**
-     * This interface will be extended in each source file that defines a LitElement.
-     *
-     * @example
-     * ```ts
-     * declare global {
-     *   interface DeclareElements {
-     *     "arcgis-root": ArcgisRoot;
-     *   }
-     * }
-     * ```
-     */
-    export interface DeclareElements {
-    }
-    type ReMappedDeclareElements = {
-        [TagName in keyof DeclareElements]: DeclareElements[TagName]["el"];
-    };
-    interface HTMLElementTagNameMap extends ReMappedDeclareElements {
-    }
-}
-export interface DeclareElements extends globalThis.DeclareElements {
+  /**
+   * This interface will be extended in each source file that defines a LitElement.
+   *
+   * @example
+   * ```ts
+   * declare global {
+   *   interface DeclareElements {
+   *     "arcgis-root": ArcgisRoot;
+   *   }
+   * }
+   * ```
+   */
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  export interface DeclareElements {}
+
+  type ReMappedDeclareElements = {
+    [TagName in keyof DeclareElements]: DeclareElements[TagName]["el"];
+  };
+
+  interface HTMLElementTagNameMap extends ReMappedDeclareElements {}
 }
+
+
+
 /**
+ * @public
+ * @privateRemarks
  * In the component files, we declare "DeclareElements" interface on the
  * `declare global` namespace as it's shorter than writing
  * `declare module "@arcgis/lumina"`. However, we want to avoid polluting
@@ -34,6 +46,7 @@ export interface DeclareElements extends globalThis.DeclareElements {
  * extend the namespaced DeclareElements based on the global DeclareElements.
  */
 declare module "../jsx/types.ts" {
-    interface DeclareElements extends globalThis.DeclareElements {
-    }
+  export interface DeclareElements extends globalThis.DeclareElements {}
 }
+
+export interface DeclareElements extends globalThis.DeclareElements {}

package/dist/globalTypes/loadLitCss.d.ts

@@ -4,59 +4,80 @@
  *
  * @see `@arcgis/lumina-compiler/plugins/loadLitCss.ts`
  */
+
+/**
+ * Tell TypeScript that .css imports will be replaced by Lit's CSSResult at
+ * build-time.
+ *
+ * @public
+ * @see `@arcgis/lumina-compiler/plugins/loadLitCss.ts`
+ */
 declare module "*.css" {
-    import type { CSSResult } from "lit";
-    export const styles: CSSResult & {
-        get styleSheet(): CSSStyleSheet;
-    };
-    export default styles;
+  import type { CSSResult } from "lit";
+  export const styles: CSSResult & { get styleSheet(): CSSStyleSheet };
+  export default styles;
 }
+
+
+
+/** @public */
 declare module "*.scss" {
-    import type { CSSResult } from "lit";
-    export const styles: CSSResult & {
-        get styleSheet(): CSSStyleSheet;
-    };
-    export default styles;
+  import type { CSSResult } from "lit";
+  export const styles: CSSResult & { get styleSheet(): CSSStyleSheet };
+  export default styles;
 }
+
+
+
+/** @public */
 declare module "*.sass" {
-    import type { CSSResult } from "lit";
-    export const styles: CSSResult & {
-        get styleSheet(): CSSStyleSheet;
-    };
-    export default styles;
+  import type { CSSResult } from "lit";
+  export const styles: CSSResult & { get styleSheet(): CSSStyleSheet };
+  export default styles;
 }
+
+
+
+/** @public */
 declare module "*.less" {
-    import type { CSSResult } from "lit";
-    export const styles: CSSResult & {
-        get styleSheet(): CSSStyleSheet;
-    };
-    export default styles;
+  import type { CSSResult } from "lit";
+  export const styles: CSSResult & { get styleSheet(): CSSStyleSheet };
+  export default styles;
 }
+
+
+
+/** @public */
 declare module "*.styl" {
-    import type { CSSResult } from "lit";
-    export const styles: CSSResult & {
-        get styleSheet(): CSSStyleSheet;
-    };
-    export default styles;
+  import type { CSSResult } from "lit";
+  export const styles: CSSResult & { get styleSheet(): CSSStyleSheet };
+  export default styles;
 }
+
+
+
+/** @public */
 declare module "*.stylus" {
-    import type { CSSResult } from "lit";
-    export const styles: CSSResult & {
-        get styleSheet(): CSSStyleSheet;
-    };
-    export default styles;
+  import type { CSSResult } from "lit";
+  export const styles: CSSResult & { get styleSheet(): CSSStyleSheet };
+  export default styles;
 }
+
+
+
+/** @public */
 declare module "*.pcss" {
-    import type { CSSResult } from "lit";
-    export const styles: CSSResult & {
-        get styleSheet(): CSSStyleSheet;
-    };
-    export default styles;
+  import type { CSSResult } from "lit";
+  export const styles: CSSResult & { get styleSheet(): CSSStyleSheet };
+  export default styles;
 }
+
+
+
+/** @public */
 declare module "*.sss" {
-    import type { CSSResult } from "lit";
-    export const styles: CSSResult & {
-        get styleSheet(): CSSStyleSheet;
-    };
-    export default styles;
+  import type { CSSResult } from "lit";
+  export const styles: CSSResult & { get styleSheet(): CSSStyleSheet };
+  export default styles;
 }
+

package/dist/globalTypes/viteEnv.d.ts

@@ -2,47 +2,81 @@
  * The following are a subset of types from vite/client.d.ts
  * Removed the types related to static assets since we handle assets differently
  */
+
+// TEST: add a canary test for when this file get's out of date with Vite
+
+/**
+ * The following are a subset of types from vite/client.d.ts
+ * Removed the types related to static assets since we handle assets differently
+ *
+ * @public
+ */
 declare module "*.wasm?init" {
-    const initWasm: (options?: WebAssembly.Imports) => Promise<WebAssembly.Instance>;
-    export default initWasm;
+  const initWasm: (options?: WebAssembly.Imports) => Promise<WebAssembly.Instance>;
+  export default initWasm;
 }
+
+
+
+/** @public */
 declare module "*?worker" {
-    const workerConstructor: new (options?: {
-        name?: string;
-    }) => Worker;
-    export default workerConstructor;
+  const workerConstructor: new (options?: { name?: string }) => Worker;
+  export default workerConstructor;
 }
+
+
+
+/** @public */
 declare module "*?worker&inline" {
-    const workerConstructor: new (options?: {
-        name?: string;
-    }) => Worker;
-    export default workerConstructor;
+  const workerConstructor: new (options?: { name?: string }) => Worker;
+  export default workerConstructor;
 }
+
+
+
+/** @public */
 declare module "*?worker&url" {
-    const src: string;
-    export default src;
+  const src: string;
+  export default src;
 }
+
+
+
+/** @public */
 declare module "*?sharedworker" {
-    const sharedWorkerConstructor: new (options?: {
-        name?: string;
-    }) => SharedWorker;
-    export default sharedWorkerConstructor;
+  const sharedWorkerConstructor: new (options?: { name?: string }) => SharedWorker;
+  export default sharedWorkerConstructor;
 }
+
+
+
+/** @public */
 declare module "*?sharedworker&inline" {
-    const sharedWorkerConstructor: new (options?: {
-        name?: string;
-    }) => SharedWorker;
-    export default sharedWorkerConstructor;
+  const sharedWorkerConstructor: new (options?: { name?: string }) => SharedWorker;
+  export default sharedWorkerConstructor;
 }
+
+
+
+/** @public */
 declare module "*?sharedworker&url" {
-    const src: string;
-    export default src;
+  const src: string;
+  export default src;
 }
+
+
+
+/** @public */
 declare module "*?raw" {
-    const src: string;
-    export default src;
+  const src: string;
+  export default src;
 }
+
+
+
+/** @public */
 declare module "*?inline" {
-    const src: string;
-    export default src;
+  const src: string;
+  export default src;
 }
+

package/dist/hmrSupport.d.ts

@@ -1,35 +1,31 @@
-import { ModuleNamespace } from 'vite/types/hot.js';
-/**
- * Update web component proxies when a module is updated.
- *
- * @remarks
- * You should not need to call this function directly - it will be inserted
- * automatically when running in serve mode.
- *
- * @private
- */
-export declare function handleHmrUpdate(newModules: (ModuleNamespace | undefined)[]): void;
-/** @private */
+/** @internal */
 export type HmrComponentMeta = {
-    readonly tagName: string;
-    /**
-     * 2nd tuple element ("attribute") is missing when attribute name can be
-     * trivially inferred from the property name (using camelToKebab()).
-     * If 2nd tuple element is empty string, it means the property does not have
-     * an attribute.
-     */
-    readonly properties: (readonly [property: string, attribute: string] | readonly [property: string])[];
-    readonly asyncMethods: readonly string[];
-    readonly syncMethods: readonly string[];
-    readonly formAssociated: boolean;
+  /** @internal */
+  readonly tagName: string;
+  /**
+   * 2nd tuple element ("attribute") is missing when attribute name can be
+   * trivially inferred from the property name (using camelToKebab()).
+   * If 2nd tuple element is empty string, it means the property does not have
+   * an attribute.
+   *
+   * @internal
+   */
+  readonly properties: (readonly [property: string, attribute: string] | readonly [property: string])[];
+  /** @internal */
+  readonly asyncMethods: readonly string[];
+  /** @internal */
+  readonly syncMethods: readonly string[];
+  /** @internal */
+  readonly formAssociated: boolean;
 };
+
 /**
- * Update lazy component meta
+ * Update lazy component meta.
  *
- * @remarks
- * You should not need to call this function directly - it will be inserted
+ * You should not need to call this function directly - it will be called
  * automatically when running in serve mode.
  *
- * @private
+ * @param meta
+ * @internal
  */
-export declare function handleComponentMetaUpdate(meta: HmrComponentMeta): void;
+export function handleComponentMetaUpdate(meta: HmrComponentMeta): void;

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,5 +1,5 @@
-import { p as propertyTrackResolve } from "./Controller-Cer_6Z29.js";
-import { c } from "./Controller-Cer_6Z29.js";
+import { p as propertyTrackResolve } from "./GenericController-C8NSb50b.js";
+import { c } from "./GenericController-C8NSb50b.js";
 import { state } from "lit/decorators/state.js";
 import { property as property$1 } from "lit/decorators/property.js";
 import { e as emptyFunction, n as noShadowRoot, p as proxyFormMethodsToEvents, a as attachToAncestor } from "./lazyLoad-B5Rj3U_I.js";
@@ -9,7 +9,7 @@ import { camelToKebab } from "@arcgis/toolkit/string";
 import { Deferred } from "@arcgis/toolkit/promise";
 import { LitElement as LitElement$1, isServer, notEqual, noChange as noChange$1, nothing as nothing$1, render } from "lit";
 import { c as controllerSymbol, s as shouldBypassReadOnly } from "./ControllerInternals-CeDntN3G.js";
-import { C as ControllerManager, a as autoDestroyDisabledPropName } from "./ControllerManager-DpJfvft9.js";
+import { C as ControllerManager, a as autoDestroyDisabledPropName } from "./ControllerManager-4cSEnB5Y.js";
 import { propertyFlagAttribute, propertyFlagUseDefault, propertyFlagNoAccessor, propertyFlagReadOnly, propertyFlagState, propertyFlagBoolean, propertyFlagNumber, propertyFlagReflect } from "./config.js";
 import { classMap } from "lit/directives/class-map.js";
 import { styleMap } from "lit/directives/style-map.js";
@@ -19,6 +19,12 @@ import { ref } from "lit/directives/ref.js";
 const property = property$1;
 const method = void 0;
 class LitElement extends LitElement$1 {
+  /**
+   * @internal
+   * @privateRemarks
+   * The constructor needs to be public for compatibility with TypeScript's
+   * CustomElementConstructor DOM type.
+   */
   constructor() {
     super();
     this.M = [];
@@ -171,8 +177,6 @@ class LitElement extends LitElement$1 {
   /**
    * The JS API's Accessor observables. This is used to integrate with the JS
    * API's reactivity system.
-   *
-   * @private
    */
   #observables;
   #originalShouldUpdate;
@@ -181,7 +185,8 @@ class LitElement extends LitElement$1 {
   #trackingTarget;
   #elementInternals;
   /**
-   * @see [MDN ElementInternals](https://developer.mozilla.org/en-US/docs/Web/API/ElementInternals)
+   * @public
+   * @see [MDN ElementInternals](https://developer.mozilla.org/docs/Web/API/ElementInternals)
    */
   get elementInternals() {
     this.#elementInternals ??= this.el.attachInternals();
@@ -327,6 +332,13 @@ class LitElement extends LitElement$1 {
       return () => this.el.removeEventListener(name, boundListener, options);
     });
   }
+  /**
+   * @public
+   * @param target
+   * @param name
+   * @param listener
+   * @param options
+   */
   listenOn(target, name, listener, options) {
     const boundListener = listener?.bind(this) ?? listener;
     this.manager.onLifecycle(() => {
@@ -337,12 +349,15 @@ class LitElement extends LitElement$1 {
   /**
    * Creates a promise that resolves once the component is fully loaded.
    *
+   * @public
    * @example
+   * ```js
    * const map = document.createElement('arcgis-map');
    * document.body.append(map);
    * map.componentOnReady().then(() => {
    *   console.log('Map is ready to go!');
    * });
+   * ```
    */
   async componentOnReady() {
     await this.#postLoadedDeferred.promise;
@@ -352,10 +367,12 @@ class LitElement extends LitElement$1 {
    * Adds a controller to the host, which connects the controller's lifecycle
    * methods to the host's lifecycle.
    *
-   * @remarks
    * Even though Lit's LitElement already has addController,
    * we overwrite it with a compatible version to have more control over
    * timing, and to add support for load/loaded lifecycle hooks.
+   *
+   * @public
+   * @param controller
    */
   addController(controller) {
     this.M.push(controller);
@@ -365,6 +382,9 @@ class LitElement extends LitElement$1 {
   }
   /**
    * Removes a controller from the host.
+   *
+   * @public
+   * @param controller
    */
   removeController(controller) {
     this.M.splice(this.M.indexOf(controller), 1);

package/dist/jsx/baseTypes.d.ts

@@ -1,39 +1,39 @@
-import { DirectiveResult } from 'lit/directive.js';
-import { Ref } from 'lit/directives/ref.js';
-export type EventHandlerUnion<T, E extends Event> = (e: E & {
+import type { DirectiveResult } from "lit/directive.js";
+import type { Ref } from "lit/directives/ref.js";
+
+/** @param event */
+export type EventHandlerUnion<T, E extends Event> = (event: E & {
     currentTarget: T;
     target: Element;
 }) => void;
-export type InputEventHandlerUnion<T, E extends InputEvent> = (e: E & {
+
+/** @param event */
+export type InputEventHandlerUnion<T, E extends InputEvent> = (event: E & {
     currentTarget: T;
     target: T extends HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement ? T : Element;
 }) => void;
-export type ChangeEventHandlerUnion<T, E extends Event> = (e: E & {
+
+/** @param event */
+export type ChangeEventHandlerUnion<T, E extends Event> = (event: E & {
     currentTarget: T;
     target: T extends HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement ? T : Element;
 }) => void;
-export type FocusEventHandlerUnion<T, E extends FocusEvent> = (e: E & {
+
+/** @param event */
+export type FocusEventHandlerUnion<T, E extends FocusEvent> = (event: E & {
     currentTarget: T;
     target: T extends HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement ? T : Element;
 }) => void;
-export type EventHandler<E> = {
-    bivarianceHack(event: E): void;
-}["bivarianceHack"];
+
+export type EventHandler<E> = { bivarianceHack(event: E): void; }["bivarianceHack"];
+
 export interface CustomAttributes<T = HTMLElement> {
-    /**
-     * [Documentation](https://webgis.esri.com/references/lumina/jsx#key-prop)
-     */
-    key?: unknown;
-    /**
-     * [Documentation](https://webgis.esri.com/references/lumina/jsx#refs)
-     */
-    ref?: EventHandler<T | undefined> | Ref<T>;
-    /**
-     * [Documentation](https://webgis.esri.com/references/lumina/jsx#lit-directives)
-     */
-    directives?: readonly DirectiveResult[];
-    /**
-     * [Documentation](https://webgis.esri.com/references/lumina/jsx#deferring-web-component-load)
-     */
-    deferLoad?: true;
-}
+  /** @see [Documentation](https://webgis.esri.com/references/lumina/jsx#key-prop) */
+  key?: unknown;
+  /** @see [Documentation](https://webgis.esri.com/references/lumina/jsx#refs) */
+  ref?: EventHandler<T | undefined> | Ref<T>;
+  /** @see [Documentation](https://webgis.esri.com/references/lumina/jsx#lit-directives) */
+  directives?: readonly DirectiveResult[];
+  /** @see [Documentation](https://webgis.esri.com/references/lumina/jsx#deferring-web-component-load) */
+  deferLoad?: true;
+}