extension-develop/dist/inject-firefox-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_firefox_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_firefox_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-firefox-client',
        baseDataPath: 'options'
    });
    const url = (0, external_loader_utils_namespaceObject.urlToRequest)(this.resourcePath);
    const firefoxReloadCode = `
  // Firefox-specific reload handler
  ;browser.runtime.onMessageExternal.addListener(
    async (request, _sender, sendResponse) => {
      const managementInfo = await new Promise((resolve) => {
        browser.management.getSelf().then(resolve);
      });
 
      // Handle initial load data
      if (request.initialLoadData) {
        sendResponse({
          id: browser.runtime.id,
          manifest: browser.runtime.getManifest(),
          management: managementInfo,
        })
        return true
      }
  
      // Enhanced reload logic for critical files in Firefox
      if (
        request.changedFile === 'manifest.json' ||
        request.changedFile === 'service_worker' ||
        request.changedFile === '_locales'
      ) {
        console.log('Firefox: Reloading extension due to critical file change:', request.changedFile);
        
        try {
          // Firefox-specific cache clearing
          if (browser.storage && browser.storage.local) {
            await browser.storage.local.clear();
          }
          
          const timestamp = Date.now();
          console.log('Firefox: Forcing extension reload at:', timestamp);
          
          sendResponse({reloaded: true, timestamp: timestamp})
          browser.runtime.reload()
        } catch (error) {
          console.error('Firefox: Failed to reload extension:', error);
          sendResponse({error: error.message})
        }
      }

      return true
    }
  );
  
  // Firefox-specific cache-busting mechanism
  ;(function() {
    const cacheBuster = Date.now();
    console.log('Firefox 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('Firefox background script is stale, forcing reload');
      browser.runtime.reload();
    }
  })();
  `;
    let manifestBg = patchedManifest.background;
    if (manifestBg) {
        const backgroundScripts = null == manifestBg ? void 0 : manifestBg.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 `${firefoxReloadCode}${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 `${firefoxReloadCode}${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
});