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

package/dist/lazyLoad.d.ts

@@ -1,7 +1,7 @@
-import { Deferred } from '@arcgis/toolkit/promise';
-import { LitElement } from './LitElement.ts';
-import { Runtime } from './makeRuntime.ts';
-import { ControllerManager } from './controllers/ControllerManager.ts';
+import type { LitElement } from "./LitElement.js";
+import type { Runtime } from "./makeRuntime.js";
+import type { ControllerManager } from "./controllers/ControllerManager.js";
+
 /**
  * Defines lazy-loading proxy components for all web components in this package.
  *
@@ -9,17 +9,26 @@ import { ControllerManager } from './controllers/ControllerManager.ts';
  * it will start loading the actual web component source code.
  */
 export interface DefineCustomElements {
-    (options?: LazyLoadOptions): void;
-    /** @deprecated Passing the Window argument is not necessary - omit the first argument */
-    (_window?: Window, options?: LazyLoadOptions): void;
+  /** @param options */
+  (options?: LazyLoadOptions): void;
+  /**
+   * @deprecated Passing the Window argument is not necessary - omit the first argument
+   * @param window
+   * @param options
+   */
+  (window?: Window, options?: LazyLoadOptions): void;
 }
-export type LazyLoadOptions = {
-    readonly resourcesUrl?: string;
-};
-interface CommonInterface extends HTMLElement {
-    componentOnReady: () => Promise<this>;
+
+export interface LazyLoadOptions {
+  readonly resourcesUrl?: string;
 }
-export declare const makeDefineCustomElements: (runtime: Runtime, structure: Readonly<Record<string, CompactMeta>>) => DefineCustomElements;
+
+/**
+ * @param runtime
+ * @param structure
+ */
+export function makeDefineCustomElements(runtime: Runtime, structure: Readonly<Record<string, CompactMeta>>): DefineCustomElements;
+
 /**
  * Use compact meta to reduce bundle size (otherwise, it would be ~65kb for
  * map-components). Also, the meta is a string to speed-up parsing
@@ -33,101 +42,13 @@ export declare const makeDefineCustomElements: (runtime: Runtime, structure: Rea
  *   is formAssociated. We can expand this field to include more information in
  *   the future using bit flags.
  */
-type CompactMeta = readonly [load: () => Promise<Record<string, typeof LitElement>>, compact?: string, flags?: 1];
-/**
- * If this file is run from a Node.js environment, HTMLElement won't be defined.
- * Falling back to uselessly extending emptyFunction in that case.
- * This will error if you try to instantiate a ProxyComponent in Node.js, but
- * that is expected - if you need to instantiate ProxyComponent, HTMLElement
- * must be defined
- */
-declare const HtmlElement: {
-    new (): HTMLElement;
-    prototype: HTMLElement;
-};
-/**
- * A web-component that, once connected to the page, starts loading the actual
- * component, and set's up two-way forwarding of attributes and methods.
- *
- * It also makes the actual component render it's content in this 'proxy'
- * component, so as to have identical DOM structure for lazy vs non-lazy builds
- * (otherwise, css selectors may break)
- *
- * @private
- */
-export declare abstract class ProxyComponent extends HtmlElement {
-    #private;
-    static observedAttributes?: readonly string[];
-    static _LitElementLoadPromise: Promise<Record<string, typeof LitElement>> | undefined;
-    static _LitElementConstructor?: typeof LitElement;
-    /**
-     * A list of instances of this component. This allows hot module replacement
-     * to update all proxy component to use a new LitElement instance.
-     */
-    static devOnly$hmrInstances: WeakRef<ProxyComponent>[] | undefined;
-    static devOnly$hmrIndex: number | undefined;
-    static _proxiedProperties?: readonly string[];
-    static _proxiedAsyncMethods?: readonly string[];
-    static _proxiedSyncMethods?: readonly string[];
-    static __runtime: Runtime;
-    protected static __tagName: string;
-    static readonly lumina = true;
-    static _initializeProxyPrototype(): void;
-    /**
-     * On HMR, preserve the values of all properties that at least once were set
-     * by someone other than component itself.
-     */
-    devOnly$hmrSetProps: Set<PropertyKey>;
-    devOnly$hmrSetAttributes: Set<string>;
-    devOnly$InitializeComponent?: (module: Record<string, typeof LitElement>) => void;
-    devOnly$hmrResetStore?: (newStore: Record<string, unknown>) => void;
-    devOnly$elementInternals?: ElementInternals;
-    /**
-     * This property is only set in development mode and exists only for usage in
-     * tests or during debugging
-     */
-    $component: LitElement | undefined;
-    /**
-     * 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()
-     */
-    __postLoadDeferred: Deferred<void>;
-    /**
-     * Resolved once LitElement's loaded() is complete
-     */
-    _postLoadedDeferred: Deferred<void>;
-    /**
-     * Direct offspring that should be awaited before loaded() is emitted
-     */
-    __offspringComponents: (CommonInterface & {
-        manager?: LitElement["manager"];
-    })[];
-    /**
-     * Promise that resolves once parent's load() completed. False if there is no
-     * parent
-     */
-    _ancestorLoadPromise?: Promise<void> | false;
-    get manager(): ControllerManager | undefined;
-    constructor();
-    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
-    connectedCallback(): void;
-    disconnectedCallback(): void;
-    /**
-     * Creates a promise that resolves once the component is fully loaded
-     */
-    componentOnReady(): Promise<this>;
-    /**
-     * Implemented on the proxy for compatibility with Lit Context.
-     */
-    addController(): void;
-    /**
-     * Implemented on the proxy for compatibility with Lit Context.
-     */
-    requestUpdate(): void;
-}
-/** @private */
+export type CompactMeta = readonly [load: () => Promise<Record<string, typeof LitElement>>, compact?: string, flags?: 1];
+
+/** @internal */
 export type GlobalThisWithPuppeteerEnv = typeof globalThis & {
-    devOnly$createdElements?: WeakRef<ProxyComponent>[];
-};
-export {};
+  /** @internal */
+  devOnly$createdElements?: WeakRef<HTMLElement & {
+      componentOnReady: () => Promise<unknown>;
+      manager?: ControllerManager;
+  }>[];
+};

