@manuscripts/body-editor 3.12.67 → 3.13.0

package/src/lib/get-media-type.ts

@@ -0,0 +1,105 @@
+/*!
+ * © 2025 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.
+ */
+interface MediaTypeInfo {
+  extension: string
+  isVideo: boolean
+  isAudio: boolean
+  isImage: boolean
+  isSupported: boolean
+  mimetype?: string
+  mimeSubtype?: string
+}
+
+export const getMediaTypeInfo = (
+  filenameOrFile: string | File
+): MediaTypeInfo => {
+  const filename =
+    typeof filenameOrFile === 'string'
+      ? filenameOrFile
+      : filenameOrFile?.name || ''
+  const extension = filename.toLowerCase().split('.').pop()?.trim() || ''
+
+  const videoExtensions = new Set([
+    'mp4',
+    'webm',
+    'avi',
+    'mov',
+    'mkv',
+    'flv',
+    'wmv',
+    'mpg',
+    'mpeg',
+  ])
+  const audioExtensions = new Set([
+    'mp3',
+    'wav',
+    'aac',
+    'ogg',
+    'flac',
+    'm4a',
+    'wma',
+  ])
+  const imageExtensions = new Set([
+    'jpg',
+    'jpeg',
+    'png',
+    'gif',
+    'bmp',
+    'svg',
+    'webp',
+    'tiff',
+    'tif',
+  ])
+
+  let mimetype: string | undefined
+  let mimeSubtype: string | undefined
+
+  if (typeof filenameOrFile !== 'string' && filenameOrFile?.type) {
+    const [type, subtype] = filenameOrFile.type.split('/')
+    if (type && subtype && ['video', 'audio', 'image'].includes(type)) {
+      mimetype = type
+      mimeSubtype = subtype
+    }
+  }
+
+  if (!mimetype || !mimeSubtype) {
+    if (videoExtensions.has(extension)) {
+      mimetype = 'video'
+      mimeSubtype = extension === 'mov' ? 'quicktime' : extension
+    } else if (audioExtensions.has(extension)) {
+      mimetype = 'audio'
+      mimeSubtype = extension === 'm4a' ? 'mp4' : extension
+    } else if (imageExtensions.has(extension)) {
+      mimetype = 'image'
+      mimeSubtype = extension === 'jpg' ? 'jpeg' : extension
+    }
+  }
+
+  const isVideo = mimetype === 'video' || videoExtensions.has(extension)
+  const isAudio = mimetype === 'audio' || audioExtensions.has(extension)
+  const isImage = mimetype === 'image' || imageExtensions.has(extension)
+  const isSupported = isVideo || isAudio || isImage
+
+  return {
+    extension,
+    isVideo,
+    isAudio,
+    isImage,
+    isSupported,
+    mimetype,
+    mimeSubtype,
+  }
+}

package/src/lib/helpers.ts

