extension-develop 3.18.4 → 3.18.5-canary.local-34c11c8f

package/dist/962.mjs

@@ -1,9 +1,10 @@
 import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
 import { createRequire } from "module";
 import { execFileSync, spawn, spawnSync as external_child_process_spawnSync } from "child_process";
+import { buildExecEnv, detectPackageManagerFromLockfile } from "prefers-yarn";
 import pintor from "pintor";
 import { EventEmitter } from "node:events";
-import { package_namespaceObject, buildSuccessWithWarnings, buildWarningsDetails, loadCommandConfig, needsInstall, getDirs, buildCommandFailed, sanitize, writingTypeDefinitions, buildWebpack, assertNoManagedDependencyConflicts, debugDirs, debugBrowser, normalizeBrowser, debugOutputPath, loadCustomConfig, buildSuccess, writingTypeDefinitionsError, getDistPath, getProjectStructure, loadBrowserConfig, authorInstallNotice, resolveCompanionExtensionsConfig, getSpecialFoldersDataForProjectRoot } from "./946.mjs";
+import { package_namespaceObject, buildSuccessWithWarnings, buildWarningsDetails, loadCommandConfig, needsInstall, getDirs, buildCommandFailed, sanitize, writingTypeDefinitions, buildWebpack, assertNoManagedDependencyConflicts, debugDirs, debugBrowser, normalizeBrowser, debugOutputPath, loadCustomConfig, buildSuccess, writingTypeDefinitionsError, getDistPath, loadBrowserConfig, getProjectStructure, authorInstallNotice, resolveCompanionExtensionsConfig, getSpecialFoldersDataForProjectRoot } from "./946.mjs";
 import { getCanonicalContentScriptEntryName } from "./526.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
@@ -247,15 +248,6 @@ function canRunCorepack() {
         return false;
     }
 }
