nextpluggable 0.0.0-stage → 0.1.1

package/dist/core/runtime.js

@@ -0,0 +1,195 @@
+import { defaultConfig, isPublicSetting } from '@nextpluggable/plugin/manifest';
+import { decrypt, isEncrypted } from '../crypto.js';
+import { jsonResponse, PluginGoneError } from '../errors.js';
+import { globals } from '../globals.js';
+import { decodeSegment } from '../storage/types.js';
+import { effectivePaths, matchPattern, normalizePathname } from './routes.js';
+import { dataKey, getFile } from './store.js';
+/** Identifies one exact build of a plugin's client bundle (used on both server and browser). */
+export function clientModuleKey(install) {
+    return install.files.client ? `${install.id}@${install.files.client.sha256.slice(0, 16)}` : null;
+}
+export function assetUrl(cfg, pluginId, sha256, file) {
+    return `${cfg.apiPath}/assets/${pluginId}/${sha256.slice(0, 16)}/${file}`;
+}
+/** Setting values safe to send to browsers, with defaults filled in. */
+export function publicConfig(install) {
+    const out = {};
+    const defaults = defaultConfig(install.manifest);
+    for (const field of install.manifest.settings ?? []) {
+        if (!isPublicSetting(field))
+            continue;
+        const v = install.config[field.key] ?? defaults[field.key];
+        if (v !== undefined)
+            out[field.key] = v;
+    }
+    return out;
+}
+/** Every setting value, secrets decrypted. Server-side only. */
+export function serverConfig(cfg, install) {
+    const out = { ...defaultConfig(install.manifest) };
+    for (const field of install.manifest.settings ?? []) {
+        const v = install.config[field.key];
+        if (v === undefined)
+            continue;
+        if (isEncrypted(v)) {
+            const plain = decrypt(cfg.secret, v);
+            if (plain !== null)
+                out[field.key] = plain;
+        }
+        else
+            out[field.key] = v;
+    }
+    return out;
+}
+export function pluginStorage(cfg, pluginId) {
+    const prefix = `data/${pluginId}/`;
+    return {
+        async get(key) {
+            const raw = await cfg.storage.get(dataKey(pluginId, key));
+            return raw === null ? null : JSON.parse(raw);
+        },
+        async set(key, value) {
+            const raw = JSON.stringify(value);
+            if (raw === undefined)
+                throw new Error('Only JSON values can be stored.');
+            if (raw.length > 1_000_000)
+                throw new Error('A stored value may be at most 1 MB.');
+            await cfg.storage.set(dataKey(pluginId, key), raw);
+        },
+        async delete(key) {
+            await cfg.storage.delete(dataKey(pluginId, key));
+        },
+        async list(keyPrefix = '') {
+            const keys = await cfg.storage.list(prefix);
+            return keys
+                .map((k) => decodeSegment(k.slice(prefix.length)))
+                .filter((k) => k.startsWith(keyPrefix))
+                .sort();
+        },
+    };
+}
+export function pluginContext(cfg, install) {
+    return {
+        pluginId: install.id,
+        config: serverConfig(cfg, install),
+        storage: pluginStorage(cfg, install.id),
+        site: { url: cfg.siteUrl },
+        paths: effectivePaths(install),
+        log: (...args) => console.log(`[plugin:${install.id}]`, ...args),
+    };
+}
+/** Evaluate a plugin's server bundle (CommonJS, self-contained) and return what it exports. */
+export function evaluateServer(pluginId, code) {
+    const getBuiltin = process.getBuiltinModule;
+    if (!getBuiltin)
+        throw new Error('Plugins with server code need Node.js 20.16 or newer.');
+    const mod = { exports: {} };
+    const req = (name) => {
+        const builtin = getBuiltin(name);
+        if (!builtin)
+            throw new Error(`Plugin "${pluginId}" tried to load "${name}", which is not available. Server bundles may only use Node built-ins at runtime.`);
+        return builtin;
+    };
+    // Plugins are trusted code chosen by the site owner; this is deliberate evaluation, not a sandbox.
+    new Function('require', 'module', 'exports', `${code}\n//# sourceURL=nextpluggable-plugin:///${pluginId}/server.js`)(req, mod, mod.exports);
+    const server = (mod.exports.default ?? mod.exports);
+    if (!server || typeof server !== 'object')
+        throw new Error(`Plugin "${pluginId}" has an invalid server entry.`);
+    return server;
+}
+/** The plugin's server module, or null when it has none. Cached by content hash. */
+export async function loadServer(cfg, install) {
+    const file = install.files.server;
+    if (!file)
+        return null;
+    const cache = globals().serverModules;
+    const key = `${install.id}@${file.sha256}`;
+    const hit = cache.get(key);
+    if (hit)
+        return hit;
+    const code = await getFile(cfg.storage, install.id, 'server', file.sha256);
+    if (code === null)
+        throw new PluginGoneError(install.id);
+    const server = evaluateServer(install.id, code);
+    for (const k of cache.keys())
+        if (k.startsWith(`${install.id}@`))
+            cache.delete(k);
+    cache.set(key, server);
+    return server;
+}
+/** Larger stylesheets are linked: inlining them would bloat every page that shows the plugin. */
+const INLINE_STYLE_MAX_BYTES = 32_000;
+/**
+ * Make a plugin's client bundle available to the SSR pass of this process and
+ * return the URLs the browser loads it from.
+ */
+export async function prepareClient(cfg, install) {
+    const client = install.files.client;
+    const moduleKey = clientModuleKey(install);
+    if (!client || !moduleKey)
+        return null;
+    const ssr = globals().ssrCode;
+    if (!ssr.has(moduleKey)) {
+        const code = await getFile(cfg.storage, install.id, 'client', client.sha256);
+        if (code === null)
+            throw new PluginGoneError(install.id);
+        for (const k of ssr.keys())
+            if (k.startsWith(`${install.id}@`))
+                ssr.delete(k);
+        ssr.set(moduleKey, code);
+    }
+    const style = install.files.style;
+    const styleCss = style && cfg.inlineStyles && style.bytes <= INLINE_STYLE_MAX_BYTES ? ((await getFile(cfg.storage, install.id, 'style', style.sha256)) ?? undefined) : undefined;
+    return {
+        moduleKey,
+        scriptSrc: assetUrl(cfg, install.id, client.sha256, 'client.js'),
+        styleHref: style ? assetUrl(cfg, install.id, style.sha256, 'style.css') : undefined,
+        styleCss,
+    };
+}
+export async function runPageLoader(cfg, install, pageId, input) {
+    const server = await loadServer(cfg, install);
+    const loader = server?.pages?.[pageId];
+    if (!loader)
+        return {};
+    const ctx = { ...pluginContext(cfg, install), ...input };
+    const result = await loader(ctx);
+    return result && typeof result === 'object' ? result : {};
+}
+/** Dispatch a request to a plugin's API handlers (`"METHOD /path"` keys). */
+export async function handlePluginApi(cfg, install, request, subpath, admin) {
+    let server;
+    try {
+        server = await loadServer(cfg, install);
+    }
+    catch (e) {
+        console.error(`[nextpluggable] Could not load plugin "${install.id}":`, e);
+        return jsonResponse({ error: 'This plugin could not be loaded.' }, 500);
+    }
+    const path = normalizePathname(subpath);
+    const method = request.method.toUpperCase() === 'HEAD' ? 'GET' : request.method.toUpperCase();
+    let methodMismatch = false;
+    for (const [key, handler] of Object.entries(server?.api ?? {})) {
+        const space = key.indexOf(' ');
+        const params = matchPattern(key.slice(space + 1), path);
+        if (!params)
+            continue;
+        if (key.slice(0, space) !== method) {
+            methodMismatch = true;
+            continue;
+        }
+        const ctx = { ...pluginContext(cfg, install), request, path, params, admin };
+        try {
+            const res = await handler(ctx);
+            if (!res || typeof res.status !== 'number' || typeof res.headers?.get !== 'function')
+                throw new Error(`Handler "${key}" did not return a Response.`);
+            return res;
+        }
+        catch (e) {
+            console.error(`[nextpluggable] Plugin "${install.id}" failed handling ${key}:`, e);
+            return jsonResponse({ error: 'The plugin ran into a problem handling this request.' }, 500);
+        }
+    }
+    return methodMismatch ? jsonResponse({ error: 'Method not allowed.' }, 405) : jsonResponse({ error: 'Not found.' }, 404);
+}