@@ -0,0 +1,199 @@
+/*!
+ * © 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 {
+  isExecutableNodeType,
+  ManuscriptEditorState,
+  ManuscriptNode,
+  schema,
+} from '@manuscripts/transform'
+import { Node, ResolvedPos } from 'prosemirror-model'
+import { NodeSelection, TextSelection } from 'prosemirror-state'
+import { EditorView } from 'prosemirror-view'
+
+export const isNodeOfType =
+  (...type: string[]) =>
+  (node: Node): boolean => {
+    const [head, ...tail] = type
+    if (node.type === node.type.schema.nodes[head]) {
+      return true
+    }
+    if (tail && tail.length) {
+      return isNodeOfType(...tail)(node)
+    }
+    return false
+  }
+
+export const nearestAncestor =
+  (func: (node: ManuscriptNode) => boolean) =>
+  ($pos: ResolvedPos): number | null => {
+    for (let d = $pos.depth; d >= 0; d--) {
+      if (func($pos.node(d))) {
+        return d
+      }
+    }
+    return null
+  }
+
+// This function finds and merges similar items in an array.
+// It uses a compare function to determine which items in the array
+// are similar (or identical), and if a match is found, uses the mergeFunc
+// to merge it with the match.
+export const mergeSimilarItems =
+  <T>(compareFunc: (a: T, b: T) => boolean, mergeFunc: (a: T, b: T) => T) =>
+  (items: T[]): T[] => {
+    return items.reduce((acc: T[], item: T) => {
+      const existingIndex = acc.findIndex((existing) =>
+        compareFunc(existing, item)
+      )
+      if (existingIndex === -1) {
+        return [...acc, item]
+      }
+      return [
+        ...acc.slice(0, existingIndex),
+        mergeFunc(acc[existingIndex], item),
+        ...acc.slice(existingIndex + 1),
+      ]
+    }, [])
+  }
+
+export const selectionForOutlineNavigation = (
+  doc: Node,
+  pos: number
+): NodeSelection | TextSelection => {
+  const node = doc.nodeAt(pos)
+  if (!node || isExecutableNodeType(node.type)) {
+    return NodeSelection.create(doc, pos)
+  }
+
+  if (node.isTextblock) {
+    return TextSelection.create(doc, pos + 1)
+  }
+
+  if (node.type === schema.nodes.section) {
+    let textPos: number | null = null
+    node.forEach((child, offset) => {
+      if (textPos !== null) {
+        return
+      }
+      if (
+        child.type === schema.nodes.section_title ||
+        child.type === schema.nodes.section_title_plain
+      ) {
+        textPos = pos + 1 + offset + 1
+      }
+    })
+    if (textPos !== null) {
+      return TextSelection.create(doc, textPos)
+    }
+  }
+
+  return NodeSelection.create(doc, pos)
+}
+
+export const handleScrollToSelectedTarget = (view: EditorView): boolean => {
+  const selection = view.state.selection
+  if (selection.empty) {
+    return false
+  }
+
+  const node = view.state.doc.nodeAt(selection.from)
+  if (!node) {
+    return false
+  }
+
+  let target: Element | null
+
+  //this is to support scrolling to nodes whose views are not managed by PM
+  if (node.attrs.id) {
+    target = view.dom.querySelector(`[id="${node.attrs.id}"]`)
+  } else {
+    let node = view.domAtPos(selection.from).node
+
+    const ELEMENT_NODE = 1
+    while (node.nodeType !== ELEMENT_NODE && node.parentElement) {
+      node = node.parentElement
+    }
+    target = node as Element
+  }
+
+  if (!target || !(target instanceof HTMLElement)) {
+    return false
+  }
+
+  // Set block alignment based on the node type
+  const blockAlignment =
+    node.type === schema.nodes.bibliography_item ? 'center' : 'start'
+
+  // Scroll the target element into view
+  target.scrollIntoView({
+    behavior: 'smooth',
+    block: blockAlignment,
+  })
+
+  return true
+}
+
+// Find the boundaries of the intended word based on the current cursor position
+export const findWordBoundaries = (
+  state: ManuscriptEditorState,
+  position: number
+) => {
+  let start = position
+  let end = position
+  const resolvedPos = state.doc.resolve(position)
+  const blockStart = resolvedPos.start()
+  const blockEnd = resolvedPos.end()
+
+  // Move backward to find the start of the word
+  while (
+    start > blockStart &&
+    !/\s/.test(state.doc.textBetween(start - 1, start))
+  ) {
+    start--
+  }
+  // Move forward to find the end of the word
+  while (end < blockEnd && !/\s/.test(state.doc.textBetween(end, end + 1))) {
+    end++
+  }
+
+  let from = start
+  let to = end
+
+  // If no word is found (cursor between spaces), search for the previous word
+  if (from === to) {
+    // Move backward through spaces
+    while (
+      start > blockStart &&
+      /\s/.test(state.doc.textBetween(start - 1, start))
+    ) {
+      start--
+    }
+    to = start
+
+    // Move backward to find the start of the previous word
+    while (
+      start > blockStart &&
+      !/\s/.test(state.doc.textBetween(start - 1, start))
+    ) {
+      start--
+    }
+
+    from = start
+  }
+
+  return { from, to }
+}

package/src/lib/hierarchy.ts

@@ -0,0 +1,117 @@
+/*!
+ * © 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 {
+  GROUP_LIST,
+  hasGroup,
+  isElementNodeType,
+  isSectionNodeType,
+  ManuscriptEditorState,
+  ManuscriptNode,
+  ManuscriptNodeType,
+  nodeNames,
+} from '@manuscripts/transform'
+import { ResolvedPos } from 'prosemirror-model'
+
+import { Dispatch } from '../commands'
+
+interface NodeWithPosition {
+  node: ManuscriptNode
+  before: number
+  after: number
+}
+
+const isListNodeType = (nodeType: ManuscriptNodeType) =>
+  hasGroup(nodeType, GROUP_LIST)
+
+export const findListParent = (
+  $pos: ResolvedPos
+): NodeWithPosition | undefined => {
+  for (let depth = $pos.depth; depth > 0; depth--) {
+    const node = $pos.node(depth)
+
+    if (isListNodeType(node.type)) {
+      return {
+        node,
+        before: $pos.before(depth),
+        after: $pos.after(depth),
+      }
+    }
+  }
+}
+
+export const findClosestParentElement = (
+  $pos: ResolvedPos
+): NodeWithPosition | undefined => {
+  const listParent = findListParent($pos)
+
+  if (listParent) {
+    return listParent
+  }
+
+  for (let depth = $pos.depth; depth > 0; depth--) {
+    const node = $pos.node(depth)
+
+    if (isSectionNodeType(node.type) || isElementNodeType(node.type)) {
+      return {
+        node,
+        before: $pos.before(depth),
+        after: $pos.after(depth),
+      }
+    }
+  }
+}
+
+export const findClosestParentElementNodeName = (
+  state: ManuscriptEditorState
+): string => {
+  if (state.selection) {
+    const fromParentElement = findClosestParentElement(state.selection.$from)
+    const toParentElement = findClosestParentElement(state.selection.$to)
+
+    if (fromParentElement && toParentElement) {
+      if (fromParentElement.node === toParentElement.node) {
+        const nodeName = nodeNames.get(fromParentElement.node.type)
+
+        if (nodeName) {
+          return nodeName
+        }
+      }
+    }
+  }
+
+  return ''
+}
+
+export const deleteClosestParentElement = (
+  state: ManuscriptEditorState,
+  dispatch?: Dispatch
+) => {
+  if (state.selection) {
+    const fromParentElement = findClosestParentElement(state.selection.$from)
+    const toParentElement = findClosestParentElement(state.selection.$to)
+
+    if (dispatch) {
+      if (fromParentElement && toParentElement) {
+        dispatch(
+          state.tr.delete(fromParentElement.before, toParentElement.after)
+        )
+      }
+    }
+    return true
+  }
+  return false
+}

package/src/lib/languages.ts

@@ -0,0 +1,37 @@
+/*!
+ * © 2025 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.
+ */
+
+export interface Language {
+  code: string
+  name: string
+  nativeName: string
+}
+
+const ENGLISH = {
+  code: 'en',
+  name: 'English',
+  nativeName: 'English',
+}
+
+export const getLanguage = (code: string, languages: Language[]) => {
+  return languages.find((l) => l.code === code) || ENGLISH
+}
+
+export const getLanguageLabel = (language: Language) => {
+  return language.nativeName && language.nativeName !== language.name
+    ? `${language.name} (${language.nativeName})`
+    : language.name
+}

