@byline/host-tanstack-start 4.16.0 → 4.17.0

package/dist/admin-shell/collections/version-history.d.ts

@@ -0,0 +1,72 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import { type ReactNode } from 'react';
+import { type CollectionDefinition } from '@byline/core';
+interface VersionHistoryDocument extends Record<string, unknown> {
+    id: string;
+    versionId?: string;
+    status: string;
+    createdAt: string;
+    createdBy?: string;
+    eventType?: string;
+    fields?: Record<string, unknown>;
+}
+export interface VersionHistoryData {
+    docs: VersionHistoryDocument[];
+    meta: {
+        total: number;
+        page: number;
+        pageSize: number;
+        totalPages: number;
+        order?: string;
+        desc?: boolean;
+    };
+    /** Admin-resolved acting-user labels keyed by the raw version actor id. */
+    actors?: Record<string, {
+        label: string;
+    }>;
+}
+interface VersionHistoryRowContext {
+    document: VersionHistoryDocument;
+    versionId: string | undefined;
+    versionNumber: number;
+    currentVersionId: string | null;
+    actorLabel: string;
+    actionLabel: string;
+    restoreStatusLabel: string;
+    openCompare: () => void;
+    openRestore: () => void;
+}
+/**
+ * Resource-specific table columns. Collection history projects configured
+ * columns; singleton history supplies its fixed status/time/actor/restore
+ * presentation so restore never depends on a `useAsTitle` field.
+ */
+export interface VersionHistoryRowPresentation {
+    headers: ReactNode;
+    auditColSpan: number;
+    renderCells: (context: VersionHistoryRowContext) => ReactNode;
+}
+export type HistoricalVersionLoader = (resourcePath: string, documentId: string, versionId: string, locale: string | undefined) => Promise<Record<string, unknown>>;
+export declare function HistoryStats({ total }: {
+    total: number;
+}): import("react").JSX.Element;
+export declare function VersionHistoryCore({ data, resourceDefinition, resourcePath, documentId, currentDocument, locale, rowPresentation, loadHistoricalVersion, onPageSizeChange, restoreVersion, onRestoreComplete, }: {
+    data: VersionHistoryData;
+    resourceDefinition: CollectionDefinition;
+    resourcePath: string;
+    documentId: string;
+    currentDocument?: Record<string, unknown> | null;
+    locale?: string;
+    rowPresentation: VersionHistoryRowPresentation;
+    loadHistoricalVersion: HistoricalVersionLoader;
+    onPageSizeChange: (pageSize: number) => void;
+    restoreVersion: (versionId: string) => Promise<unknown>;
+    onRestoreComplete: () => void | Promise<void>;
+}): import("react").JSX.Element;
+export {};

package/dist/admin-shell/collections/version-history.js