package/dist/makeRuntime.d.ts

@@ -1,148 +1,125 @@
-import { CSSResult } from 'lit';
-import { LitElement } from './LitElement.ts';
-import { AccessorObservableLike, ReactiveTrackingTarget } from './controllers/types.ts';
+import type { CSSResult } from "lit";
+import type { LitElement } from "./LitElement.js";
+
 /**
  * `@arcgis/lumina` package may be bundled once but used by multiple packages with
  * different configuration options. For that reason, the configuration options
  * cannot be a global object, but has to be an object that you pass around.
  */
-export type Runtime = RuntimeOptions & {
-    /**
-     * Get the base path to where the package assets can be found.
-     * By default, the package asset path is set to `https://js.arcgis.com/<simplified-package-name>/<released-verion>/`.
-     * We are hosting our assets on a CDN (Content Delivery Network) to ensure fast and reliable access.
-     * It is CORS-enabled, so you can load the assets from any domain.
-     * Use "setAssetPath(path)" if the path needs to be customized.
-     */
-    readonly getAssetPath: (suffix: string) => string;
-    /**
-     * Used to manually set the base path where package assets (like localization
-     * and icons) can be found.
-     *
-     * By default, the package asset path is set to `https://js.arcgis.com/<simplified-package-name>/<released-verion>/`.
-     * For example, `https://js.arcgis.com/map-components/4.30/`.
-     * We are hosting our assets on a CDN (Content Delivery Network) to ensure fast and reliable access.
-     * It is CORS-enabled, so you can load the assets from any domain.
-     * This is the recommended way to load the assets and avoid bundling them with your application.
-     * It means that by default, you don't need to use "setAssetPath" since the path is already set.
-     *
-     * However, if you need to host the assets locally, you can use "setAssetPath" to set the base path.
-     * If the script is used as "module", it's recommended to use "import.meta.url",
-     * such as "setAssetPath(import.meta.url)". Other options include
-     * "setAssetPath(document.currentScript.src)", or using a bundler's replace plugin to
-     * dynamically set the path at build time, such as "setAssetPath(process.env.ASSET_PATH)".
-     * But do note that this configuration depends on how your script is bundled, or lack of
-     * bundling, and where your assets can be loaded from. Additionally custom bundling
-     * will have to ensure the static assets are copied to its build directory.
-     */
-    readonly setAssetPath: (path: URL | string) => void;
-    /**
-     * The customElement decorator. Unlike default Lit's decorator this one
-     * provides runtime instance to the LitElement class
-     *
-     * @remarks
-     * You do not need to call this decorator in your component.
-     * It will be added automatically at build time.
-     *
-     * Instead, make sure your component file has the following:
-     * ```ts
-     * declare global {
-     *  interface DeclareElements {
-     *      "arcgis-your-component": ArcgisYourComponent;
-     *   }
-     * }
-     * ```
-     */
-    readonly customElement: (tagName: string, component: typeof LitElement) => void;
-    /**
-     * Short for trackAccess. A reference to JS API's accessor's trackAccess
-     * function to mark an observable as accessed.
-     * Used in the getter for each property in component packages that use @arcgis/core.
-     *
-     * @private
-     */
-    t?: (observable: AccessorObservableLike) => void;
-    /**
-     * Short for createObservable. A callback to create a JS API Accessor's
-     * SimpleObservable. Such observable will be created for each property in
-     * component packages that use @arcgis/core to bring reactiveUtils integration.
-     * @private
-     */
-    o?: () => AccessorObservableLike;
-    /**
-     * In CDN build, we can only import `@arcgis/core` async, so the lazy loader will need
-     * to await this promise before beginning hydration so that the reactiveUtils
-     * integration modules had time to load.
-     *
-     * @private
-     */
-    p?: Promise<void>;
-    /**
-     * A possible reference to JS API's createTrackingTarget() function to create
-     * an observer that will keep track of what properties were accessed during
-     * render().
-     *
-     * @private
-     */
-    c?: (callback: () => void) => ReactiveTrackingTarget;
-    /**
-     * A possible reference to JS API's runTracked() function to run update() with
-     * property accesses tracking enabled.
-     *
-     * @private
-     */
-    r?: (target: ReactiveTrackingTarget, callback: () => void) => void;
-};
-export type RuntimeOptions = {
-    /**
-     * The default asset path to use in NPM and CDN builds.
-     *
-     * This option will be set by Lumina compiler based on the value of the
-     * `assets.defaultPath` option in the `useLumina()` plugin.
-     */
-    readonly defaultAssetPath: string;
-    /**
-     * The attribute that indicates a component has rendered its content.
-     * Usually this attribute is added after your component's `loaded()` lifecycle
-     * happened. However, during SSR, "hydrated" is added right away on the
-     * server.
-     *
-     * Until element has this attribute, it will have `visibility:hidden` style
-     * applied.
-     *
-     * This option will be set by the Lumina compiler based on the value of
-     * the `css.hydratedAttribute` option in the `useLumina()` plugin.
-     */
-    readonly hydratedAttribute: string;
-    /**
-     * Styles that you wish to make available in each component's shadow root, but
-     * to not apply outside the shadow root
-     *
-     * This option will be set by Lumina compiler based on the value of the
-     * `css.commonStylesPath` option in the `useLumina()` plugin.
-     */
-    readonly commonStyles?: CSSResult;
-};
+export interface Runtime extends RuntimeOptions {
+  /**
+   * Get the base path to where the package assets can be found.
+   * By default, the package asset path is set to `https://js.arcgis.com/<simplified-package-name>/<released-verion>/`.
+   * We are hosting our assets on a CDN (Content Delivery Network) to ensure fast and reliable access.
+   * It is CORS-enabled, so you can load the assets from any domain.
+   * Use "setAssetPath(path)" if the path needs to be customized.
+   *
+   * @param suffix
+   */
+  getAssetPath(suffix: string): string;
+  /**
+   * Used to manually set the base path where package assets (like localization
+   * and icons) can be found.
+   *
+   * By default, the package asset path is set to `https://js.arcgis.com/<simplified-package-name>/<released-verion>/`.
+   * For example, `https://js.arcgis.com/map-components/4.30/`.
+   * We are hosting our assets on a CDN (Content Delivery Network) to ensure fast and reliable access.
+   * It is CORS-enabled, so you can load the assets from any domain.
+   * This is the recommended way to load the assets and avoid bundling them with your application.
+   * It means that by default, you don't need to use "setAssetPath" since the path is already set.
+   *
+   * However, if you need to host the assets locally, you can use "setAssetPath" to set the base path.
+   * If the script is used as "module", it's recommended to use "import.meta.url",
+   * such as "setAssetPath(import.meta.url)". Other options include
+   * "setAssetPath(document.currentScript.src)", or using a bundler's replace plugin to
+   * dynamically set the path at build time, such as "setAssetPath(process.env.ASSET_PATH)".
+   * But do note that this configuration depends on how your script is bundled, or lack of
+   * bundling, and where your assets can be loaded from. Additionally custom bundling
+   * will have to ensure the static assets are copied to its build directory.
+   *
+   * @param path
+   */
+  setAssetPath(path: URL | string): void;
+  /**
+   * The customElement decorator. Unlike default Lit's decorator this one
+   * provides runtime instance to the LitElement class
+   *
+   * You do not need to call this decorator in your component.
+   * It will be added automatically at build time.
+   *
+   * Instead, make sure your component file has the following:
+   * ```ts
+   * declare global {
+   *  interface DeclareElements {
+   *      "arcgis-your-component": ArcgisYourComponent;
+   *   }
+   * }
+   * ```
+   *
+   * @param tagName
+   * @param component
+   * @internal
+   */
+  customElement(tagName: string, component: typeof LitElement): void;
+}
+
+export interface RuntimeOptions {
+  /**
+   * The default asset path to use in NPM and CDN builds.
+   *
+   * This option will be set by Lumina compiler based on the value of the
+   * `assets.defaultPath` option in the `useLumina()` plugin.
+   */
+  readonly defaultAssetPath: string;
+  /**
+   * The attribute that indicates a component has rendered its content.
+   * Usually this attribute is added after your component's `loaded()` lifecycle
+   * happened. However, during SSR, "hydrated" is added right away on the
+   * server.
+   *
+   * Until element has this attribute, it will have `visibility:hidden` style
+   * applied.
+   *
+   * This option will be set by the Lumina compiler based on the value of
+   * the `css.hydratedAttribute` option in the `useLumina()` plugin.
+   */
+  readonly hydratedAttribute: string;
+  /**
+   * Styles that you wish to make available in each component's shadow root, but
+   * to not apply outside the shadow root
+   *
+   * This option will be set by Lumina compiler based on the value of the
+   * `css.commonStylesPath` option in the `useLumina()` plugin.
+   */
+  readonly commonStyles?: CSSResult;
+}
+
 /**
  * The options object will be provided by Lumina compiler at build-time.
  * It should not be specified in the source code.
+ *
+ * @param options
  */
