@arcgis/lumina 4.32.0-next.7 → 4.32.0-next.71

package/dist/hmrSupport.js

@@ -0,0 +1,127 @@
+import {
+  ProxyComponent,
+  noShadowRoot
+} from "./chunk-J3BVM76V.js";
+import "./chunk-PGHUBTOM.js";
+
+// src/hmrSupport.ts
+import { camelToKebab } from "@arcgis/components-utils";
+function handleHmrUpdate(newModules) {
+  newModules.forEach((newModule) => {
+    if (newModule === void 0) {
+      return;
+    }
+    Object.values(newModule).forEach((exported) => {
+      if (typeof exported !== "function" || typeof exported.tagName !== "string") {
+        return;
+      }
+      const LitConstructor = exported;
+      const ProxyClass = customElements.get(LitConstructor.tagName);
+      if (ProxyClass === void 0) {
+        throw new Error(`Failed to find custom element proxy for tag name: ${LitConstructor.tagName}`);
+      }
+      ProxyClass._LitConstructor = void 0;
+      ProxyClass._loadPromise = void 0;
+      ProxyClass._hmrIndex ??= 0;
+      ProxyClass._hmrIndex += 1;
+      ProxyClass._initializePrototype();
+      ProxyClass._hmrInstances?.forEach((instanceWeakRef) => {
+        const instance = instanceWeakRef.deref();
+        if (instance === void 0) {
+          return;
+        }
+        if (instance._litElement === void 0) {
+          void ProxyClass._loadPromise.then(() => reInitialize(instance, newModule));
+        } else {
+          reInitialize(instance, newModule);
+        }
+      });
+      return;
+    });
+  });
+}
+function reInitialize(instance, newModule) {
+  const PreviousLitConstructor = instance._litElement.constructor;
+  const isShadowRoot = PreviousLitConstructor.shadowRootOptions !== noShadowRoot;
+  if (!isShadowRoot) {
+    const root = instance.getRootNode() ?? document;
+    if ("adoptedStyleSheets" in root) {
+      const rootStyles = Array.from(root.adoptedStyleSheets);
+      PreviousLitConstructor.elementStyles.forEach((style) => {
+        const styleSheet = "styleSheet" in style ? style.styleSheet : style;
+        const index = rootStyles.lastIndexOf(styleSheet);
+        if (index > -1) {
+          rootStyles.splice(index, 1);
+        }
+      });
+      root.adoptedStyleSheets = rootStyles;
+    }
+  }
+  const properties = PreviousLitConstructor.elementProperties;
+  const preservedProperties = Array.from(properties.entries()).filter(
+    ([propertyName, descriptor]) => typeof propertyName === "string" && (instance._hmrSetProps.has(propertyName) || typeof descriptor.attribute === "string" && instance._hmrSetAttributes.has(descriptor.attribute))
+  ).map(([key]) => [key, instance[key]]);
+  instance._store = Object.fromEntries(preservedProperties);
+  if (instance.isConnected) {
+    instance._litElement.disconnectedCallback();
+  }
+  const renderRoot = instance._litElement?.renderRoot;
+  if (renderRoot) {
+    renderRoot._$litPart$ = void 0;
+    while (renderRoot.firstChild) {
+      renderRoot.removeChild(renderRoot.firstChild);
+    }
+  }
+  instance._initializeComponent(newModule);
+}
+function handleComponentMetaUpdate(meta) {
+  const ProxyClass = customElements.get(meta.tagName);
+  if (ProxyClass === void 0) {
+    return;
+  }
+  const attributes = meta.properties.map(([property, attribute]) => attribute ?? camelToKebab(property)).filter(Boolean);
+  const observedAttributes = initializeAttributeObserver();
+  observedAttributes[meta.tagName] ??= {};
+  observedAttributes[meta.tagName].original ??= new Set(ProxyClass.observedAttributes);
+  const originallyObserved = observedAttributes[meta.tagName].original;
+  observedAttributes[meta.tagName].manuallyObserved = new Set(
+    /**
+     * Never manually observe attributes that were in the original
+     * observedAttributes as those would be observed by the browser
+     */
+    attributes.filter((attribute) => !originallyObserved.has(attribute))
+  );
+  ProxyClass._asyncMethods = meta.asyncMethods;
+  ProxyClass._syncMethods = meta.syncMethods;
+  ProxyClass._properties = meta.properties.map(([name]) => name);
+  ProxyClass.observedAttributes = attributes;
+}
+function initializeAttributeObserver() {
+  const observedAttributesSymbol = Symbol.for("@arcgis/lumina:observedAttributes");
+  const globalThisWithObservedAttributes = globalThis;
+  const alreadyHadObservers = observedAttributesSymbol in globalThisWithObservedAttributes;
+  globalThisWithObservedAttributes[observedAttributesSymbol] ??= {};
+  const observedAttributes = globalThisWithObservedAttributes[observedAttributesSymbol];
+  if (!alreadyHadObservers) {
+    const makeObserver = (original) => function observeAttributes(qualifiedName, ...rest) {
+      const observed = observedAttributes[this.tagName.toLowerCase()]?.manuallyObserved;
+      if (observed?.has(qualifiedName)) {
+        const oldValue = this.getAttribute(qualifiedName);
+        const returns = original.call(this, qualifiedName, ...rest);
+        const newValue = this.getAttribute(qualifiedName);
+        this.attributeChangedCallback(qualifiedName, oldValue, newValue);
+        return returns;
+      } else {
+        return original.call(this, qualifiedName, ...rest);
+      }
+    };
+    ProxyComponent.prototype.setAttribute = makeObserver(ProxyComponent.prototype.setAttribute);
+    ProxyComponent.prototype.toggleAttribute = makeObserver(ProxyComponent.prototype.toggleAttribute);
+    ProxyComponent.prototype.removeAttribute = makeObserver(ProxyComponent.prototype.removeAttribute);
+  }
+  return observedAttributes;
+}
+export {
+  handleComponentMetaUpdate,
+  handleHmrUpdate
+};

package/dist/index.d.ts

@@ -1,16 +1,16 @@
+export { useContextProvider, useContextConsumer } from "./context";
 export type { EventOptions } from "./createEvent";
 export { createEvent } from "./createEvent";
 export { state, property, method } from "./decorators";
-export type { HmrComponentMeta } from "./hmrSupport";
-export { handleComponentMetaUpdate, handleHmrUpdate } from "./hmrSupport";
 export type { DefineCustomElements, LazyLoadOptions, GlobalThisWithPuppeteerEnv } from "./lazyLoad";
 export { makeDefineCustomElements } from "./lazyLoad";
 export { LitElement } from "./LitElement";
 export type { PublicLitElement } from "./PublicLitElement";
 export type { Runtime, RuntimeOptions, DevOnlyGlobalRuntime, DevOnlyGlobalComponentRefCallback } from "./runtime";
 export { makeRuntime } from "./runtime";
-export * from "./jsx/jsx";
+export type { EventHandler } from "./jsx/baseTypes";
+export * from "./jsx/types";
 export { safeClassMap, safeStyleMap, directive, live } from "./jsx/directives";
 export { nothing, noChange, setAttribute, stringOrBoolean } from "./jsx/utils";
 export { noShadowRoot } from "./utils";
-export { createPrototypeProxy } from "./wrappersUtils";
+export { makeReactWrapperFactory, getReactWrapperOptions } from "./wrappersUtils";