@@ -0,0 +1,259 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Fragment as external_react_Fragment, Suspense, lazy, useState } from "react";
+import { getDefaultStatus, getWorkflowStatuses } from "@byline/core";
+import { useTranslation } from "@byline/i18n/react";
+import { CloseIcon, IconButton, Modal, Select, Table } from "@byline/ui/react";
+import clsx from "clsx";
+import { RouterPager } from "../chrome/router-pager.js";
+import { formatNumber } from "../chrome/utils.js";
+import history_module from "./history.module.js";
+import { RestoreVersionModal } from "./restore-version-modal.js";
+const DiffModal = /*#__PURE__*/ lazy(()=>import("@byline/admin/react").then((m)=>({
+            default: m.DiffModal
+        })));
+const AUDIT_ACTION_KEYS = {
+    create: 'collections.history.audit.actionCreate',
+    update: 'collections.history.audit.actionUpdate',
+    restore: 'collections.history.audit.actionRestore',
+    copy_to_locale: 'collections.history.audit.actionCopyToLocale',
+    delete_locale: 'collections.history.audit.actionDeleteLocale'
+};
+function HistoryStats({ total }) {
+    return /*#__PURE__*/ jsx("span", {
+        className: clsx('byline-coll-history-stats', history_module.stats),
+        children: formatNumber(total, 0)
+    });
+}
+function padRows(value) {
+    return Array.from({
+        length: Math.max(0, value)
+    }).map((_, index)=>/*#__PURE__*/ jsx("div", {
+            className: clsx('byline-coll-history-pad-row', history_module.padRow),
+            children: "\xa0"
+        }, `empty-row-${index}`));
+}
+function VersionHistoryCore({ data, resourceDefinition, resourcePath, documentId, currentDocument, locale, rowPresentation, loadHistoricalVersion, onPageSizeChange, restoreVersion, onRestoreComplete }) {
+    const { t } = useTranslation('byline-admin');
+    const [selectedVersion, setSelectedVersion] = useState(null);
+    const [restoreTarget, setRestoreTarget] = useState(null);
+    const currentVersionId = currentDocument && 'string' == typeof currentDocument.versionId ? currentDocument.versionId : null;
+    const restoreStatus = getDefaultStatus(resourceDefinition);
+    const restoreStatusLabel = getWorkflowStatuses(resourceDefinition).find((status)=>status.name === restoreStatus)?.label ?? restoreStatus;
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsx("div", {
+                className: clsx('byline-coll-history-options', history_module.options),
+                children: /*#__PURE__*/ jsx(RouterPager, {
+                    page: data.meta.page,
+                    count: data.meta.totalPages,
+                    showFirstButton: true,
+                    showLastButton: true,
+                    componentName: "pagerTop",
+                    "aria-label": t('collections.list.pagerTopAriaLabel')
+                })
+            }),
+            /*#__PURE__*/ jsxs(Table.Container, {
+                className: clsx('byline-coll-history-table-wrap', history_module.tableWrap),
+                children: [
+                    /*#__PURE__*/ jsxs(Table, {
+                        children: [
+                            /*#__PURE__*/ jsx(Table.Header, {
+                                children: /*#__PURE__*/ jsxs(Table.Row, {
+                                    children: [
+                                        /*#__PURE__*/ jsx("th", {
+                                            scope: "col",
+                                            className: clsx('byline-coll-history-col-version', history_module.colVersion)
+                                        }),
+                                        rowPresentation.headers
+                                    ]
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(Table.Body, {
+                                children: data.docs.map((document, rowIndex)=>{
+                                    const versionId = document.versionId;
+                                    const { total, page, pageSize, desc } = data.meta;
+                                    const versionNumber = desc ? total - (page - 1) * pageSize - rowIndex : (page - 1) * pageSize + rowIndex + 1;
+                                    const actorLabel = document.createdBy ? data.actors?.[document.createdBy]?.label ?? t('collections.history.audit.formerUser') : t('collections.history.audit.unknown');
+                                    const actionKey = document.eventType ? AUDIT_ACTION_KEYS[document.eventType] : void 0;
+                                    const actionLabel = actionKey ? t(actionKey) : document.eventType ?? '';
+                                    const versionLabel = new Date(document.createdAt).toLocaleString();
+                                    const openCompare = ()=>{
+                                        if (null == versionId) return;
+                                        setSelectedVersion({
+                                            versionId,
+                                            label: versionLabel
+                                        });
+                                    };
+                                    const openRestore = ()=>{
+                                        if (null == versionId || versionId === currentVersionId) return;
+                                        setRestoreTarget({
+                                            versionId,
+                                            label: versionLabel,
+                                            versionNumber
+                                        });
+                                    };
+                                    return /*#__PURE__*/ jsxs(external_react_Fragment, {
+                                        children: [
+                                            /*#__PURE__*/ jsxs(Table.Row, {
+                                                className: clsx('byline-coll-history-row', history_module.historyRow),
+                                                children: [
+                                                    /*#__PURE__*/ jsx(Table.Cell, {
+                                                        className: clsx('byline-coll-history-version-cell', history_module.versionCell),
+                                                        children: versionId && currentDocument ? /*#__PURE__*/ jsx(IconButton, {
+                                                            size: "xs",
+                                                            variant: "outlined",
+                                                            intent: "noeffect",
+                                                            "aria-label": t('collections.history.compareAriaLabel'),
+                                                            title: t('collections.history.compareTitle'),
+                                                            className: clsx('byline-coll-history-version-button', history_module.versionButton),
+                                                            onClick: openCompare,
+                                                            children: versionNumber
+                                                        }) : null
+                                                    }),
+                                                    rowPresentation.renderCells({
+                                                        document,
+                                                        versionId,
+                                                        versionNumber,
+                                                        currentVersionId,
+                                                        actorLabel,
+                                                        actionLabel,
+                                                        restoreStatusLabel,
+                                                        openCompare,
+                                                        openRestore
+                                                    })
+                                                ]
+                                            }),
+                                            /*#__PURE__*/ jsxs(Table.Row, {
+                                                className: clsx('byline-coll-history-audit-row', history_module.auditRow),
+                                                "aria-label": t('collections.history.audit.createdBy', {
+                                                    label: actorLabel
+                                                }),
+                                                children: [
+                                                    /*#__PURE__*/ jsx(Table.Cell, {
+                                                        className: clsx('byline-coll-history-audit-spacer-cell', history_module.auditSpacerCell)
+                                                    }),
+                                                    /*#__PURE__*/ jsx(Table.Cell, {
+                                                        colSpan: rowPresentation.auditColSpan,
+                                                        className: clsx('byline-coll-history-audit-cell', history_module.auditCell),
+                                                        children: /*#__PURE__*/ jsxs("span", {
+                                                            className: clsx('byline-coll-history-audit', history_module.audit),
+                                                            children: [
+                                                                actionLabel,
+                                                                ' · ',
+                                                                t('collections.history.audit.createdBy', {
+                                                                    label: actorLabel
+                                                                }),
+                                                                ' · ',
+                                                                versionLabel
+                                                            ]
+                                                        })
+                                                    })
+                                                ]
+                                            })
+                                        ]
+                                    }, versionId ?? document.id);
+                                })
+                            })
+                        ]
+                    }),
+                    padRows(6 - data.docs.length)
+                ]
+            }),
+            /*#__PURE__*/ jsxs("div", {
+                className: clsx('byline-coll-history-options byline-coll-history-options-bottom', history_module.options, history_module.optionsBottom),
+                children: [
+                    /*#__PURE__*/ jsx(Select, {
+                        containerClassName: clsx('byline-coll-history-page-size', history_module.pageSize),
+                        id: "page_size",
+                        name: "page_size",
+                        size: "sm",
+                        defaultValue: "15",
+                        items: [
+                            {
+                                value: '15',
+                                label: '15'
+                            },
+                            {
+                                value: '30',
+                                label: '30'
+                            },
+                            {
+                                value: '50',
+                                label: '50'
+                            },
+                            {
+                                value: '100',
+                                label: '100'
+                            }
+                        ],
+                        onValueChange: (value)=>{
+                            if ('string' != typeof value || 0 === value.length) return;
+                            onPageSizeChange(Number.parseInt(value, 10));
+                        }
+                    }),
+                    /*#__PURE__*/ jsx(RouterPager, {
+                        smoothScrollToTop: true,
+                        page: data.meta.page,
+                        count: data.meta.totalPages,
+                        showFirstButton: true,
+                        showLastButton: true,
+                        componentName: "pagerBottom",
+                        "aria-label": t('collections.list.pagerBottomAriaLabel')
+                    })
+                ]
+            }),
+            selectedVersion && currentDocument && /*#__PURE__*/ jsx(Suspense, {
+                fallback: null,
+                children: /*#__PURE__*/ jsx(DiffModal, {
+                    isOpen: true,
+                    onDismiss: ()=>setSelectedVersion(null),
+                    collection: resourcePath,
+                    documentId: documentId,
+                    versionId: selectedVersion.versionId,
+                    versionLabel: selectedVersion.label,
+                    currentDocument: currentDocument,
+                    locale: locale,
+                    loadHistoricalVersion: loadHistoricalVersion
+                })
+            }),
+            /*#__PURE__*/ jsx(Modal, {
+                isOpen: null != restoreTarget,
+                onDismiss: ()=>setRestoreTarget(null),
+                closeOnOverlayClick: false,
+                children: /*#__PURE__*/ jsxs(Modal.Container, {
+                    className: clsx('byline-coll-history-restore-modal', history_module.restoreModal),
+                    children: [
+                        /*#__PURE__*/ jsxs(Modal.Header, {
+                            className: clsx('byline-coll-history-restore-modal-head', history_module.restoreModalHead),
+                            children: [
+                                /*#__PURE__*/ jsx("h3", {
+                                    className: "m-0",
+                                    children: t('collections.history.restoreModalTitle')
+                                }),
+                                /*#__PURE__*/ jsx(IconButton, {
+                                    "aria-label": t('common.actions.close'),
+                                    size: "xs",
+                                    onClick: ()=>setRestoreTarget(null),
+                                    children: /*#__PURE__*/ jsx(CloseIcon, {
+                                        width: "14px",
+                                        height: "14px",
+                                        svgClassName: "white-icon"
+                                    })
+                                })
+                            ]
+                        }),
+                        restoreTarget ? /*#__PURE__*/ jsx(RestoreVersionModal, {
+                            versionLabel: restoreTarget.label,
+                            versionNumber: restoreTarget.versionNumber,
+                            restoreStatusLabel: restoreStatusLabel,
+                            onClose: ()=>setRestoreTarget(null),
+                            restoreVersion: ()=>restoreVersion(restoreTarget.versionId),
+                            onRestoreComplete: onRestoreComplete
+                        }) : null
+                    ]
+                })
+            })
+        ]
+    });
+}
+export { HistoryStats, VersionHistoryCore };

package/dist/admin-shell/singletons/history.d.ts

@@ -0,0 +1,19 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import type { SingletonAdminConfig, SingletonDefinition, WorkflowStatus } from '@byline/core';
+import { type VersionHistoryData } from '../collections/version-history.js';
+import type { ContentLocaleOption } from '../collections/view-menu.js';
+export declare function SingletonHistoryView({ singletonDefinition, adminConfig, data, currentDocument, contentLocales, defaultContentLocale, workflowStatuses, }: {
+    singletonDefinition: SingletonDefinition;
+    adminConfig?: SingletonAdminConfig;
+    data: VersionHistoryData;
+    currentDocument?: Record<string, unknown> | null;
+    contentLocales: ReadonlyArray<ContentLocaleOption>;
+    defaultContentLocale: string;
+    workflowStatuses: WorkflowStatus[];
+}): import("react").JSX.Element;

package/dist/admin-shell/singletons/history.js

@@ -0,0 +1,170 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useRouter, useRouterState } from "@tanstack/react-router";
+import { StatusBadge } from "@byline/admin/react";
+import { useTranslation } from "@byline/i18n/react";
+import { Button, Container, Section, Table } from "@byline/ui/react";
+import clsx from "clsx";
+import { getAdminRoutePath } from "../../routes/admin-path.js";
+import { findSingletonByVersion, restoreSingletonVersion } from "../../server-fns/singletons/index.js";
+import { useNavigate } from "../chrome/loose-router.js";
+import history_module from "../collections/history.module.js";
+import { HistoryStats, VersionHistoryCore } from "../collections/version-history.js";
+import { SingletonViewMenu } from "./view-menu.js";
+function SingletonHistoryView({ singletonDefinition, adminConfig, data, currentDocument, contentLocales, defaultContentLocale, workflowStatuses }) {
+    const singleton = singletonDefinition.path;
+    const navigate = useNavigate();
+    const router = useRouter();
+    const location = useRouterState({
+        select: (state)=>state.location
+    });
+    const locale = location.search.locale;
+    const { t } = useTranslation('byline-admin');
+    function handlePageSizeChange(pageSize) {
+        const params = structuredClone(location.search);
+        delete params.page;
+        params.page_size = pageSize;
+        navigate({
+            to: getAdminRoutePath('singletons', '$singleton', 'history'),
+            params: {
+                singleton
+            },
+            search: params
+        });
+    }
+    const rowPresentation = {
+        headers: /*#__PURE__*/ jsxs(Fragment, {
+            children: [
+                /*#__PURE__*/ jsx("th", {
+                    scope: "col",
+                    children: t('collections.history.statusColumn')
+                }),
+                /*#__PURE__*/ jsx("th", {
+                    scope: "col",
+                    children: t('collections.documentHistory.colWhen')
+                }),
+                /*#__PURE__*/ jsx("th", {
+                    scope: "col",
+                    children: t('collections.documentHistory.colActor')
+                }),
+                /*#__PURE__*/ jsx("th", {
+                    scope: "col",
+                    className: clsx('byline-coll-history-col-restore', history_module.colRestore)
+                })
+            ]
+        }),
+        auditColSpan: 4,
+        renderCells: ({ document, versionId, currentVersionId, actorLabel, restoreStatusLabel, openRestore })=>/*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    /*#__PURE__*/ jsx(Table.Cell, {
+                        className: "byline-singleton-history-status-cell",
+                        children: /*#__PURE__*/ jsx(StatusBadge, {
+                            status: document.status,
+                            workflowStatuses: workflowStatuses
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(Table.Cell, {
+                        className: "byline-singleton-history-created-cell",
+                        children: new Date(document.createdAt).toLocaleString()
+                    }),
+                    /*#__PURE__*/ jsx(Table.Cell, {
+                        className: "byline-singleton-history-actor-cell",
+                        children: actorLabel
+                    }),
+                    /*#__PURE__*/ jsx(Table.Cell, {
+                        className: clsx('byline-coll-history-restore-cell', history_module.restoreCell),
+                        children: versionId && versionId !== currentVersionId ? /*#__PURE__*/ jsx(Button, {
+                            type: "button",
+                            variant: "outlined",
+                            size: "xs",
+                            intent: "noeffect",
+                            onClick: openRestore,
+                            className: clsx('byline-coll-history-restore-button', history_module.restoreButton),
+                            title: t('collections.history.restoreButtonTitle', {
+                                status: restoreStatusLabel
+                            }),
+                            children: t('collections.history.restoreButton')
+                        }) : null
+                    })
+                ]
+            })
+    };
+    const documentId = currentDocument && 'string' == typeof currentDocument.id ? currentDocument.id : '';
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsx(Section, {
+                children: /*#__PURE__*/ jsx(Container, {
+                    children: /*#__PURE__*/ jsxs("div", {
+                        className: clsx('byline-coll-history-head', history_module.head),
+                        children: [
+                            /*#__PURE__*/ jsxs("h2", {
+                                className: clsx('byline-coll-history-title', history_module.title),
+                                children: [
+                                    t('collections.history.title', {
+                                        label: singletonDefinition.label
+                                    }),
+                                    ' ',
+                                    /*#__PURE__*/ jsx(HistoryStats, {
+                                        total: data.meta.total
+                                    })
+                                ]
+                            }),
+                            /*#__PURE__*/ jsx(SingletonViewMenu, {
+                                singleton: singleton,
+                                activeView: "history",
+                                locale: locale,
+                                contentLocales: contentLocales,
+                                defaultContentLocale: defaultContentLocale,
+                                adminConfig: adminConfig,
+                                doc: null == currentDocument ? void 0 : currentDocument
+                            })
+                        ]
+                    })
+                })
+            }),
+            /*#__PURE__*/ jsx(Section, {
+                children: /*#__PURE__*/ jsx(Container, {
+                    children: /*#__PURE__*/ jsx(VersionHistoryCore, {
+                        data: data,
+                        resourceDefinition: singletonDefinition,
+                        resourcePath: singleton,
+                        documentId: documentId,
+                        currentDocument: currentDocument,
+                        locale: locale,
+                        rowPresentation: rowPresentation,
+                        loadHistoricalVersion: async (_path, _documentId, versionId, versionLocale)=>{
+                            const historical = await findSingletonByVersion({
+                                data: {
+                                    singleton,
+                                    versionId,
+                                    locale: versionLocale
+                                }
+                            });
+                            if (null == historical) throw new Error('Singleton version not found');
+                            return historical;
+                        },
+                        onPageSizeChange: handlePageSizeChange,
+                        restoreVersion: (versionId)=>restoreSingletonVersion({
+                                data: {
+                                    singleton,
+                                    versionId
+                                }
+                            }),
+                        onRestoreComplete: async ()=>{
+                            await router.invalidate();
+                            navigate({
+                                to: getAdminRoutePath('singletons', '$singleton'),
+                                params: {
+                                    singleton
+                                },
+                                search: locale ? {
+                                    locale
+                                } : {}
+                            });
+                        }
+                    })
+                })
+            })
+        ]
+    });
+}
+export { SingletonHistoryView };