-function detectByLockfile(cwd) {
-    if (!cwd) return;
-    const hasPnpmLock = __rspack_external_fs.existsSync(__rspack_external_path.join(cwd, 'pnpm-lock.yaml'));
-    const hasYarnLock = __rspack_external_fs.existsSync(__rspack_external_path.join(cwd, 'yarn.lock'));
-    const hasNpmLock = __rspack_external_fs.existsSync(__rspack_external_path.join(cwd, 'package-lock.json'));
-    if (hasPnpmLock) return 'pnpm';
-    if (hasYarnLock) return 'yarn';
-    if (hasNpmLock) return 'npm';
-}
 function hydrateResolvedPackageManager(name) {
     const resolvedCommand = resolveCommandOnPath(name);
     if (resolvedCommand) return {
@@ -275,7 +267,7 @@ function hydrateResolvedPackageManager(name) {
     }
 }
 function resolvePackageManager(opts) {
-    const lockPm = detectByLockfile(opts?.cwd);
+    const lockPm = detectPackageManagerFromLockfile(opts?.cwd);
     if (lockPm) {
         const hydrated = hydrateResolvedPackageManager(lockPm);
         if (hydrated) return hydrated;
@@ -320,18 +312,6 @@ function resolvePackageManager(opts) {
         name: 'npm'
     };
 }
-function buildExecEnv() {
-    if ('win32' !== process.platform) return;
-    const nodeDir = __rspack_external_path.dirname(process.execPath);
-    const pathSep = __rspack_external_path.delimiter;
-    const existing = process.env.PATH || process.env.Path || '';
-    if (existing.includes(nodeDir)) return;
-    return {
-        ...process.env,
-        PATH: `${nodeDir}${pathSep}${existing}`.trim(),
-        Path: `${nodeDir}${pathSep}${existing}`.trim()
-    };
-}
 function buildInstallCommand(pm, args) {
     if (pm.runnerCommand) return {
         command: pm.runnerCommand,
@@ -657,6 +637,25 @@ function getOptionalDependencyContract(contractId) {
     if (!contract) throw new Error(`Unknown optional dependency contract: ${contractId}`);
     return contract;
 }
+function isVerboseMode() {
+    return '1' === String(process.env.EXTENSION_VERBOSE || '').trim();
+}
+function installVerbForPackageManager(name) {
+    return 'npm' === name ? 'install -D' : 'add -D';
+}
+function formatInstallHint(projectPath, packageSpecs) {
+    const { name } = resolvePackageManager({
+        cwd: projectPath
+    });
+    const verb = installVerbForPackageManager(name);
+    return `${name} ${verb} ${packageSpecs.join(' ')}`;
+}
+function formatResolverError(args) {
+    const hint = formatInstallHint(args.projectPath, args.installSpecs);
+    const readableLine = `[${args.integration}] ${args.headline} Install it with: ${hint}`;
+    if (!isVerboseMode()) return readableLine;
+    return `${readableLine}\n${JSON.stringify(args.diagnostics, null, 2)}`;
+}
 function toInstallRootContract(integration, contractId, installDependencies, verifyPackageIds) {
     return {
         id: contractId,
@@ -831,10 +830,18 @@ async function ensureOptionalPackageResolved(input) {
         installDependencies: contract.installPackages,
         verifyPackageIds: contract.installPackages
     });
-    throw new Error(`[${input.integration}] ${input.dependencyId} could not be resolved.` + (missing.length > 0 ? ` Missing or invalid packages: ${missing.join(', ')}.` : '') + '\n' + JSON.stringify({
-        ...diagnostics,
-        missing
-    }, null, 2));
+    const headline = `${input.dependencyId} could not be resolved.` + (missing.length > 0 ? ` Missing or invalid packages: ${missing.join(', ')}.` : '');
+    throw new Error(formatResolverError({
+        integration: input.integration,
+        dependencyId: input.dependencyId,
+        headline,
+        installSpecs: missing.length > 0 ? missing : contract.installPackages,
+        projectPath: input.projectPath,
+        diagnostics: {
+            ...diagnostics,
+            missing
+        }
+    }));
 }
 function resolveOptionalPackageWithoutInstall(input) {
     const contract = getVerificationContract(input);
@@ -849,11 +856,18 @@ function resolveOptionalPackageWithoutInstall(input) {
         installDependencies: contract.installPackages,
         verifyPackageIds: contract.installPackages
     });
-    throw new Error(`[${input.integration}] ${input.dependencyId} could not be resolved from the project or extension-develop.\n` + JSON.stringify({
-        ...diagnostics,
-        missingPeerDeps,
-        expectation: 'Run optional dependency preflight or reinstall extension-develop.'
-    }, null, 2));
+    throw new Error(formatResolverError({
+        integration: input.integration,
+        dependencyId: input.dependencyId,
+        headline: `${input.dependencyId} could not be resolved from the project or extension-develop.`,
+        installSpecs: missingPeerDeps.length > 0 ? missingPeerDeps : contract.installPackages,
+        projectPath: input.projectPath,
+        diagnostics: {
+            ...diagnostics,
+            missingPeerDeps,
+            expectation: 'Run optional dependency preflight or reinstall extension-develop.'
+        }
+    }));
 }
 async function ensureOptionalModuleLoaded(input) {
     const resolvedPath = await ensureOptionalPackageResolved(input);
@@ -898,7 +912,16 @@ async function ensureOptionalModuleLoaded(input) {
             resolvedPath,
             loadError: lastLoadError instanceof Error ? lastLoadError.message : String(lastLoadError)
         };
-        throw new Error(`[${input.integration}] ${input.dependencyId} could not be loaded after it resolved.\n` + JSON.stringify(diagnostics, null, 2));
+        throw new Error(formatResolverError({
+            integration: input.integration,
+            dependencyId: input.dependencyId,
+            headline: `${input.dependencyId} could not be loaded after it resolved.`,
+            installSpecs: input.installDependencies || [
+                input.dependencyId
+            ],
+            projectPath: input.projectPath,
+            diagnostics
+        }));
     }
     return input.moduleAdapter ? input.moduleAdapter(loaded) : loaded;
 }
@@ -929,10 +952,19 @@ function loadOptionalModuleWithoutInstall(input) {
     } catch (directRequireError) {
         lastLoadError = directRequireError;
     }
-    if (!didLoad) throw new Error(`[${input.integration}] ${input.dependencyId} could not be loaded after resolving.\n` + JSON.stringify({
-        resolvedPath,
-        loadError: lastLoadError instanceof Error ? lastLoadError.message : String(lastLoadError)
-    }, null, 2));
+    if (!didLoad) throw new Error(formatResolverError({
+        integration: input.integration,
+        dependencyId: input.dependencyId,
+        headline: `${input.dependencyId} could not be loaded after resolving.`,
+        installSpecs: input.installDependencies || [
+            input.dependencyId
+        ],
+        projectPath: input.projectPath,
+        diagnostics: {
+            resolvedPath,
+            loadError: lastLoadError instanceof Error ? lastLoadError.message : String(lastLoadError)
+        }
+    }));
     return input.moduleAdapter ? input.moduleAdapter(loaded) : loaded;
 }
 async function optional_deps_resolver_ensureOptionalContractPackageResolved(input) {
@@ -1155,7 +1187,9 @@ async function extensionBuild(pathOrRemoteUrl, buildOptions) {
                     return reject(err);
                 }
                 if (!stats || 'function' != typeof stats.hasErrors) return reject(new Error('Build failed: bundler returned invalid stats output (no reliable compilation result).'));
-                if (!buildOptions?.silent && stats) console.log(buildWebpack(manifestDir, stats, browser));
+                if (!buildOptions?.silent && stats) try {
+                    console.log(buildWebpack(manifestDir, stats, browser));
+                } catch  {}
                 if (stats.hasErrors()) {
                     handleStatsErrors(stats);
                     if (!shouldExitOnError) return reject(new Error('Build failed with errors'));
@@ -1318,6 +1352,9 @@ class SafariDevPlugin {
     emitter = new BuildEmitter();
     extensionsToLoad = [];
     firstRun = true;
+    active = false;
+    pending = null;
+    idleWaiters = [];
     constructor(packager){
         this.packager = packager;
     }
@@ -1328,27 +1365,61 @@ class SafariDevPlugin {
             if (hasErrors) return void this.emitter.emit('error', {
                 errors: compilation.errors.map((e)=>'string' == typeof e ? e : e.message || String(e))
             });
-            const outputPath = String(compilation.options?.output?.path || '');
-            const contextDir = String(compilation.options?.context || '');
-            const wasFirstRun = this.firstRun;
-            try {
-                await this.packager(outputPath, wasFirstRun ? 'full' : 'resync');
-            } catch (error) {
-                this.emitter.emit('error', {
-                    errors: [
-                        error instanceof Error ? error.message : String(error)
-                    ]
-                });
+            const target = {
+                outputPath: String(compilation.options?.output?.path || ''),
+                contextDir: String(compilation.options?.context || '')
+            };
+            if (this.firstRun) return void await this.runOne(target, 'full');
+            if (this.active) {
+                this.pending = target;
                 return;
             }
-            this.firstRun = false;
-            this.emitter.emit('compiled', {
-                outputPath,
-                contextDir,
-                isFirstCompile: wasFirstRun
+            this.active = true;
+            this.drain(target);
+        });
+    }
+    idle() {
+        if (!this.active && !this.pending) return Promise.resolve();
+        return new Promise((resolve)=>this.idleWaiters.push(resolve));
+    }
+    async drain(target) {
+        try {
+            let next = target;
+            while(next){
+                await this.runOne(next, 'resync');
+                next = this.pending;
+                this.pending = null;
+            }
+        } finally{
+            this.active = false;
+            this.settleIdle();
+        }
+    }
+    async runOne(target, mode) {
+        const wasFirstRun = 'full' === mode;
+        try {
+            await this.packager(target.outputPath, mode);
+        } catch (error) {
+            this.emitter.emit('error', {
+                errors: [
+                    error instanceof Error ? error.message : String(error)
+                ]
             });
+            return;
+        }
+        if (wasFirstRun) this.firstRun = false;
+        this.emitter.emit('compiled', {
+            outputPath: target.outputPath,
+            contextDir: target.contextDir,
+            isFirstCompile: wasFirstRun
         });
     }
+    settleIdle() {
+        if (this.active || this.pending) return;
+        const waiters = this.idleWaiters;
+        this.idleWaiters = [];
+        for (const resolve of waiters)resolve();
+    }
 }
 async function extensionDev(pathOrRemoteUrl, devOptions) {
     let browsersPlugin;
@@ -1389,6 +1460,8 @@ async function extensionDev(pathOrRemoteUrl, devOptions) {
                     noOpen: merged.noOpen,
                     profile: merged.profile,
                     persistProfile: merged.persistProfile,
+                    keepProfileChanges: merged.keepProfileChanges,
+                    copyFromProfile: merged.copyFromProfile,
                     preferences: merged.preferences,
                     browserFlags: merged.browserFlags,
                     excludeBrowserFlags: merged.excludeBrowserFlags,