@manuscripts/body-editor 3.12.66 → 3.13.0

package/src/keys/keyword.ts

@@ -0,0 +1,69 @@
+/*!
+ * © 2019 Atypon Systems LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ManuscriptEditorState, schema } from '@manuscripts/transform'
+
+import { isNodeSelection, isTextSelection } from '../commands'
+import { EditorAction } from '../types'
+
+const ignoreEnter: EditorAction = (state) => {
+  const { selection } = state
+  if (!isTextSelection(selection)) {
+    return false
+  }
+
+  const { $from, $to } = selection
+  // Check if the selection starts and ends in a keyword node
+  const startNode = $from.node($from.depth)
+  const endNode = $to.node($to.depth)
+
+  if (
+    startNode.type === state.schema.nodes.keyword ||
+    endNode.type === state.schema.nodes.keyword
+  ) {
+    return true // Ignore Enter key press if selection is within a keyword node
+  }
+
+  return false
+}
+
+export const ignoreBackSpace = (state: ManuscriptEditorState) => {
+  const { selection } = state
+
+  if (!isNodeSelection(selection)) {
+    return selection.$from.node().type === schema.nodes.keyword
+  }
+
+  return false
+}
+
+export const ignoreDelete = (state: ManuscriptEditorState) => {
+  const { selection } = state
+
+  if (!isTextSelection(selection)) {
+    return false
+  }
+
+  return selection.$from.node().type === schema.nodes.keyword
+}
+
+const keywordKeymap: { [key: string]: EditorAction } = {
+  Enter: ignoreEnter,
+  Delete: ignoreDelete,
+  Backspace: ignoreBackSpace,
+}
+
+export default keywordKeymap

package/src/keys/list.ts

@@ -0,0 +1,156 @@
+/*!
+ * © 2019 Atypon Systems LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { skipTracking } from '@manuscripts/track-changes-plugin'
+import { ManuscriptEditorState, schema } from '@manuscripts/transform'
+import { joinBackward } from 'prosemirror-commands'
+import { Fragment, NodeType, Slice } from 'prosemirror-model'
+import {
+  liftListItem,
+  splitListItem,
+  wrapInList,
+} from 'prosemirror-schema-list'
+import { Command, EditorState, Transaction } from 'prosemirror-state'
+import { ReplaceAroundStep } from 'prosemirror-transform'
+import { findParentNodeOfType } from 'prosemirror-utils'
+
+import { Dispatch } from '../commands'
+import { EditorAction } from '../types'
+
+// TODO:: remove this command when quarterback start supporting list_item and the operation on the list
+export const skipCommandTracking =
+  (command: Command) => (state: ManuscriptEditorState, dispatch?: Dispatch) => {
+    return command(state, (tr) => {
+      if (dispatch) {
+        skipTracking(tr)
+        dispatch(tr)
+      }
+    })
+  }
+
+const listItemBackward = (
+  state: EditorState,
+  dispatch?: (tr: Transaction) => void
+) => {
+  const { selection } = state
+  const isListItem = findParentNodeOfType(schema.nodes.list_item)(selection)
+
+  if (isListItem) {
+    return joinBackward(state, dispatch)
+  }
+
+  return false
+}
+
+// Lift the list item if it's inside a parent list.
+const liftToOuterList = (itemType: NodeType): Command => {
+  return function (state: EditorState, dispatch?: (tr: Transaction) => void) {
+    const { $from, $to } = state.selection
+    const range = $from.blockRange(
+      $to,
+      (node) => node.childCount > 0 && node.firstChild?.type == itemType
+    )
+    if (!range) {
+      return false
+    }
+    if (!dispatch) {
+      return true
+    }
+    if ($from.node(range.depth - 1).type == itemType) {
+      // Inside a parent list
+      return liftListItem(itemType)(state, dispatch)
+    } // Outer list node
+    else {
+      return false
+    }
+  }
+}
+
+// This fucntion is forked from the prosemirror-schema-list package, since the original function does not support cloning attributes from the parent list.
+export function sinkListItem(itemType: NodeType): Command {
+  return function (state, dispatch) {
+    const { $from, $to } = state.selection
+    const range = $from.blockRange(
+      $to,
+      (node) => node.childCount > 0 && node.firstChild?.type == itemType
+    )
+    if (!range) {
+      return false
+    }
+    const startIndex = range.startIndex
+    if (startIndex == 0) {
+      return false
+    }
+    const parent = range.parent,
+      nodeBefore = parent.child(startIndex - 1)
+    if (nodeBefore.type != itemType) {
+      return false
+    }
+    if (dispatch) {
+      const nestedBefore =
+        nodeBefore.lastChild && nodeBefore.lastChild.type == parent.type
+      const listType = parent.attrs.listStyleType
+      const inner = Fragment.from(nestedBefore ? itemType.create() : null)
+      const slice = new Slice(
+        Fragment.from(
+          itemType.create(
+            null,
+            Fragment.from(
+              parent.type.create({ listStyleType: listType }, inner)
+            )
+          )
+        ),
+        nestedBefore ? 3 : 1,
+        0
+      )
+      const before = range.start,
+        after = range.end
+      dispatch(
+        state.tr
+          .step(
+            new ReplaceAroundStep(
+              before - (nestedBefore ? 3 : 1),
+              after,
+              before,
+              after,
+              slice,
+              1,
+              true
+            )
+          )
+          .scrollIntoView()
+      )
+    }
+    return true
+  }
+}
+
+const listKeymap: { [key: string]: EditorAction } = {
+  Enter: splitListItem(schema.nodes.list_item),
+  'Mod-[': skipCommandTracking(liftToOuterList(schema.nodes.list_item)), // outdent
+  'Mod-]': skipCommandTracking(sinkListItem(schema.nodes.list_item)), // indent
+  'Mod-Alt-o': skipCommandTracking(
+    wrapInList(schema.nodes.list, { listStyleType: 'order' })
+  ),
+  'Mod-Alt-k': skipCommandTracking(
+    wrapInList(schema.nodes.list, { listStyleType: 'bullet' })
+  ),
+  'Shift-Tab': skipCommandTracking(liftToOuterList(schema.nodes.list_item)), // outdent, same as Mod-[
+  Tab: skipCommandTracking(sinkListItem(schema.nodes.list_item)), // indent, same as Mod-]
+  Backspace: skipCommandTracking(listItemBackward),
+}
+
+export default listKeymap

package/src/keys/misc.ts

@@ -0,0 +1,112 @@
+/*!
+ * © 2019 Atypon Systems LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { schema } from '@manuscripts/transform'
+import {
+  chainCommands,
+  createParagraphNear,
+  exitCode,
+  joinBackward,
+  joinDown,
+  joinUp,
+  lift,
+  liftEmptyBlock,
+  newlineInCode,
+  splitBlock,
+  toggleMark,
+  wrapIn,
+} from 'prosemirror-commands'
+import { redo, undo } from 'prosemirror-history'
+import { undoInputRule } from 'prosemirror-inputrules'
+import { goToNextCell } from 'prosemirror-tables'
+
+import {
+  addToStart,
+  autoComplete,
+  exitEditorToContainer,
+  ignoreAtomBlockNodeBackward,
+  ignoreAtomBlockNodeForward,
+  ignoreEnterInSubtitles,
+  ignoreMetaNodeBackspaceCommand,
+  insertBlock,
+  insertBoxElement,
+  insertBreak,
+  insertCrossReference,
+  insertInlineFootnote,
+  insertInlineCitation,
+  insertInlineEquation,
+  insertLink,
+  insertSection,
+  selectAllIsolating,
+} from '../commands'
+import { EditorAction } from '../types'
+import { skipCommandTracking } from './list'
+import { focusNearestElement } from '../lib/navigation-utils'
+
+const customKeymap: { [key: string]: EditorAction } = {
+  Backspace: chainCommands(
+    undoInputRule,
+    ignoreAtomBlockNodeBackward,
+    ignoreMetaNodeBackspaceCommand,
+    skipCommandTracking(joinBackward)
+  ),
+  Delete: ignoreAtomBlockNodeForward,
+  Tab: chainCommands(goToNextCell(1), focusNearestElement),
+  Escape: exitEditorToContainer,
+  'Mod-z': undo,
+  'Mod-y': redo, // Mac
+  'Shift-Mod-z': redo, // PC
+  'Alt-ArrowUp': joinUp,
+  'Alt-ArrowDown': joinDown,
+  'Mod-BracketLeft': lift,
+  'Mod-a': selectAllIsolating,
+  'Mod-b': toggleMark(schema.marks.bold),
+  'Mod-i': toggleMark(schema.marks.italic),
+  'Shift-Mod-x': toggleMark(schema.marks.strikethrough),
+  'Mod-u': toggleMark(schema.marks.underline),
+  // 'Mod-`': toggleMark(schema.marks.code),
+  'Mod-Alt-=': toggleMark(schema.marks.superscript),
+  'Mod-Alt--': toggleMark(schema.marks.subscript),
+  'Ctrl->': wrapIn(schema.nodes.blockquote),
+  Enter: chainCommands(
+    ignoreEnterInSubtitles,
+    autoComplete,
+    addToStart,
+    newlineInCode,
+    createParagraphNear,
+    liftEmptyBlock,
+    splitBlock
+  ),
+  'Shift-Mod-Enter': insertSection(true),
+  'Mod-Enter': chainCommands(exitCode, insertSection()),
+  'Shift-Enter': chainCommands(exitCode, insertBreak),
+  // 'Shift-Ctrl-0': setBlockType(schema.nodes.paragraph),
+  // 'Shift-Ctrl-\\': setBlockType(schema.nodes.listing_element),
+  'Shift-Tab': goToNextCell(-1),
+  'Mod-Alt-p': insertBlock(schema.nodes.figure_element),
+  'Mod-Alt-t': insertBlock(schema.nodes.table_element),
+  'Mod-Alt-l': insertBlock(schema.nodes.listing_element),
+  'Mod-Alt-e': insertBlock(schema.nodes.equation_element),
+  'Mod-Alt-b': insertBoxElement,
+  'Mod-Alt-h': insertLink,
+  'Mod-Alt-f': insertInlineFootnote,
+  'Mod-Alt-c': insertInlineCitation,
+  'Mod-Alt-r': insertCrossReference,
+  'Shift-Mod-Alt-e': insertInlineEquation,
+  'Shift-Mod-e': insertInlineEquation, // PC
+}
+
+export default customKeymap

package/src/keys/title.ts

@@ -0,0 +1,221 @@
+/*!
+ * © 2019 Atypon Systems LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  isInGraphicalAbstractSection,
+  ManuscriptEditorState,
+  ManuscriptEditorView,
+  schema,
+} from '@manuscripts/transform'
+import { chainCommands } from 'prosemirror-commands'
+import { Fragment, ResolvedPos, Slice } from 'prosemirror-model'
+import { TextSelection } from 'prosemirror-state'
+
+import {
+  autoComplete,
+  Dispatch,
+  isAtEndOfTextBlock,
+  isAtStartOfTextBlock,
+  isTextSelection,
+} from '../commands'
+import { EditorAction } from '../types'
+
+const insertParagraph = (
+  dispatch: Dispatch,
+  state: ManuscriptEditorState,
+  $anchor: ResolvedPos
+) => {
+  const {
+    tr,
+    schema: { nodes },
+  } = state
+
+  const offset = $anchor.nodeAfter ? $anchor.nodeAfter.nodeSize : 0
+  const pos = $anchor.pos + offset + 1
+  const nextNode = tr.doc.resolve(pos).nodeAfter
+
+  if (
+    !nextNode ||
+    nextNode.type !== nextNode.type.schema.nodes.paragraph ||
+    nextNode.nodeSize > 2
+  ) {
+    tr.insert(pos, nodes.paragraph.create())
+  }
+
+  tr.setSelection(TextSelection.create(tr.doc, pos + 1)).scrollIntoView()
+
+  dispatch(tr)
+}
+
+const leaveTitle: EditorAction = (state, dispatch, view) => {
+  const { selection } = state
+
+  if (!isTextSelection(selection)) {
+    return false
+  }
+
+  const { $cursor } = selection
+
+  if (!$cursor) {
+    return false
+  }
+
+  const titleTypes = [
+    schema.nodes.alt_title,
+    schema.nodes.section_title,
+    schema.nodes.title,
+  ]
+
+  if (!titleTypes.includes($cursor.parent.type)) {
+    return false
+  }
+
+  if ($cursor.parent.type === schema.nodes.alt_title) {
+    return true
+  }
+
+  if (isInGraphicalAbstractSection($cursor)) {
+    return false
+  }
+
+  if (!isAtEndOfTextBlock(state, $cursor, view)) {
+    return false
+  }
+
+  if (dispatch) {
+    insertParagraph(dispatch, state, $cursor)
+  }
+
+  return true
+}
+
+const leaveCaption: EditorAction = (state) => {
+  const {
+    selection: { $anchor },
+  } = state
+  return (
+    $anchor.parent.type === $anchor.parent.type.schema.nodes.caption_title ||
+    $anchor.node($anchor.depth - 1)?.type ===
+      $anchor.parent.type.schema.nodes.caption
+  )
+}
+
+// ignore backspace at the start of section titles
+const protectTitles: EditorAction = (
+  state: ManuscriptEditorState,
+  dispatch?: Dispatch,
+  view?: ManuscriptEditorView
+) => {
+  const { selection } = state
+
+  if (!isTextSelection(selection)) {
+    return false
+  }
+
+  const { $cursor } = selection
+
+  if (!$cursor) {
+    return false
+  }
+
+  // preventing deletion of alt_titles and subtitles with backspace
+  if (
+    ($cursor.parent.type === schema.nodes.alt_title ||
+      $cursor.parent.type === schema.nodes.subtitle) &&
+    $cursor.pos === $cursor.before() + 1
+  ) {
+    return true
+  }
+
+  return (
+    $cursor.parent.type === $cursor.parent.type.schema.nodes.section_title &&
+    isAtStartOfTextBlock(state, $cursor, view)
+  )
+}
+
+export const protectReferencesTitle = (state: ManuscriptEditorState) => {
+  const { selection } = state
+
+  if (!isTextSelection(selection)) {
+    return false
+  }
+  const { $from } = selection
+  const parentNode = $from.node($from.depth - 1)
+  return (
+    $from.parent.type === schema.nodes.section_title &&
+    parentNode.type === schema.nodes.bibliography_section
+  )
+}
+
+const protectCaption: EditorAction = (
+  state: ManuscriptEditorState,
+  dispatch?: Dispatch
+) => {
+  const {
+    selection: { $anchor },
+  } = state
+  let nodeType = undefined
+
+  if (
+    $anchor.node($anchor.depth - 1)?.type ===
+      $anchor.parent.type.schema.nodes.caption &&
+    $anchor.node($anchor.depth).content.size === 1
+  ) {
+    nodeType = $anchor.node($anchor.depth - 1).type
+  } else if (
+    $anchor.parent.type === $anchor.parent.type.schema.nodes.caption_title &&
+    $anchor.parent.content.size === 1
+  ) {
+    nodeType = $anchor.parent.type
+  }
+
+  if (dispatch && nodeType) {
+    const slice = new Slice(Fragment.from([nodeType.create()]), 1, 1)
+    const tr = state.tr.replace($anchor.pos - 1, $anchor.pos, slice)
+    dispatch(tr)
+
+    return true
+  }
+
+  return false
+}
+
+const keepCaption = (state: ManuscriptEditorState, dispatch?: Dispatch) => {
+  const {
+    selection: { $anchor },
+  } = state
+  if (
+    dispatch &&
+    $anchor.parent.type === $anchor.parent.type.schema.nodes.caption_title &&
+    $anchor.parent.content.size === 1
+  ) {
+    dispatch(state.tr.delete($anchor.pos, $anchor.pos + 1))
+    return true
+  }
+  return false
+}
+
+const titleKeymap: { [key: string]: EditorAction } = {
+  Backspace: chainCommands(
+    protectTitles,
+    protectReferencesTitle,
+    protectCaption
+  ),
+  Enter: chainCommands(autoComplete, leaveTitle, leaveCaption),
+  Delete: chainCommands(keepCaption, protectReferencesTitle),
+}
+
+export default titleKeymap