@arcgis/lumina 4.33.0-next.124 → 4.33.0-next.126

package/dist/{utils-BdB9g3GU.js → lazyLoad-ByH-FaBP.js}

@@ -1,5 +1,5 @@
-import { Deferred, isEsriInternalEnv, camelToKebab } from "@arcgis/components-utils";
-import { lazyMetaSubItemJoiner, lazyMetaGroupJoiner, lazyMetaItemJoiner } from "./config.js";
+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");
@@ -67,19 +67,19 @@ function devOnlyDetectIncorrectLazyUsages(LitClass) {
     }
   });
 }
-function attachToAncestor(child) {
+const attachToAncestor = (child) => {
   let ancestor = child;
   while (ancestor = ancestor.parentNode ?? ancestor.host) {
     if (ancestor?.constructor?.lumina) {
       const litParent = ancestor;
       if (!litParent.manager?.loadedCalled) {
-        litParent._offspring.push(child);
+        (litParent.J ?? litParent["_offspring"]).push(child);
       }
-      return litParent._postLoad.promise;
+      return (litParent.I ?? litParent["_postLoad"]).promise;
     }
   }
   return false;
-}
+};
 if (process.env.NODE_ENV !== "production") {
   const litGlobalThis = globalThis;
   litGlobalThis.litIssuedWarnings ??= /* @__PURE__ */ new Set();
@@ -91,6 +91,13 @@ if (process.env.NODE_ENV !== "production") {
     "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."
   );
 }
+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;
@@ -100,248 +107,231 @@ const makeDefineCustomElements = (runtime, structure) => function defineCustomEl
   if (resourcesUrl) {
     runtime.setAssetPath(resourcesUrl);
   }
-  Object.entries(structure).forEach(createLazyElement);
-};
-function createLazyElement([tagName, [load, compactMeta = ""]]) {
-  if (customElements.get(tagName)) {
-    return;
-  }
-  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._properties = observedProperties;
+  for (const [tagName, [load, compactMeta = ""]] of Object.entries(structure)) {
+    if (customElements.get(tagName)) {
+      continue;
     }
-    static {
-      this._asyncMethods = compactAsyncMethods ? compactAsyncMethods?.split(lazyMetaItemJoiner) : void 0;
-    }
-    static {
-      this._syncMethods = compactSyncMethods?.split(lazyMetaItemJoiner);
-    }
-    static {
-      this._name = tagName;
-    }
-    constructor() {
-      const isFirstInstanceOfType = !ProxyClass._loadPromise;
-      if (isFirstInstanceOfType) {
-        ProxyClass._loadPromise = load();
-        ProxyClass._initializePrototype();
+    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;
       }
-      super();
+      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);
     }
-  };
-  customElements.define(tagName, ProxyClass);
-  if (process.env.NODE_ENV !== "production") {
-    globalThis.devOnly$ownTagNames?.add(tagName);
   }
-}
+};
 const defineProperty = Object.defineProperty;
-function parseCondensedProp(propAndAttribute) {
+const parseCondensedProp = (propAndAttribute) => {
   const name = propAndAttribute.split(lazyMetaSubItemJoiner);
   return name.length === 1 ? [name[0], camelToKebab(name[0])] : name;
-}
-const HtmlElement = globalThis.HTMLElement ?? parseCondensedProp;
+};
+const HtmlElement = globalThis.HTMLElement ?? emptyFunction;
 class ProxyComponent extends HtmlElement {
   constructor() {
     super();
-    this._store = {};
-    this._pendingAttributes = [];
-    this._postLoad = new Deferred();
-    this._postLoaded = new Deferred();
-    this._offspring = [];
+    this.#store = {};
+    this.#pendingAttributes = [];
+    this.I = new Deferred();
+    this.H = new Deferred();
+    this.J = [];
     if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
-      this._hmrSetProps = /* @__PURE__ */ new Set();
-      this._hmrSetAttributes = /* @__PURE__ */ new Set();
+      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;
+      };
     }
-    this._saveInstanceProperties();
-    const ProxyClass = this.constructor;
-    if (ProxyClass._LitConstructor) {
-      this._initializeComponent({ a: ProxyClass._LitConstructor });
+    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._loadPromise.then(awaitTopLevelPolyfill).then(this._initializeComponent.bind(this)).catch((error) => {
-        this._postLoaded.reject(error);
+      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._hmrInstances ??= [];
-      ProxyClass._hmrInstances.push(new WeakRef(this));
-      Object.defineProperty(this, "_store", { value: this._store, enumerable: false, configurable: true });
+      ProxyClass.devOnly$hmrInstances ??= [];
+      ProxyClass.devOnly$hmrInstances.push(new WeakRef(this));
     }
   }
   static {
     this.lumina = true;
   }
-  /** private */
-  static _initializePrototype() {
-    this._properties?.forEach(this._bindProp, this);
-    this._asyncMethods?.forEach(this._bindAsync, this);
-    this._syncMethods?.forEach(this._bindSync, this);
-  }
-  static _bindProp(propName) {
-    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._hmrSetProps.add(propName);
-        }
-      }
-    });
-  }
-  static _bindAsync(methodName) {
-    defineProperty(this.prototype, methodName, {
-      async value(...args) {
-        if (!this._litElement) {
-          await this._postLoaded.promise;
-        }
-        const genericLitElement = this._litElement;
-        return await genericLitElement[methodName](...args);
-      },
-      configurable: true
-    });
-  }
-  static _bindSync(methodName) {
-    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._name}> component before it's fully loaded. Please do 'await component.componentOnReady();' before calling this method.`
-          );
+  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);
+          }
         }
