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

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/src/core/super-converter/v3/handlers/mc/altermateContent/alternate-content-translator.d.ts

@@ -0,0 +1,6 @@
+/** @type {import('@translator').NodeTranslatorConfig} */
+export const config: import("@translator").NodeTranslatorConfig;
+/**
+ * @type {import('@translator').NodeTranslator}
+ */
+export const translator: import("@translator").NodeTranslator;

package/dist/super-editor/src/core/super-converter/v3/handlers/mc/altermateContent/index.d.ts

@@ -0,0 +1 @@
+export * from "./alternate-content-translator.js";

package/dist/super-editor/src/extensions/noderesizer/helpers.d.ts

@@ -0,0 +1,2 @@
+export function queryWithinRoot(domNode: any, selector: any): any;
+export function findInEventPath(event: any, selector: any): any;

package/dist/super-editor/src/tests/helpers/helpers.d.ts

@@ -1,4 +1,5 @@
 export function getTestDataByFileName(name: string): Promise<any>;
+export function getExtractedDocxData(folderName: any): Promise<{}>;
 export function getTestDataAsFileBuffer(name: any): Promise<Buffer<ArrayBufferLike>>;
 export function loadTestDataForEditorTests(filename: string): Promise<[any, any, any, any]>;
 export function initTestEditor(options?: any): Editor;

package/dist/super-editor/src/utils/shadow-root.d.ts

@@ -0,0 +1,12 @@
+export function supportsConstructableStylesheets(): boolean;
+export function ensureStyleSheet(root: ShadowRoot | (DocumentFragment & {
+    adoptedStyleSheets?: CSSStyleSheet[];
+})): void;
+export function ensureEditorShadowRoot(hostElement: HTMLElement | null): {
+    root: ShadowRoot | null;
+    mount: HTMLElement | null;
+};
+export function __shadowRootTestUtils(): {
+    resetStyleSheetCache: () => void;
+};
+export function __getEditorStylesForTest(): string;

package/dist/super-editor/style.css

@@ -279,7 +279,7 @@
   border-radius: 8px !important;
 }
 
-.button-group[data-v-f42ec7e6] {
+.button-group[data-v-c1b3551b] {
   display: flex;
 }
 
@@ -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;
@@ -1836,10 +1841,10 @@ on the right if it is inside shape textbox.
   min-height: 40px;
 }
 
-.editor-element[data-v-0c36dd72] {
+.editor-element[data-v-3d49a1a6] {
   position: relative;
 }
-.super-editor-container[data-v-0c36dd72] {
+.super-editor-container[data-v-3d49a1a6] {
   width: auto;
   height: auto;
   min-width: 8in;
@@ -1848,13 +1853,13 @@ on the right if it is inside shape textbox.
   display: flex;
   flex-direction: column;
 }
-.ruler[data-v-0c36dd72] {
+.ruler[data-v-3d49a1a6] {
   margin-bottom: 2px;
 }
-.super-editor[data-v-0c36dd72] {
+.super-editor[data-v-3d49a1a6] {
   color: initial;
 }
-.placeholder-editor[data-v-0c36dd72] {
+.placeholder-editor[data-v-3d49a1a6] {
   position: absolute;
   top: 0;
   left: 0;
@@ -1866,13 +1871,13 @@ on the right if it is inside shape textbox.
   background-color: white;
   box-sizing: border-box;
 }
-.placeholder-title[data-v-0c36dd72] {
+.placeholder-title[data-v-3d49a1a6] {
   display: flex;
   justify-content: center;
   margin-bottom: 40px;
 }
 
-.super-editor[data-v-4d5cff52] {
+.super-editor[data-v-23a4e794] {
   box-sizing: border-box;
   width: 100%;
   height: 100%;
@@ -1881,17 +1886,17 @@ on the right if it is inside shape textbox.
   transition: border 0.2s ease;
   background-color: white;
 }
-.super-input[data-v-4d5cff52] {
+.super-input[data-v-23a4e794] {
   font-size: 13px;
   font-family: inherit;
 }
-.editor-element[data-v-4d5cff52] {
+.editor-element[data-v-23a4e794] {
   height: 100%;
   width: 100%;
   border: none;
   outline: none;
 }
-.super-input-active[data-v-4d5cff52] {
+.super-input-active[data-v-23a4e794] {
   border: 1px solid #007bff;
   outline: none;
 }