nextpluggable 0.0.0-stage → 0.1.1

package/dist/dashboard/ui.js

@@ -0,0 +1,135 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from 'react';
+export class ApiError extends Error {
+    status;
+    fields;
+    constructor(message, status, fields) {
+        super(message);
+        this.status = status;
+        this.fields = fields;
+    }
+}
+export function createApi(apiPath, onUnauthorized) {
+    return async (method, path, body) => {
+        let res;
+        try {
+            res = await fetch(`${apiPath}${path}`, {
+                method,
+                credentials: 'same-origin',
+                headers: { 'x-nextpluggable': '1', ...(body !== undefined ? { 'content-type': 'application/json' } : {}) },
+                body: body !== undefined ? JSON.stringify(body) : undefined,
+                cache: 'no-store',
+            });
+        }
+        catch {
+            throw new ApiError('Could not reach the site. Check your connection and try again.', 0);
+        }
+        const data = (await res.json().catch(() => null));
+        if (!res.ok) {
+            if (res.status === 401 && path.startsWith('/admin'))
+                onUnauthorized();
+            throw new ApiError(data?.error ?? 'Something went wrong. Please try again.', res.status, data?.fields);
+        }
+        return data;
+    };
+}
+export function Button(props) {
+    const { variant, small, busy, className, children, disabled, ...rest } = props;
+    const cls = ['np-btn', variant ? `np-btn-${variant}` : '', small ? 'np-btn-sm' : '', className ?? ''].filter(Boolean).join(' ');
+    return (_jsxs("button", { type: "button", ...rest, className: cls, disabled: disabled || busy, "aria-busy": busy || undefined, children: [busy ? _jsx("span", { className: "np-spin", "aria-hidden": "true" }) : null, children] }));
+}
+export function Switch(props) {
+    return (_jsxs("label", { className: "np-switch", children: [_jsx("input", { type: "checkbox", role: "switch", checked: props.checked, disabled: props.disabled, "aria-label": props.label, onChange: (e) => props.onChange(e.target.checked) }), _jsx("i", { "aria-hidden": "true" }), props.showLabel ? _jsx("span", { children: props.label }) : null] }));
+}
+export function PluginIcon({ icon, name }) {
+    return (_jsx("span", { className: "np-icon", "aria-hidden": "true", children: icon?.startsWith('data:') ? _jsx("img", { src: icon, alt: "" }) : (icon ?? name.slice(0, 1).toUpperCase()) }));
+}
+export function Modal(props) {
+    const ref = React.useRef(null);
+    const titleId = React.useId();
+    const { onClose } = props;
+    React.useEffect(() => {
+        const previous = document.activeElement;
+        ref.current?.focus();
+        const onKey = (e) => e.key === 'Escape' && onClose();
+        document.addEventListener('keydown', onKey);
+        return () => {
+            document.removeEventListener('keydown', onKey);
+            previous?.focus?.();
+        };
+    }, [onClose]);
+    return (_jsx("div", { className: "np-overlay", onMouseDown: (e) => e.target === e.currentTarget && onClose(), children: _jsxs("div", { className: "np-modal", role: "dialog", "aria-modal": "true", "aria-labelledby": titleId, tabIndex: -1, ref: ref, children: [_jsx("header", { children: _jsx("h2", { id: titleId, children: props.title }) }), _jsx("div", { className: "np-modal-body", children: props.children }), _jsx("footer", { children: props.footer })] }) }));
+}
+export function Toasts({ toasts, dismiss }) {
+    return (_jsx("div", { className: "np-toasts", role: "status", "aria-live": "polite", children: toasts.map((t) => (_jsxs("div", { className: `np-toast${t.kind === 'error' ? ' np-toast-error' : ''}`, children: [_jsx("span", { children: t.text }), _jsx("button", { type: "button", "aria-label": "Dismiss", onClick: () => dismiss(t.id), children: "\u00D7" })] }, t.id))) }));
+}
+/** One auto-generated form control for a plugin setting. */
+export function SettingInput(props) {
+    const { field, value, error, onChange } = props;
+    const id = React.useId();
+    const describedBy = [field.help ? `${id}-help` : '', error ? `${id}-err` : ''].filter(Boolean).join(' ') || undefined;
+    const common = { id, 'aria-invalid': error ? true : undefined, 'aria-describedby': describedBy, className: 'np-input' };
+    let control;
+    switch (field.type) {
+        case 'toggle':
+            return (_jsxs("div", { className: "np-field", children: [_jsx(Switch, { checked: Boolean(value), onChange: onChange, label: field.label, showLabel: true }), field.help ? _jsx("span", { className: "np-help", children: field.help }) : null, error ? _jsx("span", { className: "np-error", children: error }) : null] }));
+        case 'textarea':
+            control = _jsx("textarea", { ...common, value: value ?? '', placeholder: field.placeholder, onChange: (e) => onChange(e.target.value) });
+            break;
+        case 'number':
+            control = (_jsx("input", { ...common, type: "number", inputMode: "decimal", value: value === undefined ? '' : String(value), min: field.min, max: field.max, step: field.step ?? 'any', placeholder: field.placeholder, onChange: (e) => onChange(e.target.value === '' ? undefined : Number(e.target.value)) }));
+            break;
+        case 'select':
+            control = (_jsxs("select", { ...common, value: value ?? '', onChange: (e) => onChange(e.target.value || undefined), children: [!field.required || value === undefined ? _jsx("option", { value: "", children: "Choose\u2026" }) : null, field.options?.map((o) => (_jsx("option", { value: o.value, children: o.label }, o.value)))] }));
+            break;
+        case 'color':
+            control = (_jsxs("span", { className: "np-color", children: [_jsx("input", { type: "color", "aria-label": `${field.label} picker`, value: /^#[0-9a-f]{6}$/i.test(String(value)) ? String(value) : '#000000', onChange: (e) => onChange(e.target.value) }), _jsx("input", { ...common, style: { maxWidth: 140 }, value: value ?? '', placeholder: field.placeholder ?? '#2563eb', onChange: (e) => onChange(e.target.value) })] }));
+            break;
+        case 'secret':
+            control = (_jsx("input", { ...common, type: "password", autoComplete: "new-password", value: value ?? '', placeholder: props.secretSet ? 'Saved. Type to replace it' : field.placeholder, onChange: (e) => onChange(e.target.value === '' ? undefined : e.target.value) }));
+            break;
+        default:
+            control = (_jsx("input", { ...common, type: field.type === 'url' ? 'url' : field.type === 'email' ? 'email' : 'text', value: value ?? '', placeholder: field.placeholder, onChange: (e) => onChange(e.target.value) }));
+    }
+    return (_jsxs("div", { className: "np-field", children: [_jsxs("label", { htmlFor: id, children: [field.label, field.required ? _jsx("span", { "aria-hidden": "true", children: " *" }) : null] }), control, field.help ? (_jsx("span", { className: "np-help", id: `${id}-help`, children: field.help })) : null, field.type === 'secret' ? _jsx("span", { className: "np-help", children: "Kept private on the server. It is never shown again after saving." }) : null, error ? (_jsx("span", { className: "np-error", id: `${id}-err`, children: error })) : null] }));
+}
+const SLOT_NAMES = {
+    'header.actions': 'your site header',
+    header: 'your site header',
+    footer: 'your site footer',
+    'body.end': 'every page',
+    sidebar: 'your sidebar',
+};
+/** What a plugin adds and is allowed to do, in plain language. */
+export function describePlugin(p) {
+    const out = [];
+    for (const page of p.pages)
+        out.push(`Adds the page “${page.title}” at ${page.path}`);
+    for (const slot of p.slots)
+        out.push(`Shows something in ${SLOT_NAMES[slot] ?? `the “${slot}” area of your site`}`);
+    for (const title of p.adminPages)
+        out.push(`Adds a “${title}” screen to this dashboard`);
+    if (p.permissions.includes('storage'))
+        out.push('Saves its own data on your site');
+    if (p.permissions.includes('email'))
+        out.push('Sends email from your site');
+    for (const perm of p.permissions)
+        if (perm.startsWith('fetch:'))
+            out.push(perm === 'fetch:*' ? 'Connects to other services on the internet' : `Connects to ${perm.slice(6)}`);
+    if (p.hasServer)
+        out.push('Runs its own code on your site’s server');
+    return out;
+}
+export function timeAgo(iso) {
+    if (!iso)
+        return 'never';
+    const s = Math.max(0, (Date.now() - new Date(iso).getTime()) / 1000);
+    if (s < 90)
+        return 'just now';
+    if (s < 3600)
+        return `${Math.round(s / 60)} minutes ago`;
+    if (s < 86_400)
+        return `${Math.round(s / 3600)} hour${Math.round(s / 3600) === 1 ? '' : 's'} ago`;
+    return `${Math.round(s / 86_400)} day${Math.round(s / 86_400) === 1 ? '' : 's'} ago`;
+}

package/dist/errors.d.ts

@@ -0,0 +1,15 @@
+/** An error whose message is safe and useful to show to a non-technical dashboard user. */
+export declare class HttpError extends Error {
+    readonly status: number;
+    readonly fields?: Record<string, string> | undefined;
+    constructor(status: number, message: string, fields?: Record<string, string> | undefined);
+}
+export declare function jsonResponse(body: unknown, status?: number, headers?: Record<string, string>): Response;
+/**
+ * A plugin's stored files are gone. Normally this means it was removed (or
+ * updated) on another server instance and this instance's cached list is stale.
+ */
+export declare class PluginGoneError extends Error {
+    readonly pluginId: string;
+    constructor(pluginId: string);
+}

package/dist/errors.js

@@ -0,0 +1,29 @@
+/** An error whose message is safe and useful to show to a non-technical dashboard user. */
+export class HttpError extends Error {
+    status;
+    fields;
+    constructor(status, message, fields) {
+        super(message);
+        this.status = status;
+        this.fields = fields;
+        this.name = 'HttpError';
+    }
+}
+export function jsonResponse(body, status = 200, headers) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store', ...headers },
+    });
+}
+/**
+ * A plugin's stored files are gone. Normally this means it was removed (or
+ * updated) on another server instance and this instance's cached list is stale.
+ */
+export class PluginGoneError extends Error {
+    pluginId;
+    constructor(pluginId) {
+        super(`The files of plugin "${pluginId}" are missing from storage. If it should be installed, remove it and install it again.`);
+        this.pluginId = pluginId;
+        this.name = 'PluginGoneError';
+    }
+}

package/dist/globals.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Process-wide state. Next.js compiles server components, route handlers and
+ * the SSR pass of client components as separate module graphs, so module-level
+ * variables are not shared between them — `globalThis` is.
+ */
+export declare const GLOBAL_KEY: unique symbol;
+export interface Globals {
+    /** Client bundle source keyed by module key, handed from the server layer to the SSR layer. */
+    ssrCode: Map<string, string>;
+    /** Evaluated plugin server modules keyed by content hash. */
+    serverModules: Map<string, unknown>;
+    /** Immutable stored files keyed by storage key. */
+    files: Map<string, string>;
+    /** Cached list of installed plugins, keyed by the instance's API path. */
+    state: Map<string, {
+        at: number;
+        value: unknown;
+    }>;
+    /** Failed sign-in timestamps keyed by client address. */
+    loginAttempts: Map<string, number[]>;
+    warned: Set<string>;
+}
+export declare function globals(): Globals;
+export declare function warnOnce(key: string, message: string): void;

package/dist/globals.js

@@ -0,0 +1,24 @@
+/**
+ * Process-wide state. Next.js compiles server components, route handlers and
+ * the SSR pass of client components as separate module graphs, so module-level
+ * variables are not shared between them — `globalThis` is.
+ */
+export const GLOBAL_KEY = Symbol.for('nextpluggable.state');
+export function globals() {
+    const g = globalThis;
+    return (g[GLOBAL_KEY] ??= {
+        ssrCode: new Map(),
+        serverModules: new Map(),
+        files: new Map(),
+        state: new Map(),
+        loginAttempts: new Map(),
+        warned: new Set(),
+    });
+}
+export function warnOnce(key, message) {
+    const g = globals();
+    if (g.warned.has(key))
+        return;
+    g.warned.add(key);
+    console.warn(`[nextpluggable] ${message}`);
+}

package/dist/index.d.ts

@@ -0,0 +1,47 @@
+import { type NextPluggableConfig } from './config.js';
+export type { NextPluggableConfig } from './config.js';
+export type { AdminUser, AuthAdapter } from './auth/types.js';
+export type { StorageAdapter } from './storage/types.js';
+export type { PluginPageProps } from './next/plugin-page.js';
+export type { SlotProps } from './next/slot.js';
+export type { PluginSitemapEntry } from './core/sitemap.js';
+export { passwordAuth, type PasswordAuthOptions } from './auth/password.js';
+export { customAuth, type CustomAuthOptions } from './auth/custom.js';
+export { fileStorage, type FileStorageOptions } from './storage/file.js';
+export { memoryStorage } from './storage/memory.js';
+export { upstashStorage, type UpstashStorageOptions } from './storage/upstash.js';
+export { postgresStorage, type PostgresStorageOptions } from './storage/postgres.js';
+/**
+ * Set up NextPluggable for a Next.js site. Call once (e.g. in `lib/nextpluggable.ts`)
+ * and wire the returned pieces into three route files — see the README.
+ */
+export declare function createNextPluggable(config?: NextPluggableConfig): {
+    /** Route handlers for `app/api/nextpluggable/[...np]/route.ts`. */
+    handlers: {
+        GET: (request: Request) => Promise<Response>;
+        POST: (request: Request) => Promise<Response>;
+        PUT: (request: Request) => Promise<Response>;
+        PATCH: (request: Request) => Promise<Response>;
+        DELETE: (request: Request) => Promise<Response>;
+    };
+    /** Page for `app/admin/plugins/[[...np]]/page.tsx`. */
+    DashboardPage: () => Promise<import("react").ReactNode>;
+    dashboardMetadata: import("next").Metadata;
+    /** Page for the root catch-all `app/[...slug]/page.tsx`: serves pages added by plugins. */
+    PluginPage: (props: import("./index.js").PluginPageProps) => Promise<import("react").ReactNode>;
+    generatePluginMetadata: (props: import("./index.js").PluginPageProps, parent?: import("next").ResolvingMetadata) => Promise<import("next").Metadata>;
+    /**
+     * `await np.hasPluginPage('/some/address')`: does a plugin serve a page there? Use it in a
+     * catch-all route of your own to decide whether to render `PluginPage` or your own content.
+     */
+    hasPluginPage: (pathname: string) => Promise<boolean>;
+    /**
+     * `await np.sitemap()`: the address of every page that switched-on plugins serve and
+     * search engines may index, as `{ url, lastModified? }`. Add them to `app/sitemap.ts`.
+     * Never throws.
+     */
+    sitemap: () => Promise<import("./index.js").PluginSitemapEntry[]>;
+    /** `<Slot name="…" />` — a place in your layout that plugins can fill. */
+    Slot: ({ name }: import("./index.js").SlotProps) => Promise<import("react").ReactNode>;
+};
+export type NextPluggable = ReturnType<typeof createNextPluggable>;

package/dist/index.js

@@ -0,0 +1,65 @@
+import { revalidatePath } from 'next/cache';
+import { createHandler } from './api/handler.js';
+import { resolveConfig } from './config.js';
+import { pluginSitemap } from './core/sitemap.js';
+import { createDashboardPage, dashboardMetadata } from './next/dashboard-page.js';
+import { createPluginPage } from './next/plugin-page.js';
+import { createSlot } from './next/slot.js';
+export { passwordAuth } from './auth/password.js';
+export { customAuth } from './auth/custom.js';
+export { fileStorage } from './storage/file.js';
+export { memoryStorage } from './storage/memory.js';
+export { upstashStorage } from './storage/upstash.js';
+export { postgresStorage } from './storage/postgres.js';
+/**
+ * Set up NextPluggable for a Next.js site. Call once (e.g. in `lib/nextpluggable.ts`)
+ * and wire the returned pieces into three route files — see the README.
+ */
+export function createNextPluggable(config = {}) {
+    const getConfig = resolveConfig(config);
+    const handle = createHandler(getConfig, {
+        // Anything cached by Next.js (static pages, ISR) is refreshed when plugins change.
+        onSiteChange() {
+            try {
+                revalidatePath('/', 'layout');
+                revalidatePath('/sitemap.xml');
+            }
+            catch (e) {
+                console.warn('[nextpluggable] Could not refresh cached pages:', e);
+            }
+        },
+    });
+    const { PluginPage, generatePluginMetadata, hasPluginPage } = createPluginPage(getConfig);
+    return {
+        /** Route handlers for `app/api/nextpluggable/[...np]/route.ts`. */
+        handlers: { GET: handle, POST: handle, PUT: handle, PATCH: handle, DELETE: handle },
+        /** Page for `app/admin/plugins/[[...np]]/page.tsx`. */
+        DashboardPage: createDashboardPage(getConfig),
+        dashboardMetadata,
+        /** Page for the root catch-all `app/[...slug]/page.tsx`: serves pages added by plugins. */
+        PluginPage,
+        generatePluginMetadata,
+        /**
+         * `await np.hasPluginPage('/some/address')`: does a plugin serve a page there? Use it in a
+         * catch-all route of your own to decide whether to render `PluginPage` or your own content.
+         */
+        hasPluginPage,
+        /**
+         * `await np.sitemap()`: the address of every page that switched-on plugins serve and
+         * search engines may index, as `{ url, lastModified? }`. Add them to `app/sitemap.ts`.
+         * Never throws.
+         */
+        sitemap: async () => {
+            try {
+                return await pluginSitemap(getConfig());
+            }
+            catch (e) {
+                // Setup that is not finished (no secret yet) must not break the site's sitemap.
+                console.error('[nextpluggable] Plugin pages could not be listed for the sitemap:', e);
+                return [];
+            }
+        },
+        /** `<Slot name="…" />` — a place in your layout that plugins can fill. */
+        Slot: createSlot(getConfig),
+    };
+}

package/dist/next/dashboard-page.d.ts

@@ -0,0 +1,5 @@
+import type { Metadata } from 'next';
+import type { ReactNode } from 'react';
+import type { ResolvedConfig } from '../config.js';
+export declare const dashboardMetadata: Metadata;
+export declare function createDashboardPage(getConfig: () => ResolvedConfig): () => Promise<ReactNode>;

package/dist/next/dashboard-page.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { headers } from 'next/headers';
+import { sessionView } from '../api/handler.js';
+import { Dashboard } from '../dashboard/Dashboard.js';
+export const dashboardMetadata = {
+    title: 'Plugins',
+    robots: { index: false, follow: false },
+};
+export function createDashboardPage(getConfig) {
+    /** Server component for the dashboard route. Checks who is signed in, then hands over to the client UI. */
+    return async function DashboardPage() {
+        let cfg;
+        try {
+            cfg = getConfig();
+        }
+        catch (e) {
+            return _jsx(Dashboard, { apiPath: "", dashboardPath: "", siteName: "", session: { user: null, mode: 'password', configured: false }, setupError: e instanceof Error ? e.message.replace('[nextpluggable] ', '') : 'Setup is incomplete.' });
+        }
+        const incoming = await headers();
+        const request = new Request(new URL(cfg.dashboardPath, cfg.siteUrl), { headers: new Headers([...incoming.entries()]) });
+        return _jsx(Dashboard, { apiPath: cfg.apiPath, dashboardPath: cfg.dashboardPath, siteName: cfg.siteName, session: await sessionView(cfg, request) });
+    };
+}

package/dist/next/plugin-page.d.ts

@@ -0,0 +1,16 @@
+import type { Metadata, ResolvingMetadata } from 'next';
+import { type ReactNode } from 'react';
+import type { PluginInfo } from '@nextpluggable/plugin';
+import type { ResolvedConfig } from '../config.js';
+import type { InstallRecord } from '../core/types.js';
+type RouteParams = Promise<Record<string, string | string[] | undefined>>;
+export interface PluginPageProps {
+    params: RouteParams;
+}
+export declare function pluginInfo(cfg: ResolvedConfig, install: InstallRecord, page?: PluginInfo['page']): PluginInfo;
+export declare function createPluginPage(getConfig: () => ResolvedConfig): {
+    PluginPage: (props: PluginPageProps) => Promise<ReactNode>;
+    generatePluginMetadata: (props: PluginPageProps, parent?: ResolvingMetadata) => Promise<Metadata>;
+    hasPluginPage: (pathname: string) => Promise<boolean>;
+};
+export {};

package/dist/next/plugin-page.js

@@ -0,0 +1,91 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { notFound, redirect } from 'next/navigation';
+import { cache } from 'react';
+import { PluginIsland } from '../client/island.js';
+import { effectivePaths, findPage, normalizePathname } from '../core/routes.js';
+import { prepareClient, publicConfig, runPageLoader } from '../core/runtime.js';
+import { getInstalledPlugins, invalidateInstalledPlugins } from '../core/state.js';
+import { PluginGoneError } from '../errors.js';
+import { pageJsonLd, pageMetadata, pageSeo } from './seo.js';
+import { PluginStyle } from './style.js';
+/** The pathname a catch-all route was called with, whatever the segment is named. */
+async function pathnameOf(params) {
+    const values = Object.values(await params);
+    const catchAll = values.find(Array.isArray);
+    if (catchAll)
+        return normalizePathname(catchAll.join('/'));
+    return normalizePathname(typeof values[0] === 'string' ? values[0] : '/');
+}
+export function pluginInfo(cfg, install, page) {
+    return { id: install.id, version: install.manifest.version, apiBase: `${cfg.apiPath}/p/${install.id}`, paths: effectivePaths(install), page };
+}
+export function createPluginPage(getConfig) {
+    // `cache` de-duplicates the work between generateMetadata and the page within one request.
+    const run = cache(async (pathname) => {
+        const attempt = async () => {
+            const cfg = getConfig();
+            const match = findPage(await getInstalledPlugins(cfg), pathname);
+            if (!match)
+                return null;
+            const result = await runPageLoader(cfg, match.install, match.page.id, { path: pathname, params: match.params });
+            return { pathname, match, result, assets: await prepareClient(cfg, match.install) };
+        };
+        try {
+            return await attempt();
+        }
+        catch (e) {
+            if (!(e instanceof PluginGoneError))
+                throw e;
+            // This instance's list of plugins was stale (the plugin was just removed or updated elsewhere): look again.
+            invalidateInstalledPlugins(getConfig());
+            try {
+                return await attempt();
+            }
+            catch (again) {
+                if (again instanceof PluginGoneError)
+                    return null;
+                throw again;
+            }
+        }
+    });
+    // Only `params` is read, never the query string, cookies or headers, so this
+    // route can be statically cached as well as rendered per request.
+    const resolveRequest = async (props) => run(await pathnameOf(props.params));
+    /**
+     * Metadata for the plugin page at the requested address. Pass Next.js's second
+     * `generateMetadata` argument through as `parent`, so a page without a sharing
+     * image of its own keeps the site's.
+     */
+    async function generatePluginMetadata(props, parent) {
+        const loaded = await resolveRequest(props);
+        if (!loaded || loaded.result.notFound || loaded.result.redirect)
+            return {};
+        const cfg = getConfig();
+        const inherited = parent ? await Promise.resolve(parent).catch(() => null) : null;
+        return pageMetadata(cfg, pageSeo(cfg, loaded.match.install, loaded.match.page, loaded.pathname, loaded.result), inherited);
+    }
+    /**
+     * Server component for a root catch-all route. Renders the plugin page that
+     * owns the requested address, or the site's 404 when none does.
+     */
+    async function PluginPage(props) {
+        const loaded = await resolveRequest(props);
+        if (!loaded || loaded.result.notFound || !loaded.assets)
+            notFound();
+        const { match, result, pathname, assets } = loaded;
+        if (result.redirect)
+            redirect(result.redirect);
+        const cfg = getConfig();
+        const jsonLd = pageJsonLd(cfg, pageSeo(cfg, match.install, match.page, pathname, result), result);
+        return (_jsxs(_Fragment, { children: [_jsx(PluginStyle, { assets: assets }), jsonLd.map((item, i) => (_jsx("script", { type: "application/ld+json", dangerouslySetInnerHTML: { __html: JSON.stringify(item).replace(/</g, '\\u003c') } }, i))), _jsx(PluginIsland, { moduleKey: assets.moduleKey, src: assets.scriptSrc, component: match.page.component, info: pluginInfo(cfg, match.install, { id: match.page.id, path: pathname, params: match.params }), config: publicConfig(match.install), props: { data: result.data ?? {}, params: match.params }, errorFallback: _jsx("p", { style: { padding: '48px 16px', textAlign: 'center' }, children: "This page could not be displayed. Please try again later." }) })] }));
+    }
+    /**
+     * Whether an installed, switched-on plugin serves a page at this address. For sites
+     * whose own catch-all route has to choose between a plugin page and something of its
+     * own: unlike `PluginPage`, it never triggers the site's 404.
+     */
+    async function hasPluginPage(pathname) {
+        return findPage(await getInstalledPlugins(getConfig()), normalizePathname(pathname)) !== null;
+    }
+    return { PluginPage, generatePluginMetadata, hasPluginPage };
+}

package/dist/next/seo.d.ts

@@ -0,0 +1,32 @@
+/**
+ * What a plugin page tells search engines and sharing previews. A plugin may say
+ * as little as nothing: every gap is filled here, so a page is complete by default.
+ */
+import type { Metadata, ResolvedMetadata } from 'next';
+import type { PluginPage } from '@nextpluggable/plugin/manifest';
+import type { PageResult } from '@nextpluggable/plugin/server';
+import type { ResolvedConfig } from '../config.js';
+import type { InstallRecord } from '../core/types.js';
+export interface PageSeo {
+    title: string;
+    /** Never empty: the loader's, else the page's, else the plugin's, else the title. */
+    description: string;
+    canonical?: string;
+    image?: string;
+    imageAlt: string;
+    type: 'website' | 'article';
+    publishedTime?: string;
+    modifiedTime?: string;
+    noindex: boolean;
+}
+/** An absolute URL on this site, or undefined when the value cannot be one. */
+export declare function absoluteUrl(cfg: Pick<ResolvedConfig, 'siteUrl'>, value: string): string | undefined;
+export declare function pageSeo(cfg: Pick<ResolvedConfig, 'siteUrl'>, install: InstallRecord, page: PluginPage, pathname: string, result: PageResult): PageSeo;
+/**
+ * Next.js metadata for the page. `inherited` is what the layouts above already
+ * declared: a page that brings no image of its own keeps the site's sharing image,
+ * site name and Twitter account, but never the site's title or description.
+ */
+export declare function pageMetadata(cfg: Pick<ResolvedConfig, 'publicSiteName'>, seo: PageSeo, inherited?: ResolvedMetadata | null): Metadata;
+/** Structured data for the page: the plugin's own, or a plain description of the page when it gives none. */
+export declare function pageJsonLd(cfg: Pick<ResolvedConfig, 'siteUrl' | 'publicSiteName'>, seo: PageSeo, result: PageResult): Record<string, unknown>[];

package/dist/next/seo.js

@@ -0,0 +1,86 @@
+const clean = (value) => {
+    if (typeof value !== 'string')
+        return undefined;
+    const text = value.replace(/\s+/g, ' ').trim();
+    return text || undefined;
+};
+/** An absolute URL on this site, or undefined when the value cannot be one. */
+export function absoluteUrl(cfg, value) {
+    try {
+        return new URL(value, `${cfg.siteUrl}/`).toString();
+    }
+    catch {
+        return undefined;
+    }
+}
+export function pageSeo(cfg, install, page, pathname, result) {
+    const meta = result.metadata ?? {};
+    const title = clean(meta.title) ?? page.title;
+    const image = clean(meta.image);
+    return {
+        title,
+        description: clean(meta.description) ?? clean(page.description) ?? clean(install.manifest.description) ?? title,
+        canonical: absoluteUrl(cfg, clean(meta.canonical) ?? pathname),
+        image: image ? absoluteUrl(cfg, image) : undefined,
+        imageAlt: clean(meta.imageAlt) ?? title,
+        type: meta.type === 'article' ? 'article' : 'website',
+        publishedTime: clean(meta.publishedTime),
+        modifiedTime: clean(meta.modifiedTime),
+        noindex: meta.noindex === true,
+    };
+}
+/**
+ * Next.js metadata for the page. `inherited` is what the layouts above already
+ * declared: a page that brings no image of its own keeps the site's sharing image,
+ * site name and Twitter account, but never the site's title or description.
+ */
+export function pageMetadata(cfg, seo, inherited) {
+    const og = inherited?.openGraph;
+    const tw = inherited?.twitter;
+    const ownImage = seo.image ? [{ url: seo.image, alt: seo.imageAlt }] : undefined;
+    // "player" and "app" cards need fields a page cannot supply.
+    const inheritedCard = tw?.card === 'summary' || tw?.card === 'summary_large_image' ? tw.card : undefined;
+    return {
+        title: seo.title,
+        description: seo.description,
+        alternates: seo.canonical ? { canonical: seo.canonical } : undefined,
+        openGraph: {
+            type: seo.type,
+            title: seo.title,
+            description: seo.description,
+            url: seo.canonical,
+            siteName: og?.siteName ?? cfg.publicSiteName,
+            locale: og?.locale,
+            images: ownImage ?? og?.images,
+            ...(seo.type === 'article' ? { publishedTime: seo.publishedTime, modifiedTime: seo.modifiedTime } : {}),
+        },
+        twitter: {
+            card: ownImage ? 'summary_large_image' : (inheritedCard ?? 'summary'),
+            title: seo.title,
+            description: seo.description,
+            site: tw?.site ?? undefined,
+            creator: tw?.creator ?? undefined,
+            images: ownImage ?? tw?.images,
+        },
+        robots: seo.noindex ? { index: false, follow: false } : undefined,
+    };
+}
+/** Structured data for the page: the plugin's own, or a plain description of the page when it gives none. */
+export function pageJsonLd(cfg, seo, result) {
+    if (result.jsonLd)
+        return Array.isArray(result.jsonLd) ? result.jsonLd : [result.jsonLd];
+    if (seo.noindex)
+        return [];
+    return [
+        {
+            '@context': 'https://schema.org',
+            '@type': 'WebPage',
+            name: seo.title,
+            description: seo.description,
+            ...(seo.canonical ? { url: seo.canonical } : {}),
+            ...(seo.image ? { image: seo.image } : {}),
+            ...(seo.modifiedTime ? { dateModified: seo.modifiedTime } : {}),
+            ...(cfg.publicSiteName ? { isPartOf: { '@type': 'WebSite', name: cfg.publicSiteName, url: cfg.siteUrl } } : {}),
+        },
+    ];
+}

package/dist/next/slot.d.ts

@@ -0,0 +1,7 @@
+import { type ReactNode } from 'react';
+import type { ResolvedConfig } from '../config.js';
+export interface SlotProps {
+    /** Slot name, e.g. `header.actions`, `footer`, `body.end`. Plugins declare which slots they fill. */
+    name: string;
+}
+export declare function createSlot(getConfig: () => ResolvedConfig): ({ name }: SlotProps) => Promise<ReactNode>;