-        const genericLitElement = this._litElement;
-        return genericLitElement[methodName](...args);
-      },
-      configurable: true
-    });
+      });
+    }
+    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;
-  }
-  /**
-   * 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
-   */
-  _saveInstanceProperties() {
-    const ProxyClass = this.constructor;
-    const genericThis = this;
-    ProxyClass._properties?.forEach((propName) => {
-      if (Object.hasOwn(this, propName)) {
-        this._store[propName] = genericThis[propName];
-        delete genericThis[propName];
-      }
-    });
+    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);
+    this.#litElement?.attributeChangedCallback(name, oldValue, newValue);
+    if (!this.#litElement) {
+      this.#pendingAttributes.push(name);
     }
     if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
-      this._hmrSetAttributes.add(name);
+      this.devOnly$hmrSetAttributes.add(name);
     }
   }
   connectedCallback() {
-    if (this._litElement) {
-      this._litElement.connectedCallback?.();
+    if (this.#litElement) {
+      this.#litElement.connectedCallback?.();
     } else {
-      queueMicrotask(() => {
-        this._ancestorLoad = attachToAncestor(this);
-      });
+      queueMicrotask(() => this.G = attachToAncestor(this));
     }
   }
   disconnectedCallback() {
-    this._litElement?.disconnectedCallback?.();
+    this.#litElement?.disconnectedCallback?.();
   }
   /**
    * Create a promise that resolves once component is fully loaded
    */
   async componentOnReady() {
-    await this._postLoaded.promise;
+    await this.H.promise;
     return this;
   }
-  /** private */
-  _initializeComponent(module) {
+  #initializeComponent(module) {
     const ProxyClass = this.constructor;
-    const tagName = ProxyClass._name;
-    const store = this._store;
+    const tagName = ProxyClass.L;
+    const store = this.#store;
     const LitConstructor = Object.values(module).find(
-      (LitConstructor2) => LitConstructor2.tagName === tagName
+      (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._hmrIndex ?? 0) === 0 ? `${tagName}--lazy` : `${tagName}--lazy-${ProxyClass._hmrIndex}` : `${tagName}--lazy`;
+    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._LitConstructor;
+    const isFirstInitialization = !ProxyClass.A;
     if (isFirstInitialization) {
-      ProxyClass._LitConstructor = LitConstructor;
+      ProxyClass.A = LitConstructor;
       customElements.define(lazyTagName, LitConstructor);
     }
-    LitConstructor.lazy = this;
+    LitConstructor.N = this;
     const litElement = document.createElement(lazyTagName);
-    LitConstructor.lazy = void 0;
+    LitConstructor.N = void 0;
+    this.#litElement = litElement;
     if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
-      Object.defineProperty(this, "_litElement", { value: litElement, configurable: true, enumerable: false });
-    } else {
-      this._litElement = litElement;
+      Object.defineProperty(this, "$component", { value: litElement, configurable: true, enumerable: false });
     }
-    this._store = litElement;
-    this._pendingAttributes.forEach((name) => {
-      const value = this.getAttribute(name);
-      litElement.attributeChangedCallback(
+    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,
-        value
-      );
-    });
+        this.getAttribute(name)
+      )
+    );
     Object.entries(store).forEach(syncLitElement, litElement);
     if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
       const litObserved = LitConstructor.observedAttributes ?? [];
@@ -350,17 +340,17 @@ class ProxyComponent extends HtmlElement {
       const missingFromLit = lazyObserved.filter((attribute) => !litObserved.includes(attribute));
       if (missingFromLazy.length > 0) {
         console.warn(
-          `The following attributes on <${ProxyClass._name}> 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`
+          `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._name}> 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`
+          `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._ancestorLoad) {
+    if (isStillConnected || this.G) {
       litElement.connectedCallback?.();
       if (!isStillConnected) {
         litElement.disconnectedCallback();
@@ -376,13 +366,13 @@ class ProxyComponent extends HtmlElement {
    * Implemented on the proxy for compatibility with Lit Context.
    */
   requestUpdate() {
-    this._litElement?.requestUpdate();
+    this.#litElement?.requestUpdate();
   }
 }
 function syncLitElement([key, value]) {
   this[key] = value;
 }
-function patchLitElement(parentClass) {
+const patchLitElement = (parentClass) => {
   const litElementPrototype = parentClass.prototype;
   const elementPrototype = Element.prototype;
   const alreadyPatched = Object.hasOwn(litElementPrototype, "isConnected");
@@ -402,14 +392,12 @@ function patchLitElement(parentClass) {
   if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
     devOnlyDetectIncorrectLazyUsages(parentClass);
   }
-}
-const awaitTopLevelPolyfill = async (module) => await (module.default?.then(
-  (module2) => typeof module2 === "function" ? { a: module2 } : module2
-) ?? module);
-const noShadowRoot = {};
+};
 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;