Merge branch 'restoringEslint' into alyssa-starter

1 files changed, 122 insertions, 91 deletions

diff --git a/src/client/views/nodes/formattedText/ProsemirrorExampleTransfer.ts b/src/client/views/nodes/formattedText/ProsemirrorExampleTransfer.ts
index 47527847b..7a8b72be0 100644
--- a/src/client/views/nodes/formattedText/ProsemirrorExampleTransfer.ts
+++ b/src/client/views/nodes/formattedText/ProsemirrorExampleTransfer.ts
@@ -1,29 +1,29 @@
 import { chainCommands, deleteSelection, exitCode, joinBackward, joinDown, joinUp, lift, newlineInCode, selectNodeBackward, setBlockType, splitBlockKeepMarks, toggleMark, wrapIn } from 'prosemirror-commands';
 import { redo, undo } from 'prosemirror-history';
 import { Schema } from 'prosemirror-model';
-import { splitListItem, wrapInList } from 'prosemirror-schema-list';
+import { liftListItem, sinkListItem, splitListItem, wrapInList } from 'prosemirror-schema-list';
 import { EditorState, NodeSelection, TextSelection, Transaction } from 'prosemirror-state';
 import { liftTarget } from 'prosemirror-transform';
-import { AclAdmin, AclAugment, AclEdit } from '../../../../fields/DocSymbols';
-import { GetEffectiveAcl } from '../../../../fields/util';
+import { EditorView } from 'prosemirror-view';
+import { ClientUtils } from '../../../../ClientUtils';
 import { Utils } from '../../../../Utils';
+import { AclAdmin, AclAugment, AclEdit, DocData } from '../../../../fields/DocSymbols';
+import { GetEffectiveAcl } from '../../../../fields/util';
 import { Docs } from '../../../documents/Documents';
 import { RTFMarkup } from '../../../util/RTFMarkup';
-import { SelectionManager } from '../../../util/SelectionManager';
-import { OpenWhere } from '../DocumentView';
-import { liftListItem, sinkListItem } from './prosemirrorPatches.js';
-import { Doc } from '../../../../fields/Doc';
+import { DocumentView } from '../DocumentView';
+import { OpenWhere } from '../OpenWhere';
 
 const mac = typeof navigator !== 'undefined' ? /Mac/.test(navigator.platform) : false;
 
 export type KeyMap = { [key: string]: any };
 