package/dist/core/sitemap.d.ts

@@ -0,0 +1,12 @@
+import type { ResolvedConfig } from '../config.js';
+export interface PluginSitemapEntry {
+    url: string;
+    lastModified?: Date;
+}
+/**
+ * Every address that switched-on plugins serve and that search engines may index, for
+ * the site's sitemap. Never throws: a plugin that fails while listing its pages keeps
+ * what it had listed so far, and a storage outage yields an empty list rather than a
+ * broken sitemap.
+ */
+export declare function pluginSitemap(cfg: ResolvedConfig): Promise<PluginSitemapEntry[]>;

package/dist/core/sitemap.js

@@ -0,0 +1,83 @@
+import { isStaticPath } from '@nextpluggable/plugin/manifest';
+import { effectivePaths, findPage, normalizePathname } from './routes.js';
+import { loadServer, pluginContext, runPageLoader } from './runtime.js';
+import { getInstalledPlugins } from './state.js';
+/** A plugin may list this many addresses; a sitemap file holds 50,000 in all. */
+const MAX_PER_PLUGIN = 10_000;
+const toDate = (value) => {
+    if (typeof value !== 'string' && !(value instanceof Date))
+        return undefined;
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? undefined : date;
+};
+async function entriesOf(cfg, install, add) {
+    const paths = effectivePaths(install);
+    const updated = toDate(install.updatedAt);
+    // Pages with a fixed address. The loader decides whether the page exists and may be indexed.
+    for (const page of install.manifest.pages ?? []) {
+        const address = paths[page.id];
+        if (!isStaticPath(address))
+            continue;
+        const result = await runPageLoader(cfg, install, page.id, { path: address, params: {} });
+        if (result.notFound || result.redirect || result.metadata?.noindex)
+            continue;
+        const canonical = result.metadata?.canonical;
+        // A page that names another address as the real one is not listed under its own.
+        if (canonical && new URL(canonical, `${cfg.siteUrl}/`).pathname !== address)
+            continue;
+        add(address, toDate(result.metadata?.modifiedTime) ?? updated);
+    }
+    // Pages with parameters: only the plugin knows which addresses exist.
+    const server = await loadServer(cfg, install);
+    if (typeof server?.sitemap !== 'function')
+        return;
+    const listed = await server.sitemap(pluginContext(cfg, install));
+    if (!Array.isArray(listed))
+        return;
+    const own = { [install.id]: install };
+    for (const entry of listed.slice(0, MAX_PER_PLUGIN)) {
+        const raw = typeof entry === 'string' ? entry : entry?.path;
+        if (typeof raw !== 'string' || !raw.startsWith('/'))
+            continue;
+        const address = normalizePathname(raw);
+        // A plugin can only add addresses of its own pages.
+        if (!findPage(own, address))
+            continue;
+        add(address, typeof entry === 'string' ? undefined : toDate(entry.lastModified));
+    }
+}
+/**
+ * Every address that switched-on plugins serve and that search engines may index, for
+ * the site's sitemap. Never throws: a plugin that fails while listing its pages keeps
+ * what it had listed so far, and a storage outage yields an empty list rather than a
+ * broken sitemap.
+ */
+export async function pluginSitemap(cfg) {
+    const out = new Map();
+    try {
+        for (const install of Object.values(await getInstalledPlugins(cfg))) {
+            if (!install.enabled)
+                continue;
+            try {
+                await entriesOf(cfg, install, (address, lastModified) => {
+                    let url;
+                    try {
+                        url = new URL(address, `${cfg.siteUrl}/`).toString();
+                    }
+                    catch {
+                        return;
+                    }
+                    if (!out.has(url))
+                        out.set(url, lastModified ? { url, lastModified } : { url });
+                });
+            }
+            catch (e) {
+                console.error(`[nextpluggable] Plugin "${install.id}" could not list all of its pages for the sitemap:`, e);
+            }
+        }
+    }
+    catch (e) {
+        console.error('[nextpluggable] Plugin pages could not be listed for the sitemap:', e);
+    }
+    return [...out.values()];
+}

