nextjs-cms 0.9.29 → 0.9.30

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

@@ -1 +0,0 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/api/server.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,CAAA;AAEpB,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAA;AAUjE,OAAO,KAAK,EAAE,0BAA0B,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAEvF,MAAM,WAAW,uBAAuB,CAAC,KAAK,SAAS,YAAY;IAC/D,OAAO,CAAC,EAAE,0BAA0B,CAAC,KAAK,CAAC,CAAA;IAC3C,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAA;CACjE;AAED,wBAAgB,gBAAgB,CAAC,KAAK,CAAC,KAAK,SAAS,YAAY,GAAG,EAAE,EAClE,IAAI,GAAE,uBAAuB,CAAC,KAAK,CAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA4G8xR,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAm0lC,CAAC;;;;;+BAAyE,CAAC;;;;;;+BAA8G,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAA7o+B,CAAC;;;;;+BAAsE,CAAC;;;;;;+BAA2G,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA1Bh1Z,OAAO;oBAAP,OAAO;;SAkBV,UAAU,CAAC,OAAO,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAQswR,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAm0lC,CAAC;;;;;+BAAyE,CAAC;;;;;;+BAA8G,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAA7o+B,CAAC;;;;;+BAAsE,CAAC;;;;;;+BAA2G,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBARzxZ,CAAC,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAQ2uR,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAm0lC,CAAC;;;;;+BAAyE,CAAC;;;;;;+BAA8G,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAA7o+B,CAAC;;;;;+BAAsE,CAAC;;;;;;+BAA2G,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAxF10Z,OAAO,CAAC,SAAS,CAAC;EAqFvD;AAED,YAAY,EAAE,0BAA0B,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA"}

package/dist/api/server.js

@@ -1,100 +0,0 @@
-import 'server-only';
-import { createHydrationHelpers } from '@trpc/react-query/rsc';
-import { fetchRequestHandler } from '@trpc/server/adapters/fetch';
-import { headers } from 'next/headers';
-import { cache } from 'react';
-import { getConfigImportVersion } from '../core/config/index.js';
-import { loadPlugins } from '../plugins/loader.js';
-import { coreRouters } from './root.js';
-import { createCallerFactory, createTRPCContext, router } from './trpc.js';
-import { createQueryClient } from './trpc/query-client.js';
-import { createAsyncCallerProxy } from './utils/async-caller-proxy.js';
-export function createTRPCRouter(opts = {}) {
-    const userRouters = (opts.routers ?? {});
-    for (const key of Object.keys(userRouters)) {
-        if (key in coreRouters) {
-            throw new Error(`[trpc] Router key "${key}" conflicts with a core router.`);
-        }
-    }
-    const appRouter = router({
-        ...coreRouters,
-        ...userRouters,
-    });
-    let cachedRouter = null;
-    let pendingRouter = null;
-    let cachedVersion = -1;
-    let pendingVersion = -1;
-    async function getMergedRouter() {
-        const currentVersion = getConfigImportVersion();
-        if (cachedRouter && cachedVersion === currentVersion) {
-            return cachedRouter;
-        }
-        if (pendingRouter && pendingVersion === currentVersion) {
-            return pendingRouter;
-        }
-        cachedRouter = null;
-        pendingVersion = currentVersion;
-        pendingRouter = (async () => {
-            const loadedPlugins = await loadPlugins();
-            const pluginRouters = {};
-            const seen = new Set([...Object.keys(coreRouters), ...Object.keys(userRouters)]);
-            for (const plugin of loadedPlugins) {
-                if (!plugin.plugin.router)
-                    continue;
-                if (seen.has(plugin.routerKey)) {
-                    const message = `[plugins] Router key "${plugin.routerKey}" conflicts with core/user router. Skipping.`;
-                    throw new Error(message);
-                }
-                pluginRouters[plugin.routerKey] = plugin.plugin.router;
-                seen.add(plugin.routerKey);
-            }
-            const mergedRouter = router({
-                ...coreRouters,
-                ...pluginRouters,
-                ...userRouters,
-            });
-            cachedRouter = mergedRouter;
-            cachedVersion = currentVersion;
-            return mergedRouter;
-        })();
-        try {
-            return await pendingRouter;
-        }
-        finally {
-            if (pendingVersion === currentVersion) {
-                pendingRouter = null;
-            }
-        }
-    }
-    const createContext = cache(async () => {
-        const heads = new Headers(await headers());
-        heads.set('x-trpc-source', 'rsc');
-        return createTRPCContext({
-            headers: heads,
-        });
-    });
-    const getQueryClient = cache(createQueryClient);
-    const getCaller = cache(async () => (await getMergedRouter()).createCaller(await createContext()));
-    const callerProxy = createAsyncCallerProxy(getCaller);
-    const helpers = createHydrationHelpers(callerProxy, getQueryClient);
-    const handler = async (req) => fetchRequestHandler({
-        endpoint: '/api/trpc',
-        req,
-        router: await getMergedRouter(),
-        createContext: () => createTRPCContext({ headers: req.headers }),
-        onError: opts.onError ??
-            (process.env.NODE_ENV === 'development'
-                ? ({ path, error }) => {
-                    console.error(`tRPC failed on ${path ?? '<no-path>'}: ${error.message}`);
-                }
-                : undefined),
-    });
-    return {
-        appRouter,
-        handler: { GET: handler, POST: handler },
-        api: helpers.trpc,
-        HydrateClient: helpers.HydrateClient,
-        createCaller: createCallerFactory(appRouter),
-        getRouter: getMergedRouter,
-    };
-}

