@parhelia/core 0.1.10745

package/dist/config/config.js

@@ -0,0 +1,1087 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { RichTextEditor } from "../editor/field-types/RichTextEditor";
+import { createRichTextContextMenu } from "../editor/field-types/richtext/contextMenuFactory";
+import { LinkFieldEditor } from "../editor/field-types/LinkFieldEditor";
+import { PictureFieldEditor } from "../editor/field-types/PictureFieldEditor";
+import { InternalLinkFieldEditor } from "../editor/field-types/InternalLinkFieldEditor";
+import TreeListEditor from "../editor/field-types/TreeListEditor";
+import { SingleLineText } from "../editor/field-types/SingleLineText";
+import { MultiLineText } from "../editor/field-types/MultiLineText";
+import { DropLinkEditor } from "../editor/field-types/DropLinkEditor";
+import { DropListEditor } from "../editor/field-types/DropListEditor";
+import { RawEditor } from "../editor/field-types/RawEditor";
+import { CheckboxEditor } from "../editor/field-types/CheckboxEditor";
+import { DateFieldEditor } from "../editor/field-types/DateFieldEditor";
+import { DateTimeFieldEditor } from "../editor/field-types/DateTimeFieldEditor";
+import { NameValueListEditor } from "../editor/field-types/NameValueListEditor";
+import { ItemLocked } from "../editor/editor-warnings/ItemLocked";
+import { NoWriteAccess } from "../editor/editor-warnings/NoWriteAccess";
+import { ValidationErrors } from "../editor/editor-warnings/ValidationErrors";
+import { ComponentTree } from "../editor/sidebar/ComponentTree";
+import { Performance } from "../editor/sidebar/Performance";
+import { EditHistory } from "../editor/sidebar/EditHistory";
+import { Sessions } from "../editor/sidebar/Sessions";
+import { Workbox } from "../editor/sidebar/Workbox";
+import { DictionaryEditor } from "../editor/sidebar/DictionaryEditor";
+import { EditIcon, GraphQLIcon, JsonIcon, } from "../editor/ui/Icons";
+import { Debug } from "../editor/sidebar/Debug";
+import { GraphQL } from "../editor/sidebar/GraphQL";
+import { ModernSplashScreen } from "../splash-screen/ModernSplashScreen";
+import { Titlebar } from "../editor/Titlebar";
+import { NoWriteLanguageAccess } from "../editor/editor-warnings/NoLanguageWriteAccess";
+import { NoWorkflowWriteAccess } from "../editor/editor-warnings/NoWorkflowWriteAccess";
+import { AgentsView } from "../agents-view/AgentsView";
+import { createEditToolbar } from "../editor/menubar/ToolbarFactory";
+import { Validation } from "../editor/sidebar/Validation";
+import { deleteItemCommand, insertItemCommand, moveItemsCommand, copyItemsCommand, publishItemCommand, renameItemCommand, duplicateItemCommand, } from "../editor/commands/itemCommands";
+import { loadInsertOptions } from "../editor/services/editService";
+import { getDefaultTourSteps } from "../tour/default-tour";
+import { EditView } from "../editor/views/EditView";
+import { InsertMenuTemplate } from "../editor/context-menu/InsertMenu";
+import { Status } from "../editor/control-center/Status";
+import { Setup } from "../editor/control-center/Setup";
+import { IndexOverview } from "../editor/control-center/IndexOverview";
+import { Info } from "../editor/control-center/Info";
+import { QuotaInfo } from "../editor/control-center/QuotaInfo";
+import { About } from "../editor/control-center/About";
+import { WebSocketMessages } from "../editor/control-center/WebSocketMessages";
+import { LatestFeedback } from "../editor/control-center/LatestFeedback";
+import { AllAgentsPanel } from "../editor/control-center/AllAgentsPanel";
+import { ParheliaSetupOverview } from "../editor/control-center/parhelia-setup/Overview";
+import { DbSetupStep } from "../editor/control-center/setup-steps/DbSetupStep";
+import { SettingsSetupStep } from "../editor/control-center/setup-steps/SettingsSetupStep";
+import { AiSetupStep } from "../editor/control-center/setup-steps/AiSetupStep";
+import { IndexSetupStep } from "../editor/control-center/setup-steps/IndexSetupStep";
+import { MainContentTree } from "../editor/sidebar/MainContentTree";
+import { AttachmentEditor } from "../editor/field-types/AttachmentEditor";
+import { Comments } from "../editor/reviews/Comments";
+import { Reviews } from "../editor/reviews/Reviews";
+import { rejectReviewCommand } from "../editor/reviews/reviewCommands";
+import { approveReviewCommand } from "../editor/reviews/reviewCommands";
+import { getPreviewTourSteps } from "../tour/preview-tour";
+import { ImageFieldEditor } from "../editor/field-types/ImageFieldEditor";
+import { ReviewCommands } from "../editor/menubar/toolbar-sections/ReviewCommands";
+import { BookA, History, FolderTreeIcon, InboxIcon, Layers, MessageCircleMore, Settings, Users, Bug, Timer, WandSparkles, BadgeCheck, ShieldCheck, Info as InfoIcon, BarChart3, Search, Home, File, ExternalLink, Image as ImageIcon, Video, X, Expand, Download, Bot, } from "lucide-react";
+import { Completions } from "../editor/sidebar/Completions";
+import { NewPage } from "../splash-screen/NewPage";
+import { OpenPage } from "../splash-screen/OpenPage";
+import { GenericToolbar } from "../editor/menubar/GenericToolbar";
+import { EditControls, UtilityControls, } from "../editor/menubar/toolbar-sections";
+export const contentItemId = "0DE95AE4-41AB-4D01-9EB0-67441B7C2450";
+export const templatesRootItemId = "3c1715fe-6a13-4fcf-845f-de308ba9741d";
+export const rootItemId = "11111111-1111-1111-1111-111111111111";
+const openTargetActionButton = {
+    label: "Open target item",
+    icon: (_jsx(ExternalLink, { strokeWidth: 1, size: 16 })),
+    clientAction: ({ field, editContext }) => {
+        const fieldValue = field.value;
+        if (fieldValue?.targetItemId) {
+            editContext.loadItem({
+                id: fieldValue.targetItemId,
+                language: field.descriptor.item.language,
+                version: 0,
+            });
+        }
+    },
+    isGenerator: false,
+    id: "open-target-in-content-editor",
+    description: "Opens the target item in the content/page editor",
+};
+// Picture variant buttons - these will be exported for external packages
+const selectImageButton = {
+    label: "Select",
+    icon: (_jsx(ImageIcon, { strokeWidth: 1, size: 16 })),
+    isPimaryAction: true, // Primary action - appears outside menu but show nontheless in the menu
+    clientAction: async (props) => {
+        const { field, editContext, variantName, variantData } = props;
+        if (!variantName)
+            return;
+        const variant = variantData ||
+            field.value?.variants?.find((v) => v.name === variantName);
+        const selectedImageId = await editContext?.selectMedia({
+            selectedIdPath: variant?.idPath || "",
+            mode: "images",
+        });
+        if (selectedImageId) {
+            const raw = (() => {
+                try {
+                    return field?.rawValue && field?.rawValue[0] === "{"
+                        ? JSON.parse(field?.rawValue)
+                        : { Variants: [] };
+                }
+                catch (error) {
+                    console.warn("Failed to parse picture field raw value:", error);
+                    return { Variants: [] };
+                }
+            })();
+            const selected = raw.Variants?.find((x) => x.Name == variantName);
+            if (!selected) {
+                if (!raw.Variants)
+                    raw.Variants = [];
+                raw.Variants.push({
+                    Name: variantName,
+                    MediaId: selectedImageId,
+                });
+            }
+            else {
+                selected.MediaId = selectedImageId;
+            }
+            editContext.operations.editField({
+                field: field.descriptor,
+                rawValue: JSON.stringify(raw),
+                refresh: "immediate",
+            });
+        }
+    },
+    isGenerator: false,
+    id: "select-image",
+    description: "Select an image from the media library",
+};
+const selectVideoButton = {
+    label: "Video",
+    icon: (_jsx(Video, { strokeWidth: 1, size: 16 })),
+    visible: ({ field }) => field.value?.allowVideos ?? false,
+    clientAction: async (props) => {
+        const { field, editContext, variantName, variantData } = props;
+        if (!variantName)
+            return;
+        const variant = variantData ||
+            field.value?.variants?.find((v) => v.name === variantName);
+        const selectedVideoId = await editContext?.selectMedia({
+            selectedIdPath: variant?.idPath || "",
+            mode: "video",
+        });
+        if (selectedVideoId) {
+            const raw = (() => {
+                try {
+                    return field?.rawValue && field?.rawValue[0] === "{"
+                        ? JSON.parse(field?.rawValue)
+                        : { Variants: [] };
+                }
+                catch (error) {
+                    console.warn("Failed to parse picture field raw value:", error);
+                    return { Variants: [] };
+                }
+            })();
+            const selected = raw.Variants?.find((x) => x.Name == variantName);
+            if (!selected) {
+                if (!raw.Variants)
+                    raw.Variants = [];
+                raw.Variants.push({
+                    Name: variantName,
+                    VideoId: selectedVideoId,
+                });
+            }
+            else {
+                selected.VideoId = selectedVideoId;
+            }
+            editContext.operations.editField({
+                field: field.descriptor,
+                rawValue: JSON.stringify(raw),
+                refresh: "immediate",
+            });
+        }
+    },
+    isGenerator: false,
+    id: "select-video",
+    description: "Select a video from the media library",
+};
+const resetVariantButton = {
+    label: "Reset",
+    icon: (_jsx(X, { strokeWidth: 1, size: 16 })),
+    visible: ({ rawVariant }) => !!rawVariant,
+    clientAction: async (props) => {
+        const { field, editContext, variantName } = props;
+        if (!variantName)
+            return;
+        const raw = (() => {
+            try {
+                return field?.rawValue && field?.rawValue[0] === "{"
+                    ? JSON.parse(field?.rawValue)
+                    : { Variants: [] };
+            }
+            catch (error) {
+                console.warn("Failed to parse picture field raw value:", error);
+                return { Variants: [] };
+            }
+        })();
+        raw.Variants = raw.Variants.filter((x) => x.Name !== variantName);
+        editContext.operations.editField({
+            field: field.descriptor,
+            rawValue: JSON.stringify(raw),
+            refresh: "immediate",
+        });
+    },
+    isGenerator: false,
+    id: "reset-variant",
+    description: "Reset the variant to default state",
+};
+const cropVariantButton = {
+    label: "Crop",
+    icon: (_jsx(Expand, { strokeWidth: 1, size: 16 })),
+    visible: ({ variantData }) => !!variantData?.mediaId,
+    componentAction: "open-cropper",
+    isGenerator: false,
+    id: "crop-variant",
+    description: "Crop the image variant",
+};
+const openPictureMediaItemButton = {
+    label: "Open media item",
+    icon: (_jsx(ExternalLink, { strokeWidth: 1, size: 16 })),
+    visible: ({ variantData }) => !!variantData?.mediaId,
+    clientAction: (props) => {
+        const { field, editContext, variantData } = props;
+        const mediaId = variantData?.mediaId;
+        if (mediaId) {
+            editContext.loadItem({
+                id: mediaId,
+                language: field.descriptor.item.language,
+                version: 0,
+            });
+        }
+    },
+    isGenerator: false,
+    id: "open-picture-media-item",
+    description: "Opens the media item in the content editor",
+};
+const openImageMediaItemButton = {
+    label: "Open media item",
+    icon: (_jsx(ExternalLink, { strokeWidth: 1, size: 16 })),
+    clientAction: ({ field, editContext }) => {
+        // Extract mediaId from XML rawValue: <image mediaid="{GUID}" />
+        const rawValue = field.rawValue || "";
+        const mediaIdMatch = rawValue.match(/mediaid="[{]?([0-9a-fA-F-]+)[}]?"/i);
+        if (mediaIdMatch && mediaIdMatch[1]) {
+            editContext.loadItem({
+                id: mediaIdMatch[1],
+                language: field.descriptor.item.language,
+                version: 0,
+            });
+        }
+    },
+    isGenerator: false,
+    id: "open-image-media-item",
+    description: "Opens the media item in the content editor",
+};
+const openAttachmentButton = {
+    label: "Open",
+    icon: (_jsx(ExternalLink, { strokeWidth: 1, size: 16 })),
+    visible: ({ field }) => !!field.value?.src,
+    clientAction: ({ field }) => {
+        const src = field.value?.src;
+        if (src) {
+            window.open(src, "_blank", "noopener,noreferrer");
+        }
+    },
+    isGenerator: false,
+    id: "open-attachment",
+    description: "Opens the attachment in a new tab",
+};
+const downloadAttachmentButton = {
+    label: "Download",
+    icon: (_jsx(Download, { strokeWidth: 1, size: 16 })),
+    visible: ({ field }) => !!field.value?.src,
+    clientAction: ({ field }) => {
+        const src = field.value?.src;
+        const fileName = field.value?.fileName;
+        const mimeType = field.value?.mimeType;
+        if (src) {
+            const link = document.createElement("a");
+            link.href = src;
+            link.download = fileName || "";
+            if (mimeType) {
+                link.type = mimeType;
+            }
+            document.body.appendChild(link);
+            link.click();
+            document.body.removeChild(link);
+        }
+    },
+    isGenerator: false,
+    id: "download-attachment",
+    description: "Downloads the attachment file",
+};
+const pageEditorRightSidebar = {
+    title: "COMPONENT NAVIGATOR & HISTORY",
+    panels: [
+        {
+            name: "component-tree",
+            icon: _jsx(Layers, { size: 14 }),
+            title: "Component Navigator",
+            content: _jsx(ComponentTree, {}),
+            initialSize: 20,
+        },
+    ],
+};
+const editView = _jsx(EditView, {});
+export const pageEditorViewBase = {
+    toolbar: createEditToolbar,
+    rightSidebar: pageEditorRightSidebar,
+    defaultCenterPanelView: editView,
+    titlebar: _jsx(Titlebar, {}),
+    toolbarFactory: createEditToolbar,
+};
+// Reusable paste configs to avoid redundancy per field type
+const textPaste = {
+    enabled: () => true,
+    kind: { type: "text" },
+    hideIfInvalidClipboard: true,
+    target: "value",
+};
+const guidPaste = {
+    enabled: () => true,
+    kind: { type: "guid" },
+    hideIfInvalidClipboard: true,
+    target: "rawValue",
+};
+const guidListPaste = {
+    enabled: () => true,
+    kind: { type: "guid-list", separator: "|" },
+    hideIfInvalidClipboard: true,
+    target: "rawValue",
+};
+export const getConfiguration = () => {
+    const defaultPictureVariantButtons = [
+        selectImageButton,
+        selectVideoButton,
+        cropVariantButton,
+        openPictureMediaItemButton,
+        resetVariantButton,
+    ];
+    // Check if fullscreen query parameter is set
+    const isFullscreenMode = typeof window !== "undefined" &&
+        new URLSearchParams(window.location.search).get("fullscreen") === "true";
+    return {
+        extensions: {},
+        setup: {
+            steps: [DbSetupStep, SettingsSetupStep, AiSetupStep, IndexSetupStep],
+        },
+        forceFullscreen: isFullscreenMode,
+        tours: {
+            default: {
+                getSteps: (params) => getDefaultTourSteps(params, {
+                    firstComponentTemplateId: "39593ec8-0d85-46f2-9573-c368ef7e4ae3",
+                    firstComponentTemplateName: "Section",
+                    firstComponentTextFieldName: "Title",
+                    firstComponentTextFieldId: "f352f51f-062c-4874-a561-6283f8679583",
+                    firstComponentRichTextFieldName: "Introduction",
+                    firstComponentRichTextFieldId: "b44b547b-33f5-4379-8ac3-c57ccea2d407",
+                }),
+            },
+            preview: {
+                getSteps: (params) => getPreviewTourSteps(params),
+            },
+        },
+        activeTour: "default",
+        commands: {
+            renameItem: renameItemCommand,
+            deleteItem: deleteItemCommand,
+            insertItem: insertItemCommand,
+            publishItem: publishItemCommand,
+            moveItems: moveItemsCommand,
+            copyItems: copyItemsCommand,
+            allItemCommands: [
+                renameItemCommand,
+                deleteItemCommand,
+                publishItemCommand,
+                duplicateItemCommand,
+                copyItemsCommand,
+                moveItemsCommand,
+                // exportItemsCommand,
+                // importItemsCommand,
+            ],
+            reviewcommands: [approveReviewCommand, rejectReviewCommand],
+        },
+        events: {},
+        services: {
+            aiService: {
+                endpoint: "/parhelia/ai",
+            },
+        },
+        fieldTypes: {
+            raw: {
+                editor: RawEditor,
+            },
+            "single-line text": {
+                editor: SingleLineText,
+                paste: textPaste,
+            },
+            "multi-line text": {
+                editor: MultiLineText,
+                paste: textPaste,
+            },
+            "rich text": {
+                editor: RichTextEditor,
+                contextMenuFactory: createRichTextContextMenu,
+            },
+            "general link": {
+                editor: LinkFieldEditor,
+            },
+            picture: {
+                editor: PictureFieldEditor,
+                variantButtons: defaultPictureVariantButtons,
+            },
+            image: {
+                editor: ImageFieldEditor,
+                buttons: [openImageMediaItemButton],
+            },
+            droplink: {
+                editor: DropLinkEditor,
+                buttons: [openTargetActionButton],
+                paste: guidPaste,
+            },
+            "enhanced dropLink": {
+                editor: DropLinkEditor,
+                buttons: [openTargetActionButton],
+                paste: guidPaste,
+            },
+            "enhanced internal link": {
+                editor: InternalLinkFieldEditor,
+                buttons: [openTargetActionButton],
+                paste: guidPaste,
+            },
+            droplist: {
+                editor: DropListEditor,
+            },
+            treelistex: {
+                editor: TreeListEditor,
+                paste: guidListPaste,
+            },
+            treelist: {
+                editor: TreeListEditor,
+                paste: guidListPaste,
+            },
+            "enhanced treelist": {
+                editor: TreeListEditor,
+                paste: guidListPaste,
+            },
+            "tree list": {
+                editor: TreeListEditor,
+                paste: guidListPaste,
+            },
+            "tag treelist": {
+                editor: TreeListEditor,
+                paste: guidListPaste,
+            },
+            multilist: {
+                editor: TreeListEditor,
+                paste: guidListPaste,
+            },
+            checkbox: {
+                editor: CheckboxEditor,
+            },
+            date: {
+                editor: DateFieldEditor,
+            },
+            datetime: {
+                editor: DateTimeFieldEditor,
+            },
+            "name value list": {
+                editor: NameValueListEditor,
+            },
+            "enhanced name value list": {
+                editor: NameValueListEditor,
+            },
+            droptree: {
+                editor: InternalLinkFieldEditor,
+                buttons: [openTargetActionButton],
+                paste: {
+                    enabled: () => true,
+                    isValid: (text) => /[\{\(]?[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}[\}\)]?/.test(text?.trim() ?? ""),
+                    transform: (text) => {
+                        const match = text
+                            ?.trim()
+                            .match(/[\{\(]?[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}[\}\)]?/);
+                        const id = match?.[0]?.replace(/[{}()]/g, "");
+                        return id ? `{${id.toUpperCase()}}` : undefined;
+                    },
+                    hideIfInvalidClipboard: true,
+                    target: "rawValue",
+                },
+            },
+            attachment: {
+                editor: AttachmentEditor,
+                buttons: [openAttachmentButton, downloadAttachmentButton],
+            },
+        },
+        editorWarnings: [
+            NoWriteAccess,
+            NoWriteLanguageAccess,
+            NoWorkflowWriteAccess,
+            ItemLocked,
+            ValidationErrors,
+        ],
+        outline: {
+            width: 100,
+        },
+        debounceFieldEditsInterval: 250,
+        devices: [
+            { name: "iPhone 14 Pro Max", width: 430, height: 932 },
+            { name: "iPhone SE", width: 375, height: 667 },
+            { name: "Pixel 7", width: 412, height: 915 },
+            { name: "iPad Mini", width: 768, height: 1024 },
+            { name: "iPad Pro", width: 1024, height: 1366 },
+            { name: "Responsive", width: undefined, height: undefined },
+        ],
+        controlCenter: {
+            groups: [
+                {
+                    title: "System",
+                    icon: _jsx(InfoIcon, { strokeWidth: 1 }),
+                    panels: [
+                        {
+                            id: "setup",
+                            title: "Setup",
+                            icon: _jsx(Settings, { strokeWidth: 1 }),
+                            content: _jsx(Setup, {}),
+                        },
+                        {
+                            id: "parhelia-setup",
+                            title: "Parhelia Setup",
+                            icon: _jsx(Settings, { strokeWidth: 1 }),
+                            content: _jsx(ParheliaSetupOverview, {}),
+                        },
+                        {
+                            id: "info",
+                            title: "System Info",
+                            icon: _jsx(InfoIcon, { strokeWidth: 1 }),
+                            content: _jsx(Info, {}),
+                        },
+                        {
+                            id: "quota",
+                            title: "AI Quota",
+                            icon: _jsx(BarChart3, { strokeWidth: 1 }),
+                            content: _jsx(QuotaInfo, {}),
+                        },
+                        {
+                            id: "about",
+                            title: "About",
+                            icon: _jsx(InfoIcon, { strokeWidth: 1 }),
+                            content: _jsx(About, {}),
+                        },
+                        {
+                            id: "websocket-messages",
+                            title: "WebSocket Messages",
+                            icon: _jsx(MessageCircleMore, { strokeWidth: 1 }),
+                            content: _jsx(WebSocketMessages, {}),
+                        },
+                        {
+                            id: "all-agents",
+                            title: "All Agents",
+                            icon: _jsx(Users, { strokeWidth: 1 }),
+                            content: _jsx(AllAgentsPanel, {}),
+                        },
+                    ],
+                },
+                {
+                    title: "Search",
+                    icon: _jsx(Search, { strokeWidth: 1 }),
+                    panels: [
+                        {
+                            id: "index",
+                            title: "Index",
+                            icon: _jsx(Search, { strokeWidth: 1 }),
+                            content: _jsx(IndexOverview, {}),
+                        },
+                    ],
+                },
+            ],
+        },
+        translationCenter: {
+            groups: [],
+        },
+        editor: {
+            defaultPanelSizes: [400, 300],
+            dialogs: {
+                newPage: {
+                    expandTreeNode: "bafb88a1-506a-4671-b47b-1947730d25f6",
+                },
+            },
+            defaultPinnedViews: ["parhelia", "ai", "content-tree"],
+            views: [
+                {
+                    name: "splash-screen",
+                    title: "Splash Screen",
+                    icon: _jsx(Home, { strokeWidth: 1 }),
+                    hidden: true,
+                    defaultCenterPanelView: _jsx(ModernSplashScreen, {}),
+                    hideViewSelector: true,
+                },
+                {
+                    name: "open-page",
+                    title: "Open Page",
+                    icon: _jsx(Home, { strokeWidth: 1 }),
+                    hidden: true,
+                    defaultCenterPanelView: _jsx(OpenPage, {}),
+                    hideViewSelector: true,
+                },
+                {
+                    name: "new-page",
+                    title: "New Page",
+                    icon: _jsx(Home, { strokeWidth: 1 }),
+                    hidden: true,
+                    defaultCenterPanelView: _jsx(NewPage, {}),
+                    hideViewSelector: true,
+                },
+                {
+                    name: "agents-overview",
+                    title: "Agents Overview",
+                    icon: _jsx(Bot, { strokeWidth: 1 }),
+                    defaultCenterPanelView: _jsx(AgentsView, {}),
+                    hideViewSelector: false,
+                    menuBar: _jsx(_Fragment, {}),
+                },
+                {
+                    name: "page-editor",
+                    title: "Edit",
+                    icon: _jsx(EditIcon, {}),
+                    hidden: true,
+                    ...pageEditorViewBase,
+                },
+                // {
+                //   name: "ghostwriter ",
+                //   title: "Ghostwriter",
+                //   icon: <Ghost size={16} />,
+                //   leftSidebar: {
+                //     panels: [
+                //       {
+                //         name: "ghostwriter",
+                //         icon: <Ghost size={16} />,
+                //         title: "Ghostwriter",
+                //         content: <GhostWriter />,
+                //         initialSize: 100,
+                //       },
+                //     ],
+                //   },
+                //   ...pageEditorViewBase,
+                // },
+                {
+                    name: "history",
+                    title: "History",
+                    icon: _jsx(History, { strokeWidth: 1 }),
+                    leftSidebar: {
+                        panels: [
+                            {
+                                name: "history",
+                                title: "History",
+                                content: _jsx(EditHistory, {}),
+                                initialSize: 15,
+                            },
+                        ],
+                    },
+                    ...pageEditorViewBase,
+                },
+                {
+                    name: "completions",
+                    title: "Completions",
+                    icon: _jsx(WandSparkles, { strokeWidth: 1 }),
+                    leftSidebar: {
+                        panels: [
+                            {
+                                name: "completions",
+                                title: "Completions",
+                                content: _jsx(Completions, {}),
+                                initialSize: 15,
+                            },
+                        ],
+                    },
+                    ...pageEditorViewBase,
+                },
+                {
+                    name: "comments",
+                    title: "Feedback",
+                    icon: _jsx(MessageCircleMore, { strokeWidth: 1 }),
+                    leftSidebar: {
+                        panels: [
+                            {
+                                name: "comments",
+                                title: "Comments & Suggestions",
+                                content: _jsx(Comments, {}),
+                                initialSize: 65,
+                                noOverflow: true,
+                            },
+                            {
+                                name: "latest-feedback",
+                                title: "Latest Feedback",
+                                content: _jsx(LatestFeedback, {}),
+                                initialSize: 35,
+                            },
+                        ],
+                    },
+                    ...pageEditorViewBase,
+                },
+                {
+                    name: "reviews",
+                    title: "Reviews",
+                    icon: _jsx(BadgeCheck, { strokeWidth: 1 }),
+                    leftSidebar: {
+                        panels: [
+                            {
+                                name: "reviews",
+                                title: "Reviews",
+                                content: _jsx(Reviews, {}),
+                                initialSize: 100,
+                                noOverflow: true,
+                            },
+                        ],
+                    },
+                    ...pageEditorViewBase,
+                },
+                {
+                    name: "validation",
+                    title: "Validation",
+                    icon: _jsx(ShieldCheck, { strokeWidth: 1 }),
+                    leftSidebar: {
+                        panels: [
+                            {
+                                name: "validation",
+                                title: "Validation",
+                                content: _jsx(Validation, {}),
+                                initialSize: 100,
+                                noOverflow: true,
+                            },
+                        ],
+                    },
+                    ...pageEditorViewBase,
+                },
+                {
+                    name: "publish",
+                    title: "Publish",
+                    icon: _jsx(InboxIcon, { strokeWidth: 1 }),
+                    leftSidebar: {
+                        panels: [
+                            {
+                                name: "Workbox",
+                                title: "Workbox",
+                                content: _jsx(Workbox, {}),
+                                initialSize: 50,
+                            },
+                        ],
+                    },
+                    ...pageEditorViewBase,
+                },
+                {
+                    name: "content-tree",
+                    title: "Content Tree",
+                    icon: _jsx(FolderTreeIcon, { strokeWidth: 1 }),
+                    defaultCenterPanelView: editView,
+                    leftSidebar: {
+                        panels: [
+                            {
+                                name: "tree",
+                                title: "Content Tree",
+                                content: _jsx(MainContentTree, { mode: "normal", hideRootNodes: true }),
+                                initialSize: 80,
+                            },
+                        ],
+                    },
+                    rightSidebar: pageEditorRightSidebar,
+                    toolbarFactory: createEditToolbar,
+                    titlebar: _jsx(Titlebar, {}),
+                },
+                {
+                    name: "dictionary",
+                    title: "Dictionary",
+                    icon: _jsx(BookA, { strokeWidth: 1 }),
+                    leftSidebar: {
+                        panels: [
+                            {
+                                name: "dictionary",
+                                title: "Dictionary",
+                                content: _jsx(DictionaryEditor, {}),
+                                initialSize: 100,
+                            },
+                        ],
+                    },
+                    ...pageEditorViewBase,
+                },
+                {
+                    name: "sessions",
+                    title: "Sessions",
+                    icon: _jsx(Users, { strokeWidth: 1 }),
+                    leftSidebar: {
+                        panels: [
+                            {
+                                name: "sessions",
+                                title: "Sessions",
+                                content: _jsx(Sessions, {}),
+                                initialSize: 100,
+                            },
+                        ],
+                    },
+                    ...pageEditorViewBase,
+                },
+                {
+                    name: "rendering-performance",
+                    title: "Rendering Performance",
+                    icon: _jsx(Timer, { strokeWidth: 1 }),
+                    leftSidebar: {
+                        panels: [
+                            {
+                                name: "rendering-performance",
+                                title: "Rendering Performance",
+                                content: _jsx(Performance, {}),
+                                initialSize: 100,
+                            },
+                        ],
+                    },
+                    ...pageEditorViewBase,
+                },
+                {
+                    name: "debug",
+                    title: "Debug",
+                    icon: _jsx(Bug, { strokeWidth: 1 }),
+                    titlebar: _jsx(Titlebar, {}),
+                    toolbarFactory: createEditToolbar,
+                    leftSidebar: {
+                        panels: [
+                            {
+                                name: "debug",
+                                icon: _jsx(JsonIcon, {}),
+                                title: "Layout JSON",
+                                content: _jsx(Debug, {}),
+                                initialSize: 35,
+                            },
+                            {
+                                name: "graphql",
+                                icon: _jsx(GraphQLIcon, {}),
+                                title: "GraphQL",
+                                content: _jsx(GraphQL, {}),
+                                initialSize: 35,
+                            },
+                        ],
+                    },
+                    rightSidebar: pageEditorRightSidebar,
+                    defaultCenterPanelView: editView,
+                },
+                // {
+                //   name: "component-designer",
+                //   title: "Component Designer",
+                //   icon: "pi pi-palette",
+                //   defaultCenterPanelView: <ComponentDesigner />,
+                //   menuBar: <ComponentDesignerMenu />,
+                //   leftSidebar: {
+                //     panels: [
+                //       {
+                //         name: "component-tree",
+                //         icon: "pi pi-list",
+                //         title: "Outline",
+                //         content: <ComponentTree />,
+                //         initialSize: 30,
+                //       },
+                //       {
+                //         name: "ai-terminal",
+                //         icon: "pi pi-comments",
+                //         title: "AI",
+                //         content: <ComponentDesignerAiTerminal />,
+                //         initialSize: 40,
+                //       },
+                //       {
+                //         name: "history",
+                //         icon: "pi pi-clock",
+                //         title: "History",
+                //         content: <EditHistory />,
+                //         initialSize: 30,
+                //       },
+                //     ],
+                //   },
+                // },
+                {
+                    name: "control-center",
+                    title: "Control Center",
+                    icon: _jsx(Settings, { strokeWidth: 1 }),
+                    defaultCenterPanelView: _jsx(Status, {}),
+                    menuBar: _jsx(_Fragment, {}),
+                },
+            ],
+            itemActionsMenu: {
+                itemsFactory: (editContext) => {
+                    const groups = [];
+                    if (!editContext.contentEditorItem)
+                        return [];
+                    const items = [editContext.contentEditorItem];
+                    const generateItems = (commands) => commands.map((command) => {
+                        if (typeof command === "string") {
+                            return {
+                                id: "separator",
+                                separator: true,
+                                label: "",
+                                icon: undefined,
+                            };
+                        }
+                        return {
+                            id: command.id,
+                            label: command.label,
+                            icon: command.icon,
+                            disabled: editContext.isCommandDisabled({
+                                command: command,
+                                data: { items },
+                            }),
+                            command: async (event) => {
+                                await editContext.executeCommand({
+                                    command: command,
+                                    event: event,
+                                    data: { items },
+                                });
+                            },
+                        };
+                    });
+                    groups.push({
+                        id: "review",
+                        label: "Review",
+                        items: generateItems(editContext.configuration.commands.reviewcommands),
+                    });
+                    groups.push({
+                        id: "all-item-commands",
+                        label: "All Item Commands",
+                        items: generateItems(editContext.configuration.commands.allItemCommands),
+                    });
+                    groups.push({
+                        id: "new",
+                        label: "New",
+                        items: [
+                            {
+                                id: "new-page",
+                                label: "New Page",
+                                icon: _jsx(File, { strokeWidth: 1 }),
+                                command: async () => {
+                                    editContext.switchView("new-page");
+                                },
+                            },
+                        ],
+                    });
+                    // groups.push({
+                    //   id: "about",
+                    //   label: "About",
+                    //   items: [
+                    //     {
+                    //       id: "about",
+                    //       label: "About",
+                    //       icon: "",
+                    //       command: async () => {
+                    //         editContext.openDialog(AboutDialog, {});
+                    //       },
+                    //     },
+                    //   ],
+                    // });
+                    // groups.push({
+                    //   id: "account",
+                    //   label: "Account",
+                    //   items: [
+                    //     {
+                    //       id: "logout",
+                    //       label: "Log Out",
+                    //       icon: "",
+                    //       command: async () => {
+                    //         // Redirect to Sitecore logout endpoint
+                    //         window.location.href = "/sitecore/login?action=logout";
+                    //       },
+                    //     },
+                    //   ],
+                    // });
+                    return groups;
+                },
+            },
+            contentTree: {
+                contextMenu: {
+                    factory: async (props) => {
+                        const editContext = props.editContext;
+                        if (!props.items)
+                            return;
+                        const menuItems = props.editContext.configuration.commands.allItemCommands?.map((x) => {
+                            const commandData = {
+                                items: props.items,
+                            };
+                            return {
+                                id: x.id,
+                                label: x.label,
+                                icon: x.icon,
+                                command: async (triggerEvent) => {
+                                    const result = await editContext?.executeCommand({
+                                        command: x,
+                                        data: commandData,
+                                        event: triggerEvent,
+                                    });
+                                    if (props.commandCallback)
+                                        props.commandCallback(x, result);
+                                },
+                                disabled: editContext?.isCommandDisabled({
+                                    command: x,
+                                    data: commandData,
+                                }),
+                            };
+                        });
+                        // const copyMenuItem = {
+                        //   label: "Copy",
+                        //   id: "copy",
+                        //   template: (
+                        //     <CopyMoveMenuTemplate
+                        //       command={editContext.configuration.commands.copyItems}
+                        //       items={props.items}
+                        //       commandCallback={(command, result) =>
+                        //         props.commandCallback?.(command, result)
+                        //       }
+                        //     />
+                        //   ),
+                        // };
+                        // menuItems.push(copyMenuItem);
+                        // const moveMenuItem = {
+                        //   label: "Move",
+                        //   id: "move",
+                        //   template: (
+                        //     <CopyMoveMenuTemplate
+                        //       command={editContext.configuration.commands.moveItems}
+                        //       items={props.items}
+                        //       commandCallback={(command, result) =>
+                        //         props.commandCallback?.(command, result)
+                        //       }
+                        //     />
+                        //   ),
+                        // };
+                        // menuItems.push(moveMenuItem);
+                        if (props.items.length > 1)
+                            return menuItems;
+                        const item = props.items[0];
+                        if (!item)
+                            return menuItems;
+                        const insertOptions = await loadInsertOptions(item.descriptor);
+                        const insertMenuItem = {
+                            label: "Insert",
+                            id: "insert",
+                            disabled: insertOptions.length == 0,
+                            template: (_jsx(InsertMenuTemplate, { insertOptions: insertOptions, item: item, commandCallback: props.commandCallback, mode: "overlay" })),
+                        };
+                        return [insertMenuItem, ...menuItems];
+                    },
+                },
+            },
+        },
+    };
+};
+export function configureForUser(configuration, user) {
+    if (user.isLimitedPreviewUser) {
+        const previewToolbar = (editContext) => (_jsx(GenericToolbar, { left: [{ key: "review-commands", component: _jsx(ReviewCommands, {}) }], center: [{ key: "edit-mode", component: _jsx(EditControls, {}) }], right: [
+                {
+                    key: "utility-controls",
+                    component: _jsx(UtilityControls, {}),
+                },
+            ] }));
+        return {
+            ...configuration,
+            activeTour: "preview",
+            editor: {
+                ...configuration.editor,
+                views: configuration.editor.views
+                    .filter((x) => x.name === "comments" || x.name === "reviews")
+                    .map((x) => {
+                    return {
+                        ...x,
+                        toolbarFactory: previewToolbar,
+                    };
+                }),
+            },
+        };
+    }
+    return configuration;
+}
+//# sourceMappingURL=config.js.map