@arcgis/lumina 4.33.0-next.16 → 4.33.0-next.161

package/dist/makeRuntime.d.ts

@@ -0,0 +1,148 @@
+import { CSSResult } from 'lit';
+import { LitElement } from './LitElement';
+import { AccessorObservableLike, ReactiveTrackingTarget } from './controllers/types';
+/**
+ * `@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 it's 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.
+ */
+export declare const 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
+ *
+ * @private
+ */
+export type DevOnlyGlobalRuntime = typeof globalThis & {
+    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
+ */
+export type DevOnlyGlobalComponentRefCallback = typeof globalThis & {
+    devOnly$luminaComponentRefCallback?: (component: LitElement) => void;
+};

package/dist/proxyExports-Cdzj7WL_.js

@@ -0,0 +1,60 @@
+import { d as setParentController, e as retrieveParentControllers, o as setAmbientChildController, t as trackKey, h as bypassReadOnly } from "./Controller-BQOv8BAL.js";
+const proxyExports = (Class) => (...args) => {
+  const ambientControllers = retrieveParentControllers();
+  const instance = new Class(...args);
+  const initialExports = instance.exports;
+  setParentController(ambientControllers.at(-1));
+  const manager = instance.component.manager;
+  manager.W(instance, initialExports);
+  instance.watchExports(manager.W.bind(manager, instance));
+  setAmbientChildController(instance);
+  const hostCandidates = [instance.component, ...ambientControllers].reverse();
+  return trackKey(
+    hostCandidates,
+    (resolution) => resolution === void 0 ? void 0 : setProxy(instance, resolution, initialExports),
+    initialExports
+  );
+};
+const setProxy = (controller, { host, key, isReactive: assignedToProp }, initialExports) => {
+  const genericHost = host;
+  const controllerValueChanged = genericHost[key] !== controller.exports;
+  const hostValueChanged = genericHost[key] !== initialExports;
+  const controllerUpdatedExports = initialExports !== controller.exports;
+  if (controllerValueChanged && !hostValueChanged && controllerUpdatedExports) {
+    genericHost[key] = controller.exports;
+  }
+  const isProxyExportsOnComponent = host === controller.component;
+  if (isProxyExportsOnComponent) {
+    if (assignedToProp) {
+      const manager = controller.component.manager;
+      if (hostValueChanged) {
+        manager.W(controller, genericHost[key]);
+      }
+      controller.onUpdate((changes) => {
+        if (changes.has(key)) {
+          const value = genericHost[key];
+          if (value !== controller.exports) {
+            manager.W(controller, value);
+          }
+        }
+      });
+    }
+    controller.O = assignedToProp ? void 0 : key;
+  }
+  const isReadOnly = controller.component.constructor.elementProperties.get(key)?.readOnly;
+  controller.watchExports(() => {
+    if (genericHost[key] === controller.exports) {
+      return;
+    }
+    if (isReadOnly) {
+      bypassReadOnly(() => {
+        genericHost[key] = controller.exports;
+      });
+    } else {
+      genericHost[key] = controller.exports;
+    }
+  });
+};
+export {
+  proxyExports as p
+};

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 const renderElement: <Element extends HTMLElement = HTMLElement>(element: JsxNode) => Element;

package/dist/runtime.d.ts

@@ -1,109 +1,6 @@
-import type { CSSResult } from "lit";
-import type { LitElement } from "./LitElement";
+export declare const runtime: import('./makeRuntime').Runtime;
 /**
- * `@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.
+ * "customElement" needs to be exported - it will be used by the build system.
+ * You should not call it directly.
  */
-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;
-};
-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 it's 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.
- */
-export declare 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
- *
- * @private
- */
-export type DevOnlyGlobalRuntime = typeof globalThis & {
-    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
- */
-export type DevOnlyGlobalComponentRefCallback = typeof globalThis & {
-    devOnly$luminaComponentRefCallback?: (component: LitElement) => void;
-};
+export declare const customElement: (tagName: string, component: typeof import('./LitElement').LitElement) => void;

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/utils.d.ts

@@ -1,3 +1,5 @@
+import { LitElement } from './LitElement';
+import { Runtime } from './makeRuntime';
 /**
  * Add this static property to your component to disable shadow root.
  *
@@ -18,3 +20,9 @@ export declare const noShadowRoot: ShadowRootInit;
  * attachShadow() since we use this exact empty object as a magic value to opt
  * out of shadow root.
  */
+export declare function emptyFunction(): undefined;
+/** @private */
+export declare const devOnly$getLitElementTagNameAndRuntime: ((componentClass: typeof LitElement) => {
+    tagName: string;
+    runtime: Runtime;
+}) | undefined;

package/dist/wrappersUtils.d.ts

@@ -27,7 +27,19 @@ export declare const makeReactWrapperFactory: (react: unknown, createComponent:
  *
  * @private
  */
-export declare const getReactWrapperOptions: <Element extends HTMLElement, Events extends EventNames>(tagNameAndElement: Element, events: Events) => Options<Element & {
+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 {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcgis/lumina",
-  "version": "4.33.0-next.16",
+  "version": "4.33.0-next.161",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
@@ -13,6 +13,8 @@
     "./typings": {
       "types": "./dist/typings/index.d.ts"
     },
+    "./controllers": "./dist/controllers/index.js",
+    "./controllers/accessor": "./dist/controllers/accessor/index.js",
     "./package.json": "./package.json"
   },
   "files": [
@@ -20,13 +22,12 @@
   ],
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@arcgis/components-controllers": "4.33.0-next.16",
-    "@arcgis/components-utils": "4.33.0-next.16",
+    "@arcgis/components-utils": "4.33.0-next.161",
     "@lit-labs/ssr": "^3.2.2",
     "@lit-labs/ssr-client": "^1.1.7",
-    "@lit/context": "^1.1.3",
+    "@lit/context": "^1.1.5",
     "csstype": "^3.1.3",
-    "lit": "^3.2.0",
-    "tslib": "^2.7.0"
+    "lit": "^3.3.0",
+    "tslib": "^2.8.1"
   }
 }