restored input parsing rules back to prosemirror and added some news

4 files changed, 83 insertions, 23 deletions

diff --git a/src/client/util/RichTextRules.ts b/src/client/util/RichTextRules.ts
index 8c4c76027..979b76988 100644
--- a/src/client/util/RichTextRules.ts
+++ b/src/client/util/RichTextRules.ts
@@ -1,14 +1,6 @@
-import {
-    inputRules,
-    wrappingInputRule,
-    textblockTypeInputRule,
-    smartQuotes,
-    emDash,
-    ellipsis
-} from "prosemirror-inputrules";
-import { Schema, NodeSpec, MarkSpec, DOMOutputSpecArray, NodeType } from "prosemirror-model";
-
+import { textblockTypeInputRule, smartQuotes, emDash, ellipsis, InputRule } from "prosemirror-inputrules";
 import { schema } from "./RichTextSchema";
+import { wrappingInputRule } from "./prosemirrorPatches";
 
 export const inpRules = {
     rules: [
@@ -21,17 +13,29 @@ export const inpRules = {
 
         // 1. ordered list
         wrappingInputRule(
-            /^(\d+)\.\s$/,
+            /^1\.\s$/,
             schema.nodes.ordered_list,
-            match => ({ order: +match[1] }),
-            (match, node) => node.childCount + node.attrs.order === +match[1]
+            () => {
+                return ({ mapStyle: "decimal", bulletStyle: 1 })
+            },
+            (match: any, node: any) => {
+                return node.childCount + node.attrs.order === +match[1];
+            },
+            (type: any) => ({ type: type, attrs: { mapStyle: "decimal", bulletStyle: 1 } })
         ),
         // a. alphabbetical list
         wrappingInputRule(
-            /^([a-z]+)\.\s$/,
-            schema.nodes.alphabet_list,
-            match => ({ order: +match[1] }),
-            (match, node) => node.childCount + node.attrs.order === +match[1]
+            /^a\.\s$/,
+            schema.nodes.ordered_list,
+            // match => {
+            () => {
+                return ({ mapStyle: "alpha", bulletStyle: 1 })
+                // return ({ order: +match[1] })
+            },
+            (match: any, node: any) => {
+                return node.childCount + node.attrs.order === +match[1];
+            },
+            (type: any) => ({ type: type, attrs: { mapStyle: "alpha", bulletStyle: 1 } })
         ),
 
         // * bullet list
@@ -42,9 +46,17 @@ export const inpRules = {
 
         // # heading
         textblockTypeInputRule(
-            new RegExp("^(#{1,6})\\s$"),
+            new RegExp(/^(#{1,6})\s$/),
             schema.nodes.heading,
-            match => ({ level: match[1].length })
-        )
+            match => {
+                return ({ level: match[1].length });
+            }
+        ),
+
+        new InputRule(
+            new RegExp(/^#([0-9]+)\s$/),
+            (state, match, start, end) => {
+                return state.tr.deleteRange(start, end).addStoredMark(schema.marks.pFontSize.create({ fontSize: Number(match[1]) }))
+            }),
     ]
 };
diff --git a/src/client/util/prosemirrorPatches.js b/src/client/util/prosemirrorPatches.js
index 6bf4395ad..188e3e1c5 100644
--- a/src/client/util/prosemirrorPatches.js
+++ b/src/client/util/prosemirrorPatches.js
@@ -2,11 +2,13 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var prosemirrorInputRules = require('prosemirror-inputrules');
 var prosemirrorTransform = require('prosemirror-transform');
 var prosemirrorModel = require('prosemirror-model');
 
 exports.liftListItem = liftListItem;
 exports.sinkListItem = sinkListItem;
+exports.wrappingInputRule = wrappingInputRule;
 // :: (NodeType) → (state: EditorState, dispatch: ?(tr: Transaction)) → bool
 // Create a command to lift the list item around the selection up into
 // a wrapping list.
@@ -89,4 +91,49 @@ function sinkListItem(itemType) {
         }
         return true
     }
+}
+
+function findWrappingOutside(range, type) {
+    var parent = range.parent;
+    var startIndex = range.startIndex;
+    var endIndex = range.endIndex;
+    var around = parent.contentMatchAt(startIndex).findWrapping(type);
+    if (!around) { return null }
+    var outer = around.length ? around[0] : type;
+    return parent.canReplaceWith(startIndex, endIndex, outer) ? around : null
+}
+
+function findWrappingInside(range, type) {
+    var parent = range.parent;
+    var startIndex = range.startIndex;
+    var endIndex = range.endIndex;
+    var inner = parent.child(startIndex);
+    var inside = type.contentMatch.findWrapping(inner.type);
+    if (!inside) { return null }
+    var lastType = inside.length ? inside[inside.length - 1] : type;
+    var innerMatch = lastType.contentMatch;
+    for (var i = startIndex; innerMatch && i < endIndex; i++) { innerMatch = innerMatch.matchType(parent.child(i).type); }
+    if (!innerMatch || !innerMatch.validEnd) { return null }
+    return inside
+}
+function findWrapping(range, nodeType, attrs, innerRange, customWithAttrs = null) {
+    if (innerRange === void 0) innerRange = range;
+    let withAttrs = (type) => ({ type: type, attrs: null });
+    var around = findWrappingOutside(range, nodeType);
+    var inner = around && findWrappingInside(innerRange, nodeType);
+    if (!inner) { return null }
+    return around.map(withAttrs).concat({ type: nodeType, attrs: attrs }).concat(inner.map(customWithAttrs ? customWithAttrs : withAttrs))
+}
+function wrappingInputRule(regexp, nodeType, getAttrs, joinPredicate, customWithAttrs = null) {
+    return new prosemirrorInputRules.InputRule(regexp, function (state, match, start, end) {
+        var attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+        var tr = state.tr.delete(start, end);
+        var $start = tr.doc.resolve(start), range = $start.blockRange(), wrapping = range && findWrapping(range, nodeType, attrs, undefined, customWithAttrs);
+        if (!wrapping) { return null }
+        tr.wrap(range, wrapping);
+        var before = tr.doc.resolve(start - 1).nodeBefore;
+        if (before && before.type == nodeType && prosemirrorTransform.canJoin(tr.doc, start - 1) &&
+            (!joinPredicate || joinPredicate(match, before))) { tr.join(start - 1); }
+        return tr
+    })
 }
\ No newline at end of file
diff --git a/src/client/views/nodes/FormattedTextBox.tsx b/src/client/views/nodes/FormattedTextBox.tsx
index 93c97fa23..6a6000dc5 100644
--- a/src/client/views/nodes/FormattedTextBox.tsx
+++ b/src/client/views/nodes/FormattedTextBox.tsx
@@ -38,6 +38,7 @@ import { DictationManager } from '../../util/DictationManager';
 import { ReplaceStep } from 'prosemirror-transform';
 import { DocumentType } from '../../documents/DocumentTypes';
 import { formattedTextBoxCommentPlugin, FormattedTextBoxComment } from './FormattedTextBoxComment';
+import { inputRules } from 'prosemirror-inputrules';
 
 library.add(faEdit);
 library.add(faSmile, faTextHeight, faUpload);
@@ -355,8 +356,8 @@ export class FormattedTextBox extends DocComponent<(FieldViewProps & FormattedTe
         this._keymap["ACTIVE"] = this.extensionDoc.text;  // hack to ignore an initial carriage return only when creating a textbox from the action menu
         return {
             schema,
-            inpRules, //these currently don't do anything, but could eventually be helpful
             plugins: this.props.isOverlay ? [
+                inputRules(inpRules),
                 this.tooltipTextMenuPlugin(),
                 history(),
                 keymap(this._keymap),
diff --git a/src/server/index.ts b/src/server/index.ts
index 082e9422d..50ce2b14e 100644
--- a/src/server/index.ts
+++ b/src/server/index.ts
@@ -811,8 +811,8 @@ const EndpointHandlerMap = new Map<GoogleApiServerUtils.Action, GoogleApiServerU
 ]);
 
 app.post(RouteStore.googleDocs + "/:sector/:action", (req, res) => {
-    let sector: GoogleApiServerUtils.Service = req.params.sector;
-    let action: GoogleApiServerUtils.Action = req.params.action;
+    let sector: GoogleApiServerUtils.Service = req.params.sector as GoogleApiServerUtils.Service;
+    let action: GoogleApiServerUtils.Action = req.params.action as GoogleApiServerUtils.Action;
     GoogleApiServerUtils.GetEndpoint(GoogleApiServerUtils.Service[sector], { credentials, token }).then(endpoint => {
         let handler = EndpointHandlerMap.get(action);
         if (endpoint && handler) {