-export declare const makeRuntime: (options?: RuntimeOptions) => Runtime;
+export function makeRuntime(options?: RuntimeOptions): Runtime;
+
 /**
  * Exposing the reference to the runtime globally when in tests or development.
- * This is primarily for usage by dynamically created components in tests
+ * This is primarily for usage by dynamically created components in tests.
  *
- * @private
+ * @internal
  */
 export type DevOnlyGlobalRuntime = typeof globalThis & {
-    devOnly$luminaRuntime?: Runtime;
+  /** @internal */
+  devOnly$luminaRuntime?: Runtime;
 };
+
 /**
  * Called from the component constructor when in development or test mode.
  * Used primarily by mount to get a reference to the rendered component.
  *
- * @private
+ * @internal
  */
 export type DevOnlyGlobalComponentRefCallback = typeof globalThis & {
-    devOnly$luminaComponentRefCallback?: (component: LitElement) => void;
-};
+  /** @internal */
+  devOnly$luminaComponentRefCallback?: (component: LitElement) => void;
+};

package/dist/{proxyExports-BkN6hND0.js → proxyExports-ZRLty8oJ.js}

@@ -1,5 +1,5 @@
 import { b as setParentController, h as setAmbientChildController, d as retrieveParentControllers, e as bypassReadOnly } from "./ControllerInternals-CeDntN3G.js";