-export let updateBullets = (tx2: Transaction, schema: Schema, assignedMapStyle?: string, from?: number, to?: number) => {
+export const updateBullets = (tx2: Transaction, schema: Schema, assignedMapStyle?: string, from?: number, to?: number) => {
     let mapStyle = assignedMapStyle;
-    tx2.doc.descendants((node: any, offset: any, index: any) => {
+    tx2.doc.descendants((node: any, offset: any /* , index: any */) => {
         if ((from === undefined || to === undefined || (from <= offset + node.nodeSize && to >= offset)) && (node.type === schema.nodes.ordered_list || node.type === schema.nodes.list_item)) {
-            const path = (tx2.doc.resolve(offset) as any).path;
-            let depth = Array.from(path).reduce((p: number, c: any) => p + (c.hasOwnProperty('type') && c.type === schema.nodes.ordered_list ? 1 : 0), 0);
+            const { path } = tx2.doc.resolve(offset) as any;
+            let depth = Array.from(path).reduce((p: number, c: any) => p + (c.type === schema.nodes.ordered_list ? 1 : 0), 0);
             if (node.type === schema.nodes.ordered_list) {
                 if (depth === 0 && !assignedMapStyle) mapStyle = node.attrs.mapStyle;
                 depth++;
@@ -34,38 +34,44 @@ export let updateBullets = (tx2: Transaction, schema: Schema, assignedMapStyle?:
     return tx2;
 };
 
-export function buildKeymap<S extends Schema<any>>(schema: S, props: any, mapKeys?: KeyMap): KeyMap {
+export function buildKeymap<S extends Schema<any>>(schema: S, props: any): KeyMap {
     const keys: { [key: string]: any } = {};
 
     function bind(key: string, cmd: any) {
-        if (mapKeys) {
-            const mapped = mapKeys[key];
-            if (mapped === false) return;
-            if (mapped) key = mapped;
-        }
         keys[key] = cmd;
     }
 
+    function onKey(): boolean | undefined {
+        // bcz: this is pretty hacky -- prosemirror doesn't send us the keyboard event, but the 'event' variable is in scope.. so we access it anyway
+        // eslint-disable-next-line no-restricted-globals
+        return props.onKey?.(event, props);
+    }
+
     const canEdit = (state: any) => {
-        switch (GetEffectiveAcl(props.TemplateDataDocument)) {
+        const permissions = GetEffectiveAcl(props.TemplateDataDocument ?? props.Document[DocData]);
+        switch (permissions) {
             case AclAugment:
-                const prevNode = state.selection.$cursor.nodeBefore;
-                const prevUser = !prevNode ? Doc.CurrentUserEmail : prevNode.marks[prevNode.marks.length - 1].attrs.userid;
-                if (prevUser != Doc.CurrentUserEmail) {
-                    return false;
+                {
+                    const prevNode = state.selection.$cursor.nodeBefore;
+                    const prevUser = !prevNode ? ClientUtils.CurrentUserEmail() : prevNode.marks.lastElement()?.attrs.userid;
+                    if (prevUser !== ClientUtils.CurrentUserEmail()) {
+                        return false;
+                    }
                 }
+                break;
+            default:
         }
         return true;
     };
 
     const toggleEditableMark = (mark: any) => (state: EditorState, dispatch: (tx: Transaction) => void) => canEdit(state) && toggleMark(mark)(state, dispatch);
 
-    //History commands
+    // History commands
     bind('Mod-z', undo);
     bind('Shift-Mod-z', redo);
     !mac && bind('Mod-y', redo);
 
-    //Commands to modify Mark
+    // Commands to modify Mark
     bind('Mod-b', toggleEditableMark(schema.marks.strong));
     bind('Mod-B', toggleEditableMark(schema.marks.strong));
 
@@ -77,19 +83,19 @@ export function buildKeymap<S extends Schema<any>>(schema: S, props: any, mapKey
     bind('Mod-u', toggleEditableMark(schema.marks.underline));
     bind('Mod-U', toggleEditableMark(schema.marks.underline));
 
-    //Commands for lists
+    // Commands for lists
     bind('Ctrl-i', (state: EditorState, dispatch: (tx: Transaction) => void) => canEdit(state) && wrapInList(schema.nodes.ordered_list)(state as any, dispatch as any));
 
-    bind('Ctrl-Tab', () => (props.onKey?.(event, props) ? true : true));
-    bind('Alt-Tab', () => (props.onKey?.(event, props) ? true : true));
-    bind('Meta-Tab', () => (props.onKey?.(event, props) ? true : true));
-    bind('Meta-Enter', () => (props.onKey?.(event, props) ? true : true));
+    bind('Ctrl-Tab', () => onKey() || true);
+    bind('Alt-Tab', () => onKey() || true);
+    bind('Meta-Tab', () => onKey() || true);
+    bind('Meta-Enter', () => onKey() || true);
     bind('Tab', (state: EditorState, dispatch: (tx: Transaction) => void) => {
-        if (props.onKey?.(event, props)) return true;
+        if (onKey()) return true;
         if (!canEdit(state)) return true;
         const ref = state.selection;
         const range = ref.$from.blockRange(ref.$to);
-        const marks = state.storedMarks || (state.selection.$to.parentOffset && state.selection.$from.marks());
+        const marks = state.storedMarks || state.selection.$to.parentOffset ? state.selection.$from.marks() : undefined;
         if (
             !sinkListItem(schema.nodes.list_item)(state, (tx2: Transaction) => {
                 const tx3 = updateBullets(tx2, schema);
@@ -102,25 +108,29 @@ export function buildKeymap<S extends Schema<any>>(schema: S, props: any, mapKey
             const newstate = state.applyTransaction(state.tr.setSelection(TextSelection.create(state.doc, range!.start, range!.end)));
             if (
                 !wrapInList(schema.nodes.ordered_list)(newstate.state as any, (tx2: Transaction) => {
-                    const tx3 = updateBullets(tx2, schema);
+                    const tx25 = updateBullets(tx2, schema);
+                    const olNode = tx25.doc.nodeAt(range!.start)!;
+                    const tx3 = tx25.setNodeMarkup(range!.start, olNode.type, olNode.attrs, marks);
                     // when promoting to a list, assume list will format things so don't copy the stored marks.
                     marks && tx3.ensureMarks([...marks]);
                     marks && tx3.setStoredMarks([...marks]);
-                    dispatch(tx3);
+                    const tx4 = tx3.setSelection(TextSelection.near(tx3.doc.resolve(state.selection.to + 2)));
+                    dispatch(tx4);
                 })
             ) {
                 console.log('bullet promote fail');
             }
         }
+        return undefined;
     });
 
     bind('Shift-Tab', (state: EditorState, dispatch: (tx: Transaction) => void) => {
-        if (props.onKey?.(event, props)) return true;
+        if (onKey()) return true;
         if (!canEdit(state)) return true;
         const marks = state.storedMarks || (state.selection.$to.parentOffset && state.selection.$from.marks());
 
         if (
-            !liftListItem(schema.nodes.list_item)(state.tr, (tx2: Transaction) => {
+            !liftListItem(schema.nodes.list_item)(state, (tx2: Transaction) => {
                 const tx3 = updateBullets(tx2, schema);
                 marks && tx3.ensureMarks([...marks]);
                 marks && tx3.setStoredMarks([...marks]);
@@ -129,15 +139,16 @@ export function buildKeymap<S extends Schema<any>>(schema: S, props: any, mapKey
         ) {
             console.log('bullet demote fail');
         }
+        return undefined;
     });
 
-    //Command to create a new Tab with a PDF of all the command shortcuts
-    bind('Mod-/', (state: EditorState, dispatch: (tx: Transaction) => void) => {
-        const newDoc = Docs.Create.PdfDocument(Utils.prepend('/assets/cheat-sheet.pdf'), { _width: 300, _height: 300 });
+    // Command to create a new Tab with a PDF of all the command shortcuts
+    bind('Mod-/', () => {
+        const newDoc = Docs.Create.PdfDocument(ClientUtils.prepend('/assets/cheat-sheet.pdf'), { _width: 300, _height: 300 });
         props.addDocTab(newDoc, OpenWhere.addRight);
     });
 
-    //Commands to modify BlockType
+    // Commands to modify BlockType
     bind('Ctrl->', (state: EditorState, dispatch: (tx: Transaction) => void) => canEdit(state && wrapIn(schema.nodes.blockquote)(state as any, dispatch as any)));
     bind('Alt-\\', (state: EditorState, dispatch: (tx: Transaction) => void) => canEdit(state) && setBlockType(schema.nodes.paragraph)(state as any, dispatch as any));
     bind('Shift-Ctrl-\\', (state: EditorState, dispatch: (tx: Transaction) => void) => canEdit(state) && setBlockType(schema.nodes.code_block)(state as any, dispatch as any));
@@ -153,31 +164,25 @@ export function buildKeymap<S extends Schema<any>>(schema: S, props: any, mapKey
         bind('Shift-Ctrl-' + i, (state: EditorState, dispatch: (tx: Transaction) => void) => canEdit(state) && setBlockType(schema.nodes.heading, { level: i })(state as any, dispatch as any));
     }
 
-    //Command to create a horizontal break line
+    // Command to create a horizontal break line
     const hr = schema.nodes.horizontal_rule;
     bind('Mod-_', (state: EditorState, dispatch: (tx: Transaction) => void) => canEdit(state) && dispatch(state.tr.replaceSelectionWith(hr.create()).scrollIntoView()));
 
-    //Command to unselect all
+    // Command to unselect all
     bind('Escape', (state: EditorState, dispatch: (tx: Transaction) => void) => {
         dispatch(state.tr.setSelection(TextSelection.create(state.doc, state.selection.from, state.selection.from)));
         (document.activeElement as any).blur?.();
-        SelectionManager.DeselectAll();
+        DocumentView.DeselectAll();
     });
 
-    const splitMetadata = (marks: any, tx: Transaction) => {
-        marks && tx.ensureMarks(marks.filter((val: any) => val.type !== schema.marks.metadata && val.type !== schema.marks.metadataKey && val.type !== schema.marks.metadataVal));
-        marks && tx.setStoredMarks(marks.filter((val: any) => val.type !== schema.marks.metadata && val.type !== schema.marks.metadataKey && val.type !== schema.marks.metadataVal));
-        return tx;
-    };
-
-    bind('Alt-Enter', () => (props.onKey?.(event, props) ? true : true));
-    bind('Ctrl-Enter', () => (props.onKey?.(event, props) ? true : true));
+    bind('Alt-Enter', () => onKey() || true);
+    bind('Ctrl-Enter', () => onKey() || true);
     bind('Cmd-a', (state: EditorState, dispatch: (tx: Transaction) => void) => {
         dispatch(state.tr.setSelection(new TextSelection(state.doc.resolve(1), state.doc.resolve(state.doc.content.size - 1))));
         return true;
     });
-    bind('Cmd-?', (state: EditorState, dispatch: (tx: Transaction) => void) => {
-        RTFMarkup.Instance.open();
+    bind('Cmd-?', () => {
+        RTFMarkup.Instance.setOpen(true);
         return true;
     });
     bind('Cmd-e', (state: EditorState, dispatch: (tx: Transaction) => void) => {
@@ -192,14 +197,14 @@ export function buildKeymap<S extends Schema<any>>(schema: S, props: any, mapKey
     });
     bind('Cmd-]', (state: EditorState, dispatch: (tx: Transaction) => void) => {
         const resolved = state.doc.resolve(state.selection.from) as any;
-        const tr = state.tr;
+        const { tr } = state;
         if (resolved?.parent.type.name === 'paragraph') {
             tr.setNodeMarkup(resolved.path[resolved.path.length - 4], schema.nodes.paragraph, { ...resolved.parent.attrs, align: 'right' }, resolved.parent.marks);
         } else {
             const node = resolved.nodeAfter;
             const sm = state.storedMarks || undefined;
             if (node) {
-                tr.replaceRangeWith(state.selection.from, state.selection.from, schema.nodes.paragraph.create({ align: 'right' })).setStoredMarks([...node.marks, ...(sm ? sm : [])]);
+                tr.replaceRangeWith(state.selection.from, state.selection.from, schema.nodes.paragraph.create({ align: 'right' })).setStoredMarks([...node.marks, ...(sm || [])]);
             }
         }
         dispatch(tr);
@@ -207,14 +212,14 @@ export function buildKeymap<S extends Schema<any>>(schema: S, props: any, mapKey
     });
     bind('Cmd-\\', (state: EditorState, dispatch: (tx: Transaction) => void) => {
         const resolved = state.doc.resolve(state.selection.from) as any;
-        const tr = state.tr;
+        const { tr } = state;
         if (resolved?.parent.type.name === 'paragraph') {
             tr.setNodeMarkup(resolved.path[resolved.path.length - 4], schema.nodes.paragraph, { ...resolved.parent.attrs, align: 'center' }, resolved.parent.marks);
         } else {
             const node = resolved.nodeAfter;
             const sm = state.storedMarks || undefined;
             if (node) {
-                tr.replaceRangeWith(state.selection.from, state.selection.from, schema.nodes.paragraph.create({ align: 'center' })).setStoredMarks([...node.marks, ...(sm ? sm : [])]);
+                tr.replaceRangeWith(state.selection.from, state.selection.from, schema.nodes.paragraph.create({ align: 'center' })).setStoredMarks([...node.marks, ...(sm || [])]);
             }
         }
         dispatch(tr);
@@ -222,14 +227,14 @@ export function buildKeymap<S extends Schema<any>>(schema: S, props: any, mapKey
     });
     bind('Cmd-[', (state: EditorState, dispatch: (tx: Transaction) => void) => {
         const resolved = state.doc.resolve(state.selection.from) as any;
-        const tr = state.tr;
+        const { tr } = state;
         if (resolved?.parent.type.name === 'paragraph') {
             tr.setNodeMarkup(resolved.path[resolved.path.length - 4], schema.nodes.paragraph, { ...resolved.parent.attrs, align: 'left' }, resolved.parent.marks);
         } else {
             const node = resolved.nodeAfter;
             const sm = state.storedMarks || undefined;
             if (node) {
-                tr.replaceRangeWith(state.selection.from, state.selection.from, schema.nodes.paragraph.create({ align: 'left' })).setStoredMarks([...node.marks, ...(sm ? sm : [])]);
+                tr.replaceRangeWith(state.selection.from, state.selection.from, schema.nodes.paragraph.create({ align: 'left' })).setStoredMarks([...node.marks, ...(sm || [])]);
             }
         }
         dispatch(tr);
@@ -239,7 +244,7 @@ export function buildKeymap<S extends Schema<any>>(schema: S, props: any, mapKey
     bind('Cmd-f', (state: EditorState, dispatch: (tx: Transaction) => void) => {
         const content = state.tr.selection.empty ? undefined : state.tr.selection.content().content.textBetween(0, state.tr.selection.content().size + 1);
         const newNode = schema.nodes.footnote.create({}, content ? state.schema.text(content) : undefined);
-        const tr = state.tr;
+        const { tr } = state;
         tr.replaceSelectionWith(newNode); // replace insertion with a footnote.
         dispatch(
             tr.setSelection(
@@ -260,8 +265,8 @@ export function buildKeymap<S extends Schema<any>>(schema: S, props: any, mapKey
     });
 
     // backspace = chainCommands(deleteSelection, joinBackward, selectNodeBackward);
-    bind('Backspace', (state: EditorState, dispatch: (tx: Transaction) => void) => {
-        if (props.onKey?.(event, props)) return true;
+    const backspace = (state: EditorState, dispatch: (tx: Transaction) => void, view: EditorView) => {
+        if (onKey()) return true;
         if (!canEdit(state)) return true;
 
         if (
@@ -272,6 +277,10 @@ export function buildKeymap<S extends Schema<any>>(schema: S, props: any, mapKey
             if (
                 !joinBackward(state, (tx: Transaction) => {
                     dispatch(updateBullets(tx, schema));
+                    if (view.state.selection.$anchor.node(-1)?.type === schema.nodes.list_item) {
+                        // gets rid of an extra paragraph when joining two list items together.
+                        joinBackward(view.state, (tx2: Transaction) => view.dispatch(tx2));
+                    }
                 })
             ) {
                 if (
@@ -284,59 +293,81 @@ export function buildKeymap<S extends Schema<any>>(schema: S, props: any, mapKey
             }
         }
         return true;
-    });
+    };
+    bind('Backspace', backspace);
 
-    //newlineInCode, createParagraphNear, liftEmptyBlock, splitBlock
-    //command to break line
-    bind('Enter', (state: EditorState, dispatch: (tx: Transaction) => void) => {
-        if (props.onKey?.(event, props)) return true;
+    // newlineInCode, createParagraphNear, liftEmptyBlock, splitBlock
+    // command to break line
+
+    const enter = (state: EditorState, dispatch: (tx: Transaction) => void, view: EditorView, once = true) => {
+        if (onKey()) return true;
         if (!canEdit(state)) return true;
 
         const trange = state.selection.$from.blockRange(state.selection.$to);
-        const path = (state.selection.$from as any).path;
-        const depth = trange ? liftTarget(trange) : undefined;
-        const split = path.length > 5 && !path[path.length - 3].textContent && path[path.length - 6].type !== schema.nodes.list_item;
-        if (split && trange && depth !== undefined && depth !== null) {
+        const depth = trange ? liftTarget(trange) : null;
+        if (
+            depth !== null &&
+            state.selection.$from.node(-1)?.type === state.schema.nodes.blockquote && //
+            !state.selection.$from.node().content.size &&
+            trange
+        ) {
             dispatch(state.tr.lift(trange, depth) as any);
             return true;
         }
 
         const marks = state.storedMarks || (state.selection.$to.parentOffset && state.selection.$from.marks());
-        const cr = state.selection.$from.node().textContent.endsWith('\n');
-        if (/*cr ||*/ !newlineInCode(state, dispatch as any)) {
-            if (
+        if (!newlineInCode(state, dispatch as any)) {
+            const olNode = view.state.selection.$anchor.node(-2);
+            const liNode = view.state.selection.$anchor.node(-1);
+            // prettier-ignore
+            if (liNode?.type === schema.nodes.list_item && !liNode.textContent && 
+                olNode?.type === schema.nodes.ordered_list && once && view.state.selection.$from.depth === 3) 
+            {
+                // handles case of hitting enter at then end of a top-level empty list item - the result is to create a paragraph
+                for (let i = 0; i < 10 && view.state.selection.$from.depth > 1 && liftListItem(schema.nodes.list_item)(view.state, view.dispatch); i++);
+            } else if (
                 !splitListItem(schema.nodes.list_item)(state as any, (tx2: Transaction) => {
                     const tx3 = updateBullets(tx2, schema);
                     marks && tx3.ensureMarks([...marks]);
                     marks && tx3.setStoredMarks([...marks]);
                     dispatch(tx3);
+                    // removes an extra paragraph created when selecting text across two list items or splitting an empty list item
+                    !once && view.dispatch(view.state.tr.deleteRange(view.state.selection.from - 5, view.state.selection.from - 2));
                 })
             ) {
-                const fromattrs = state.selection.$from.node().attrs;
-                if (
-                    !splitBlockKeepMarks(state, (tx3: Transaction) => {
-                        const tonode = tx3.selection.$to.node();
-                        if (tx3.selection.to && tx3.doc.nodeAt(tx3.selection.to - 1)) {
-                            const tx4 = tx3.setNodeMarkup(tx3.selection.to - 1, tonode.type, fromattrs, tonode.marks);
-                            splitMetadata(marks, tx4);
-                            if (!liftListItem(schema.nodes.list_item)(tx4, dispatch as (tx: Transaction) => void)) {
+                if (once && view.state.selection.$from.node(-2)?.type === schema.nodes.ordered_list && view.state.selection.$from.node(-1)?.type === schema.nodes.list_item && view.state.selection.$from.node(-1)?.textContent === '') {
+                    // handles case of hitting enter on an empty list item which needs to create a second empty paragraph, then split it by calling enter() again
+                    view.dispatch(view.state.tr.insert(view.state.selection.from, schema.nodes.paragraph.create({})));
+                    enter(view.state, view.dispatch, view, false);
+                } else {
+                    const fromattrs = state.selection.$from.node().attrs;
+                    if (
+                        !splitBlockKeepMarks(state, (tx3: Transaction) => {
+                            const tonode = tx3.selection.$to.node();
+                            if (tx3.selection.to && tx3.doc.nodeAt(tx3.selection.to - 1)) {
+                                const tx4 = tx3.setNodeMarkup(tx3.selection.to - 1, tonode.type, fromattrs, tonode.marks).setStoredMarks(marks || []);
                                 dispatch(tx4);
                             }
-                        } else dispatch(tx3.insertText('\r\n'));
-                    })
-                ) {
-                    return false;
+
+                            if (view.state.selection.$anchor.nodeAfter?.type === schema.nodes.text && once) {
+                                // if text is selected across list items, then we need to forcibly insert a new line since the splitBlock code joins the two list items.
+                                enter(view.state, dispatch, view, false);
+                            }
+                        })
+                    ) {
+                        return false;
+                    }
                 }
             }
         }
         return true;
-    });
+    };
+    bind('Enter', enter);
 
-    //Command to create a blank space
-    bind('Space', (state: EditorState, dispatch: (tx: Transaction) => void) => {
-        if (props.TemplateDataDocument && GetEffectiveAcl(props.TemplateDataDocument) != AclEdit && GetEffectiveAcl(props.TemplateDataDocument) != AclAugment && GetEffectiveAcl(props.TemplateDataDocument) != AclAdmin) return true;
-        const marks = state.storedMarks || (state.selection.$to.parentOffset && state.selection.$from.marks());
-        dispatch(splitMetadata(marks, state.tr));
+    // Command to create a blank space
+    bind('Space', () => {
+        const editDoc = props.TemplateDataDocument ?? props.Document[DocData];
+        if (editDoc && ![AclAdmin, AclAugment, AclEdit].includes(GetEffectiveAcl(editDoc))) return true;
         return false;
     });