@drip-apex/sdk 0.1.0 → 0.3.0

package/src/shadow.ts

@@ -0,0 +1,99 @@
+type ShadowHost = Element & { shadowRoot: ShadowRoot };
+
+const hosts = new Set<ShadowHost>();
+const rootObservers = new Map<ShadowRoot, MutationObserver>();
+const listeners = new Set<(records: MutationRecord[], root: ShadowRoot) => void>();
+let initialized = false;
+
+function registerSubtree(root: ParentNode): void {
+  const candidates: Element[] = [];
+  if (typeof Element === "function" && root instanceof Element) candidates.push(root);
+  root.querySelectorAll?.("*")?.forEach((element) => candidates.push(element));
+  for (const element of candidates) {
+    if (!element.shadowRoot) continue;
+    const host = element as ShadowHost;
+    if (!hosts.has(host)) {
+      hosts.add(host);
+      observeRoot(host.shadowRoot);
+    }
+    registerSubtree(host.shadowRoot);
+  }
+}
+
+function observeRoot(root: ShadowRoot): void {
+  if (typeof MutationObserver === "undefined" || rootObservers.has(root)) return;
+  const rootObserver = new MutationObserver((records) => {
+    for (const record of records) {
+      record.addedNodes.forEach((node) => {
+        if (typeof Element === "function" && node instanceof Element) registerSubtree(node);
+      });
+    }
+    listeners.forEach((listener) => listener(records, root));
+  });
+  rootObserver.observe(root, { attributes: true, characterData: true, childList: true, subtree: true });
+  rootObservers.set(root, rootObserver);
+}
+
+function pruneHosts(): void {
+  for (const host of hosts) {
+    if (!host.isConnected) {
+      rootObservers.get(host.shadowRoot)?.disconnect();
+      rootObservers.delete(host.shadowRoot);
+      hosts.delete(host);
+    }
+  }
+}
+
+function initializeShadowDomSupport(): void {
+  if (initialized || typeof document === "undefined") return;
+  initialized = true;
+  registerSubtree(document);
+  if (typeof MutationObserver === "undefined" || !document.documentElement) return;
+  const documentObserver = new MutationObserver((records) => {
+    pruneHosts();
+    for (const record of records) {
+      record.addedNodes.forEach((node) => {
+        if (typeof Element === "function" && node instanceof Element) registerSubtree(node);
+      });
+    }
+  });
+  documentObserver.observe(document.documentElement, { childList: true, subtree: true });
+}
+
+function hostsInDocumentOrder(): ShadowHost[] {
+  return Array.from(hosts).sort((a, b) => {
+    const position = a.compareDocumentPosition(b);
+    if (position & Node.DOCUMENT_POSITION_DISCONNECTED) return 0;
+    return position & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1;
+  });
+}
+
+export function queryAllDeep(selector: string): Element[] {
+  const documentMatches = Array.from(document.querySelectorAll(selector));
+  if (documentMatches.length > 0) return documentMatches;
+  initializeShadowDomSupport();
+  pruneHosts();
+  // Re-walk the document on every miss: attachShadow on an already-inserted
+  // element produces no mutation record, so the observers cannot see it.
+  registerSubtree(document);
+  if (hosts.size === 0) return documentMatches;
+
+  const matches: Element[] = [];
+  for (const host of hostsInDocumentOrder()) {
+    host.shadowRoot.querySelectorAll(selector).forEach((el) => matches.push(el));
+  }
+  return matches;
+}
+
+export function shadowRootFor(element: Element): ShadowRoot | null {
+  if (typeof element.getRootNode !== "function") return null;
+  const root = element.getRootNode();
+  return typeof ShadowRoot === "function" && root instanceof ShadowRoot ? root : null;
+}
+
+export function onShadowMutations(
+  listener: (records: MutationRecord[], root: ShadowRoot) => void,
+): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}