-import { t as trackKey } from "./Controller-Cer_6Z29.js";
+import { t as trackKey } from "./GenericController-C8NSb50b.js";
 const proxyExports = (Class) => (...args) => {
   const ambientControllers = retrieveParentControllers();
   const instance = new Class(...args);

package/dist/render.d.ts

@@ -1,11 +1,13 @@
-import { JsxNode } from './jsx/types.ts';
+import type { JsxNode } from "./jsx/types.js";
+
 /**
  * Retrieve an HTML element to be manually appended to an existing component.
  *
+ * @param element
  * @example
  * ```ts
  * const fullScreen = renderElement(<arcgis-fullscreen />);
  * document.body.appendChild(fullScreen);
  * ```
  */
-export declare const renderElement: <Element extends HTMLElement = HTMLElement>(element: JsxNode) => Element;
+export function renderElement<Element extends HTMLElement = HTMLElement>(element: JsxNode): Element;

package/dist/utils.d.ts

@@ -1,9 +1,9 @@
-import { LitElement } from './LitElement.ts';
-import { Runtime } from './makeRuntime.ts';
+import type { LitElement } from "./LitElement.js";
+import type { Runtime } from "./makeRuntime.js";
+
 /**
  * Add this static property to your component to disable shadow root.
  *
- * @remarks
  * Without shadow root, any styles added using the `styles` property will
  * be applied to the entire DOM that the component is attached to, not just to
  * the insides of this component.
@@ -12,22 +12,17 @@ import { Runtime } from './makeRuntime.ts';
  * ```ts
  *   static override shadowRootOptions = noShadowRoot;
  * ```
- *
- * @privateRemarks
- * This property is an empty object at runtime for bundle size reasons.
- * While empty object is not a valid shadowRootOption, it is never passed to
- * attachShadow() since we use this exact empty object as a magic value to opt
- * out of shadow root.
  */
-export declare const noShadowRoot: ShadowRootInit;
-export declare function emptyFunction(): undefined;
+export const noShadowRoot: ShadowRootInit;
+
 /**
  * Exposed as a dev-only util for use by Lumina's mount() test helper. We need
  * to expose a wrapper util because private properties are mangled and so cannot
  * be reliably accessed outside the package.
- * @private
+ *
+ * @internal
  */
-export declare const devOnly$getLitElementTagNameAndRuntime: ((componentClass: typeof LitElement) => {
+export const devOnly$getLitElementTagNameAndRuntime: ((componentClass: typeof LitElement) => {
     tagName: string | undefined;
     runtime: Runtime | undefined;
-}) | undefined;
+}) | undefined;

package/dist/wrappersUtils.d.ts

@@ -1,45 +1,44 @@
+/** @internal */
 export interface Options<I extends HTMLElement, E extends EventNames> {
-    react: any;
-    tagName: string;
-    elementClass: Constructor<I>;
-    events?: E;
-    displayName?: string;
+  /** @internal */
+  react: any;
+  /** @internal */
+  tagName: string;
+  /** @internal */
+  elementClass: new () => I;
+  /** @internal */
+  events?: E;
+  /** @internal */
+  displayName?: string;
 }
+
+/** @internal */
 export type EventNames = Record<string, string>;
-type Constructor<T> = new () => T;
+
 /**
  * Wrap `createComponent` from `@lit/react` to improve lazy loading
  * compatibility.
  *
- * @private
+ * @deprecated since 5.0. React wrappers are not needed in React 19 or above
+ * @param react
+ * @param createComponent
+ * @internal
  */
-export declare const makeReactWrapperFactory: (react: unknown, createComponent: (options: Options<HTMLElement, EventNames>) => unknown) => (options: Pick<Options<HTMLElement, EventNames>, "events" | "tagName">) => unknown;
+export function makeReactWrapperFactory(react: unknown, createComponent: (options: Options<HTMLElement, EventNames>) => unknown): ((options: Pick<Options<HTMLElement, EventNames>, "events" | "tagName">) => unknown);
+
 /**
  * Helper for `createComponent` to declare options in a type-safe and concise
  * manner.
  *
- * @remarks
  * Only tagName and events need to be provided to the wrapped version of the
  * `createComponent` function. However, since we inherit the typings from
  * the original `createComponent`, TypeScript would still force us to provide
  * `react` and `elementClass` properties - instead, this helper convinces
  * TypeScript that we are providing `react` and `elementClass` properties.
  *
- * @private
+ * @deprecated since 5.0. React wrappers are not needed in React 19 or above
+ * @param tagNameAndElement
+ * @param events
+ * @internal
  */
-export declare const getReactWrapperOptions: <Element extends HTMLElement, Events extends EventNames>(
-/**
- * We want "Events" type argument to be inferred, but Element type
- * argument to be explicitly specified. That isn't possible until
- * https://github.com/microsoft/TypeScript/issues/26242.
- *
- * As a workaround we are making Element inferred by passing Element type as
- * a tag name:
- * ```ts
- * getReactWrapperOptions("te-st" as HTMLTeStElement, {});
- * ```
- */
-tagNameAndElement: Element, events: Events) => Options<Element & {
-    class?: string;
-}, Events>;
-export {};
+export function getReactWrapperOptions<Element extends HTMLElement, Events extends EventNames>(tagNameAndElement: Element, events: Events): Options<Element & { class?: string; }, Events>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcgis/lumina",
-  "version": "5.2.0-next.2",
+  "version": "5.2.0-next.21",
   "description": "Runtime for WebGIS SDK web components",
   "sideEffects": false,
   "type": "module",
@@ -15,8 +15,11 @@
     "./globalTypes": {
       "types": "./dist/globalTypes/index.d.ts"
     },
-    "./typings": {
-      "types": "./dist/globalTypes/index.d.ts"
+    "./jsx/baseTypes": {
+      "types": "./dist/jsx/baseTypes.d.ts"
+    },
+    "./jsx/generatedTypes": {
+      "types": "./dist/jsx/generatedTypes.d.ts"
     },
     "./PublicLitElement": {
       "types": "./dist/PublicLitElement.d.ts"
@@ -32,7 +35,7 @@
   "dependencies": {
     "csstype": "^3.1.3",
     "tslib": "^2.8.1",
-    "@arcgis/toolkit": "~5.2.0-next.2"
+    "@arcgis/toolkit": "~5.2.0-next.21"
   },
   "peerDependencies": {
     "@lit/context": "^1.1.6",

package/dist/devOnlyDetectIncorrectLazyUsages.d.ts

@@ -1,14 +0,0 @@
-import { LitElement } from './LitElement.ts';
-/**
- * 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.
- *
- * In practice, this means using this.el.getAttribute() instead of
- * this.getAttribute() and etc for each DOM method.
- *
- * To detect incorrect usages, this function overwrites each DOM member on the
- * LitElement prototype with an exception-throwing function.
- *
- * This code does not ship in production builds.
- */
-export declare function devOnlyDetectIncorrectLazyUsages(LitClass: typeof LitElement): void;

package/dist/lifecycleSupport.d.ts

@@ -1,8 +0,0 @@
-import { ProxyComponent } from './lazyLoad.ts';
-/**
- * If there is a parent component, tell it to await it's loaded() until we
- * completed load().
- * Also, return a promise that will delay our load() until parent's load()
- * is completed.
- */
-export declare const attachToAncestor: (child: ProxyComponent["__offspringComponents"][number]) => Promise<void> | false;

package/dist/tests/wrappersUtils.typeTest.d.ts

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