package/dist/api/utils/async-caller-proxy.d.ts

@@ -1,2 +0,0 @@
-export declare function createAsyncCallerProxy<TCaller>(getCaller: () => Promise<TCaller>): TCaller;
-//# sourceMappingURL=async-caller-proxy.d.ts.map

package/dist/api/utils/async-caller-proxy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"async-caller-proxy.d.ts","sourceRoot":"","sources":["../../../src/api/utils/async-caller-proxy.ts"],"names":[],"mappings":"AAWA,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAyB1F"}

package/dist/api/utils/async-caller-proxy.js

@@ -1,36 +0,0 @@
-const resolveCallerPath = (root, path) => {
-    let current = root;
-    for (const key of path) {
-        if (!current || (typeof current !== 'object' && typeof current !== 'function')) {
-            return undefined;
-        }
-        current = current[key];
-    }
-    return current;
-};
-export function createAsyncCallerProxy(getCaller) {
-    const callProcedure = async (path, args) => {
-        const caller = await getCaller();
-        const proc = resolveCallerPath(caller, path);
-        if (typeof proc !== 'function') {
-            throw new Error(`tRPC procedure not found: ${path.join('.')}`);
-        }
-        return proc(...args);
-    };
-    const createCallerProxy = (path = []) => {
-        const proxyTarget = (...args) => callProcedure(path, args);
-        return new Proxy(proxyTarget, {
-            get(_target, prop) {
-                if (prop === 'then')
-                    return undefined;
-                if (typeof prop !== 'string')
-                    return undefined;
-                return createCallerProxy([...path, prop]);
-            },
-            apply(_target, _thisArg, args) {
-                return callProcedure(path, args);
-            },
-        });
-    };
-    return createCallerProxy();
-}

package/dist/api/utils/lazy-caller-proxy.d.ts

@@ -1,2 +0,0 @@
-export declare function createLazyCallerProxy<TCaller>(getCaller: () => Promise<TCaller>): TCaller;
-//# sourceMappingURL=lazy-caller-proxy.d.ts.map

package/dist/api/utils/lazy-caller-proxy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lazy-caller-proxy.d.ts","sourceRoot":"","sources":["../../../src/api/utils/lazy-caller-proxy.ts"],"names":[],"mappings":"AAWA,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAyBzF"}

package/dist/api/utils/lazy-caller-proxy.js

@@ -1,36 +0,0 @@
-const resolveCallerPath = (root, path) => {
-    let current = root;
-    for (const key of path) {
-        if (!current || (typeof current !== 'object' && typeof current !== 'function')) {
-            return undefined;
-        }
-        current = current[key];
-    }
-    return current;
-};
-export function createLazyCallerProxy(getCaller) {
-    const callProcedure = async (path, args) => {
-        const caller = await getCaller();
-        const proc = resolveCallerPath(caller, path);
-        if (typeof proc !== 'function') {
-            throw new Error(`tRPC procedure not found: ${path.join('.')}`);
-        }
-        return proc(...args);
-    };
-    const createCallerProxy = (path = []) => {
-        const proxyTarget = (...args) => callProcedure(path, args);
-        return new Proxy(proxyTarget, {
-            get(_target, prop) {
-                if (prop === 'then')
-                    return undefined;
-                if (typeof prop !== 'string')
-                    return undefined;
-                return createCallerProxy([...path, prop]);
-            },
-            apply(_target, _thisArg, args) {
-                return callProcedure(path, args);
-            },
-        });
-    };
-    return createCallerProxy();
-}

