@arcgis/lumina 4.33.0-next.99 → 4.34.0-next.1

package/dist/lazyLoad-DUvrNd2L.js

@@ -0,0 +1,406 @@
+import { isEsriInternalEnv, Deferred, camelToKebab } from "@arcgis/components-utils";
+import { lazyMetaGroupJoiner, lazyMetaItemJoiner, lazyMetaSubItemJoiner } from "./config.js";
+function devOnlyDetectIncorrectLazyUsages(LitClass) {
+  const genericPrototype = LitClass.prototype;
+  const descriptor = Object.getOwnPropertyDescriptor(genericPrototype, "innerText");
+  if (descriptor !== void 0 && descriptor.set?.name === "setWrapper") {
+    return;
+  }
+  const allowList = /* @__PURE__ */ new Set([
+    // We shouldn't be overwriting this property
+    "constructor",
+    // Called by Lit - we proxy it to this.el in ProxyComponent
+    "setAttribute",
+    // Called by Lit SSR - we proxy it to this.el in ProxyComponent
+    "removeAttribute",
+    // Called by Lit - we proxy it to this.el in ProxyComponent
+    "isConnected",
+    // Called by Lit, but only in dev mode for warnings, so we don't have to proxy.
+    "localName",
+    // Called by Lit Context - we proxy it to this.el in ProxyComponent.
+    // Interestingly, they never call removeEventListener.
+    "addEventListener"
+  ]);
+  const customErrorMessages = {
+    addEventListener: "use this.listen() or this.el.addEventListener()"
+  };
+  Object.entries({
+    ...Object.getOwnPropertyDescriptors(HTMLElement.prototype),
+    ...Object.getOwnPropertyDescriptors(Element.prototype),
+    ...Object.getOwnPropertyDescriptors(Node.prototype),
+    ...Object.getOwnPropertyDescriptors(EventTarget.prototype)
+  }).forEach(([key, value]) => {
+    if (allowList.has(key)) {
+      return;
+    }
+    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] = 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 {
+      throw new Error(`Unexpected value type for ${key}: ${value}`);
+    }
+  });
+}
+const attachToAncestor = (child) => {
+  let ancestor = child;
+  while (ancestor = ancestor.parentNode ?? ancestor.host) {
+    if (ancestor?.constructor?.lumina) {
+      const litParent = ancestor;
+      if (!litParent.manager?.loadedCalled) {
+        (litParent.J ?? litParent["_offspring"]).push(child);
+      }
+      return (litParent.I ?? litParent["_postLoad"]).promise;
+    }
+  }
+  return false;
+};
+if (process.env.NODE_ENV !== "production") {
+  const litGlobalThis = globalThis;
+  litGlobalThis.litIssuedWarnings ??= /* @__PURE__ */ new Set();
+  litGlobalThis.litIssuedWarnings.add("dev-mode");
+  litGlobalThis.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."
+  );
+  litGlobalThis.litIssuedWarnings.add(
+    "Overriding ReactiveElement.getPropertyDescriptor() is deprecated. The override will not be called with standard decorators See https://lit.dev/msg/no-override-get-property-descriptor for more information."
+  );
+  if (isEsriInternalEnv()) {
+    globalThis.calciteConfig ??= { version: " " };
+  }
+}
+const noShadowRoot = {};
+function emptyFunction() {
+}
+const devOnly$getLitElementTagNameAndRuntime = process.env.NODE_ENV !== "production" && isEsriInternalEnv() ? (componentClass) => ({
+  tagName: componentClass.L,
+  runtime: componentClass.K
+}) : void 0;
+const makeDefineCustomElements = (runtime, structure) => function defineCustomElements(windowOrOptions, options) {
+  if (!globalThis.customElements) {
+    return;
+  }
+  const resolvedOptions = options ?? windowOrOptions ?? {};
+  const resourcesUrl = resolvedOptions.resourcesUrl;
+  if (resourcesUrl) {
+    runtime.setAssetPath(resourcesUrl);
+  }
+  for (const [tagName, [load, compactMeta = ""]] of Object.entries(structure)) {
+    if (customElements.get(tagName)) {
+      continue;
+    }
+    const [compactObservedProps, compactAsyncMethods, compactSyncMethods] = compactMeta.split(lazyMetaGroupJoiner);
+    const observedProps = compactObservedProps ? compactObservedProps?.split(lazyMetaItemJoiner).map(parseCondensedProp) : void 0;
+    const observedProperties = observedProps?.map(([property]) => property);
+    const ProxyClass = class extends ProxyComponent {
+      static {
+        this.observedAttributes = observedProps?.map(([, attribute]) => attribute).filter((attribute) => attribute !== "");
+      }
+      static {
+        this.C = observedProperties;
+      }
+      static {
+        this.E = compactAsyncMethods ? compactAsyncMethods?.split(lazyMetaItemJoiner) : void 0;
+      }
+      static {
+        this.D = compactSyncMethods?.split(lazyMetaItemJoiner);
+      }
+      static {
+        this.L = tagName;
+      }
+      static {
+        this.K = runtime;
+      }
+      constructor() {
+        const isFirstInstanceOfType = !ProxyClass.B;
+        if (isFirstInstanceOfType) {
+          ProxyClass.B = load();
+          ProxyClass.F();
+        }
+        super();
+      }
+    };
+    customElements.define(tagName, ProxyClass);
+    if (process.env.NODE_ENV !== "production") {
+      globalThis.devOnly$ownTagNames?.add(tagName);
+    }
+  }
+};
+const defineProperty = Object.defineProperty;
+const parseCondensedProp = (propAndAttribute) => {
+  const name = propAndAttribute.split(lazyMetaSubItemJoiner);
+  return name.length === 1 ? [name[0], camelToKebab(name[0])] : name;
+};
+const HtmlElement = globalThis.HTMLElement ?? emptyFunction;
+class ProxyComponent extends HtmlElement {
+  constructor() {
+    super();
+    this.#store = {};
+    this.#pendingAttributes = [];
+    this.I = new Deferred();
+    this.H = new Deferred();
+    this.J = [];
+    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+      this.devOnly$hmrSetProps = /* @__PURE__ */ new Set();
+      this.devOnly$hmrSetAttributes = /* @__PURE__ */ new Set();
+      globalThis.devOnly$createdElements ??= [];
+      globalThis.devOnly$createdElements.push(new WeakRef(this));
+      this.devOnly$InitializeComponent = this.#initializeComponent.bind(this);
+      this.devOnly$hmrResetStore = (newStore) => {
+        this.#store = newStore;
+      };
+    }
+    const that = this;
+    const ProxyClass = that.constructor;
+    that["_offspring"] = that.J;
+    that["_postLoad"] = that.I;
+    ProxyClass.C?.forEach((propName) => {
+      if (Object.hasOwn(that, propName)) {
+        that.#store[propName] = that[propName];
+        delete that[propName];
+      }
+    });
+    if (ProxyClass.A) {
+      that.#initializeComponent({ a: ProxyClass.A });
+    } else {
+      void ProxyClass.B.then(async (module) => {
+        await ProxyClass.K.p;
+        that.#initializeComponent(
+          /**
+           * "$$" is our top-level await polyfill due to broken top-level await
+           * support in Safari. Only applies in CDN build.
+           * See https://devtopia.esri.com/WebGIS/arcgis-web-components/issues/3933
+           * and https://bugs.webkit.org/show_bug.cgi?id=242740
+           */
+          await (module.default?.then(
+            (module2) => typeof module2 === "function" ? { a: module2 } : module2
+          ) ?? module)
+        );
+      }).catch((error) => {
+        that.H.reject(error);
+        setTimeout(() => {
+          throw error;
+        });
+      });
+    }
+    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+      ProxyClass.devOnly$hmrInstances ??= [];
+      ProxyClass.devOnly$hmrInstances.push(new WeakRef(this));
+    }
+  }
+  static {
+    this.lumina = true;
+  }
+  static F() {
+    for (const propName of this.C ?? []) {
+      defineProperty(this.prototype, propName, {
+        configurable: true,
+        enumerable: true,
+        get() {
+          return this.#store[propName];
+        },
+        set(value) {
+          this.#store[propName] = value;
+          if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+            this.devOnly$hmrSetProps.add(propName);
+          }
+        }
+      });
+    }
+    for (const methodName of this.E ?? []) {
+      defineProperty(this.prototype, methodName, {
+        async value(...args) {
+          if (!this.#litElement) {
+            await this.H.promise;
+          }
+          const genericLitElement = this.#litElement;
+          return await genericLitElement[methodName](...args);
+        },
+        configurable: true
+      });
+    }
+    for (const methodName of this.D ?? []) {
+      defineProperty(this.prototype, methodName, {
+        value(...args) {
+          if (process.env.NODE_ENV !== "production" && !this.#litElement) {
+            const ProxyClass = this.constructor;
+            throw new Error(
+              `Tried to call method ${methodName}() on <${ProxyClass.L}> component before it's fully loaded. Please do 'await component.componentOnReady();' before calling this method.`
+            );
+          }
+          const genericLitElement = this.#litElement;
+          return genericLitElement[methodName](...args);
+        },
+        configurable: true
+      });
+    }
+  }
+  #litElement;
+  #store;
+  #pendingAttributes;
+  get manager() {
+    return this.#litElement?.manager;
+  }
+  /*
+   * This method must be statically present rather than added later, or else,
+   * browsers won't call it. Same for connected and disconnected callbacks.
+   */
+  attributeChangedCallback(name, oldValue, newValue) {
+    this.#litElement?.attributeChangedCallback(name, oldValue, newValue);
+    if (!this.#litElement) {
+      this.#pendingAttributes.push(name);
+    }
+    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+      this.devOnly$hmrSetAttributes.add(name);
+    }
+  }
+  connectedCallback() {
+    if (this.#litElement) {
+      this.#litElement.connectedCallback?.();
+    } else {
+      queueMicrotask(() => this.G = attachToAncestor(this));
+    }
+  }
+  disconnectedCallback() {
+    this.#litElement?.disconnectedCallback?.();
+  }
+  /**
+   * Create a promise that resolves once component is fully loaded
+   */
+  async componentOnReady() {
+    await this.H.promise;
+    return this;
+  }
+  #initializeComponent(module) {
+    const ProxyClass = this.constructor;
+    const tagName = ProxyClass.L;
+    const store = this.#store;
+    const LitConstructor = Object.values(module).find(
+      (LitConstructor2) => LitConstructor2.L === tagName
+    );
+    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && !LitConstructor) {
+      throw new Error(
+        `Unable to find the LitElement class for the "${tagName}" custom element in the lazy-loaded module`
+      );
+    }
+    const lazyTagName = process.env.NODE_ENV !== "production" && isEsriInternalEnv() ? (ProxyClass.devOnly$hmrIndex ?? 0) === 0 ? `${tagName}--lazy` : `${tagName}--lazy-${ProxyClass.devOnly$hmrIndex}` : `${tagName}--lazy`;
+    let parentClass = LitConstructor;
+    while (parentClass && !Object.hasOwn(parentClass, "lumina")) {
+      parentClass = Object.getPrototypeOf(parentClass);
+    }
+    patchLitElement(parentClass);
+    const isFirstInitialization = !ProxyClass.A;
+    if (isFirstInitialization) {
+      ProxyClass.A = LitConstructor;
+      customElements.define(lazyTagName, LitConstructor);
+    }
+    LitConstructor.N = this;
+    const litElement = document.createElement(lazyTagName);
+    LitConstructor.N = void 0;
+    this.#litElement = litElement;
+    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+      Object.defineProperty(this, "$component", { value: litElement, configurable: true, enumerable: false });
+    }
+    this.#store = litElement;
+    this.#pendingAttributes.forEach(
+      (name) => litElement.attributeChangedCallback(
+        name,
+        // Lit doesn't look at this value, thus even if attribute already exists, that's ok
+        null,
+        this.getAttribute(name)
+      )
+    );
+    Object.entries(store).forEach(syncLitElement, litElement);
+    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+      const litObserved = LitConstructor.observedAttributes ?? [];
+      const lazyObserved = ProxyClass.observedAttributes ?? [];
+      const missingFromLazy = litObserved.filter((attribute) => !lazyObserved.includes(attribute));
+      const missingFromLit = lazyObserved.filter((attribute) => !litObserved.includes(attribute));
+      if (missingFromLazy.length > 0) {
+        console.warn(
+          `The following attributes on <${ProxyClass.L}> are present on the Lit element, but are missing from the lazy proxy component: ${missingFromLazy.join(", ")}. This either indicates a bug in Lumina, or you are creating the attribute dynamically in a way that compiler cannot infer statically. For these attributes, lazy-loading version of your component won't work correctly, thus this must be resolved`
+        );
+      }
+      if (missingFromLit.length > 0) {
+        console.warn(
+          `The following attributes on <${ProxyClass.L}> are defined on the lazy proxy component, but not on the actual Lit element: ${missingFromLit.join(", ")}. This either indicates a bug in Lumina, or you are creating the attribute dynamically in a way that compiler cannot infer statically. This is a non-critical issue, but does indicate that something is going wrong and should be fixed`
+        );
+      }
+    }
+    const isStillConnected = this.isConnected;
+    if (isStillConnected || this.G) {
+      litElement.connectedCallback?.();
+      if (!isStillConnected) {
+        litElement.disconnectedCallback();
+      }
+    }
+  }
+  /**
+   * Implemented on the proxy for compatibility with Lit Context.
+   */
+  addController() {
+  }
+  /**
+   * Implemented on the proxy for compatibility with Lit Context.
+   */
+  requestUpdate() {
+    this.#litElement?.requestUpdate();
+  }
+}
+function syncLitElement([key, value]) {
+  this[key] = value;
+}
+const patchLitElement = (parentClass) => {
+  const litElementPrototype = parentClass.prototype;
+  const elementPrototype = Element.prototype;
+  const alreadyPatched = Object.hasOwn(litElementPrototype, "isConnected");
+  if (!alreadyPatched) {
+    litElementPrototype.setAttribute = function(qualifiedName, value) {
+      elementPrototype.setAttribute.call(this.el, qualifiedName, value);
+    };
+    litElementPrototype.removeAttribute = function(qualifiedName) {
+      elementPrototype.removeAttribute.call(this.el, qualifiedName);
+    };
+    defineProperty(litElementPrototype, "isConnected", {
+      get() {
+        return Reflect.get(elementPrototype, "isConnected", this.el);
+      }
+    });
+  }
+  if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+    devOnlyDetectIncorrectLazyUsages(parentClass);
+  }
+};
+export {
+  ProxyComponent as P,
+  attachToAncestor as a,
+  devOnly$getLitElementTagNameAndRuntime as d,
+  emptyFunction as e,
+  makeDefineCustomElements as m,
+  noShadowRoot as n
+};