package/dist/core/state.d.ts

@@ -0,0 +1,13 @@
+import type { ResolvedConfig } from '../config.js';
+import type { Installs } from './types.js';
+/**
+ * Installed plugins, read through a short-lived per-process cache so that a
+ * page render costs at most one storage read every `cacheTtlMs`.
+ *
+ * The cache lives on `globalThis` and is keyed by the instance's API path, not
+ * by any object identity: Next.js loads the site's setup module once per module
+ * graph (pages, route handlers), and a change made through the dashboard's
+ * route handler must be visible to the very next page render.
+ */
+export declare function getInstalledPlugins(cfg: ResolvedConfig): Promise<Installs>;
+export declare function invalidateInstalledPlugins(cfg: ResolvedConfig): void;

package/dist/core/state.js

@@ -0,0 +1,23 @@
+import { globals } from '../globals.js';
+import { getInstalls } from './store.js';
+/**
+ * Installed plugins, read through a short-lived per-process cache so that a
+ * page render costs at most one storage read every `cacheTtlMs`.
+ *
+ * The cache lives on `globalThis` and is keyed by the instance's API path, not
+ * by any object identity: Next.js loads the site's setup module once per module
+ * graph (pages, route handlers), and a change made through the dashboard's
+ * route handler must be visible to the very next page render.
+ */
+export async function getInstalledPlugins(cfg) {
+    const cache = globals().state;
+    const hit = cache.get(cfg.apiPath);
+    if (hit && Date.now() - hit.at < cfg.cacheTtlMs)
+        return hit.value;
+    const value = await getInstalls(cfg.storage);
+    cache.set(cfg.apiPath, { at: Date.now(), value });
+    return value;
+}
+export function invalidateInstalledPlugins(cfg) {
+    globals().state.delete(cfg.apiPath);
+}

