@elementspanel/panel 1.0.1 → 1.0.2

package/app.js

@@ -4204,9 +4204,9 @@ function recordFromPackage(pluginId, name, source, packageRoot, metadata, side)
 /**
  * Every npm plugin the runtime can load for a side, built-in and project-installed.
  *
- * Built-in mappings win over a project mapping for the same id: a third-party
- * package must not shadow a plugin that ships with the runtime. A project package
- * that does not describe the requested side is skipped instead of failing, which
+ * Built-in package names win over a project mapping for the same id. An explicit
+ * project dependency on that same package selects the user's installed version.
+ * A project package that does not describe the requested side is skipped instead of failing, which
  * is what lets a two-sided project share one dependency list between sides.
  */
 function listNpmPlugins(side, options = {}) {
@@ -4244,7 +4244,10 @@ function listNpmPlugins(side, options = {}) {
             continue;
         if (dependenciesOf(host)[name] === undefined)
             continue;
-        mappings.set(pluginId, { name, source: "bundled" });
+        mappings.set(pluginId, {
+            name,
+            source: dependenciesOf(project)[name] === undefined ? "bundled" : "project"
+        });
     }
     const hostDependencies = dependenciesOf(host);
     const projectDependencies = dependenciesOf(project);
@@ -4423,9 +4426,9 @@ async function installNpmPlugin(options) {
         if (!host)
             throw new Error(`Missing runtime package metadata: ${packageRoot}`);
         const hostId = (_a = Object.entries(mappingsOf(host)).find(([, value]) => value === name && dependenciesOf(host)[name] !== undefined)) === null || _a === void 0 ? void 0 : _a[0];
-        const targetRoot = hostId ? packageRoot : projectRoot;
-        if (hostId && isEssentialNpmPlugin(hostId))
-            throw new Error(`The essential plugin "${hostId}" cannot be replaced while running.`);
+        const targetRoot = hostId && dependenciesOf(readProjectManifest(projectRoot))[name] === undefined
+            ? packageRoot
+            : projectRoot;
         if (options.pluginId &&
             mappingsOf(host)[options.pluginId] &&
             dependenciesOf(host)[String(mappingsOf(host)[options.pluginId])] !== undefined &&
@@ -4472,7 +4475,7 @@ async function installNpmPlugin(options) {
             const mapped = mappingsOf(readProjectManifest(targetRoot))[pluginId];
             if (mapped !== undefined && mapped !== name)
                 throw new Error(`Plugin id ${pluginId} is already installed as ${String(mapped)}.`);
-            const record = recordFromPackage(pluginId, name, hostId ? "bundled" : "project", entry.root, entry.metadata, side);
+            const record = recordFromPackage(pluginId, name, targetRoot === packageRoot ? "bundled" : "project", entry.root, entry.metadata, side);
             if (!record)
                 throw new Error(`The package ${name} does not provide a ${side} plugin named ${pluginId}.`);
             if (/^[0-9]/.test(version) && record.version !== version)
@@ -4556,7 +4559,9 @@ async function uninstallNpmPlugin(pluginId, options = {}) {
         var _a, _b;
         const host = readJson(path_1.default.join(packageRoot, "package.json"));
         const bundledName = mappingsOf(host)[pluginId];
-        const targetRoot = typeof bundledName === "string" && dependenciesOf(host)[bundledName] !== undefined
+        const targetRoot = typeof bundledName === "string" &&
+            dependenciesOf(host)[bundledName] !== undefined &&
+            dependenciesOf(readProjectManifest(projectRoot))[bundledName] === undefined
             ? packageRoot
             : projectRoot;
         const manifest = readProjectManifest(targetRoot);
@@ -5584,7 +5589,7 @@ const ENTRY_CANDIDATES = [
 ];
 const FOUNDATION_PLUGIN_IDS = new Set(["i18n", "storage", "runtime"]);
 const ESSENTIAL_PLUGIN_IDS = new Set(["i18n", "storage", "runtime", "console"]);
-const RESTART_PLUGIN_IDS = new Set([...ESSENTIAL_PLUGIN_IDS, "server", "config"]);
+const RESTART_CONFIG_PLUGIN_IDS = new Set([...ESSENTIAL_PLUGIN_IDS, "server", "config"]);
 const loaded = [];
 const frontendManifestWarnings = new Set();
 function warnFrontendManifest(message, error) {
@@ -5667,13 +5672,6 @@ async function installPlugin(plugin) {
     try {
         record.backendRevision = backendRevision(plugin);
         (0, mcsmanager_common_1.validatePluginCompatibility)(plugin.manifest.elements);
-        const previousRevision = codeRevisions.get(plugin.manifest.id);
-        if (RESTART_PLUGIN_IDS.has(plugin.manifest.id) &&
-            previousRevision &&
-            previousRevision !== record.backendRevision) {
-            record.restartRequired = true;
-            return record;
-        }
         codeRevisions.set(plugin.manifest.id, record.backendRevision);
         const module = toModule(await (0, mcsmanager_common_1.loadPluginModule)(plugin.entry, plugin.packageRoot || plugin.directory, record.backendRevision), plugin.manifest.id);
         if (!module)
@@ -5759,27 +5757,67 @@ async function reconcilePlugins() {
         onWarning: (message, error) => logger.warn(message, error)
     });
     const next = new Map(discovered.map((plugin) => [plugin.manifest.id, plugin]));
-    for (const running of [...loaded].reverse()) {
+    const codeChanged = (running, plugin) => running.entry !== backendEntry(plugin) ||
+        running.manifest.version !== plugin.manifest.version ||
+        running.backendRevision !== backendRevision(plugin);
+    // Foundation services own state used throughout the graph. Dispose consumers
+    // before providers, then recreate every module before publishing new services.
+    // This also prevents Cordis from restarting consumers during async cleanup.
+    const reloadAll = loaded.some((running) => {
         const plugin = next.get(running.manifest.id);
-        const changed = plugin &&
-            (running.entry !== backendEntry(plugin) ||
-                running.manifest.version !== plugin.manifest.version ||
-                running.backendRevision !== backendRevision(plugin) ||
-                JSON.stringify(running.manifest.config) !== JSON.stringify(plugin.manifest.config));
-        if ((!plugin || changed) && !RESTART_PLUGIN_IDS.has(running.manifest.id)) {
-            await removeRunning(running.manifest.id);
+        return plugin && (0, mcsmanager_common_1.isEssentialNpmPlugin)(running.manifest.id) && codeChanged(running, plugin);
+    });
+    if (reloadAll) {
+        for (const running of loaded) {
+            if ((0, mcsmanager_common_1.isEssentialNpmPlugin)(running.manifest.id) && !next.has(running.manifest.id))
+                throw new Error(`Missing essential plugin during reload: ${running.manifest.id}`);
+        }
+        for (const plugin of discovered) {
+            if (!(0, mcsmanager_common_1.isEssentialNpmPlugin)(plugin.manifest.id))
+                continue;
+            (0, mcsmanager_common_1.validatePluginCompatibility)(plugin.manifest.elements);
+            if (!plugin.entry)
+                throw new Error(`Missing essential plugin entry: ${plugin.manifest.id}`);
+        }
+    }
+    // Publish listeners only after every route and authentication plugin is back.
+    const started = reloadAll && context_1.ctx.lifecycle.isActive;
+    if (reloadAll)
+        context_1.ctx.lifecycle.isActive = false;
+    try {
+        if (reloadAll)
+            await context_1.ctx.parallel("plugins/reloading");
+        const removed = [];
+        for (const running of [...loaded].reverse()) {
+            const plugin = next.get(running.manifest.id);
+            const changed = plugin &&
+                (codeChanged(running, plugin) ||
+                    JSON.stringify(running.manifest.config) !== JSON.stringify(plugin.manifest.config));
+            if (reloadAll ||
+                ((!plugin || changed) && !RESTART_CONFIG_PLUGIN_IDS.has(running.manifest.id))) {
+                await removeRunning(running.manifest.id);
+                removed.push(running);
+            }
+        }
+        for (const running of removed)
             forgetCachedModule(running.entry, running.packageRoot || running.directory);
+        // Evict the whole batch before importing anything: dependencies may be shared
+        // by several plugins, including the i18next instance used by the foundations.
+        const pending = discovered.filter((plugin) => !loaded.some((record) => record.manifest.id === plugin.manifest.id));
+        for (const plugin of pending)
+            forgetCachedModule(plugin.entry, plugin.packageRoot || plugin.directory);
+        for (const plugin of pending) {
+            loaded.push(await installPlugin(plugin));
+            await settle();
         }
+        (0, mcsmanager_common_1.sortPlugins)(loaded);
+        await settle();
+        return loaded;
     }
-    for (const plugin of discovered) {
-        if (loaded.some((record) => record.manifest.id === plugin.manifest.id))
-            continue;
-        forgetCachedModule(plugin.entry, plugin.packageRoot || plugin.directory);
-        loaded.push(await installPlugin(plugin));
+    finally {
+        if (started)
+            await context_1.ctx.start();
     }
-    (0, mcsmanager_common_1.sortPlugins)(loaded);
-    await settle();
-    return loaded;
 }
 /** Install or update an npm dependency, retaining the user's enablement on upgrades. */
 function installPanelNpmPlugin(options) {
@@ -6031,7 +6069,7 @@ function configurePanelPlugin(id, config) {
             (0, mcsmanager_common_1.validatePluginSettings)(plugin.manifest.configFields, config);
         (0, mcsmanager_common_1.writePluginOverride)(id, { config });
         // Core network/storage configuration is applied on restart; never tear down the reply path.
-        if (RESTART_PLUGIN_IDS.has(id)) {
+        if (RESTART_CONFIG_PLUGIN_IDS.has(id)) {
             return {
                 ...getPanelPluginInventory().find((item) => item.id === id),
                 result: { saved: true, application: "restart-required" }