package/dist/lazyLoad.d.ts

@@ -50,102 +50,59 @@ declare const HtmlElement: {
  * @private
  */
 export declare abstract class ProxyComponent extends HtmlElement {
+    #private;
     static observedAttributes?: readonly string[];
-    /** @private */
-    static _loadPromise: Promise<Record<string, typeof LitElement>> | undefined;
-    /** private */
-    static _LitConstructor?: typeof LitElement;
+    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.
-     *
-     * private
      */
-    static _hmrInstances: WeakRef<ProxyComponent>[] | undefined;
-    /** private */
-    static _hmrIndex: number | undefined;
-    /** private */
-    static _properties?: readonly string[];
-    /** private */
-    static _asyncMethods?: readonly string[];
-    /** private */
-    static _syncMethods?: readonly string[];
-    protected static _name: string;
+    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;
-    /** private */
-    static _initializePrototype(): void;
-    private static _bindProp;
-    private static _bindAsync;
-    private static _bindSync;
+    static _initializeProxyPrototype(): void;
     /**
      * On HMR, preserve the values of all properties that at least once were set
      * by someone other than component itself.
-     *
-     * private
      */
-    _hmrSetProps: Set<PropertyKey>;
-    /** private */
-    _hmrSetAttributes: Set<string>;
-    /** private */
-    _litElement: LitElement | undefined;
-    /** private */
-    _store: LitElement | Record<string, unknown>;
+    devOnly$hmrSetProps: Set<PropertyKey>;
+    devOnly$hmrSetAttributes: Set<string>;
+    devOnly$InitializeComponent?: (module: Record<string, typeof LitElement>) => void;
+    devOnly$hmrResetStore?: (newStore: Record<string, unknown>) => void;
     /**
-     * If attributeChangedCallback() is called before the LitElement is loaded,
-     * store the attributes here, and replay later
+     * This property is only set in development mode and exists only for usage in
+     * tests or during debugging
      */
-    private _pendingAttributes;
+    $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()
      */
-    _postLoad: Deferred<void>;
+    __postLoadDeferred: Deferred<void>;
     /**
      * Resolved once LitElement's loaded() is complete
      */
-    _postLoaded: Deferred<void>;
+    _postLoadedDeferred: Deferred<void>;
     /**
      * Direct offspring that should be awaited before loaded() is emitted
      */
-    _offspring: (CommonInterface & {
+    __offspringComponents: (CommonInterface & {
         manager?: LitElement["manager"];
     })[];
     /**
      * Promise that resolves once parent's load() completed. False if there is no
      * parent
      */
-    _ancestorLoad?: Promise<void> | false;
+    _ancestorLoadPromise?: Promise<void> | false;
     get manager(): ControllerManager | undefined;
     constructor();
-    /**
-     * Until the custom element is registered on the page, an instance of that
-     * element can be constructed and some properties on that instance set.
-     *
-     * These properties are set before the element prototype is set to this proxy
-     * class and thus none of our getters/setters are yet registered - such
-     * properties will be set by JavaScript on the instance directly.
-     *
-     * Once element is registered, the properties set in the meanwhile will shadow
-     * the getter/setters, and thus break reactivity. The fix is to delete these
-     * properties from the instance, and re-apply them once accessors are set.
-     *
-     * @example
-     * ```ts
-     * import { defineCustomElements } from '@arcgis/map-components';
-     * const map = document.createElement('arcgis-map');
-     * // This will shadow the getter/setters
-     * map.itemId = '...';
-     * // This finally defines the custom elements and sets the property accessors
-     * defineCustomElements();
-     * ```
-     *
-     * @remarks
-     * This is an equivalent of the __saveInstanceProperties method in Lit's
-     * ReactiveElement. Lit takes care of this on LitElement, but we have to take
-     * care of this on the lazy proxy
-     */
-    protected _saveInstanceProperties(): void;
     attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
     connectedCallback(): void;
     disconnectedCallback(): void;
@@ -153,8 +110,6 @@ export declare abstract class ProxyComponent extends HtmlElement {
      * Create a promise that resolves once component is fully loaded
      */
     componentOnReady(): Promise<this>;
-    /** private */
-    _initializeComponent(module: Record<string, typeof LitElement>): void;
     /**
      * Implemented on the proxy for compatibility with Lit Context.
      */

package/dist/lifecycleSupport.d.ts

@@ -5,4 +5,4 @@ import { ProxyComponent } from './lazyLoad';
  * Also, return a promise that will delay our load() until parent's load()
  * is completed.
  */
-export declare function attachToAncestor(child: ProxyComponent["_offspring"][number]): Promise<void> | false;
+export declare const attachToAncestor: (child: ProxyComponent["__offspringComponents"][number]) => Promise<void> | false;

package/dist/makeRuntime.d.ts

@@ -1,5 +1,6 @@
 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
@@ -53,6 +54,44 @@ export type Runtime = RuntimeOptions & {
      * ```
      */
     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 = {
     /**
@@ -88,7 +127,7 @@ export type RuntimeOptions = {
  * 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;
+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

package/dist/{proxyExports-CK5BLFLO.js → proxyExports-Cdzj7WL_.js}

@@ -1,12 +1,12 @@
-import { e as setParentController, f as retrieveParentControllers, u as setAmbientChildController, t as trackKey, l as bypassReadOnly } from "./Controller-CZ8Djohh.js";
+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._markExports(instance, initialExports);
-  instance.watchExports((exports) => manager._markExports(instance, exports));
+  manager.W(instance, initialExports);
+  instance.watchExports(manager.W.bind(manager, instance));
   setAmbientChildController(instance);
   const hostCandidates = [instance.component, ...ambientControllers].reverse();
   return trackKey(
@@ -15,7 +15,7 @@ const proxyExports = (Class) => (...args) => {
     initialExports
   );
 };
-function setProxy(controller, { host, key, isReactive: assignedToProp }, initialExports) {
+const setProxy = (controller, { host, key, isReactive: assignedToProp }, initialExports) => {
   const genericHost = host;
   const controllerValueChanged = genericHost[key] !== controller.exports;
   const hostValueChanged = genericHost[key] !== initialExports;
@@ -28,18 +28,18 @@ function setProxy(controller, { host, key, isReactive: assignedToProp }, initial
     if (assignedToProp) {
       const manager = controller.component.manager;
       if (hostValueChanged) {
-        manager._markExports(controller, genericHost[key]);
+        manager.W(controller, genericHost[key]);
       }
       controller.onUpdate((changes) => {
         if (changes.has(key)) {
           const value = genericHost[key];
           if (value !== controller.exports) {
-            manager._markExports(controller, value);
+            manager.W(controller, value);
           }
         }
       });
     }
-    controller.assignedProperty = assignedToProp ? void 0 : key;
+    controller.O = assignedToProp ? void 0 : key;
   }
   const isReadOnly = controller.component.constructor.elementProperties.get(key)?.readOnly;
   controller.watchExports(() => {
@@ -54,7 +54,7 @@ function setProxy(controller, { host, key, isReactive: assignedToProp }, initial
       genericHost[key] = controller.exports;
     }
   });
-}
+};
 export {
   proxyExports as p
 };

package/dist/render.d.ts

@@ -2,4 +2,4 @@ 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;
+export declare const renderElement: <Element extends HTMLElement = HTMLElement>(element: JsxNode) => Element;

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;