package/dist/admin-shell/singletons/history.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+export {};

package/dist/admin-shell/singletons/preview-link.d.ts

@@ -0,0 +1,12 @@
+import type { SingletonAdminConfig, SingletonPreviewDocument } from '@byline/core';
+/**
+ * Explicit-preview-only singleton affordance. A singleton's stored path is
+ * internal identity metadata, so unlike collection previews there is no
+ * schema or conventional path fallback.
+ */
+export declare function SingletonPreviewLink({ doc, adminConfig, locale, className, }: {
+    doc: SingletonPreviewDocument;
+    adminConfig: SingletonAdminConfig;
+    locale?: string;
+    className?: string;
+}): import("react").JSX.Element | null;

package/dist/admin-shell/singletons/preview-link.js

@@ -0,0 +1,54 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useState } from "react";
+import { useTranslation } from "@byline/i18n/react";
+import { ExternalLinkIcon, IconButton, useToastManager } from "@byline/ui/react";
+import clsx from "clsx";
+import { enablePreviewModeFn } from "../../server-fns/preview/index.js";
+function SingletonPreviewLink({ doc, adminConfig, locale, className }) {
+    const toastManager = useToastManager();
+    const { t } = useTranslation('byline-admin');
+    const [busy, setBusy] = useState(false);
+    const url = adminConfig.preview?.url(doc, {
+        locale
+    }) ?? null;
+    if (null == url) return null;
+    const handleClick = async ()=>{
+        if (busy) return;
+        setBusy(true);
+        try {
+            await enablePreviewModeFn();
+            window.location.assign(url);
+        } catch (err) {
+            toastManager.add({
+                title: t('collections.preview.toastTitle'),
+                description: t("collections.preview.failedDescription", {
+                    message: err.message
+                }),
+                data: {
+                    intent: 'danger',
+                    iconType: 'danger',
+                    icon: true,
+                    close: true
+                }
+            });
+        } finally{
+            setBusy(false);
+        }
+    };
+    return /*#__PURE__*/ jsx(IconButton, {
+        className: clsx('byline-preview-link', className),
+        size: "xs",
+        variant: "text",
+        disabled: busy,
+        onClick: handleClick,
+        "aria-label": t('collections.preview.openAriaLabel'),
+        title: t('collections.preview.title'),
+        children: /*#__PURE__*/ jsx(ExternalLinkIcon, {
+            width: "20px",
+            height: "20px",
+            className: "byline-preview-link-icon"
+        })
+    });
+}
+export { SingletonPreviewLink };

package/dist/admin-shell/singletons/view-menu.d.ts

@@ -0,0 +1,13 @@
+import type { SingletonAdminConfig, SingletonPreviewDocument } from '@byline/core';
+import type { ContentLocaleOption } from '../collections/view-menu.js';
+export type SingletonViewMenuPath = 'edit' | 'history';
+/** Id-less edit/history navigation; preview appears only for a mapped document. */
+export declare function SingletonViewMenu({ singleton, activeView, locale, contentLocales, defaultContentLocale, adminConfig, doc, }: {
+    singleton: string;
+    activeView: SingletonViewMenuPath;
+    locale?: string;
+    contentLocales: ReadonlyArray<ContentLocaleOption>;
+    defaultContentLocale: string;
+    adminConfig?: SingletonAdminConfig;
+    doc?: SingletonPreviewDocument;
+}): import("react").JSX.Element;