domma-cms 0.71.0 → 0.72.0

package/server/services/adminHome.js

@@ -0,0 +1,87 @@
+/**
+ * Admin home - the screen `#/` (Dashboard) opens.
+ *
+ * Every admin screen is a Tool, and "Dashboard" is simply whichever Tool home
+ * points at. Three sources, first answer wins:
+ *
+ *   1. A confined role's own home (roles.getAdminScope) - it is also the only
+ *      place a confined user may land.
+ *   2. The site's `adminHome` (config/site.json, System > Site Settings).
+ *   3. `/` - the built-in dashboard, or the plugin view that replaces it
+ *      (`views.dashboard`).
+ *
+ * The site's choice is skipped when the sidebar does not know that screen (a
+ * Tool whose plugin has been disabled) or the user lacks the permission guarding
+ * it (its sidebar entry's `permission`), so nobody lands on a dead end. The server stays the authority for data either way;
+ * this only decides where the admin opens.
+ */
+import {normaliseAdminPath} from './roles.js';
+
+/**
+ * True if `permissions` grants `resource` - the same test the sidebar uses
+ * (sidebar-renderer.js canAny), so home never opens what the sidebar hides.
+ */
+function holds(permissions, resource) {
+    if (!resource) return true;
+    const p = permissions || [];
+    return p.includes(resource) || ['read', 'create', 'update', 'delete'].some(a => p.includes(`${resource}.${a}`));
+}
+
+const trimUrl = (url) => (typeof url === 'string' ? url.replace(/\/+$/, '') || '#/' : '');
+
+/**
+ * The path, top down, to the first menu entry whose url is `url` - a Tool
+ * placeholder (`ref`) included, since it is where that Tool renders - or null.
+ */
+function pathTo(url, nodes, trail = []) {
+    for (const n of nodes || []) {
+        if (!n) continue;
+        if (trimUrl(n.url) === url) return [...trail, n];
+        const hit = pathTo(url, n.items, [...trail, n]);
+        if (hit) return hit;
+    }
+    return null;
+}
+
+/** True if the menu hides `text` the older way: a url-less, childless hidden item of that name. */
+function hiddenByName(text, nodes) {
+    const t = String(text || '').toLowerCase();
+    for (const n of nodes || []) {
+        if (!n) continue;
+        if (n.hidden && !n.url && !(n.items || []).length && String(n.text || '').toLowerCase() === t) return true;
+        if (hiddenByName(text, n.items)) return true;
+    }
+    return false;
+}
+
+/**
+ * @param {object} o
+ * @param {{home: string}|null} o.scope        the user's admin scope (confinement)
+ * @param {string[]}            o.permissions  what the user holds
+ * @param {unknown}             o.siteHome     site.json `adminHome`
+ * @param {object[]|Function}   [o.registered] registered sidebar items (their `.item`s), or a function returning them
+ * @param {object[]|Function}   [o.menuItems]  the admin-sidebar menu's items, or a function returning them
+ * @param {(visibility: unknown) => boolean} [o.canSee] the sidebar's visibility test for this user
+ * @returns {Promise<string>|string} an admin route path
+ */
+export async function resolveAdminHome({scope, permissions, siteHome, registered = [], menuItems = [], canSee = () => true}) {
+    if (scope?.home) return scope.home;
+    const home = normaliseAdminPath(siteHome);
+    if (!home || home === '/') return '/';
+    const url = `#${home}`;
+    const list = async (v) => (typeof v === 'function' ? await v() : v) || [];
+    // Only a screen the sidebar shows this user: an enabled Tool, or a page in
+    // the menu. Where the menu places it decides whether it is shown - a hidden
+    // entry, or a hidden or gated folder on the way to it, rules it out even
+    // for a registered Tool, exactly as the sidebar leaves it out.
+    const tool = (await list(registered)).find(i => i && !i.hidden && trimUrl(i.url) === url);
+    const items = await list(menuItems);
+    const path = pathTo(url, items);
+    if (!tool && (!path || path.at(-1).ref)) return '/';      // nothing enables it
+    if (tool && !path && hiddenByName(tool.text, items)) return '/';
+    const gates = [...(path || []), ...(tool ? [tool] : [])];
+    const open = gates.every(n => !n.hidden
+        && holds(permissions, n.permission)
+        && (n.visibility == null || canSee(n.visibility)));
+    return open ? home : '/';
+}

