extension-develop 3.10.2 → 3.10.4-canary.1

package/dist/215.cjs

@@ -10,6 +10,7 @@ exports.modules = {
         var external_ws_ = __webpack_require__("ws");
         var external_ws_default = /*#__PURE__*/ __webpack_require__.n(external_ws_);
         var messages = __webpack_require__("./webpack/plugin-browsers/browsers-lib/messages.ts");
+        var discovery = __webpack_require__("./webpack/plugin-browsers/run-chromium/chromium-source-inspection/discovery.ts");
         async function getExtensionInfo(cdp, extensionId) {
             return await cdp.sendCommand('Extensions.getExtensionInfo', {
                 extensionId
@@ -34,28 +35,6 @@ exports.modules = {
                 return false;
             }
         }
-        var discovery = __webpack_require__("./webpack/plugin-browsers/run-chromium/chromium-source-inspection/discovery.ts");
-        function establishBrowserConnection(url, isDev, onMessage, onRejectPending) {
-            return new Promise((resolve, reject)=>{
-                const ws = new (external_ws_default())(url);
-                ws.on('open', ()=>{
-                    if (isDev) console.log(messages.F1E());
-                    resolve(ws);
-                });
-                ws.on('message', (data)=>{
-                    onMessage(data.toString());
-                });
-                ws.on('error', (error)=>{
-                    if (isDev) console.error(messages.fRy(error.message));
-                    onRejectPending(error.message);
-                    reject(error);
-                });
-                ws.on('close', ()=>{
-                    if (isDev) console.log(messages.hE8());
-                    onRejectPending('CDP connection closed');
-                });
-            });
-        }
         function mergeShadowIntoDocument(mainHTML, shadowContent) {
             try {
                 if (!mainHTML) return '';
@@ -68,12 +47,247 @@ exports.modules = {
                 }
                 const hostOpen = /(<[^>]*data-extension-root=(["'])true\2[^>]*>)/i;
                 if (hostOpen.test(mainHTML)) return mainHTML.replace(hostOpen, `$1<div id="extension-root">${shadowContent}</div>`);
-                if (/<\/body>/i.test(mainHTML)) return mainHTML.replace(/<\/body>/i, `<div id="extension-root">${shadowContent}</div></body>`);
-                return `${mainHTML}\n<div id="extension-root">${shadowContent}</div>`;
+                return mainHTML;
             } catch  {
                 return mainHTML;
             }
         }
+        const CONTENT_ROOT_SELECTOR = '#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])';
+        const NON_DEVTOOLS_CONTENT_ROOT_SELECTOR = '#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])';
+        const EXTENSION_ROOT_META_EXPRESSION = `(() => {
+          const readGeneration = (node) => {
+            try {
+              const raw = node && node.getAttribute
+                ? node.getAttribute('data-extjs-reinject-generation')
+                : '';
+              const parsed = Number(raw);
+              return Number.isFinite(parsed) ? parsed : undefined;
+            } catch (error) {
+              return undefined;
+            }
+          };
+          const normalize = (node) => ({
+            tag: node && node.tagName ? String(node.tagName).toLowerCase() : 'unknown',
+            id: node && node.id ? String(node.id) : undefined,
+            key: node && node.getAttribute ? node.getAttribute('data-extjs-reinject-key') || undefined : undefined,
+            generation: readGeneration(node),
+            status: node && node.getAttribute ? node.getAttribute('data-extjs-reinject-status') || undefined : undefined,
+            build: node && node.getAttribute ? node.getAttribute('data-extjs-reinject-build') || undefined : undefined,
+            hasShadowRoot: !!(node && node.shadowRoot),
+            hasShadowContent: !!(node && node.shadowRoot && String(node.shadowRoot.innerHTML || '').trim())
+          });
+          const registry = (typeof globalThis === 'object' && globalThis)
+            ? (globalThis.__EXTENSIONJS_DEV_REINJECT__ || {})
+            : {};
+          const registries = Object.entries(registry)
+            .slice(0, 10)
+            .map(([key, entry]) => {
+              const candidate = entry && typeof entry === 'object' ? entry : {};
+              const cleanup = candidate && typeof candidate.cleanup === 'function'
+                ? candidate.cleanup
+                : (typeof entry === 'function' ? entry : undefined);
+              return {
+                key,
+                generation: typeof candidate.generation === 'number'
+                  ? candidate.generation
+                  : (cleanup && typeof cleanup.__extjsGeneration === 'number'
+                    ? cleanup.__extjsGeneration
+                    : undefined),
+                hasCleanup: typeof cleanup === 'function',
+                build: typeof candidate.build === 'string'
+                  ? candidate.build
+                  : (cleanup && typeof cleanup.__extjsBuild === 'string'
+                    ? cleanup.__extjsBuild
+                    : undefined)
+              };
+            });
+          const pageCandidate = {
+            key: document.documentElement.getAttribute('data-extjs-last-reinject-key') || undefined,
+            generation: (() => {
+              const parsed = Number(document.documentElement.getAttribute('data-extjs-last-reinject-generation') || '');
+              return Number.isFinite(parsed) ? parsed : undefined;
+            })(),
+            status: document.documentElement.getAttribute('data-extjs-last-reinject-status') || undefined,
+            build: document.documentElement.getAttribute('data-extjs-last-reinject-build') || undefined
+          };
+          const roots = Array.from(
+            document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])')
+          )
+            .slice(0, 10)
+            .map(normalize)
+            .filter((entry) =>
+              entry.hasShadowRoot ||
+              entry.hasShadowContent ||
+              typeof entry.key === 'string' ||
+              typeof entry.generation === 'number' ||
+              typeof entry.status === 'string' ||
+              typeof entry.build === 'string'
+            )
+            .map(({hasShadowRoot, hasShadowContent, ...entry}) => entry);
+          const markers = Array.from(
+            document.querySelectorAll('[data-extjs-reinject-marker="true"]')
+          )
+            .slice(0, 10)
+            .map(normalize);
+          const pageHasBackingEvidence =
+            roots.length > 0 ||
+            markers.length > 0 ||
+            registries.some((entry) =>
+              entry.key === pageCandidate.key ||
+              typeof entry.generation === 'number' ||
+              !!entry.hasCleanup ||
+              typeof entry.build === 'string'
+            );
+          const page = pageHasBackingEvidence ? pageCandidate : undefined;
+          const generations = roots
+            .concat(markers)
+            .map((entry) => entry.generation)
+            .concat(typeof page.generation === 'number' ? [page.generation] : [])
+            .concat(
+              registries
+                .map((entry) => entry.generation)
+                .filter((value) => typeof value === 'number')
+            )
+            .filter((value) => typeof value === 'number');
+          return {
+            rootCount: roots.length,
+            markerCount: markers.length,
+            latestGeneration: generations.length ? Math.max(...generations) : 0,
+            roots,
+            markers,
+            registries,
+            page
+          };
+        })()`;
+        const SHADOW_STYLE_SNAPSHOT_EXPRESSION = `(() => {
+          try {
+            const hosts = Array.from(document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])'));
+            if (!hosts.length) return null;
+            for (const host of hosts) {
+              const sr = host && host.shadowRoot;
+              if (!sr) continue;
+              const styles = Array.from(sr.querySelectorAll('style')).map((styleEl) => {
+                const html = String(styleEl.outerHTML || '');
+                const text = String(styleEl.textContent || '');
+                return {
+                  html,
+                  textLength: text.length,
+                  textSnippet: text.trim().slice(0, 200)
+                };
+              });
+              return {
+                rootMode: 'shadow',
+                count: styles.length,
+                styles
+              };
+            }
+            return null;
+          } catch {
+            return null;
+          }
+        })()`;
+        const HAS_VISIBLE_SHADOW_HOST_EXPRESSION = `(() => { try {
+                const hosts = Array.from(document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])'));
+                if (!hosts.length) return false;
+                for (const h of hosts) {
+                  try {
+                    const sr = h && h.shadowRoot;
+                    if (sr && (String(sr.innerHTML||'').length > 0)) return true;
+                  } catch { /* ignore */ }
+                }
+                return false;
+              } catch { return false } })()`;
+        async function collectExecutionContexts(cdp, sessionId) {
+            const rawCdp = cdp;
+            if ('function' != typeof rawCdp.sendCommand || 'function' != typeof rawCdp.onProtocolEvent) return [];
+            const contextsById = new Map();
+            const unsubscribe = rawCdp.onProtocolEvent((message)=>{
+                if (String(message.sessionId || '') !== sessionId) return;
+                if ('Runtime.executionContextCreated' !== String(message.method || '')) return;
+                const context = message.params?.context;
+                const contextId = context?.id;
+                if ('number' == typeof contextId) contextsById.set(contextId, context);
+            });
+            try {
+                await rawCdp.sendCommand('Runtime.enable', {}, sessionId, 3000);
+                await new Promise((resolve)=>setTimeout(resolve, 100));
+            } catch  {
+                return [];
+            } finally{
+                unsubscribe();
+            }
+            return Array.from(contextsById.values());
+        }
+        async function getIsolatedContextId(cdp, sessionId) {
+            const contexts = await collectExecutionContexts(cdp, sessionId);
+            const preferredContext = contexts.find((context)=>{
+                const auxData = context?.auxData || {};
+                return 'isolated' === auxData.type && String(context?.origin || '').startsWith('chrome-extension://');
+            });
+            if ('number' == typeof preferredContext?.id) return preferredContext.id;
+            const fallbackContext = contexts.find((context)=>context?.auxData?.type === 'isolated');
+            return 'number' == typeof fallbackContext?.id ? fallbackContext.id : void 0;
+        }
+        async function evaluateWithContentContext(cdp, sessionId, expression, shouldAccept) {
+            let pageResult;
+            try {
+                pageResult = await cdp.evaluate(sessionId, expression);
+                if (shouldAccept(pageResult)) return pageResult;
+            } catch  {}
+            try {
+                const isolatedContextId = await getIsolatedContextId(cdp, sessionId);
+                if ('number' == typeof isolatedContextId) {
+                    const isolatedResult = await cdp.evaluateInContext(sessionId, expression, isolatedContextId);
+                    if (shouldAccept(isolatedResult)) return isolatedResult;
+                    if (void 0 !== pageResult) return pageResult;
+                    return isolatedResult;
+                }
+            } catch  {}
+            return pageResult;
+        }
+        function isExtensionRootMetaPayload(value) {
+            if (!value || 'object' != typeof value) return false;
+            const v = value;
+            return 'number' == typeof v.rootCount && 'number' == typeof v.markerCount && 'number' == typeof v.latestGeneration && Array.isArray(v.roots) && Array.isArray(v.markers) && Array.isArray(v.registries);
+        }
+        async function evaluateExtensionRootMeta(cdp, sessionId) {
+            try {
+                const payload = await evaluateWithContentContext(cdp, sessionId, EXTENSION_ROOT_META_EXPRESSION, isExtensionRootMetaPayload);
+                return payload;
+            } catch  {
+                return;
+            }
+        }
+        async function evaluateShadowStyleSnapshot(cdp, sessionId) {
+            try {
+                const payload = await evaluateWithContentContext(cdp, sessionId, SHADOW_STYLE_SNAPSHOT_EXPRESSION, (value)=>null === value || 'object' == typeof value && null !== value);
+                if (null == payload) return;
+                return payload;
+            } catch  {
+                return;
+            }
+        }
+        async function pollForVisibleShadowHostContent(cdp, sessionId, deadlineMs = 4000) {
+            const deadline = Date.now() + deadlineMs;
+            const started = Date.now();
+            while(Date.now() < deadline){
+                try {
+                    const hasRoot = await hasVisibleShadowHostContent(cdp, sessionId);
+                    if (hasRoot) return;
+                } catch  {}
+                const elapsed = Date.now() - started;
+                const delay = elapsed < 1000 ? 150 : 350;
+                await new Promise((r)=>setTimeout(r, delay));
+            }
+        }
+        async function hasVisibleShadowHostContent(cdp, sessionId) {
+            try {
+                const v = await evaluateWithContentContext(cdp, sessionId, HAS_VISIBLE_SHADOW_HOST_EXPRESSION, (value)=>true === value || false === value);
+                return true === v;
+            } catch  {
+                return false;
+            }
+        }
         async function getPageHTML(cdp, sessionId, includeShadow = 'open-only') {
             try {
                 await cdp.evaluate(sessionId, 'document.title');
@@ -98,40 +312,62 @@ exports.modules = {
       })()`);
             const mainHTML = 'string' == typeof mainHTMLRaw ? mainHTMLRaw : String(mainHTMLRaw || '');
             if ('off' === includeShadow) return mainHTML;
+            const hasVisibleContentRoot = await evaluateWithContentContext(cdp, sessionId, `(() => {
+      try {
+        return !!document.querySelector(${JSON.stringify(NON_DEVTOOLS_CONTENT_ROOT_SELECTOR)})
+      } catch {
+        return false
+      }
+    })()`, (value)=>'boolean' == typeof value);
+            if (!hasVisibleContentRoot) return mainHTML;
             try {
-                const mergedHtmlRaw = await cdp.evaluate(sessionId, `(() => { try { 
+                const mergedHtmlRaw = await evaluateWithContentContext(cdp, sessionId, `(() => { try { 
         var cloned = document.documentElement.cloneNode(true); 
-        var host = cloned.querySelector('#extension-root,[data-extension-root="true"]'); 
-        if (!host) { 
-          var body = cloned.querySelector('body') || cloned; 
-          var newRoot = document.createElement('div'); 
-          newRoot.id='extension-root'; 
-          body.appendChild(newRoot); 
-          host = newRoot; 
-        } 
+        var selector = ${JSON.stringify(NON_DEVTOOLS_CONTENT_ROOT_SELECTOR)};
         var s = new XMLSerializer(); 
-        var shadow = ''; 
         try { 
-          var liveHost = document.querySelector('[data-extension-root=\"true\"]') || document.getElementById('extension-root'); 
-          if (liveHost && liveHost.shadowRoot) { 
-            shadow = Array.from(liveHost.shadowRoot.childNodes).map(function(n){ 
+          var liveHosts = Array.from(document.querySelectorAll(selector));
+          if (!liveHosts.length) return '';
+          var clonedHosts = Array.from(cloned.querySelectorAll(selector));
+          if (clonedHosts.length < liveHosts.length) {
+            var cloneDoc = cloned.ownerDocument || document;
+            var cloneBody = cloned.querySelector('body') || cloned;
+            for (var missingIndex = clonedHosts.length; missingIndex < liveHosts.length; missingIndex++) {
+              var missingLiveHost = liveHosts[missingIndex];
+              if (!missingLiveHost || !missingLiveHost.tagName || !cloneBody || typeof cloneBody.appendChild !== 'function') continue;
+              var shell = cloneDoc.createElement(String(missingLiveHost.tagName || 'div').toLowerCase());
+              try {
+                Array.from(missingLiveHost.attributes || []).forEach(function(attr){
+                  try { shell.setAttribute(attr.name, attr.value); } catch(_) {}
+                });
+              } catch(_) {}
+              try { cloneBody.appendChild(shell); } catch(_) {}
+              clonedHosts.push(shell);
+            }
+          }
+          for (var index = 0; index < liveHosts.length; index++) {
+            var host = clonedHosts[index];
+            var liveHost = liveHosts[index];
+            if (!host || !liveHost || !liveHost.shadowRoot) continue;
+            var shadow = Array.from(liveHost.shadowRoot.childNodes).map(function(n){ 
               try { return s.serializeToString(n) } catch(e){ return '' } 
-            }).join(''); 
+            }).join('');
+            if (!shadow) continue;
+            try { host.innerHTML = shadow; } catch(e) {}
           } 
         } catch(e) {} 
-        try { host.innerHTML = shadow; } catch(e) {} 
         var doctype = document.doctype; 
         var dt = doctype ? '<!DOCTYPE ' + doctype.name + (doctype.publicId ? ' PUBLIC \"' + doctype.publicId + '\"' : '') + (doctype.systemId ? ' \"' + doctype.systemId + '\"' : '') + '>' : ''; 
         return String(dt + '\\n' + (cloned.outerHTML || document.documentElement.outerHTML)); 
-      } catch(e) { try { return String(document.documentElement.outerHTML); } catch(_) { return '' } } })()`);
+      } catch(e) { try { return String(document.documentElement.outerHTML); } catch(_) { return '' } } })()`, (value)=>'string' == typeof value && /<html[\s>]/i.test(value));
                 const mergedHtml = 'string' == typeof mergedHtmlRaw ? mergedHtmlRaw : String(mergedHtmlRaw || '');
                 if (mergedHtml && /<html[\s>]/i.test(mergedHtml)) return mergedHtml;
             } catch  {}
             let shadowContent = '';
             try {
-                shadowContent = await cdp.evaluate(sessionId, `(() => {
+                shadowContent = await evaluateWithContentContext(cdp, sessionId, `(() => {
           try {
-            const hosts = Array.from(document.querySelectorAll('[data-extension-root="true"]'));
+            const hosts = Array.from(document.querySelectorAll(${JSON.stringify(CONTENT_ROOT_SELECTOR)}));
             if (!hosts.length) return '';
             const preferMarkers = ['iskilar_box','content_script','content_title','js-probe'];
             let firstNonEmpty = '';
@@ -158,7 +394,7 @@ exports.modules = {
             }
             return firstNonEmpty || '';
           } catch { return '' }
-        })()`);
+        })()`, (value)=>'string' == typeof value && value.trim().length > 0);
             } catch  {}
             if (shadowContent) try {
                 const sc = 'string' == typeof shadowContent ? shadowContent : String(shadowContent || '');
@@ -199,8 +435,8 @@ exports.modules = {
             const started = Date.now();
             while(Date.now() < deadline){
                 try {
-                    const injected = await cdp.evaluate(sessionId, `(() => { try {
-          const hosts = Array.from(document.querySelectorAll('#extension-root,[data-extension-root="true"]'));
+                    const injected = await evaluateWithContentContext(cdp, sessionId, `(() => { try {
+          const hosts = Array.from(document.querySelectorAll(${JSON.stringify(CONTENT_ROOT_SELECTOR)}));
           if (!hosts.length) return false;
           const markers = ['iskilar_box','content_script','content_title','js-probe'];
           for (const h of hosts) {
@@ -218,13 +454,35 @@ exports.modules = {
             } catch { /* ignore */ }
           }
           return false;
-        } catch { return false } })()`);
-                    if (Boolean(injected)) return;
+        } catch { return false } })()`, (value)=>Boolean(value));
+                    if (Boolean(injected)) return true;
                 } catch  {}
                 const elapsed = Date.now() - started;
                 const delay = elapsed < 2000 ? 150 : 500;
                 await new Promise((r)=>setTimeout(r, delay));
             }
+            return false;
+        }
+        function establishBrowserConnection(url, isDev, onMessage, onRejectPending) {
+            return new Promise((resolve, reject)=>{
+                const ws = new (external_ws_default())(url);
+                ws.on('open', ()=>{
+                    if (isDev) console.log(messages.F1E());
+                    resolve(ws);
+                });
+                ws.on('message', (data)=>{
+                    onMessage(data.toString());
+                });
+                ws.on('error', (error)=>{
+                    if (isDev) console.error(messages.fRy(error.message));
+                    onRejectPending(error.message);
+                    reject(error);
+                });
+                ws.on('close', ()=>{
+                    if (isDev) console.log(messages.hE8());
+                    onRejectPending('CDP connection closed');
+                });
+            });
         }
         function _define_property(obj, key, value) {
             if (key in obj) Object.defineProperty(obj, key, {
@@ -274,8 +532,14 @@ exports.modules = {
                     this.ws = null;
                 }
             }
+            isConnected() {
+                return !!this.ws && this.ws.readyState === external_ws_default().OPEN;
+            }
             onProtocolEvent(handler) {
-                this.eventCallback = handler;
+                this.eventCallbacks.add(handler);
+                return ()=>{
+                    this.eventCallbacks.delete(handler);
+                };
             }
             handleMessage(data) {
                 try {
@@ -294,7 +558,7 @@ exports.modules = {
                         const params = message.params || {};
                         if (this.isDev()) console.log(messages.p8m(String(params.sessionId || ''), String(params.targetInfo?.type || '')));
                     }
-                    if (this.eventCallback) this.eventCallback(message);
+                    for (const eventCallback of this.eventCallbacks)eventCallback(message);
                 } catch (error) {
                     if (this.isDev()) {
                         const err = error;
@@ -382,10 +646,32 @@ exports.modules = {
             async waitForContentScriptInjection(sessionId) {
                 return waitForContentScriptInjection(this, sessionId);
             }
-            async evaluate(sessionId, expression) {
+            async getExtensionRootMeta(sessionId) {
+                return evaluateExtensionRootMeta(this, sessionId);
+            }
+            async getShadowStyleSnapshot(sessionId) {
+                return evaluateShadowStyleSnapshot(this, sessionId);
+            }
+            async pollForVisibleShadowHostContent(sessionId, deadlineMs) {
+                return pollForVisibleShadowHostContent(this, sessionId, deadlineMs);
+            }
+            async hasVisibleShadowHostContent(sessionId) {
+                return hasVisibleShadowHostContent(this, sessionId);
+            }
+            async evaluate(sessionId, expression, options) {
                 const response = await this.sendCommand('Runtime.evaluate', {
                     expression,
-                    returnByValue: true
+                    returnByValue: true,
+                    awaitPromise: options?.awaitPromise === true
+                }, sessionId);
+                return response.result?.value;
+            }
+            async evaluateInContext(sessionId, expression, contextId, options) {
+                const response = await this.sendCommand('Runtime.evaluate', {
+                    expression,
+                    contextId,
+                    returnByValue: true,
+                    awaitPromise: options?.awaitPromise === true
                 }, sessionId);
                 return response.result?.value;
             }
@@ -398,25 +684,20 @@ exports.modules = {
                 });
             }
             async forceReloadExtension(extensionId) {
-                try {
-                    await this.sendCommand('Extensions.reload', {
-                        extensionId,
-                        forceReload: true
-                    });
-                    return true;
-                } catch (error) {
-                    const attempts = 8;
-                    for(let i = 0; i < attempts; i++){
-                        try {
-                            const ok = await this.reloadExtensionViaTargetEval(extensionId);
-                            if (ok) return true;
-                        } catch  {}
-                        const backoffMs = Math.min(1200, 150 * (i + 1));
-                        await new Promise((r)=>setTimeout(r, backoffMs));
+                const attempts = 8;
+                let lastError = null;
+                for(let i = 0; i < attempts; i++){
+                    try {
+                        const ok = await this.reloadExtensionViaTargetEval(extensionId);
+                        if (ok) return true;
+                    } catch (error) {
+                        lastError = error;
                     }
-                    console.warn(messages.ccn(extensionId, error.message || String(error)));
-                    return false;
+                    const backoffMs = Math.min(1200, 150 * (i + 1));
+                    await new Promise((r)=>setTimeout(r, backoffMs));
                 }
+                console.warn(messages.ccn(extensionId, lastError?.message || String(lastError || 'runtime.reload failed')));
+                return false;
             }
             async getExtensionInfo(extensionId) {
                 try {
@@ -479,7 +760,7 @@ exports.modules = {
                 _define_property(this, "host", void 0);
                 _define_property(this, "ws", null);
                 _define_property(this, "targetWebSocketUrl", null);
-                _define_property(this, "eventCallback", void 0);
+                _define_property(this, "eventCallbacks", new Set());
                 _define_property(this, "messageId", 0);
                 _define_property(this, "pendingRequests", new Map());
                 this.port = port;