@manuscripts/body-editor 3.12.67 → 3.13.0

package/src/lib/utils.ts

@@ -0,0 +1,323 @@
+/*!
+ * © 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 {
+  BibliographyItemAttrs,
+  BibliographyItemType,
+  isElementNodeType,
+  isSectionNodeType,
+  ManuscriptEditorState,
+  ManuscriptNode,
+  ManuscriptNodeType,
+  schema,
+} from '@manuscripts/transform'
+import {
+  Fragment,
+  Node as ProseMirrorNode,
+  NodeType,
+  ResolvedPos,
+} from 'prosemirror-model'
+import { EditorState, Selection } from 'prosemirror-state'
+import {
+  ContentNodeWithPos,
+  findChildrenByType,
+  findParentNode,
+  findParentNodeOfTypeClosestToPos,
+} from 'prosemirror-utils'
+
+import { fieldConfigMap } from '../components/references/ReferenceForm/config'
+import { arrowDown } from '../icons'
+import { handleEnterKey } from './navigation-utils'
+import { getEditorProps } from '../plugins/editor-props'
+
+export function* iterateChildren(
+  node: ManuscriptNode,
+  recurse = false
+): Iterable<ManuscriptNode> {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i)
+    yield child
+
+    if (recurse) {
+      for (const grandchild of iterateChildren(child, true)) {
+        yield grandchild
+      }
+    }
+  }
+}
+
+export const getMatchingChild = (
+  parent: ManuscriptNode,
+  matcher: (node: ManuscriptNode) => boolean,
+  deep = false
+): ManuscriptNode | undefined => {
+  for (const node of iterateChildren(parent, deep)) {
+    if (matcher(node)) {
+      return node
+    }
+  }
+}
+
+export const getMatchingDescendant = (
+  parent: ManuscriptNode,
+  matcher: (node: ManuscriptNode) => boolean
+): ManuscriptNode | undefined => {
+  for (const node of iterateChildren(parent, true)) {
+    if (matcher(node)) {
+      return node
+    }
+  }
+}
+
+export const getChildOfType = (
+  parent: ManuscriptNode,
+  nodeType: ManuscriptNodeType,
+  deep = false
+): boolean =>
+  !!getMatchingChild(parent, (node) => node.type.name === nodeType.name, deep)
+
+export const findParentNodeWithId: (selection: Selection) => ContentNodeWithPos | undefined = findParentNode((node) => 'id' in node.attrs)
+
+export const findParentNodeWithIdValue: (selection: Selection) => ContentNodeWithPos | undefined = findParentNode((node) => node.attrs.id)
+
+export const findParentSection: (selection: Selection) => ContentNodeWithPos | undefined = findParentNode((node) =>
+  isSectionNodeType(node.type)
+)
+
+export const findParentElement = (selection: Selection, validIds?: string[]): ContentNodeWithPos | undefined =>
+  findParentNode((node) => {
+    // if validIds was passed and this element is not in it, then keep looking
+    if (validIds && !validIds.includes(node.attrs.id)) {
+      return false
+    }
+    return isElementNodeType(node.type) && node.attrs.id
+  })(selection)
+
+export const isChildOfNodeTypes = (
+  doc: ManuscriptNode,
+  pos: number,
+  parentNodeTypes: NodeType[]
+) => {
+  if (pos > doc.content.size) {
+    return false
+  }
+  const resolvedPos = doc.resolve(pos)
+  // Iterate through the parent nodes
+  for (let depth = resolvedPos.depth; depth >= 0; depth--) {
+    if (parentNodeTypes.includes(resolvedPos.node(depth).type)) {
+      return true
+    }
+  }
+
+  return false
+}
+
+export const isSelectionInNode = (
+  state: EditorState,
+  targetNode: ProseMirrorNode
+) => {
+  const resolvedFrom = state.doc.resolve(state.selection.from)
+
+  for (let depth = resolvedFrom.depth; depth >= 0; depth--) {
+    const node = resolvedFrom.node(depth)
+    if (node === targetNode) {
+      return true
+    }
+  }
+  return false
+}
+
+export const isSelectionInBody = (state: EditorState): boolean => {
+  return isSelectionInNodeByType(state, 'body')
+}
+
+const isSelectionInNodeByType = (
+  state: EditorState,
+  nodeType: string
+): boolean => {
+  const { $from } = state.selection
+
+  for (let depth = $from.depth; depth >= 0; depth--) {
+    if ($from.node(depth).type.name === nodeType) {
+      return true
+    }
+  }
+
+  return false
+}
+
+export const createHeader = (typeName: string, text: string) => {
+  const header = document.createElement('h1')
+  header.classList.add(`title-${typeName}`, 'authors-info-header')
+  header.textContent = text
+  return header
+}
+
+export const isNotNull = <T>(a: T | null): a is T => a !== null
+
+export const hasParent = (
+  $pos: ResolvedPos,
+  type: ManuscriptNodeType | ManuscriptNodeType[]
+) => {
+  if (Array.isArray(type)) {
+    return type.some(
+      (nodeType) => !!findParentNodeOfTypeClosestToPos($pos, nodeType)
+    )
+  }
+  return !!findParentNodeOfTypeClosestToPos($pos, type)
+}
+
+// It will check if the field should be rendered based on selected item type
+// and field name
+export const shouldRenderField = (
+  field: string,
+  type: BibliographyItemType
+): boolean => {
+  return fieldConfigMap[type]?.has(field) ?? false
+}
+
+// It will clean unnecessary fields from the item
+// id and type will be kept
+export const cleanItemValues = (item: BibliographyItemAttrs) => {
+  const type = item.type as BibliographyItemType
+  const cleanedItem: BibliographyItemAttrs = { ...item }
+
+  for (const key of Object.keys(item) as (keyof BibliographyItemAttrs)[]) {
+    if (!shouldRenderField(key, type)) {
+      switch (key) {
+        case 'id':
+        case 'type':
+          break
+        case 'author':
+        case 'editor':
+        case 'issued':
+        case 'accessed':
+        case 'event-date':
+          cleanedItem[key] = undefined
+          break
+        default:
+          cleanedItem[key] = ''
+      }
+    }
+  }
+  return cleanedItem
+}
+
+export const isBodyLocked = (state: EditorState) => {
+  const props = getEditorProps(state)
+  return (
+    !!findChildrenByType(state.doc, schema.nodes.attachment).length &&
+    props.lockBody
+  )
+}
+
+// It checks if the selection is inside a body node and if the body is locked
+// the body is locked if feature lockBody is set true and there is an attachment node in document
+export const isEditAllowed = (state: EditorState) => {
+  return !(isBodyLocked(state) && isSelectionInBody(state))
+}
+
+export const createToggleButton = (
+  listener: (event: MouseEvent | KeyboardEvent) => void,
+  what: string
+) => {
+  const altTitlesButton = document.createElement('button')
+  altTitlesButton.classList.add('toggle-button-open', 'button-reset')
+  altTitlesButton.setAttribute('aria-label', `Expand ${what}`)
+  altTitlesButton.innerHTML = arrowDown
+  const activate = (e: MouseEvent | KeyboardEvent) => {
+    e.preventDefault()
+    listener(e)
+  }
+  altTitlesButton.addEventListener('click', (e) => {
+    activate(e)
+  })
+  altTitlesButton.addEventListener('keydown', handleEnterKey(activate))
+  return altTitlesButton
+}
+
+export const getInsertPos = (
+  type: ManuscriptNodeType,
+  parent: ManuscriptNode,
+  pos: number
+) => {
+  let insertPos = pos + parent.nodeSize - 1
+
+  parent.forEach((child, offset, index) => {
+    if (parent.canReplaceWith(index, index, type)) {
+      insertPos = pos + offset
+    }
+  })
+
+  return insertPos
+}
+
+// this will look just at parent node children
+export const findInsertionPosition = (
+  type: ManuscriptNodeType,
+  doc: ManuscriptNode
+) => {
+  let insertPos = 0
+
+  doc.forEach((child, offset, index) => {
+    if (doc.canReplaceWith(index, index, type)) {
+      insertPos = offset
+    }
+  })
+  // this will test if we can insert target type as last child in parent node
+  if (
+    insertPos === 0 &&
+    doc.canReplaceWith(doc.childCount, doc.childCount, type)
+  ) {
+    insertPos = doc.content.size
+  }
+  return insertPos
+}
+
+export const filterBlockNodes = (
+  fragment: Fragment,
+  predicate?: (node: ProseMirrorNode) => boolean
+) => {
+  const updatedNodes: ProseMirrorNode[] = []
+
+  fragment.forEach((child) => {
+    if (!child.isBlock) {
+      updatedNodes.push(child)
+      return
+    }
+
+    const newContent = child.content.size
+      ? filterBlockNodes(child.content, predicate)
+      : child.content
+    if (!predicate || predicate(child)) {
+      updatedNodes.push(child.type.create(child.attrs, newContent, child.marks))
+    }
+  })
+
+  return Fragment.fromArray(updatedNodes)
+}
+export const getLastTitleNode = (state: ManuscriptEditorState) => {
+  const altTitleNode = findChildrenByType(
+    state.doc,
+    state.schema.nodes.alt_titles
+  )[0]
+  if (altTitleNode) {
+    return altTitleNode
+  }
+
+  const titleNode = findChildrenByType(state.doc, state.schema.nodes.title)[0]
+  return titleNode
+}

package/src/lib/view.ts

@@ -0,0 +1,100 @@
+/*!
+ * © 2024 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 {
+  ManuscriptEditorView,
+  ManuscriptNodeType,
+  schema,
+} from '@manuscripts/transform'
+import { Attrs } from 'prosemirror-model'
+import { NodeSelection } from 'prosemirror-state'
+import * as utils from 'prosemirror-utils'
+
+import { isHidden } from './track-changes-utils'
+import { sanitizeAttrsChange } from '@manuscripts/track-changes-plugin'
+
+const metaNodeTypes = [
+  schema.nodes.bibliography_item,
+  schema.nodes.affiliation,
+  schema.nodes.contributor,
+]
+
+const updateMetaNode = 'track-changes-update-meta-node'
+
+export const findChildByID = (
+  view: ManuscriptEditorView,
+  id: string
+): utils.NodeWithPos | undefined => {
+  const doc = view.state.doc
+  const children = utils.findChildren(doc, (n) => n.attrs.id === id)
+  return children.length ? children[0] : undefined
+}
+
+export const findChildByType = (
+  view: ManuscriptEditorView,
+  type: ManuscriptNodeType
+): utils.NodeWithPos | undefined => {
+  const children = findChildrenByType(view, type)
+  return children.length ? children[0] : undefined
+}
+
+export const findChildrenByType = (
+  view: ManuscriptEditorView,
+  type: ManuscriptNodeType
+): utils.NodeWithPos[] => {
+  const doc = view.state.doc
+  return utils.findChildrenByType(doc, type).filter((n) => !isHidden(n.node))
+}
+
+export const findChildrenAttrsByType = <T extends Attrs>(
+  view: ManuscriptEditorView,
+  type: ManuscriptNodeType
+): T[] => {
+  return findChildrenByType(view, type).map((n) => n.node.attrs) as T[]
+}
+
+export const updateNodeAttrs = (
+  view: ManuscriptEditorView,
+  type: ManuscriptNodeType,
+  attrs: Attrs
+) => {
+  const child = findChildByID(view, attrs.id)
+  if (child) {
+    const copy = sanitizeAttrsChange(attrs, child.node.attrs)
+    // @ts-ignore attrs readonly - deleting from a copy
+    delete copy.dataTracked
+    const pos = child.pos
+    const tr = view.state.tr
+    tr.setNodeMarkup(pos, undefined, copy).setSelection(
+      NodeSelection.create(tr.doc, pos)
+    )
+    if (metaNodeTypes.includes(type)) {
+      tr.setMeta(updateMetaNode, true)
+    }
+    view.dispatch(tr)
+    return true
+  }
+  return false
+}
+
+export const deleteNode = (view: ManuscriptEditorView, id: string) => {
+  const child = findChildByID(view, id)
+  if (child) {
+    const pos = child.pos
+    const node = child.node
+    view.dispatch(view.state.tr.delete(pos, pos + node.nodeSize))
+  }
+}