@harbour-enterprises/superdoc 0.21.0-next.4 → 0.21.0-next.5

package/dist/style.css

@@ -2122,6 +2122,11 @@ on the right if it is inside shape textbox.
   height: 12px;
   width: 12px;
 }
+.slash-menu-custom-item {
+  display: flex;
+  align-items: center;
+  width: 100%;
+}
 .popover {
   background: white;
   border-radius: 6px;
@@ -2424,46 +2429,46 @@ img[data-v-7dd69850] {
     box-shadow: 0 0 5px hsla(0, 0%, 0%, 0.05);
 }
 
-.superdoc[data-v-07532c12] {
+.superdoc[data-v-dbfba5b9] {
   display: flex;
 }
-.right-sidebar[data-v-07532c12] {
+.right-sidebar[data-v-dbfba5b9] {
   min-width: 320px;
 }
-.floating-comments[data-v-07532c12] {
+.floating-comments[data-v-dbfba5b9] {
   min-width: 300px;
   width: 300px;
 }
-.superdoc__layers[data-v-07532c12] {
+.superdoc__layers[data-v-dbfba5b9] {
   height: 100%;
   position: relative;
   box-sizing: border-box;
 }
-.superdoc__document[data-v-07532c12] {
+.superdoc__document[data-v-dbfba5b9] {
   width: 100%;
   position: relative;
 }
-.superdoc__sub-document[data-v-07532c12] {
+.superdoc__sub-document[data-v-dbfba5b9] {
   width: 100%;
   position: relative;
 }
-.superdoc__selection-layer[data-v-07532c12] {
+.superdoc__selection-layer[data-v-dbfba5b9] {
   position: absolute;
   min-width: 100%;
   min-height: 100%;
   z-index: 10;
   pointer-events: none;
 }
-.superdoc__temp-selection[data-v-07532c12] {
+.superdoc__temp-selection[data-v-dbfba5b9] {
   position: absolute;
 }
-.superdoc__comments-layer[data-v-07532c12] {
+.superdoc__comments-layer[data-v-dbfba5b9] {
   /* position: absolute; */
   top: 0;
   height: 100%;
   position: relative;
 }
-.superdoc__right-sidebar[data-v-07532c12] {
+.superdoc__right-sidebar[data-v-dbfba5b9] {
   width: 320px;
   min-width: 320px;
   padding: 0 10px;
@@ -2473,14 +2478,14 @@ img[data-v-7dd69850] {
 }
 
 /* Tools styles */
-.tools[data-v-07532c12] {
+.tools[data-v-dbfba5b9] {
   position: absolute;
   z-index: 3;
   display: flex;
   flex-direction: column;
   gap: 6px;
 }
-.tools .tool-icon[data-v-07532c12] {
+.tools .tool-icon[data-v-dbfba5b9] {
   font-size: 20px;
   border-radius: 12px;
   border: none;
@@ -2488,7 +2493,7 @@ img[data-v-7dd69850] {
   background-color: #dbdbdb;
   cursor: pointer;
 }
-.tools-item[data-v-07532c12] {
+.tools-item[data-v-dbfba5b9] {
   display: flex;
   align-items: center;
   justify-content: center;
@@ -2498,10 +2503,10 @@ img[data-v-7dd69850] {
   border-radius: 12px;
   cursor: pointer;
 }
-.tools-item i[data-v-07532c12] {
+.tools-item i[data-v-dbfba5b9] {
   cursor: pointer;
 }
-.superdoc__tools-icon[data-v-07532c12] {
+.superdoc__tools-icon[data-v-dbfba5b9] {
   width: 20px;
   height: 20px;
   flex-shrink: 0;
@@ -2516,15 +2521,15 @@ img[data-v-7dd69850] {
 
 /* 834px is iPad screen size in portrait orientation */
 @media (max-width: 834px) {
-.superdoc .superdoc__layers[data-v-07532c12] {
+.superdoc .superdoc__layers[data-v-dbfba5b9] {
     margin: 0;
     border: 0 !important;
     box-shadow: none;
 }
-.superdoc__sub-document[data-v-07532c12] {
+.superdoc__sub-document[data-v-dbfba5b9] {
     max-width: 100%;
 }
-.superdoc__right-sidebar[data-v-07532c12] {
+.superdoc__right-sidebar[data-v-dbfba5b9] {
     padding: 10px;
     width: 55px;
     position: relative;
@@ -2532,7 +2537,7 @@ img[data-v-7dd69850] {
 }
 
 /* AI Writer styles */
-.ai-writer-container[data-v-07532c12] {
+.ai-writer-container[data-v-dbfba5b9] {
   position: fixed;
   z-index: 1000;
   background: white;
@@ -2550,13 +2555,13 @@ img[data-v-7dd69850] {
 } */
 
 /* Tools styles */
-.tools[data-v-07532c12] {
+.tools[data-v-dbfba5b9] {
   position: absolute;
   z-index: 3;
   display: flex;
   gap: 6px;
 }
-.tools .tool-icon[data-v-07532c12] {
+.tools .tool-icon[data-v-dbfba5b9] {
   font-size: 20px;
   border-radius: 12px;
   border: none;
@@ -2564,7 +2569,7 @@ img[data-v-7dd69850] {
   background-color: #dbdbdb;
   cursor: pointer;
 }
-.tools-item[data-v-07532c12] {
+.tools-item[data-v-dbfba5b9] {
   display: flex;
   align-items: center;
   justify-content: center;
@@ -2575,18 +2580,18 @@ img[data-v-7dd69850] {
   border-radius: 12px;
   cursor: pointer;
 }
-.tools-item i[data-v-07532c12] {
+.tools-item i[data-v-dbfba5b9] {
   cursor: pointer;
 }
-.superdoc__tools-icon[data-v-07532c12] {
+.superdoc__tools-icon[data-v-dbfba5b9] {
   width: 20px;
   height: 20px;
   flex-shrink: 0;
 }
-.ai-tool > svg[data-v-07532c12] {
+.ai-tool > svg[data-v-dbfba5b9] {
   fill: transparent;
 }
-.ai-tool[data-v-07532c12]::before {
+.ai-tool[data-v-dbfba5b9]::before {
   content: '';
   position: absolute;
   width: 20px;
@@ -2607,7 +2612,7 @@ img[data-v-7dd69850] {
   filter: brightness(1.2);
   transition: filter 0.2s ease;
 }
-.ai-tool[data-v-07532c12]:hover::before {
+.ai-tool[data-v-dbfba5b9]:hover::before {
   filter: brightness(1.3);
 }
 

package/dist/super-editor/src/components/slash-menu/menuItems.d.ts

@@ -14,7 +14,9 @@
  *     requiresClipboard?: boolean
  *     requiresTableParent?: boolean
  *     requiredSectionParent?: boolean,
- *     requiresModule?: string
+ *     requiresModule?: string,
+ *     render?: (context: Object) => HTMLElement,
+ *     showWhen?: (context: Object) => boolean
  *   }>
  * }>} Array of menu sections
  */
@@ -32,5 +34,7 @@ export function getItems(context: any): Array<{
         requiresTableParent?: boolean;
         requiredSectionParent?: boolean;
         requiresModule?: string;
+        render?: (context: any) => HTMLElement;
+        showWhen?: (context: any) => boolean;
     }>;
 }>;

package/dist/super-editor/src/components/slash-menu/tests/testHelpers.d.ts

@@ -0,0 +1,466 @@
+/**
+ * Test helper utilities for slash menu components
+ * Extracts shared patterns from utils.test.js, SlashMenu.test.js, and menuItems.test.js
+ */
+/**
+ * Creates a mock ProseMirror selection object with configurable properties
+ */
+export function createMockSelection(options?: {}): {
+    from: number;
+    to: number;
+    empty: boolean;
+    $head: {
+        marks: import("vitest").Mock<() => {
+            type: {
+                name: any;
+            };
+        }[]>;
+    };
+    $from: {
+        depth: number;
+        node: import("vitest").Mock<() => {
+            type: {
+                name: string;
+            };
+        }>;
+    };
+    $to: {
+        depth: number;
+        node: import("vitest").Mock<() => {
+            type: {
+                name: string;
+            };
+        }>;
+    };
+    constructor: {
+        near: import("vitest").Mock<() => {
+            from: number;
+            to: number;
+        }>;
+    };
+};
+/**
+ * Creates a mock ProseMirror state object with configurable properties
+ */
+export function createMockState(options?: {}): {
+    selection: {
+        from: number;
+        to: number;
+        empty: boolean;
+        $head: {
+            marks: import("vitest").Mock<() => {
+                type: {
+                    name: any;
+                };
+            }[]>;
+        };
+        $from: {
+            depth: number;
+            node: import("vitest").Mock<() => {
+                type: {
+                    name: string;
+                };
+            }>;
+        };
+        $to: {
+            depth: number;
+            node: import("vitest").Mock<() => {
+                type: {
+                    name: string;
+                };
+            }>;
+        };
+        constructor: {
+            near: import("vitest").Mock<() => {
+                from: number;
+                to: number;
+            }>;
+        };
+    };
+    doc: {
+        textBetween: import("vitest").Mock<() => string>;
+        nodeAt: import("vitest").Mock<() => {
+            type: {
+                name: string;
+            };
+        }>;
+        resolve: import("vitest").Mock<() => {}>;
+    };
+    schema: {
+        marks: {};
+        nodes: {
+            paragraph: {
+                name: string;
+            };
+            table: {
+                name: string;
+            };
+            bulletList: {
+                name: string;
+            };
+            documentSection: {
+                name: string;
+            };
+        };
+    };
+    storedMarks: any;
+    history: {
+        undoDepth: number;
+        redoDepth: number;
+    };
+    tr: {
+        setMeta: import("vitest").Mock<() => any>;
+        setSelection: import("vitest").Mock<() => any>;
+    };
+};
+/**
+ * Creates a mock ProseMirror view object with configurable properties
+ */
+export function createMockView(options?: {}): {
+    state: {
+        selection: {
+            from: number;
+            to: number;
+            empty: boolean;
+            $head: {
+                marks: import("vitest").Mock<() => {
+                    type: {
+                        name: any;
+                    };
+                }[]>;
+            };
+            $from: {
+                depth: number;
+                node: import("vitest").Mock<() => {
+                    type: {
+                        name: string;
+                    };
+                }>;
+            };
+            $to: {
+                depth: number;
+                node: import("vitest").Mock<() => {
+                    type: {
+                        name: string;
+                    };
+                }>;
+            };
+            constructor: {
+                near: import("vitest").Mock<() => {
+                    from: number;
+                    to: number;
+                }>;
+            };
+        };
+        doc: {
+            textBetween: import("vitest").Mock<() => string>;
+            nodeAt: import("vitest").Mock<() => {
+                type: {
+                    name: string;
+                };
+            }>;
+            resolve: import("vitest").Mock<() => {}>;
+        };
+        schema: {
+            marks: {};
+            nodes: {
+                paragraph: {
+                    name: string;
+                };
+                table: {
+                    name: string;
+                };
+                bulletList: {
+                    name: string;
+                };
+                documentSection: {
+                    name: string;
+                };
+            };
+        };
+        storedMarks: any;
+        history: {
+            undoDepth: number;
+            redoDepth: number;
+        };
+        tr: {
+            setMeta: import("vitest").Mock<() => any>;
+            setSelection: import("vitest").Mock<() => any>;
+        };
+    };
+    coordsAtPos: import("vitest").Mock<() => {
+        left: number;
+        top: number;
+    }>;
+    posAtCoords: import("vitest").Mock<() => {
+        pos: number;
+    }>;
+    dispatch: import("vitest").Mock<(...args: any[]) => any>;
+    focus: import("vitest").Mock<(...args: any[]) => any>;
+    dom: {
+        addEventListener: import("vitest").Mock<(...args: any[]) => any>;
+        removeEventListener: import("vitest").Mock<(...args: any[]) => any>;
+    };
+};
+/**
+ * Creates a mock editor object with configurable options
+ */
+export function createMockEditor(options?: {}): {
+    view: {
+        state: {
+            selection: {
+                from: number;
+                to: number;
+                empty: boolean;
+                $head: {
+                    marks: import("vitest").Mock<() => {
+                        type: {
+                            name: any;
+                        };
+                    }[]>;
+                };
+                $from: {
+                    depth: number;
+                    node: import("vitest").Mock<() => {
+                        type: {
+                            name: string;
+                        };
+                    }>;
+                };
+                $to: {
+                    depth: number;
+                    node: import("vitest").Mock<() => {
+                        type: {
+                            name: string;
+                        };
+                    }>;
+                };
+                constructor: {
+                    near: import("vitest").Mock<() => {
+                        from: number;
+                        to: number;
+                    }>;
+                };
+            };
+            doc: {
+                textBetween: import("vitest").Mock<() => string>;
+                nodeAt: import("vitest").Mock<() => {
+                    type: {
+                        name: string;
+                    };
+                }>;
+                resolve: import("vitest").Mock<() => {}>;
+            };
+            schema: {
+                marks: {};
+                nodes: {
+                    paragraph: {
+                        name: string;
+                    };
+                    table: {
+                        name: string;
+                    };
+                    bulletList: {
+                        name: string;
+                    };
+                    documentSection: {
+                        name: string;
+                    };
+                };
+            };
+            storedMarks: any;
+            history: {
+                undoDepth: number;
+                redoDepth: number;
+            };
+            tr: {
+                setMeta: import("vitest").Mock<() => any>;
+                setSelection: import("vitest").Mock<() => any>;
+            };
+        };
+        coordsAtPos: import("vitest").Mock<() => {
+            left: number;
+            top: number;
+        }>;
+        posAtCoords: import("vitest").Mock<() => {
+            pos: number;
+        }>;
+        dispatch: import("vitest").Mock<(...args: any[]) => any>;
+        focus: import("vitest").Mock<(...args: any[]) => any>;
+        dom: {
+            addEventListener: import("vitest").Mock<(...args: any[]) => any>;
+            removeEventListener: import("vitest").Mock<(...args: any[]) => any>;
+        };
+    };
+    options: {
+        documentMode: string;
+        isAiEnabled: boolean;
+        slashMenuConfig: any;
+        aiApiKey: any;
+        aiEndpoint: any;
+    };
+    isEditable: boolean;
+    commands: any;
+    on: import("vitest").Mock<(...args: any[]) => any>;
+    off: import("vitest").Mock<(...args: any[]) => any>;
+    emit: import("vitest").Mock<(...args: any[]) => any>;
+};
+/**
+ * Creates a mock editor context object for slash menu utilities
+ */
+export function createMockContext(options?: {}): {
+    editor: any;
+    cursorPosition: {
+        x: number;
+        y: number;
+    };
+    pos: number;
+    node: {
+        type: {
+            name: string;
+        };
+    };
+    event: any;
+    selectedText: string;
+    hasSelection: boolean;
+    trigger: string;
+    clipboardContent: {
+        html: any;
+        text: any;
+        hasContent: boolean;
+    };
+    selectionStart: number;
+    selectionEnd: number;
+    isInTable: boolean;
+    isInList: boolean;
+    isInSectionNode: boolean;
+    currentNodeType: string;
+    activeMarks: any[];
+    isTrackedChange: boolean;
+    documentMode: string;
+    canUndo: boolean;
+    canRedo: boolean;
+    isEditable: boolean;
+};
+/**
+ * Sets up common mocks and returns cleanup functions
+ * Returns an object with mock functions and a cleanup function
+ */
+export function setupCommonMocks(): {
+    mocks: {
+        readFromClipboard: import("vitest").Mock<(...args: any[]) => any>;
+        selectionHasNodeOrMark: import("vitest").Mock<() => boolean>;
+        moveCursorToMouseEvent: import("vitest").Mock<(...args: any[]) => any>;
+        handleClipboardPaste: import("vitest").Mock<() => boolean>;
+    };
+    spies: {
+        docAddEventListener: import("vitest").MockInstance<{
+            <K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        }>;
+        docRemoveEventListener: import("vitest").MockInstance<{
+            <K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        }>;
+    };
+    cleanup: () => void;
+};
+/**
+ * Creates a beforeEach setup function with common mock resets
+ * Has a callback for any custom setup that needs to be done before each test
+ */
+export function createBeforeEachSetup(customSetup?: () => void): () => void;
+/**
+ * Mounts a Vue component with common props and returns wrapper with helper methods
+ */
+export function mountSlashMenuComponent(component: any, options?: {}): {
+    wrapper: import("@vue/test-utils").VueWrapper<unknown, import("vue").ComponentPublicInstance<unknown, Omit<unknown, never>>>;
+    props: any;
+    openMenu(menuPosition?: {
+        left: string;
+        top: string;
+    }): Promise<void>;
+    closeMenu(): Promise<void>;
+    triggerKeydown(key: any, target?: string): Promise<void>;
+};
+/**
+ * Filters menu items by various criteria (helper for testing menu item filtering)
+ */
+export function filterMenuItems(sections: any, criteria?: {}): any;
+/**
+ * Creates mock menu items for testing
+ */
+export function createMockMenuItems(count?: number, customItems?: any[]): {
+    id: string;
+    items: any[];
+}[];
+/**
+ * Creates a mock item with custom render function for testing
+ */
+export function createMockRenderItem(id?: string, renderFn?: any): {
+    id: string;
+    label: string;
+    render: any;
+    allowedTriggers: string[];
+};
+/**
+ * Common assertions for editor mock objects
+ */
+export function assertEditorMockStructure(editor: any): void;
+/**
+ * Common assertions for menu sections structure
+ */
+export function assertMenuSectionsStructure(sections: any): void;
+/**
+ * Asserts that event listeners are properly set up
+ */
+export function assertEventListenersSetup(editor: any, documentSpies: any): void;
+/**
+ * Asserts that event listeners are properly cleaned up
+ */
+export function assertEventListenersCleanup(editor: any, documentSpies: any): void;
+export namespace SlashMenuConfigs {
+    namespace withAI {
+        let includeDefaultItems: boolean;
+        let customItems: any[];
+    }
+    namespace customOnly {
+        let includeDefaultItems_1: boolean;
+        export { includeDefaultItems_1 as includeDefaultItems };
+        let customItems_1: {
+            id: string;
+            items: {
+                id: string;
+                label: string;
+                allowedTriggers: string[];
+                action: import("vitest").Mock<(...args: any[]) => any>;
+            }[];
+        }[];
+        export { customItems_1 as customItems };
+    }
+    function withProvider(providerFn: any): {
+        includeDefaultItems: boolean;
+        menuProvider: any;
+    };
+    namespace withConditionalItems {
+        let includeDefaultItems_2: boolean;
+        export { includeDefaultItems_2 as includeDefaultItems };
+        let customItems_2: {
+            id: string;
+            items: ({
+                id: string;
+                label: string;
+                allowedTriggers: string[];
+                action: import("vitest").Mock<(...args: any[]) => any>;
+                showWhen?: undefined;
+            } | {
+                id: string;
+                label: string;
+                allowedTriggers: string[];
+                action: import("vitest").Mock<(...args: any[]) => any>;
+                showWhen: (context: any) => any;
+            })[];
+        }[];
+        export { customItems_2 as customItems };
+    }
+}

package/dist/super-editor/src/components/slash-menu/utils.d.ts

@@ -3,7 +3,14 @@
  *
  * @param {Object} editor - The editor instance
  * @param {MouseEvent} [event] - Optional mouse event (for context menu)
- * @returns {Object} context - { editor, selectedText, pos, node, event }
+ * @returns {Promise<Object>} context - Enhanced editor context with comprehensive state information
  */
-export function getEditorContext(editor: any, event?: MouseEvent): any;
+export function getEditorContext(editor: any, event?: MouseEvent): Promise<any>;
 export function getPropsByItemId(itemId: string, props: any): any;
+declare function getStructureFromResolvedPos(state: any, pos: any): {
+    isInTable: boolean;
+    isInList: boolean;
+    isInSectionNode: boolean;
+};
+declare function isCollaborationEnabled(editor: any): boolean;
+export { getStructureFromResolvedPos as __getStructureFromResolvedPosForTest, isCollaborationEnabled as __isCollaborationEnabledForTest };

package/dist/super-editor/style.css

@@ -1748,6 +1748,11 @@ on the right if it is inside shape textbox.
   height: 12px;
   width: 12px;
 }
+.slash-menu-custom-item {
+  display: flex;
+  align-items: center;
+  width: 100%;
+}
 .popover {
   background: white;
   border-radius: 6px;