nextjs-cms 0.9.22 → 0.9.24

package/dist/plugins/loader.js

@@ -5,30 +5,21 @@ if (typeof window !== 'undefined') {
 import { createRequire } from 'module';
 import path from 'path';
 import { getCMSConfig, getConfigImportVersion } from '../core/config/index.js';
-import chalk from 'chalk';
-export function definePlugin(plugin) {
-    return plugin;
-}
-const deriveRouterKey = (packageName) => {
-    const baseName = packageName.split('/').pop() ?? packageName;
-    const withoutPrefix = baseName.startsWith('plugin-') ? baseName.slice('plugin-'.length) : baseName;
-    const parts = withoutPrefix.split(/[-_]/g).filter(Boolean);
-    const [first, ...rest] = parts;
-    let key = first ? first + rest.map((part) => part[0]?.toUpperCase() + part.slice(1)).join('') : withoutPrefix;
-    if (!key) {
-        key = baseName.replace(/[^A-Za-z0-9_]/g, '_');
-    }
-    if (!/^[A-Za-z_]/.test(key)) {
-        key = `plugin${key ? key[0]?.toUpperCase() + key.slice(1) : ''}`;
-    }
-    return key;
-};
+import { derivePluginName, derivePluginRouterKey } from './derive.js';
+import { logWarn, logError, logInfo } from '../utils/console-log.js';
 let cachedPlugins = null;
 let cachedConfigVersion = -1;
 let loadPromise = null;
 let jitiInstance = null;
 const appRequire = createRequire(path.join(process.cwd(), 'package.json'));
 const pkgRequire = createRequire(import.meta.url);
+let serverOnlyEmptyPath = null;
+const getServerOnlyEmptyPath = () => {
+    if (!serverOnlyEmptyPath) {
+        serverOnlyEmptyPath = path.join(path.dirname(pkgRequire.resolve('server-only')), 'empty.js');
+    }
+    return serverOnlyEmptyPath;
+};
 const resolvePluginPath = (pluginPackage) => {
     try {
         return appRequire.resolve(pluginPackage);
@@ -54,6 +45,9 @@ export const loadPluginModule = async (pluginPackage) => {
             fsCache: true,
             moduleCache: true,
             rebuildFsCache: true,
+            alias: {
+                'server-only': getServerOnlyEmptyPath(),
+            },
             // Optional: nicer debugging in stack traces (off by default in jiti)
             // sourceMaps: true,
         });
@@ -63,38 +57,66 @@ export const loadPluginModule = async (pluginPackage) => {
     const mod = jitiInstance(resolved);
     return mod?.default ?? mod;
 };
-function resolvePluginInstance(registration, mod) {
-    const candidate = mod.createPlugin
+async function resolvePluginInstance(registration, mod) {
+    const candidate = await (mod.createPlugin
         ? mod.createPlugin(registration.options)
         : typeof mod.default === 'function'
             ? mod.default()
-            : (mod.default ?? mod.plugin);
+            : (mod.default ?? mod.plugin));
     if (!candidate) {
-        console.warn(`[plugins] Plugin "${registration.package}" did not return a plugin instance`);
+        logWarn('plugins', `Plugin "${registration.package}" did not return a plugin instance.`);
         return null;
     }
-    if (!candidate.name || !candidate.title) {
-        console.warn(`[plugins] Plugin "${registration.package}" is missing required "name" or "title". Skipping.`);
+    if (!candidate.title) {
+        logWarn('plugins', `Plugin "${registration.package}" is missing required "title". Skipping.`);
         return null;
     }
-    // Apply config-level title override if provided
-    const resolvedTitle = registration.title ?? candidate.title;
-    // Apply route-level title overrides if provided
-    // For single-route plugins, the config-level title also applies to the route
-    const isSingleRoute = (candidate.routes?.length ?? 0) <= 1;
-    const resolvedRoutes = (candidate.routes ?? []).map((route) => {
-        const routeOverride = registration.routes?.[route.path];
-        // Priority: route-specific override > config title (single-route only) > route default
-        const effectiveTitle = routeOverride?.title ?? (isSingleRoute ? registration.title : undefined) ?? route.title;
-        return {
-            ...route,
-            title: effectiveTitle,
-        };
+    const name = derivePluginName(registration.package);
+    const pkg = registration.package;
+    const override = registration.override;
+    const declaredRoutes = candidate.routes ?? [];
+    const isSingleRoute = declaredRoutes.length <= 1;
+    const groupRoutes = registration.groupRoutes ?? true;
+    // Validate override.routes keys against declared paths
+    if (override?.routes) {
+        const declaredPaths = new Set(declaredRoutes.map((r) => r.path));
+        for (const path of Object.keys(override.routes)) {
+            if (!declaredPaths.has(path)) {
+                const known = Array.from(declaredPaths).join(', ') || '(none)';
+                logWarn('plugins', `override.routes["${path}"] in "${pkg}" does not match any declared route. Known paths: ${known}`);
+            }
+        }
+    }
+    // Warn on ineffective override shapes
+    if (!isSingleRoute && groupRoutes === false && (override?.title || override?.icon)) {
+        logWarn('plugins', `override.title / override.icon set for "${pkg}" but groupRoutes is false — group label is not rendered, so these have no effect.`);
+    }
+    // Resolve route titles/icons
+    const resolvedRoutes = declaredRoutes.map((route) => {
+        let title = route.title;
+        let icon = route.icon;
+        // Single-route: plugin-level override applies to the route itself.
+        if (isSingleRoute) {
+            if (override?.title)
+                title = override.title;
+            if (override?.icon)
+                icon = override.icon;
+        }
+        // Per-route override always wins over plugin-level.
+        const routeOverride = override?.routes?.[route.path];
+        if (routeOverride?.title)
+            title = routeOverride.title;
+        if (routeOverride?.icon)
+            icon = routeOverride.icon;
+        return { ...route, title, icon };
     });
+    // Resolve plugin-level title/icon — only used as group label for multi-route grouped plugins.
+    const resolvedPluginTitle = !isSingleRoute && override?.title ? override.title : candidate.title;
+    const resolvedPluginIcon = !isSingleRoute && override?.icon ? override.icon : candidate.icon;
     return {
-        title: resolvedTitle,
-        name: candidate.name,
-        registryName: candidate.registryName,
+        title: resolvedPluginTitle,
+        icon: resolvedPluginIcon,
+        name,
         version: candidate.version,
         router: candidate.router,
         routes: resolvedRoutes,
@@ -113,45 +135,42 @@ export async function loadPlugins() {
         const config = await getCMSConfig();
         const registrations = config.plugins ?? [];
         const seenPackages = new Set();
-        const seenRouterKeys = new Set();
+        const seenNames = new Set();
         const loaded = [];
         for (const registration of registrations) {
             if (!registration.package) {
-                console.warn(`[plugins] Plugin registration is missing "package" field.`);
-                console.warn(`[plugins] Please check your cms.config.ts file.`);
-                console.warn(`[plugins] Skipping this plugin registration.`);
+                logWarn('plugins', 'Plugin registration is missing "package" field — check your cms.config.ts. Skipping.');
+                continue;
+            }
+            if (seenPackages.has(registration.package)) {
+                logError('plugins', `Duplicate plugin package "${registration.package}" registered. Skipping duplicate.`);
                 continue;
             }
             const mod = await loadPluginModule(registration.package);
             if (!mod)
                 continue;
-            const plugin = resolvePluginInstance(registration, mod);
+            const plugin = await resolvePluginInstance(registration, mod);
             if (!plugin)
                 continue;
-            const routerKey = deriveRouterKey(registration.package);
-            if (seenPackages.has(registration.package)) {
-                console.error(`[plugins] Duplicate plugin package "${registration.package}" registered. Skipping duplicate.`);
-                continue;
-            }
-            if (seenRouterKeys.has(routerKey)) {
-                console.error(`[plugins] Duplicate plugin router key "${routerKey}" derived from "${registration.package}". Skipping.`);
+            if (seenNames.has(plugin.name)) {
+                logError('plugins', `Duplicate plugin name "${plugin.name}" derived from "${registration.package}". Skipping.`);
                 continue;
             }
             seenPackages.add(registration.package);
-            seenRouterKeys.add(routerKey);
+            seenNames.add(plugin.name);
             if (typeof plugin.init === 'function') {
                 try {
                     await plugin.init({ config: registration });
                 }
                 catch (error) {
-                    console.error(`[plugins] Plugin "${registration.package}" init failed:`, error);
+                    logError('plugins', `Plugin "${registration.package}" init failed.`, error);
                 }
             }
             loaded.push({
                 config: registration,
                 plugin,
                 moduleName: registration.package,
-                routerKey,
+                routerKey: derivePluginRouterKey(registration.package),
             });
         }
         cachedPlugins = loaded;
@@ -172,17 +191,16 @@ export async function getPluginRoutes() {
         const requireComponent = routes.length > 1;
         return routes.map((route) => {
             if (requireComponent && !route.component) {
-                console.warn(chalk.red(`[plugins] Route "${route.path}" from "${entry.config.package}" should set "component" because the plugin defines multiple routes.`));
+                logWarn('plugins', `Route "${route.path}" from "${entry.config.package}" should set "component" because the plugin defines multiple routes.`);
             }
             if (!requireComponent && route.component) {
-                console.warn(chalk.gray(`[plugins] Route "${route.path}" from "${entry.config.package}" should omit "component" and export a default component, because the plugin defines a single route.`));
+                logInfo('plugins', `Route "${route.path}" from "${entry.config.package}" should omit "component" and export a default component, because the plugin defines a single route.`);
             }
             return {
                 ...route,
                 title: route.title,
                 pluginId: entry.config.package,
                 pluginName: entry.plugin.name,
-                pluginRegistryName: entry.plugin.registryName,
             };
         });
     });
@@ -192,6 +210,45 @@ export async function findPluginRouteByPath(path) {
     const routes = await getPluginRoutes();
     return routes.find((route) => route.path === normalized) ?? null;
 }
+/**
+ * Returns the navigation structure for all loaded plugins, accounting for
+ * `groupRoutes` and per-plugin `override` resolution. Single-route plugins emit
+ * one leaf. Multi-route plugins emit a group (default) or one leaf per route
+ * when `groupRoutes: false`.
+ *
+ * Pure data — does not filter by privilege. The sidebar layer applies that.
+ */
+export async function getPluginNavigation() {
+    const loaded = await loadPlugins();
+    const items = [];
+    for (const entry of loaded) {
+        const routes = entry.plugin.routes ?? [];
+        if (routes.length === 0)
+            continue;
+        const isSingleRoute = routes.length === 1;
+        const groupRoutes = entry.config.groupRoutes ?? true;
+        if (isSingleRoute || !groupRoutes) {
+            for (const route of routes) {
+                items.push({
+                    kind: 'leaf',
+                    title: route.title,
+                    path: route.path,
+                    icon: route.icon,
+                    pluginName: entry.plugin.name,
+                });
+            }
+            continue;
+        }
+        items.push({
+            kind: 'group',
+            title: entry.plugin.title,
+            icon: entry.plugin.icon,
+            pluginName: entry.plugin.name,
+            children: routes.map((r) => ({ title: r.title, path: r.path, icon: r.icon })),
+        });
+    }
+    return items;
+}
 /**
  * Gets the dashboard override plugin route if configured.
  * @returns The LoadedPluginRoute for the dashboard override, or null if not configured

package/dist/plugins/manifest.d.ts

@@ -0,0 +1,28 @@
+import type { PluginConfigEntry } from '../core/config/config-loader.js';
+import type { MultilingualString } from '../translations/language-utils.js';
+import type { IconName } from 'lucide-react/dynamic';
+export interface PluginManifestRoute {
+    path: string;
+    title: MultilingualString;
+    icon?: IconName;
+    component?: string;
+}
+export interface PluginManifest {
+    name: string;
+    registryName: string;
+    title: MultilingualString;
+    routes?: PluginManifestRoute[];
+}
+export interface LoadedPluginManifestRoute extends PluginManifestRoute {
+    pluginId: string;
+    pluginName: string;
+    pluginRegistryName: string;
+}
+export interface LoadedPluginManifest {
+    config: PluginConfigEntry;
+    manifest: PluginManifest;
+    moduleName: string;
+}
+export declare function getPluginManifests(): Promise<LoadedPluginManifest[]>;
+export declare function getPluginRouteManifests(): Promise<LoadedPluginManifestRoute[]>;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/plugins/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/plugins/manifest.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAA;AACxE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAC3E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAEpD,MAAM,WAAW,mBAAmB;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,kBAAkB,CAAA;IACzB,IAAI,CAAC,EAAE,QAAQ,CAAA;IACf,SAAS,CAAC,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,cAAc;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,kBAAkB,CAAA;IACzB,MAAM,CAAC,EAAE,mBAAmB,EAAE,CAAA;CACjC;AAED,MAAM,WAAW,yBAA0B,SAAQ,mBAAmB;IAClE,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,kBAAkB,EAAE,MAAM,CAAA;CAC7B;AAED,MAAM,WAAW,oBAAoB;IACjC,MAAM,EAAE,iBAAiB,CAAA;IACzB,QAAQ,EAAE,cAAc,CAAA;IACxB,UAAU,EAAE,MAAM,CAAA;CACrB;AAoDD,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,oBAAoB,EAAE,CAAC,CA+B1E;AAED,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,yBAAyB,EAAE,CAAC,CAUpF"}

package/dist/plugins/manifest.js

@@ -0,0 +1,83 @@
+import { createRequire } from 'module';
+import path from 'path';
+import fs from 'fs';
+import { getCMSConfig } from '../core/config/index.js';
+const appRequire = createRequire(path.join(process.cwd(), 'package.json'));
+const pkgRequire = createRequire(import.meta.url);
+const resolvePluginPackageJson = (pluginPackage) => {
+    const target = `${pluginPackage}/package.json`;
+    try {
+        return appRequire.resolve(target);
+    }
+    catch {
+        try {
+            return pkgRequire.resolve(target, { paths: [process.cwd()] });
+        }
+        catch {
+            return null;
+        }
+    }
+};
+const readManifestFromPackage = (pluginPackage) => {
+    const pkgJsonPath = resolvePluginPackageJson(pluginPackage);
+    if (!pkgJsonPath) {
+        console.warn(`[plugins] Could not resolve "${pluginPackage}/package.json".`);
+        return null;
+    }
+    let pkg;
+    try {
+        pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+    }
+    catch (error) {
+        console.warn(`[plugins] Failed to read "${pkgJsonPath}":`, error);
+        return null;
+    }
+    const manifest = pkg.pluginManifest;
+    if (!manifest) {
+        console.warn(`[plugins] Package "${pluginPackage}" is missing the "pluginManifest" field in package.json. ` +
+            `Plugins must declare metadata statically so the CLI can read it without evaluating plugin code.`);
+        return null;
+    }
+    if (!manifest.name || !manifest.registryName || !manifest.title) {
+        console.warn(`[plugins] Package "${pluginPackage}" has an invalid "pluginManifest" — required fields: name, registryName, title.`);
+        return null;
+    }
+    return manifest;
+};
+export async function getPluginManifests() {
+    const config = await getCMSConfig();
+    const registrations = config.plugins ?? [];
+    const seenPackages = new Set();
+    const seenNames = new Set();
+    const loaded = [];
+    for (const registration of registrations) {
+        if (!registration.package)
+            continue;
+        if (seenPackages.has(registration.package))
+            continue;
+        const manifest = readManifestFromPackage(registration.package);
+        if (!manifest)
+            continue;
+        if (seenNames.has(manifest.name)) {
+            console.warn(`[plugins] Duplicate plugin name "${manifest.name}" — skipping "${registration.package}".`);
+            continue;
+        }
+        seenPackages.add(registration.package);
+        seenNames.add(manifest.name);
+        loaded.push({
+            config: registration,
+            manifest,
+            moduleName: registration.package,
+        });
+    }
+    return loaded;
+}
+export async function getPluginRouteManifests() {
+    const loaded = await getPluginManifests();
+    return loaded.flatMap((entry) => (entry.manifest.routes ?? []).map((route) => ({
+        ...route,
+        pluginId: entry.config.package,
+        pluginName: entry.manifest.name,
+        pluginRegistryName: entry.manifest.registryName,
+    })));
+}

package/dist/plugins/prefetch.d.ts

@@ -0,0 +1,16 @@
+import type { LoadedPluginRoute } from './loader.js';
+/**
+ * Walks a dot-path into a tRPC RSC `api` proxy and invokes `.prefetch()` at the leaf.
+ *
+ * Example: `runApiPrefetch(api, 'cpanelEmails.getEmails')` runs
+ * `await api.cpanelEmails.getEmails.prefetch()`.
+ *
+ * Throws if any segment is missing or the leaf has no `prefetch` helper, so a typo
+ * in `PluginRoute.prefetch` fails loudly during development.
+ */
+export declare function runApiPrefetch(api: unknown, dotPath: string): Promise<void>;
+/** Normalizes a route's `prefetch` field (string | string[] | undefined) into an array. */
+export declare function getRoutePrefetchPaths(route: Pick<LoadedPluginRoute, 'prefetch'>): string[];
+/** Runs all declared prefetches for a route in parallel. */
+export declare function runRoutePrefetches(api: unknown, route: Pick<LoadedPluginRoute, 'prefetch'>): Promise<void>;
+//# sourceMappingURL=prefetch.d.ts.map

package/dist/plugins/prefetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefetch.d.ts","sourceRoot":"","sources":["../../src/plugins/prefetch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAEpD;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAoBjF;AAED,2FAA2F;AAC3F,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,IAAI,CAAC,iBAAiB,EAAE,UAAU,CAAC,GAAG,MAAM,EAAE,CAG1F;AAED,4DAA4D;AAC5D,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,iBAAiB,EAAE,UAAU,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAIhH"}

package/dist/plugins/prefetch.js

@@ -0,0 +1,40 @@
+/**
+ * Walks a dot-path into a tRPC RSC `api` proxy and invokes `.prefetch()` at the leaf.
+ *
+ * Example: `runApiPrefetch(api, 'cpanelEmails.getEmails')` runs
+ * `await api.cpanelEmails.getEmails.prefetch()`.
+ *
+ * Throws if any segment is missing or the leaf has no `prefetch` helper, so a typo
+ * in `PluginRoute.prefetch` fails loudly during development.
+ */
+export async function runApiPrefetch(api, dotPath) {
+    const segments = dotPath.split('.').filter(Boolean);
+    if (segments.length === 0) {
+        throw new Error('[plugins] Empty prefetch path.');
+    }
+    let node = api;
+    for (const key of segments) {
+        if (node == null || (typeof node !== 'object' && typeof node !== 'function')) {
+            throw new Error(`[plugins] Cannot resolve prefetch path "${dotPath}" — segment "${key}" is unreachable.`);
+        }
+        node = node[key];
+    }
+    const prefetch = node?.prefetch;
+    if (typeof prefetch !== 'function') {
+        throw new Error(`[plugins] Prefetch path "${dotPath}" does not resolve to a procedure with a prefetch helper.`);
+    }
+    await prefetch();
+}
+/** Normalizes a route's `prefetch` field (string | string[] | undefined) into an array. */
+export function getRoutePrefetchPaths(route) {
+    if (!route.prefetch)
+        return [];
+    return Array.isArray(route.prefetch) ? route.prefetch : [route.prefetch];
+}
+/** Runs all declared prefetches for a route in parallel. */
+export async function runRoutePrefetches(api, route) {
+    const paths = getRoutePrefetchPaths(route);
+    if (paths.length === 0)
+        return;
+    await Promise.all(paths.map((path) => runApiPrefetch(api, path)));
+}

package/dist/plugins/registry.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Static import map for all official @nextjscms plugins.
+ *
+ * Why this file exists: the plugin loader needs to import plugin packages by
+ * name at runtime. Bare `await import(variable)` calls are rejected by
+ * Turbopack/webpack as "too dynamic" because the bundler cannot statically
+ * see which packages may be loaded. Listing each package as a literal
+ * `() => import('@nextjscms/plugin-x')` thunk lets the bundler analyze the
+ * import sites, and the host's module loader applies the correct export
+ * conditions at runtime — most importantly "react-server" during RSC
+ * requests, so plugin transitive deps marked `import 'server-only'` resolve
+ * to a no-op instead of throwing.
+ *
+ * Each thunk is wrapped in its own arrow so the import is deferred until the
+ * plugin is actually configured in cms.config.ts. Plugins not installed in
+ * the host app will fail at thunk invocation, which the loader treats as a
+ * normal "plugin not available" outcome.
+ *
+ * When a new official plugin is published, add an entry here.
+ */
+export declare const officialPluginRegistry: Record<string, () => Promise<unknown>>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/plugins/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/plugins/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAIzE,CAAA"}

package/dist/plugins/registry.js

@@ -0,0 +1,25 @@
+/**
+ * Static import map for all official @nextjscms plugins.
+ *
+ * Why this file exists: the plugin loader needs to import plugin packages by
+ * name at runtime. Bare `await import(variable)` calls are rejected by
+ * Turbopack/webpack as "too dynamic" because the bundler cannot statically
+ * see which packages may be loaded. Listing each package as a literal
+ * `() => import('@nextjscms/plugin-x')` thunk lets the bundler analyze the
+ * import sites, and the host's module loader applies the correct export
+ * conditions at runtime — most importantly "react-server" during RSC
+ * requests, so plugin transitive deps marked `import 'server-only'` resolve
+ * to a no-op instead of throwing.
+ *
+ * Each thunk is wrapped in its own arrow so the import is deferred until the
+ * plugin is actually configured in cms.config.ts. Plugins not installed in
+ * the host app will fail at thunk invocation, which the loader treats as a
+ * normal "plugin not available" outcome.
+ *
+ * When a new official plugin is published, add an entry here.
+ */
+export const officialPluginRegistry = {
+    '@nextjscms/plugin-cpanel-dashboard': () => import('@nextjscms/plugin-cpanel-dashboard'),
+    '@nextjscms/plugin-cpanel-emails': () => import('@nextjscms/plugin-cpanel-emails'),
+    '@nextjscms/plugin-google-analytics': () => import('@nextjscms/plugin-google-analytics'),
+};

package/dist/plugins/server.d.ts

@@ -1,2 +1,4 @@
 export * from './loader.js';
+export { derivePluginName, derivePluginRouterKey, extractPluginName, PLUGIN_PACKAGE_PREFIX } from './derive.js';
+export { runApiPrefetch, runRoutePrefetches, getRoutePrefetchPaths } from './prefetch.js';
 //# sourceMappingURL=server.d.ts.map

package/dist/plugins/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/plugins/server.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/plugins/server.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAC/G,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA"}

package/dist/plugins/server.js

@@ -1 +1,3 @@
 export * from './loader.js';
+export { derivePluginName, derivePluginRouterKey, extractPluginName, PLUGIN_PACKAGE_PREFIX } from './derive.js';
+export { runApiPrefetch, runRoutePrefetches, getRoutePrefetchPaths } from './prefetch.js';

package/dist/plugins/types.d.ts

@@ -0,0 +1,79 @@
+import type { IconName } from 'lucide-react/dynamic';
+import type { MultilingualString } from '../translations/language-utils.js';
+export interface PluginRouteOverride {
+    title?: MultilingualString;
+    icon?: IconName;
+}
+export interface PluginRuntimeConfigEntry {
+    package: string;
+    options?: Record<string, unknown>;
+    override?: {
+        title?: MultilingualString;
+        icon?: IconName;
+        routes?: Record<string, PluginRouteOverride>;
+    };
+    groupRoutes?: boolean;
+}
+export interface PluginInitContext {
+    config: PluginRuntimeConfigEntry;
+}
+export interface PluginRoute {
+    path: string;
+    /**
+     * The title of the route.
+     * Can be a plain string or a localized object with language codes as keys.
+     */
+    title: MultilingualString;
+    icon?: IconName | undefined;
+    component?: string;
+    /**
+     * Dot-paths into the host's tRPC router (e.g. `'cpanelEmails.getEmails'`) that the
+     * host should prefetch on the server before rendering the plugin's component. The
+     * results are placed into the React Query cache and hydrated into the client tree
+     * via the host-rendered `<HydrateClient>` boundary.
+     */
+    prefetch?: string | string[];
+}
+export type PluginRouteWithoutComponent = Omit<PluginRoute, 'component'> & {
+    component?: never;
+};
+export type PluginRouteWithComponent = PluginRoute & {
+    component: string;
+};
+export interface CMSPlugin {
+    /**
+     * The human facing title of the plugin.
+     * Can be a plain string or a localized object with language codes as keys.
+     * @example 'Some Plugin Title'
+     * @example { en: 'Some Plugin Title', ar: 'عنوان الإضافة' }
+     */
+    title: MultilingualString;
+    /**
+     * Optional sidebar icon for the plugin group (multi-route, when `groupRoutes !== false`).
+     * Single-route plugins use the route's own `icon` instead.
+     */
+    icon?: IconName;
+    version?: string;
+    router?: unknown;
+    routes?: readonly PluginRoute[];
+    init?: (ctx: PluginInitContext) => Promise<void> | void;
+}
+type CMSPluginBase = Omit<CMSPlugin, 'routes'>;
+export type CMSPluginSingleRoute = CMSPluginBase & {
+    routes?: readonly [] | readonly [PluginRouteWithoutComponent];
+};
+export type CMSPluginMultiRoute = CMSPluginBase & {
+    routes: readonly [PluginRouteWithComponent, PluginRouteWithComponent, ...PluginRouteWithComponent[]];
+};
+export type CMSPluginDescriptorBase = Omit<CMSPluginBase, 'router' | 'init'> & {
+    package: string;
+};
+export type CMSPluginDescriptorSingleRoute = CMSPluginDescriptorBase & {
+    routes?: readonly [] | readonly [PluginRouteWithoutComponent];
+};
+export type CMSPluginDescriptorMultiRoute = CMSPluginDescriptorBase & {
+    routes: readonly [PluginRouteWithComponent, PluginRouteWithComponent, ...PluginRouteWithComponent[]];
+};
+export type CMSPluginDescriptor = CMSPluginDescriptorSingleRoute | CMSPluginDescriptorMultiRoute;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/plugins/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/plugins/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAE3E,MAAM,WAAW,mBAAmB;IAChC,KAAK,CAAC,EAAE,kBAAkB,CAAA;IAC1B,IAAI,CAAC,EAAE,QAAQ,CAAA;CAClB;AAED,MAAM,WAAW,wBAAwB;IACrC,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACjC,QAAQ,CAAC,EAAE;QACP,KAAK,CAAC,EAAE,kBAAkB,CAAA;QAC1B,IAAI,CAAC,EAAE,QAAQ,CAAA;QACf,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAA;KAC/C,CAAA;IACD,WAAW,CAAC,EAAE,OAAO,CAAA;CACxB;AAED,MAAM,WAAW,iBAAiB;IAC9B,MAAM,EAAE,wBAAwB,CAAA;CACnC;AAED,MAAM,WAAW,WAAW;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ;;;OAGG;IACH,KAAK,EAAE,kBAAkB,CAAA;IACzB,IAAI,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAA;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAC/B;AAED,MAAM,MAAM,2BAA2B,GAAG,IAAI,CAAC,WAAW,EAAE,WAAW,CAAC,GAAG;IAAE,SAAS,CAAC,EAAE,KAAK,CAAA;CAAE,CAAA;AAEhG,MAAM,MAAM,wBAAwB,GAAG,WAAW,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,CAAA;AAE1E,MAAM,WAAW,SAAS;IACtB;;;;;OAKG;IACH,KAAK,EAAE,kBAAkB,CAAA;IACzB;;;OAGG;IACH,IAAI,CAAC,EAAE,QAAQ,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,MAAM,CAAC,EAAE,SAAS,WAAW,EAAE,CAAA;IAC/B,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;CAC1D;AAED,KAAK,aAAa,GAAG,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAA;AAE9C,MAAM,MAAM,oBAAoB,GAAG,aAAa,GAAG;IAC/C,MAAM,CAAC,EAAE,SAAS,EAAE,GAAG,SAAS,CAAC,2BAA2B,CAAC,CAAA;CAChE,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG,aAAa,GAAG;IAC9C,MAAM,EAAE,SAAS,CAAC,wBAAwB,EAAE,wBAAwB,EAAE,GAAG,wBAAwB,EAAE,CAAC,CAAA;CACvG,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG,IAAI,CAAC,aAAa,EAAE,QAAQ,GAAG,MAAM,CAAC,GAAG;IAC3E,OAAO,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,8BAA8B,GAAG,uBAAuB,GAAG;IACnE,MAAM,CAAC,EAAE,SAAS,EAAE,GAAG,SAAS,CAAC,2BAA2B,CAAC,CAAA;CAChE,CAAA;AAED,MAAM,MAAM,6BAA6B,GAAG,uBAAuB,GAAG;IAClE,MAAM,EAAE,SAAS,CAAC,wBAAwB,EAAE,wBAAwB,EAAE,GAAG,wBAAwB,EAAE,CAAC,CAAA;CACvG,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG,8BAA8B,GAAG,6BAA6B,CAAA"}

package/dist/translations/base/en.d.ts

@@ -369,6 +369,7 @@ declare const _default: {
     readonly addedAgo: "Added {time} ago";
     readonly hoursAgo: "hours ago";
     readonly main: "Main";
+    readonly plugins: "Plugins";
     readonly categorySections: "Category Sections";
     readonly sectionsWithItems: "Sections with Items";
     readonly simpleSections: "Simple Sections";

package/dist/translations/base/en.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../../src/translations/base/en.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBAogBU"}
+{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../../src/translations/base/en.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBAqgBU"}

package/dist/translations/base/en.js

@@ -369,6 +369,7 @@ export default {
     addedAgo: 'Added {time} ago',
     hoursAgo: 'hours ago',
     main: 'Main',
+    plugins: 'Plugins',
     categorySections: 'Category Sections',
     sectionsWithItems: 'Sections with Items',
     simpleSections: 'Simple Sections',