extension-develop/dist/inject-chromium-client-loader.js

The develop step of Extension.js

"use strict";
var __webpack_require__ = {};
(()=>{
    __webpack_require__.d = (exports1, definition)=>{
        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
            enumerable: true,
            get: definition[key]
        });
    };
})();
(()=>{
    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
})();
(()=>{
    __webpack_require__.r = (exports1)=>{
        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
            value: 'Module'
        });
        Object.defineProperty(exports1, '__esModule', {
            value: true
        });
    };
})();
var __webpack_exports__ = {};
__webpack_require__.r(__webpack_exports__);
__webpack_require__.d(__webpack_exports__, {
    default: ()=>inject_chromium_client_loader
});
const external_path_namespaceObject = require("path");
const external_fs_namespaceObject = require("fs");
const external_loader_utils_namespaceObject = require("loader-utils");
const external_schema_utils_namespaceObject = require("schema-utils");
require("os");
require("crypto");
require("child_process");
require("package-manager-detector");
require("pintor");
external_path_namespaceObject.join(process.cwd(), 'node_modules/extension-develop/dist/certs');
const CHROMIUM_BASED_BROWSERS = [
    'chrome',
    'edge'
];
const GECKO_BASED_BROWSERS = [
    'firefox'
];
[
    ...CHROMIUM_BASED_BROWSERS,
    ...GECKO_BASED_BROWSERS
];
function filterKeysForThisBrowser(manifest, browser) {
    const patchedManifest = JSON.parse(JSON.stringify(manifest), function(key, value) {
        const indexOfColon = key.indexOf(':');
        if (-1 === indexOfColon) return value;
        const prefix = key.substring(0, indexOfColon);
        if (prefix === browser || 'chromium' === prefix && CHROMIUM_BASED_BROWSERS.includes(browser) || 'chromium' === prefix && browser.includes('chromium') || 'gecko' === prefix && browser.includes('gecko')) this[key.substring(indexOfColon + 1)] = value;
    });
    return patchedManifest;
}
const schema = {
    type: 'object',
    properties: {
        test: {
            type: 'string'
        },
        manifestPath: {
            type: 'string'
        }
    }
};
function inject_chromium_client_loader(source) {
    const options = this.getOptions();
    const manifestPath = options.manifestPath;
    const browser = options.browser;
    const projectPath = external_path_namespaceObject.dirname(manifestPath);
    const manifest = JSON.parse(external_fs_namespaceObject.readFileSync(manifestPath, 'utf-8'));
    const patchedManifest = filterKeysForThisBrowser(manifest, browser);
    (0, external_schema_utils_namespaceObject.validate)(schema, options, {
        name: 'reload:inject-background-client',
        baseDataPath: 'options'
    });
    const url = (0, external_loader_utils_namespaceObject.urlToRequest)(this.resourcePath);
    const generalReloadCode = `
  // Enhanced reload handler with cache-busting
  ;chrome.runtime.onMessageExternal.addListener(
    async (request, _sender, sendResponse) => {
      const managementInfo = await new Promise((resolve) => {
        chrome.management.getSelf(resolve);
      });
 
      // Ping-pong between the user extension background page(this)
      // and the middleware socket client (reloadService.ts),
      // which will then send a message to the server
      // (startServer.ts) so it can display the extension info.
      if (request.initialLoadData) {
        sendResponse({
          id: chrome.runtime.id,
          manifest: chrome.runtime.getManifest(),
          management: managementInfo,
        })
        return true
      }
  
      // Enhanced reload logic for critical files
      if (
        request.changedFile === 'declarative_net_request' ||
        request.changedFile === 'manifest.json' ||
        request.changedFile === 'service_worker' ||
        request.changedFile === '_locales'
      ) {
        // Force immediate reload with cache-busting
        try {
          // Clear any cached data
          if (chrome.storage && chrome.storage.local) {
            await chrome.storage.local.clear();
          }
          
          // Force reload with timestamp to bypass cache
          const timestamp = Date.now();
          console.log('\u{1F504} Forcing extension reload at:', timestamp);
          
          sendResponse({reloaded: true, timestamp: timestamp})
          chrome.runtime.reload()
        } catch (error) {
          console.error('\u{274C} Failed to reload extension:', error);
          sendResponse({error: error.message})
        }
      }

      return true
    }
  );
  
  // Additional cache-busting mechanism
  ;(function() {
    const cacheBuster = Date.now();
    console.log('Background script loaded with cache buster:', cacheBuster);
    
    // Force reload if this script is older than 1 second (optimized for faster manifest reloads)
    const scriptAge = Date.now() - cacheBuster;
    if (scriptAge > 1000) {
      console.log('Background script is stale, forcing reload');
      chrome.runtime.reload();
    }
  })();
  `;
    let manifestBg = patchedManifest.background;
    if ('firefox' !== browser) {
        manifestBg = manifest["chromium:background"] || manifest["chrome:background"] || manifest["edge:background"] || manifestBg;
        if (manifestBg) {
            const backgroundScripts = (null == manifestBg ? void 0 : manifestBg.scripts) || (null == manifestBg ? void 0 : manifestBg["chromium:scripts"]) || (null == manifestBg ? void 0 : manifestBg["chrome:scripts"]) || (null == manifestBg ? void 0 : manifestBg["edge:scripts"]);
            if (backgroundScripts) {
                if (2 === patchedManifest.manifest_version) for (const bgScript of [
                    backgroundScripts[0]
                ]){
                    const absoluteUrl = external_path_namespaceObject.resolve(projectPath, bgScript);
                    if (url.includes(absoluteUrl)) return `${generalReloadCode}${source}`;
                }
            }
            const serviceWorker = null == manifestBg ? void 0 : manifestBg.service_worker;
            if (serviceWorker) {
                if (3 === patchedManifest.manifest_version) {
                    const absoluteUrl = external_path_namespaceObject.resolve(projectPath, serviceWorker);
                    if (url.includes(absoluteUrl)) return `${generalReloadCode}${source}`;
                }
            }
        }
    }
    return source;
}
exports["default"] = __webpack_exports__["default"];
for(var __webpack_i__ in __webpack_exports__)if (-1 === [
    "default"
].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
Object.defineProperty(exports, '__esModule', {
    value: true
});