package/dist/core/store.d.ts

@@ -0,0 +1,17 @@
+import { type StorageAdapter } from '../storage/types.js';
+import type { Catalog, FileKind, Installs, SourceRecord, StoredFile } from './types.js';
+export declare const getSources: (s: StorageAdapter) => Promise<SourceRecord[]>;
+export declare const saveSources: (s: StorageAdapter, sources: SourceRecord[]) => Promise<void>;
+export declare const getInstalls: (s: StorageAdapter) => Promise<Installs>;
+export declare const saveInstalls: (s: StorageAdapter, installs: Installs) => Promise<void>;
+export declare const getCatalog: (s: StorageAdapter, sourceId: string) => Promise<Catalog | null>;
+export declare const saveCatalog: (s: StorageAdapter, catalog: Catalog) => Promise<void>;
+export declare const deleteCatalog: (s: StorageAdapter, sourceId: string) => Promise<void>;
+export declare const fileKey: (pluginId: string, kind: FileKind, sha256: string) => string;
+export declare function putFile(s: StorageAdapter, pluginId: string, kind: FileKind, sha256: string, content: string): Promise<void>;
+/** Plugin files are content-addressed and never change, so they are cached in memory for the life of the process. */
+export declare function getFile(s: StorageAdapter, pluginId: string, kind: FileKind, sha256: string): Promise<string | null>;
+/** Delete stored files of a plugin except the ones listed. */
+export declare function pruneFiles(s: StorageAdapter, pluginId: string, keep: Partial<Record<FileKind, StoredFile>>[]): Promise<void>;
+export declare const dataKey: (pluginId: string, key: string) => string;
+export declare function deletePluginData(s: StorageAdapter, pluginId: string): Promise<void>;

package/dist/core/store.js