package/server/services/hooks.js

@@ -71,27 +71,51 @@ export async function registerMenuLocation(slot, def) {
 const _registeredSidebarItems = [];
 
 /**
- * Register a sidebar item from a plugin. Items are merged into the rendered
- * admin sidebar at render time - they are NOT persisted into menu JSON.
- * Plugins re-register on each server boot via their setupPlugin hook.
+ * Register a Tool's sidebar entry. Entries are placed into the rendered admin
+ * sidebar at render time - they are NOT persisted into menu JSON - so plugins
+ * re-register on each server boot.
  *
- * @param {{parent?: string, item: {text: string, url: string, icon?: string, permission?: string, items?: object[]}}} opts
+ * `folder` is the Tool's DEFAULT place: the `key` of an admin-sidebar folder
+ * (`'tools'`, `'content'`, `'data'`, `'system'`, ...). It defaults to `'tools'`,
+ * and an admin who moves the Tool in the menu overrides it - the renderer
+ * places by `url` first (see placeTools in admin/js/lib/sidebar-grouping.js).
+ * `parent` is the older form: any node matched by its text.
+ *
+ * @param {{folder?: string, parent?: string, item: {text: string, url: string, icon?: string, permission?: string, folder?: string, items?: object[]}}} opts
  */
 export function registerSidebarItem(opts) {
     if (!opts || !opts.item || typeof opts.item.text !== 'string') {
         throw new Error('registerSidebarItem: opts.item.text is required');
     }
+    const {folder: itemFolder, ...item} = opts.item;
     _registeredSidebarItems.push({
         parent: opts.parent || null,
-        item:   opts.item
+        folder: opts.folder || itemFolder || DEFAULT_TOOL_FOLDER,
+        item
     });
 }
 
+/** Where a Tool's sidebar entry goes when it names no folder. */
+export const DEFAULT_TOOL_FOLDER = 'tools';
+
+/** Sidebar URLs taken off the sidebar - a built-in Tool a plugin has taken over. */
+const _hiddenSidebarUrls = new Set();
+
+/**
+ * Leave the item with this URL out of the sidebar. For a core Tool whose entry
+ * is registered before the plugins load, so it cannot simply not be registered.
+ *
+ * @param {string} url - e.g. '#/contacts'
+ */
+export function hideSidebarUrl(url) {
+    _hiddenSidebarUrls.add(url);
+}
+
 /**
  * @returns {Array<{parent: string|null, item: object}>}
  */
 export function getRegisteredSidebarItems() {
-    return _registeredSidebarItems.slice();
+    return _registeredSidebarItems.filter(entry => !_hiddenSidebarUrls.has(entry?.item?.url));
 }
 
 // ---------------------------------------------------------------------------

package/server/services/menus.js

@@ -714,15 +714,22 @@ export function validateMenu(menu) {
                 return;
             }
 
-            if (!item.text || typeof item.text !== 'string') {
+            // A Tool placeholder (`ref`, admin-sidebar) takes its label from the
+            // Tool's registration unless the admin gave it one of its own.
+            if (item.ref === true && item.url && !item.text) {
+                // fine - the url is checked below like any leaf
+            } else if (!item.text || typeof item.text !== 'string') {
                 errors.push(`Item ${path}: text is required`);
             }
             // url is only required for LEAF items (no children). Folder items
             // - those with their own `items` array - are pure groupings and
             // don't need a navigation target. The admin sidebar uses this
             // shape extensively (Content / Data / System headings etc.).
+            // A keyed item is an admin-sidebar folder (see sidebar-migration.js)
+            // even while empty - the Tools folder is, until a Tool is enabled.
             const hasChildren = Array.isArray(item.items) && item.items.length > 0;
-            if (!hasChildren) {
+            const isKeyedFolder = typeof item.key === 'string' && item.key !== '' && !item.url;
+            if (!hasChildren && !isKeyedFolder) {
                 if (!item.url || typeof item.url !== 'string' || !URL_PREFIX_RE.test(item.url)) {
                     errors.push(`Item ${path}: url must start with /, #, http(s)://, or mailto:`);
                 }
@@ -1082,15 +1089,38 @@ export async function resolveOverlaysForPage(ctx = {}, user = null) {
         .sort((a, b) => String(a.slug).localeCompare(String(b.slug)));
 }
 
-export function filterItemsForUser(items, user) {
+/**
+ * The admin sidebar's stand-in for an item this user may not see: only its
+ * url (or folder key) and `hidden`, so Tool placement still knows the admin put
+ * a Tool there - it must not fall back into Tools for exactly the users it was
+ * restricted from - while the label never reaches them.
+ */
+function restrictedStub(item) {
+    const children = Array.isArray(item.items) ? item.items.map(restrictedStub).filter(Boolean) : [];
+    if (!item.url && !item.key && !children.length) return null;
+    return {
+        ...(item.url && {url: item.url}),
+        ...(item.key && {key: item.key}),
+        hidden: true,
+        // Marks a role gate, as opposed to an admin's hide, for ensureLockedTools.
+        restricted: true,
+        ...(children.length && {items: children})
+    };
+}
+
+export function filterItemsForUser(items, user, {keepHidden = false} = {}) {
     const out = [];
     for (const item of items) {
-        if (item.hidden) continue;
+        if (item.hidden && !keepHidden) continue;
         if (item.visibility != null) {
-            if (!checkVisibility(user, item.visibility)) continue;
+            if (!checkVisibility(user, item.visibility)) {
+                const stub = keepHidden ? restrictedStub(item) : null;
+                if (stub) out.push(stub);
+                continue;
+            }
         }
         const children = Array.isArray(item.items)
-            ? filterItemsForUser(item.items, user)
+            ? filterItemsForUser(item.items, user, {keepHidden})
             : [];
         out.push({...item, items: children});
     }

package/server/services/plugins.js

@@ -20,6 +20,7 @@ import {
     registerMenuLocation,
     registerSanitizeRules,
     registerShortcode,
+    hideSidebarUrl,
     registerSidebarItem,
     registerTransform
 } from './hooks.js';
@@ -138,6 +139,49 @@ const CORE_PLUGINS = new Set([]);
 /** Is this plugin a built-in feature rather than an optional add-on? */
 export function isCorePlugin(name) { return CORE_PLUGINS.has(name); }
 
+/**
+ * The Tools promoted out of plugins/ in 0.67.0 - core code now, each with its
+ * own `#/<name>` screen and sidebar entry (server/server.js).
+ *
+ * Not plugins, so `supersedes` could never reach them the way it reaches the
+ * free Blog. A plugin that names one in `supersedes` TAKES IT OVER instead:
+ * the core Tool's sidebar entry is hidden and its screen hands over to the
+ * plugin's first admin route. The core Tool's API stays up - other plugins
+ * (Invoices reads contacts) depend on it, and the paid edition works over the
+ * same data - and, like supersession, nothing is written down: a lapsed
+ * licence means the plugin does not load and the core Tool is simply back.
+ */
+export const BUILT_IN_TOOLS = new Set(['notes', 'todo', 'analytics', 'contacts']);
+
+/** Built-in Tool → {plugin, route}, for the plugins that loaded this boot. */
+const _toolTakeovers = {};
+
+/**
+ * Which built-in Tools a loaded plugin has taken over.
+ *
+ * @returns {Object.<string, {plugin: string, route: string|null}>}
+ */
+export function getToolTakeovers() {
+    return {..._toolTakeovers};
+}
+
+/**
+ * The takeovers one manifest claims: every built-in Tool in its `supersedes`
+ * that no earlier plugin has claimed. Pure, for the test.
+ *
+ * @param   {object} manifest
+ * @param   {object} [taken] - claims already made
+ * @returns {Object.<string, {plugin: string, route: string|null}>}
+ */
+export function toolTakeoversOf(manifest, taken = {}) {
+    const out = {};
+    const route = manifest?.admin?.routes?.[0]?.path ?? null;
+    for (const tool of Array.isArray(manifest?.supersedes) ? manifest.supersedes : []) {
+        if (BUILT_IN_TOOLS.has(tool) && !taken[tool] && !out[tool]) out[tool] = {plugin: manifest.name, route};
+    }
+    return out;
+}
+
 /**
  * Scan the plugins/ directory and return all valid manifests.
  * Validates mandatory fields and required files (plugin.js, config.js).
@@ -417,23 +461,34 @@ export async function registerPlugins(fastify) {
           await fastify.register(plugin, {
             prefix,
             auth: {authenticate, requireRole, requireAdmin, requireVisibility, requirePermission},
-              hooks: {registerShortcode, registerSanitizeRules, registerTransform, registerMenuLocation, registerSidebarItem, on: hooks.on.bind(hooks), ...pluginRoleHooks(manifest.name)},
+              hooks: {registerShortcode, registerSanitizeRules, registerTransform, registerMenuLocation,
+                  // Stamped with the plugin's name, so the Menus editor can say where a Tool came from.
+                  registerSidebarItem: (opts) => registerSidebarItem({...opts, item: {source: manifest.displayName || manifest.name, ...opts?.item}}),
+                  on: hooks.on.bind(hooks), ...pluginRoleHooks(manifest.name)},
               settings,
               config: {}
           });
             loaded.push(manifest.name);
 
+            // A built-in Tool this plugin replaces: hide the core sidebar entry
+            // (the admin sends its screen to the plugin - getAdminPluginConfig).
+            for (const [tool, claim] of Object.entries(toolTakeoversOf(manifest, _toolTakeovers))) {
+                _toolTakeovers[tool] = claim;
+                hideSidebarUrl(`#/${tool}`);
+                fastify.log.info(`[plugins] built-in Tool "${tool}" taken over by "${manifest.name}".`);
+            }
+
             // Bridge plugin.json `admin.sidebar` entries into the sidebar
             // registry so they render in the admin sidebar. The admin renderer
             // reads plugin nav from /api/sidebar/registered-items; plugins
             // declare their nav in the manifest rather than calling
-            // registerSidebarItem, so register it here on their behalf.
-            // Tag each item with the plugin's core status so the admin sidebar
-            // can auto-group it: core plugins → Tools folder, optional → Plugins.
+            // registerSidebarItem, so register it here on their behalf. An
+            // entry's `folder` is its default place (Tools when it names none);
+            // an admin can move it anywhere in the menu.
             const isCore = CORE_PLUGINS.has(manifest.name);
             for (const item of manifest.admin?.sidebar || []) {
                 try {
-                    registerSidebarItem({item: {...item, core: isCore}});
+                    registerSidebarItem({item: {source: manifest.displayName || manifest.name, ...item, core: isCore}});
                 } catch (err) {
                     fastify.log.warn(`[plugins] sidebar item for "${manifest.name}" skipped: ${err.message}`);
                 }
@@ -1113,6 +1168,33 @@ export function pluginExpiry(manifest, given) {
         : null;
 }
 
+
+/**
+ * The sidebar name of the screen a view draws, for its banner - '' when the
+ * plugin has one screen or the view has no sidebar entry of its own.
+ *
+ * A route maps a path to a view and a sidebar entry links to a path, so the
+ * entry whose link is one of the view's routes names it. Sub-entries win over
+ * the top-level one: Site Manager's top entry and its "Sites" entry share a
+ * link, and "Sites" is the screen.
+ *
+ * @param   {object} manifest
+ * @param   {string} viewName
+ * @returns {string}
+ */
+export function viewSection(manifest, viewName) {
+    const admin = manifest.admin || {};
+    const paths = new Set((admin.routes || [])
+        .filter(r => r && r.view === viewName && typeof r.path === 'string')
+        .map(r => `#${r.path}`));
+    if (!paths.size) return '';
+    const top = admin.sidebar || [];
+    const entries = [...top.flatMap(e => (e && e.items) || []), ...top];
+    const hit = entries.find(e => e && paths.has(e.url));
+    const text = hit ? String(hit.text || '').trim() : '';
+    return text && text !== (manifest.displayName || manifest.name) ? text : '';
+}
+
 export async function getAdminPluginConfig() {
     const manifests = await discoverPlugins();
     const states = getPluginStates();
@@ -1160,6 +1242,7 @@ export async function getAdminPluginConfig() {
             meta[viewName] = {
                 plugin:      manifest.name,
                 displayName: manifest.displayName || manifest.name,
+                section:     viewSection(manifest, viewName),
                 version:     manifest.version || '1.0.0',
                 date:        manifest.date || '',
                 author:      manifest.author || '',
@@ -1189,5 +1272,5 @@ export async function getAdminPluginConfig() {
         }
     }
 
-    return { sidebar, routes, views, css, meta };
+    return { sidebar, routes, views, css, meta, takeovers: getToolTakeovers() };
 }

package/server/services/roles.js

@@ -337,11 +337,22 @@ const ADMIN_PATH_RE = /^\/[A-Za-z0-9\-_/]*$/;
  * @param {*} raw
  * @returns {{home: string, allow: string[]}|null}
  */
-export function normaliseAdminScope(raw) {
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
-    const clean = p => (typeof p === 'string' && ADMIN_PATH_RE.test(p.trim()))
+/**
+ * An admin route path (`/portal`, `/plugins/x/dashboard`), cleaned - or null if
+ * it is not one. Trailing slashes go; the root stays `/`.
+ *
+ * @param {unknown} p
+ * @returns {string|null}
+ */
+export function normaliseAdminPath(p) {
+    return (typeof p === 'string' && ADMIN_PATH_RE.test(p.trim()))
         ? (p.trim().replace(/\/+$/, '') || '/')
         : null;
+}
+
+export function normaliseAdminScope(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+    const clean = normaliseAdminPath;
     const allow = [...new Set((Array.isArray(raw.allow) ? raw.allow : []).map(clean).filter(Boolean))];
     const home  = clean(raw.home) || allow[0] || null;
     if (!home) return null;

package/server/services/sidebar-migration.js

@@ -3,8 +3,13 @@
  *
  * Runs once on server boot. Idempotent - guarded by the existence of
  * config/menus/admin-sidebar.json. Seeds the admin sidebar menu with the
- * standard tree (Overview, Projects, Content, Data, System, Documentation)
- * and patches config/menu-locations.json to map the `admin-sidebar` slot.
+ * standard tree (Overview, Projects, Content, Data, Tools, System,
+ * Documentation) and patches config/menu-locations.json to map the
+ * `admin-sidebar` slot.
+ *
+ * Top-level folders carry a stable `key`. A Tool names its default folder by
+ * key, so an admin can rename a folder without the Tools that live in it
+ * falling out of it. ensureFolderKeys() brings menus seeded before keys up.
  */
 import fs from 'fs/promises';
 import path from 'path';
@@ -16,19 +21,19 @@ const DEFAULT_CONFIG_DIR = path.resolve(path.dirname(__filename), '..', '..', 'c
 
 const SEED_ITEMS = [
     {
-        text: 'Overview', icon: 'home',
+        text: 'Overview', key: 'overview', icon: 'home',
         items: [
             {text: 'Dashboard', url: '#/', icon: 'home'}
         ]
     },
     {
-        text: 'Projects', icon: 'folder', permission: 'projects',
+        text: 'Projects', key: 'projects', icon: 'folder', permission: 'projects',
         items: [
             {text: 'Manage projects', url: '#/projects', icon: 'folder', permission: 'projects'}
         ]
     },
     {
-        text: 'Content', icon: 'edit',
+        text: 'Content', key: 'content', icon: 'edit',
         items: [
             {text: 'Pages', url: '#/pages', icon: 'file-text', permission: 'pages'},
             {text: 'Media', url: '#/media', icon: 'image',     permission: 'media'},
@@ -36,7 +41,7 @@ const SEED_ITEMS = [
         ]
     },
     {
-        text: 'Data', icon: 'database',
+        text: 'Data', key: 'data', icon: 'database',
         items: [
             {text: 'Collections', url: '#/collections', icon: 'database',  permission: 'collections'},
             {text: 'Forms',       url: '#/forms',       icon: 'layout',    permission: 'collections'},
@@ -47,8 +52,12 @@ const SEED_ITEMS = [
             {text: 'Components',  url: '#/components',  icon: 'component', permission: 'components'}
         ]
     },
+    // Enabled Tools are placed here at render time (placeTools in
+    // admin/js/lib/sidebar-grouping.js); the folder is persisted so an admin
+    // can rename, move or reorder it like any other.
+    {text: 'Tools', key: 'tools', icon: 'tool', items: []},
     {
-        text: 'System', icon: 'settings',
+        text: 'System', key: 'system', icon: 'settings',
         items: [
             {text: 'Notifications', url: '#/system/notifications', icon: 'bell',     permission: 'notifications'},
             {text: 'Roles',         url: '#/roles',                icon: 'shield',   permission: 'plugins'},
@@ -63,7 +72,7 @@ const SEED_ITEMS = [
         ]
     },
     {
-        text: 'Documentation', icon: 'book',
+        text: 'Documentation', key: 'documentation', icon: 'book',
         items: [
             DOC_USAGE_SUBMENU(),
             DOC_TUTORIALS_SUBMENU(),
@@ -307,3 +316,68 @@ export async function ensureDocumentationSubmenus(opts = {}) {
     console.log('[admin-sidebar] Upgraded Documentation group with per-topic submenus');
     return {updated: true};
 }
+
+/** Keys for the folders the seed has always created, matched by their original name. */
+const SEED_FOLDER_KEYS = {
+    overview: 'overview', projects: 'projects', content: 'content', data: 'data',
+    tools: 'tools', system: 'system', documentation: 'documentation'
+};
+
+/**
+ * Give an existing install's top-level folders their stable `key`, and - once -
+ * a persisted Tools folder for enabled Tools to be placed into.
+ *
+ *  - A folder is keyed only if it has no key yet and still carries one of the
+ *    seed's names; a folder the admin made, or renamed before keys existed, is
+ *    left alone (placement falls back to Tools for it).
+ *  - The Tools folder is added only on the first run (`meta.toolsFolder`), so
+ *    an admin who later deletes it does not get it back on every boot. Until
+ *    then placement synthesises one, exactly as before.
+ *
+ * Returns `{updated: boolean, reason?: string}`.
+ *
+ * @param {{configDir?: string}} [opts]
+ */
+export async function ensureFolderKeys(opts = {}) {
+    const configDir = opts.configDir || DEFAULT_CONFIG_DIR;
+    const menuPath  = path.join(configDir, 'menus', 'admin-sidebar.json');
+
+    if (!await exists(menuPath)) {
+        return {updated: false, reason: 'admin-sidebar.json not present'};
+    }
+
+    const menu  = await readJson(menuPath);
+    const items = Array.isArray(menu.items) ? menu.items : (menu.items = []);
+    const isFolder = (n) => n && typeof n === 'object' && !n.url && n.type !== 'separator' && n.type !== 'spacer';
+
+    let changed = false;
+    const used = new Set(items.filter(n => isFolder(n) && n.key).map(n => n.key));
+    for (const node of items) {
+        if (!isFolder(node) || node.key) continue;
+        const key = SEED_FOLDER_KEYS[String(node.text || '').trim().toLowerCase()];
+        if (!key || used.has(key)) continue;
+        node.key = key;
+        used.add(key);
+        changed = true;
+    }
+
+    // An empty menu is left empty: the renderer's minimal fallback (Dashboard,
+    // Menus) is what an admin needs to repair it, and a lone Tools folder would
+    // stop that fallback from applying.
+    if (!menu.meta?.toolsFolder && items.length) {
+        if (!used.has('tools')) {
+            const idx = items.findIndex(n => isFolder(n) && ['system', 'documentation'].includes(n.key));
+            const tools = {text: 'Tools', key: 'tools', icon: 'tool', items: []};
+            items.splice(idx === -1 ? items.length : idx, 0, tools);
+        }
+        menu.meta = {...(menu.meta || {}), toolsFolder: true};
+        changed = true;
+    }
+
+    if (!changed) return {updated: false, reason: 'already up to date'};
+
+    menu.meta = {...(menu.meta || {}), updatedAt: new Date().toISOString()};
+    await writeJson(menuPath, menu);
+    console.log('[admin-sidebar] Gave the sidebar folders stable keys');
+    return {updated: true};
+}

package/admin/js/lib/sidebar-grouping.test.js

@@ -1 +0,0 @@
-import{test as o}from"node:test";import s from"node:assert/strict";import{groupPluginItems as a,stripItemByUrl as p,insertFoldersBeforeSystem as u,pruneEmptySynthesisedFolders as i,TOOLS_FOLDER_TEXT as m,MANAGE_PLUGINS_URL as d}from"./sidebar-grouping.js";const n=(e,t=null)=>({parent:t,item:e});o("groupPluginItems routes every enabled item to Tools, whatever its core flag",()=>{const{toolsFolder:e}=a([n({text:"Analytics",url:"#/plugins/analytics",core:!0}),n({text:"Todo",url:"#/plugins/todo",core:!1}),n({text:"Notes",url:"#/plugins/notes"})]);s.equal(e.text,m),s.deepEqual(e.items.map(t=>t.text),["Analytics","Todo","Notes"])}),o("Marketplace is a standalone entry, not a folder",()=>{const{managePluginsItem:e}=a([n({text:"Todo",url:"#/plugins/todo"})]);s.equal(e.text,"Marketplace"),s.equal(e.url,d),s.equal(e.permission,"plugins"),s.ok(!("items"in e),"it must not carry a sub-tree")}),o("groupPluginItems omits the Tools folder only when nothing is enabled",()=>{const e=a([n({text:"Todo",url:"#/plugins/todo"})]);s.deepEqual(e.toolsFolder.items.map(l=>l.text),["Todo"]);const t=a([]);s.equal(t.toolsFolder,null),s.equal(t.managePluginsItem.text,"Marketplace")}),o("groupPluginItems keeps explicitly-parented items separate",()=>{const{parented:e,toolsFolder:t}=a([n({text:"Nested",url:"#/x"},"Content"),n({text:"Todo",url:"#/plugins/todo",core:!1})]);s.equal(e.length,1),s.equal(e[0].parent,"Content"),s.deepEqual(t.items.map(l=>l.text),["Todo"])}),o("each call returns its own Marketplace object",()=>{const e=a([]).managePluginsItem,t=a([]).managePluginsItem;s.notEqual(e,t),s.deepEqual(e,t)}),o("stripItemByUrl removes the management link at any depth",()=>{const e=[{text:"Overview",items:[{text:"Dashboard",url:"#/"}]},{text:"System",items:[{text:"Users",url:"#/users"},{text:"Plugins",url:"#/plugins"}]}],l=p(e,"#/plugins").find(r=>r.text==="System");s.deepEqual(l.items.map(r=>r.text),["Users"]),s.equal(e.find(r=>r.text==="System").items.length,2)}),o("insertFoldersBeforeSystem places Tools then Marketplace before System",()=>{const t=u([{text:"Overview"},{text:"Data"},{text:"System"},{text:"Documentation"}],[{text:"Tools",items:[]},{text:"Marketplace",url:"#/plugins"},null]);s.deepEqual(t.map(l=>l.text),["Overview","Data","Tools","Marketplace","System","Documentation"])}),o("insertFoldersBeforeSystem appends when no System/Documentation anchor",()=>{const t=u([{text:"Overview"},{text:"Data"}],[{text:"Marketplace",url:"#/plugins"}]);s.deepEqual(t.map(l=>l.text),["Overview","Data","Marketplace"])}),o("pruneEmptySynthesisedFolders drops an empty Tools folder but keeps built-ins",()=>{const e=[{text:"Overview",items:[]},{text:"Tools",items:[]}];s.deepEqual(i(e).map(t=>t.text),["Overview"])}),o("pruneEmptySynthesisedFolders leaves the standalone Marketplace alone",()=>{const e=[{text:"Tools",items:[{text:"Analytics"}]},{text:"Marketplace",url:"#/plugins"}];s.deepEqual(i(e).map(t=>t.text),["Tools","Marketplace"])});