package/src/lib/lists.ts

@@ -0,0 +1,56 @@
+/*!
+ * © 2025 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 { ListStyleType } from '@manuscripts/transform'
+
+export const parseCssListStyleType = (style: string): ListStyleType => {
+  switch (style) {
+    case 'disc':
+      return 'bullet'
+    case 'decimal':
+      return 'order'
+    case 'lower-alpha':
+      return 'alpha-lower'
+    case 'upper-alpha':
+      return 'alpha-upper'
+    case 'lower-roman':
+      return 'roman-lower'
+    case 'upper-roman':
+      return 'roman-upper'
+    case 'none':
+      return 'simple'
+    default:
+      return 'simple'
+  }
+}
+
+export const writeCssListStyleType = (type: ListStyleType) => {
+  switch (type) {
+    case 'bullet':
+      return 'disc'
+    case 'order':
+      return 'decimal'
+    case 'alpha-lower':
+      return 'lower-alpha'
+    case 'alpha-upper':
+      return 'upper-alpha'
+    case 'roman-lower':
+      return 'lower-roman'
+    case 'roman-upper':
+      return 'upper-roman'
+    case 'simple':
+      return 'none'
+  }
+}

package/src/lib/math.ts

@@ -0,0 +1,111 @@
+/*!
+ * © 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.
+ */
+
+/**
+ * The versions file is generated at build time using
+ * the `versions.mjs` script.
+ */
+//@ts-ignore
+//eslint-disable-next-line import/no-unresolved
+import { MATHJAX_VERSION } from '../versions'
+
+const src = `https://cdn.jsdelivr.net/npm/mathjax@${MATHJAX_VERSION}/es5/tex-svg.js`
+
+/**
+ * MathJax uses delimiters to find math in the doc by default, which is
+ * not what we want. This will override that behavior and will instead
+ * look for equation nodes, and is based on the
+ * [MathJax upgrade guide](https://docs.mathjax.org/en/v3.2-latest/upgrading/v2.html).
+ */
+//@ts-ignore
+const findMath = (doc) => {
+  let nodes = doc.options.elements
+  if (!nodes) {
+    nodes = doc.document.querySelectorAll('.equation')
+  }
+  for (const node of nodes) {
+    const math = new doc.options.MathItem(
+      node.textContent,
+      doc.inputJax[0],
+      node.tagName !== 'SPAN'
+    )
+    const text = document.createTextNode('')
+    node.innerHTML = ''
+    node.appendChild(text)
+    math.start = { node: text, delim: '', n: 0 }
+    math.end = { node: text, delim: '', n: 0 }
+    doc.math.push(math)
+  }
+}
+
+const config = {
+  options: {
+    renderActions: {
+      find: [10, findMath, ''],
+    },
+  },
+}
+
+export const initMathJax = () => {
+  // @ts-ignore
+  window.MathJax = config
+  const script = document.createElement('script')
+  script.src = src
+  script.async = true
+  document.head.appendChild(script)
+}
+
+export const renderMath = (node: HTMLElement) => {
+  /* eslint-disable */
+  //@ts-ignore
+  if (!window.MathJax) {
+    initMathJax()
+  }
+  //@ts-ignore
+  if (window.MathJax.typeset) {
+    //@ts-ignore
+    if (!node.parentNode) {
+      awaitMounting(node).then(() => {
+        //@ts-ignore
+        window.MathJax.typeset([node])
+      })
+    } else {
+      //@ts-ignore
+      window.MathJax.typeset([node])
+    }
+  }
+  /* eslint-enable */
+}
+
+function awaitMounting(node: HTMLElement) {
+  return new Promise<void>(function (resolve, reject) {
+    let max = 10
+    function wait() {
+      max--
+      if (!node.parentNode) {
+        setTimeout(() => {
+          wait()
+        }, 0)
+      } else {
+        resolve()
+      }
+      if (max <= 0) {
+        reject()
+      }
+    }
+    wait()
+  })
+}