@@ -0,0 +1,58 @@
+import { globals } from '../globals.js';
+import { encodeSegment } from '../storage/types.js';
+const FILE_NAMES = { client: 'client.js', server: 'server.js', style: 'style.css' };
+async function readJson(storage, key, fallback) {
+    const raw = await storage.get(key);
+    if (raw === null)
+        return fallback;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`[nextpluggable] Stored record "${key}" is corrupted.`);
+    }
+}
+export const getSources = (s) => readJson(s, 'sources.json', []);
+export const saveSources = (s, sources) => s.set('sources.json', JSON.stringify(sources));
+export const getInstalls = (s) => readJson(s, 'installs.json', {});
+export const saveInstalls = (s, installs) => s.set('installs.json', JSON.stringify(installs));
+export const getCatalog = (s, sourceId) => readJson(s, `catalogs/${sourceId}.json`, null);
+export const saveCatalog = (s, catalog) => s.set(`catalogs/${catalog.sourceId}.json`, JSON.stringify(catalog));
+export const deleteCatalog = (s, sourceId) => s.delete(`catalogs/${sourceId}.json`);
+export const fileKey = (pluginId, kind, sha256) => `files/${pluginId}/${sha256}.${FILE_NAMES[kind]}`;
+export async function putFile(s, pluginId, kind, sha256, content) {
+    const key = fileKey(pluginId, kind, sha256);
+    await s.set(key, content);
+    globals().files.set(key, content);
+}
+/** Plugin files are content-addressed and never change, so they are cached in memory for the life of the process. */
+export async function getFile(s, pluginId, kind, sha256) {
+    const key = fileKey(pluginId, kind, sha256);
+    const cache = globals().files;
+    const hit = cache.get(key);
+    if (hit !== undefined)
+        return hit;
+    const content = await s.get(key);
+    if (content !== null)
+        cache.set(key, content);
+    return content;
+}
+/** Delete stored files of a plugin except the ones listed. */
+export async function pruneFiles(s, pluginId, keep) {
+    const keepKeys = new Set();
+    for (const set of keep)
+        for (const [kind, f] of Object.entries(set))
+            if (f)
+                keepKeys.add(fileKey(pluginId, kind, f.sha256));
+    for (const key of await s.list(`files/${pluginId}/`)) {
+        if (keepKeys.has(key))
+            continue;
+        await s.delete(key);
+        globals().files.delete(key);
+    }
+}
+export const dataKey = (pluginId, key) => `data/${pluginId}/${encodeSegment(key)}`;
+export async function deletePluginData(s, pluginId) {
+    for (const key of await s.list(`data/${pluginId}/`))
+        await s.delete(key);
+}

package/dist/core/types.d.ts

@@ -0,0 +1,69 @@
+import type { PluginBuild, PluginManifest } from '@nextpluggable/plugin/manifest';
+export interface SourceRecord {
+    id: string;
+    type: 'github' | 'local';
+    /** Human name, e.g. `acme/site-plugins`. */
+    label: string;
+    addedAt: string;
+    github?: {
+        owner: string;
+        repo: string;
+        /** Branch or tag to follow. Default: the repository's default branch. */
+        ref?: string;
+        /** Sub-directory that holds the plugins. */
+        dir?: string;
+        /** Access token, encrypted with the site secret. */
+        token?: string;
+    };
+    local?: {
+        dir: string;
+    };
+}
+export interface CatalogEntry {
+    /** Plugin directory inside the source. */
+    path: string;
+    build: PluginBuild;
+    /** Fingerprint of dist/build.json — changes whenever the plugin is rebuilt. */
+    buildHash: string;
+}
+export interface Catalog {
+    sourceId: string;
+    /** Commit the listing was read at. */
+    revision: string;
+    fetchedAt: string;
+    name?: string;
+    description?: string;
+    plugins: CatalogEntry[];
+    problems: {
+        path: string;
+        message: string;
+    }[];
+}
+export type FileKind = 'client' | 'server' | 'style';
+export interface StoredFile {
+    sha256: string;
+    bytes: number;
+}
+export interface InstallRecord {
+    id: string;
+    manifest: PluginManifest;
+    icon?: string;
+    buildHash: string;
+    source: {
+        id: string;
+        label: string;
+        path: string;
+        revision: string;
+    };
+    files: Partial<Record<FileKind, StoredFile>>;
+    /** Files of the previously installed version, kept so pages cached before an update keep working. */
+    previousFiles?: Partial<Record<FileKind, StoredFile>>;
+    enabled: boolean;
+    /** Setting values; secrets are encrypted. */
+    config: Record<string, string | number | boolean>;
+    /** Page addresses chosen by the site owner, keyed by page id. */
+    paths: Record<string, string>;
+    installedAt: string;
+    updatedAt: string;
+}
+export type Installs = Record<string, InstallRecord>;

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/crypto.d.ts