package/dist/api/utils/router-types.d.ts

@@ -1,7 +0,0 @@
-import type { AnyRouter } from '@trpc/server';
-import type { CoreRouters } from '../root.js';
-export type RouterRecord = Record<string, AnyRouter>;
-export type NonConflictingRouterRecord<TUser extends RouterRecord> = Extract<keyof TUser, keyof CoreRouters> extends never ? TUser : {
-    [K in keyof TUser]: K extends keyof CoreRouters ? never : TUser[K];
-};
-//# sourceMappingURL=router-types.d.ts.map

package/dist/api/utils/router-types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"router-types.d.ts","sourceRoot":"","sources":["../../../src/api/utils/router-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAE7C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAE7C,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;AAEpD,MAAM,MAAM,0BAA0B,CAAC,KAAK,SAAS,YAAY,IAC7D,OAAO,CAAC,MAAM,KAAK,EAAE,MAAM,WAAW,CAAC,SAAS,KAAK,GAC/C,KAAK,GACL;KACK,CAAC,IAAI,MAAM,KAAK,GAAG,CAAC,SAAS,MAAM,WAAW,GAAG,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC;CACrE,CAAA"}

package/dist/plugins/manifest.d.ts

@@ -1,28 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,83 +0,0 @@
-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/registry.d.ts

@@ -1,22 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,25 +0,0 @@
-/**
- * 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/utils/log.d.ts

@@ -1,18 +0,0 @@
-/**
- * Unified console output for runtime warnings, errors, and info messages
- * outside of CLI commands.
- *
- * Format: `<glyph> [<scope>] <message>` — color-coded so misconfiguration and
- * runtime hiccups stand out in dev server output.
- *
- * - `logWarn`  — yellow ⚠, non-fatal misconfiguration the dev should address.
- * - `logError` — red ✗, recoverable runtime error or skipped operation.
- * - `logInfo`  — gray ℹ, hint or non-actionable note.
- *
- * For CLI commands use clack/`p.log.*` with chalk directly — they have their
- * own UX conventions.
- */
-export declare const logWarn: (scope: string, message: string) => void;
-export declare const logError: (scope: string, message: string, cause?: unknown) => void;
-export declare const logInfo: (scope: string, message: string) => void;
-//# sourceMappingURL=log.d.ts.map

package/dist/utils/log.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../src/utils/log.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,OAAO,GAAI,OAAO,MAAM,EAAE,SAAS,MAAM,KAAG,IAExD,CAAA;AAED,eAAO,MAAM,QAAQ,GAAI,OAAO,MAAM,EAAE,SAAS,MAAM,EAAE,QAAQ,OAAO,KAAG,IAM1E,CAAA;AAED,eAAO,MAAM,OAAO,GAAI,OAAO,MAAM,EAAE,SAAS,MAAM,KAAG,IAExD,CAAA"}

package/dist/utils/log.js

@@ -1,28 +0,0 @@
-import chalk from 'chalk';
-/**
- * Unified console output for runtime warnings, errors, and info messages
- * outside of CLI commands.
- *
- * Format: `<glyph> [<scope>] <message>` — color-coded so misconfiguration and
- * runtime hiccups stand out in dev server output.
- *
- * - `logWarn`  — yellow ⚠, non-fatal misconfiguration the dev should address.
- * - `logError` — red ✗, recoverable runtime error or skipped operation.
- * - `logInfo`  — gray ℹ, hint or non-actionable note.
- *
- * For CLI commands use clack/`p.log.*` with chalk directly — they have their
- * own UX conventions.
- */
-export const logWarn = (scope, message) => {
-    console.warn(chalk.yellow(`⚠ [${scope}] ${message}`));
-};
-export const logError = (scope, message, cause) => {
-    if (cause === undefined) {
-        console.error(chalk.red(`✗ [${scope}] ${message}`));
-        return;
-    }
-    console.error(chalk.red(`✗ [${scope}] ${message}`), cause);
-};
-export const logInfo = (scope, message) => {
-    console.info(chalk.gray(`ℹ [${scope}] ${message}`));
-};