@@ -0,0 +1,14 @@
+export declare const sha256Hex: (data: string | Uint8Array) => string;
+export declare function hmac(secret: string, data: string): string;
+/** Constant-time string comparison (compares digests so length is not leaked). */
+export declare function safeEqual(a: string, b: string): boolean;
+export declare const isEncrypted: (value: unknown) => value is string;
+/** AES-256-GCM with a key derived from the site secret. Used for plugin secrets and source tokens at rest. */
+export declare function encrypt(secret: string, plaintext: string): string;
+/** Returns null when the value cannot be decrypted (wrong secret or tampering). */
+export declare function decrypt(secret: string, value: string): string | null;
+/** A signed, expiring token: `<payload>.<signature>`. */
+export declare function signToken(secret: string, payload: Record<string, unknown>): string;
+export declare function verifyToken<T extends {
+    exp: number;
+}>(secret: string, token: string | undefined | null): T | null;

package/dist/crypto.js

@@ -0,0 +1,61 @@
+import { createCipheriv, createDecipheriv, createHash, createHmac, hkdfSync, randomBytes, timingSafeEqual } from 'node:crypto';
+export const sha256Hex = (data) => createHash('sha256').update(data).digest('hex');
+const b64u = (buf) => Buffer.from(buf).toString('base64url');
+export function hmac(secret, data) {
+    return createHmac('sha256', secret).update(data).digest('base64url');
+}
+/** Constant-time string comparison (compares digests so length is not leaked). */
+export function safeEqual(a, b) {
+    return timingSafeEqual(createHash('sha256').update(a).digest(), createHash('sha256').update(b).digest());
+}
+function key(secret, purpose) {
+    return Buffer.from(hkdfSync('sha256', secret, 'nextpluggable', purpose, 32));
+}
+const ENC_PREFIX = 'enc:v1:';
+export const isEncrypted = (value) => typeof value === 'string' && value.startsWith(ENC_PREFIX);
+/** AES-256-GCM with a key derived from the site secret. Used for plugin secrets and source tokens at rest. */
+export function encrypt(secret, plaintext) {
+    const iv = randomBytes(12);
+    const cipher = createCipheriv('aes-256-gcm', key(secret, 'settings'), iv);
+    const body = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final(), cipher.getAuthTag()]);
+    return `${ENC_PREFIX}${b64u(iv)}:${b64u(body)}`;
+}
+/** Returns null when the value cannot be decrypted (wrong secret or tampering). */
+export function decrypt(secret, value) {
+    if (!isEncrypted(value))
+        return null;
+    const [ivPart, bodyPart] = value.slice(ENC_PREFIX.length).split(':');
+    if (!ivPart || !bodyPart)
+        return null;
+    try {
+        const body = Buffer.from(bodyPart, 'base64url');
+        const decipher = createDecipheriv('aes-256-gcm', key(secret, 'settings'), Buffer.from(ivPart, 'base64url'));
+        decipher.setAuthTag(body.subarray(body.length - 16));
+        return Buffer.concat([decipher.update(body.subarray(0, body.length - 16)), decipher.final()]).toString('utf8');
+    }
+    catch {
+        return null;
+    }
+}
+/** A signed, expiring token: `<payload>.<signature>`. */
+export function signToken(secret, payload) {
+    const body = Buffer.from(JSON.stringify(payload)).toString('base64url');
+    return `${body}.${hmac(secret, body)}`;
+}
+export function verifyToken(secret, token) {
+    if (!token)
+        return null;
+    const dot = token.lastIndexOf('.');
+    if (dot < 1)
+        return null;
+    const body = token.slice(0, dot);
+    if (!safeEqual(hmac(secret, body), token.slice(dot + 1)))
+        return null;
+    try {
+        const payload = JSON.parse(Buffer.from(body, 'base64url').toString('utf8'));
+        return typeof payload.exp === 'number' && payload.exp > Date.now() ? payload : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/dashboard/Dashboard.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import type { SessionView } from '../views.js';
+export interface DashboardProps {
+    apiPath: string;
+    dashboardPath: string;
+    siteName: string;
+    session: SessionView;
+    /** Set when the site's configuration is incomplete (shown instead of the dashboard). */
+    setupError?: string;
+}
+export declare function Dashboard(props: DashboardProps): React.JSX.Element;