@kaizen/components 1.68.5 → 1.68.7

package/src/RichTextEditor/RichTextEditor/utils/controlmap.tsx

@@ -1,13 +1,13 @@
-import React from "react"
-import { Icon } from "~components/__future__/Icon"
-import { ToolbarItems, ToolbarControlTypes } from "../../types"
-import { listIsActive, markIsActive } from "../../utils/commands"
+import React from 'react'
+import { Icon } from '~components/__future__/Icon'
+import { ToolbarItems, ToolbarControlTypes } from '../../types'
+import { listIsActive, markIsActive } from '../../utils/commands'
 import {
   ProseMirrorCommands,
   ProseMirrorModel,
   ProseMirrorSchemaList,
   ProseMirrorState,
-} from "../../utils/prosemirror"
+} from '../../utils/prosemirror'
 
 /** Configuration for individual controls */
 type ToolbarControl = {
@@ -19,14 +19,10 @@ type ToolbarControl = {
 }
 
 /** Toolbar controls mapped to a group */
-type GroupedToolbarControls = {
-  [group: string]: ToolbarControl[]
-}
+type GroupedToolbarControls = Record<string, ToolbarControl[]>
 
 /** An index for each control's group */
-type ControlGroupTypes = {
-  [key in ToolbarControlTypes]?: string
-}
+type ControlGroupTypes = Partial<Record<ToolbarControlTypes, string>>
 
 /** Chains multiple commands to dispatch each transitions in sequential order */
 const chainTransactions =
@@ -34,7 +30,7 @@ const chainTransactions =
   (state, dispatch): boolean => {
     const updateStateAndDispatch = (tr: ProseMirrorState.Transaction): void => {
       state = state.apply(tr)
-      dispatch && dispatch(tr)
+      dispatch?.(tr)
     }
     const lastCommand = commands.pop()
 
@@ -42,13 +38,13 @@ const chainTransactions =
       command(state, updateStateAndDispatch)
     }
 
-    return lastCommand !== undefined && lastCommand(state, dispatch)
+    return lastCommand?.(state, dispatch) ?? false
   }
 
 /** Dispatches a transaction to create initial p tag required for pm commands */
 const createInitialParagraph = (
   state: ProseMirrorState.EditorState,
-  dispatch?: (tr: ProseMirrorState.Transaction) => void
+  dispatch?: (tr: ProseMirrorState.Transaction) => void,
 ): boolean => {
   if (dispatch) {
     const { tr, schema } = state
@@ -66,10 +62,10 @@ const createToggleMarkCommand =
     const docIsEmpty = state.doc.content.size === 0
 
     if (docIsEmpty) {
-      return chainTransactions(
-        createInitialParagraph,
-        ProseMirrorCommands.toggleMark(mark)
-      )(state, dispatch)
+      return chainTransactions(createInitialParagraph, ProseMirrorCommands.toggleMark(mark))(
+        state,
+        dispatch,
+      )
     }
     return ProseMirrorCommands.toggleMark(mark)(state, dispatch)
   }
@@ -81,37 +77,35 @@ const createToggleListCommand =
     const docIsEmpty = state.doc.content.size === 0
 
     if (docIsEmpty) {
-      return chainTransactions(
-        createInitialParagraph,
-        ProseMirrorSchemaList.wrapInList(node)
-      )(state, dispatch)
+      return chainTransactions(createInitialParagraph, ProseMirrorSchemaList.wrapInList(node))(
+        state,
+        dispatch,
+      )
     }
     return ProseMirrorSchemaList.wrapInList(node)(state, dispatch)
   }
 
 /** Create command for reducing indents in a List */
-const createLiftListCommand =
-  (): ProseMirrorState.Command => (state, dispatch) => {
-    const { $from } = state.selection
-    // calculate the parent node from the current tag selected
-    const listItemNode = $from.node($from.depth - 1)?.type
-    return ProseMirrorSchemaList.liftListItem(listItemNode)(state, dispatch)
-  }
+const createLiftListCommand = (): ProseMirrorState.Command => (state, dispatch) => {
+  const { $from } = state.selection
+  // calculate the parent node from the current tag selected
+  const listItemNode = $from.node($from.depth - 1)?.type
+  return ProseMirrorSchemaList.liftListItem(listItemNode)(state, dispatch)
+}
 
 /** Create command for indenting in a List */
-const createIndentListCommand =
-  (): ProseMirrorState.Command => (state, dispatch) => {
-    const { $from } = state.selection
-    const listItemNode = $from.node($from.depth - 1)?.type
+const createIndentListCommand = (): ProseMirrorState.Command => (state, dispatch) => {
+  const { $from } = state.selection
+  const listItemNode = $from.node($from.depth - 1)?.type
 
-    return ProseMirrorSchemaList.sinkListItem(listItemNode)(state, dispatch)
-  }
+  return ProseMirrorSchemaList.sinkListItem(listItemNode)(state, dispatch)
+}
 
 /** handler lift list disabled state */
 const liftListIsDisabled = (state: ProseMirrorState.EditorState): boolean => {
   const { $from } = state.selection
   const listItemNode = $from.node($from.depth - 1)?.type
-  const isValidListItem = listItemNode?.name === "listItem" || false
+  const isValidListItem = listItemNode?.name === 'listItem' || false
 
   return !isValidListItem
 }
@@ -120,7 +114,7 @@ const liftListIsDisabled = (state: ProseMirrorState.EditorState): boolean => {
 const indentListIsDisabled = (state: ProseMirrorState.EditorState): boolean => {
   const { $from, $to } = state.selection
   const listItemNode = $from.node($from.depth - 1)?.type
-  const isValidListItem = listItemNode?.name === "listItem" || false
+  const isValidListItem = listItemNode?.name === 'listItem' || false
 
   if (!isValidListItem) {
     return true
@@ -128,7 +122,7 @@ const indentListIsDisabled = (state: ProseMirrorState.EditorState): boolean => {
 
   const range = $from.blockRange(
     $to,
-    node => node.childCount > 0 && node.firstChild!.type === listItemNode
+    (node) => node.childCount > 0 && node.firstChild!.type === listItemNode,
   )
 
   return !range || range.startIndex === 0 ? true : false
@@ -140,163 +134,139 @@ const createControlGroupIndex = (controls: ToolbarItems[]): ControlGroupTypes =>
     if (!currentControl?.name) return groups
     return {
       ...groups,
-      [currentControl.name]: currentControl.group || "ungrouped",
+      [currentControl.name]: currentControl.group ?? 'ungrouped',
     }
   }, {})
 
 /** Creates an initial object used to map button configuration into its respective groups */
-const createInitialControls = (
-  controlGroupIndex: ControlGroupTypes
-): GroupedToolbarControls => {
-  const uniqueGroups: string[] = Array.from(
-    new Set(Object.values(controlGroupIndex))
-  )
+const createInitialControls = (controlGroupIndex: ControlGroupTypes): GroupedToolbarControls => {
+  const uniqueGroups: string[] = Array.from(new Set(Object.values(controlGroupIndex)))
 
-  const initialControlObject: Record<string, ToolbarControl[]> =
-    uniqueGroups.reduce((controlObject, controlKey) => {
-      if (controlKey === "ungrouped") return controlObject
+  const initialControlObject: Record<string, ToolbarControl[]> = uniqueGroups.reduce(
+    (controlObject, controlKey) => {
+      if (controlKey === 'ungrouped') return controlObject
       return {
         ...controlObject,
         [controlKey]: [],
       }
-    }, {})
+    },
+    {},
+  )
   // This ensure that ungrouped controls are always last
-  initialControlObject["ungrouped"] = []
+  initialControlObject.ungrouped = []
   return initialControlObject
 }
 
 /** Retrieves the name of the group a control belongs to */
 const getGroupIndex = (
   controlGroupIndex: ControlGroupTypes,
-  controlType?: ToolbarControlTypes
+  controlType?: ToolbarControlTypes,
 ): string => {
   if (controlType) {
-    return controlGroupIndex[controlType] ?? "ungrouped"
+    return controlGroupIndex[controlType] ?? 'ungrouped'
   }
-  return "ungrouped"
+  return 'ungrouped'
 }
 
 /** Filters out empty control groups and returns a multi dimensional array  */
-const filterToolbarControls = (
-  groupedControls: GroupedToolbarControls
-): ToolbarControl[][] =>
-  Object.values(groupedControls).filter(controls => controls.length > 0)
+const filterToolbarControls = (groupedControls: GroupedToolbarControls): ToolbarControl[][] =>
+  Object.values(groupedControls).filter((controls) => controls.length > 0)
 
 /** Builds an array of object used to map control configuration to rte toolbar buttons */
 export const buildControlMap = (
   schema: ProseMirrorModel.Schema,
   editorState: ProseMirrorState.EditorState,
-  controls?: ToolbarItems[]
+  controls?: ToolbarItems[],
 ): ToolbarControl[][] => {
   if (!controls) return []
   const controlGroupIndex: ControlGroupTypes = createControlGroupIndex(controls)
-  const toolbarControls: GroupedToolbarControls =
-    createInitialControls(controlGroupIndex)
+  const toolbarControls: GroupedToolbarControls = createInitialControls(controlGroupIndex)
   const listNodes = [schema.nodes.bulletList, schema.nodes.orderedList]
 
   if (schema.marks.strong) {
     const type = schema.marks.strong
-    const groupIndex = getGroupIndex(controlGroupIndex, "bold")
+    const groupIndex = getGroupIndex(controlGroupIndex, 'bold')
     toolbarControls[groupIndex].push({
       isActive: markIsActive(editorState, type),
       action: createToggleMarkCommand(type),
-      label: "Bold",
+      label: 'Bold',
       icon: <Icon name="format_bold" isPresentational />,
     })
   }
 
   if (schema.marks.em) {
     const type = schema.marks.em
-    const groupIndex = getGroupIndex(controlGroupIndex, "italic")
+    const groupIndex = getGroupIndex(controlGroupIndex, 'italic')
     toolbarControls[groupIndex].push({
       isActive: markIsActive(editorState, type),
       action: createToggleMarkCommand(type),
-      label: "Italic",
+      label: 'Italic',
       icon: <Icon name="format_italic" isPresentational />,
     })
   }
 
   if (schema.marks.underline) {
     const type = schema.marks.underline
-    const groupIndex = getGroupIndex(controlGroupIndex, "underline")
+    const groupIndex = getGroupIndex(controlGroupIndex, 'underline')
     toolbarControls[groupIndex].push({
       isActive: markIsActive(editorState, type),
       action: createToggleMarkCommand(type),
-      label: "Underline",
+      label: 'Underline',
       icon: <Icon name="format_underlined" isPresentational />,
     })
   }
 
   if (schema.nodes.bulletList) {
     const type = schema.nodes.bulletList
-    const groupIndex = getGroupIndex(controlGroupIndex, "bulletList")
+    const groupIndex = getGroupIndex(controlGroupIndex, 'bulletList')
     toolbarControls[groupIndex].push({
       action: createToggleListCommand(type),
       isActive: listIsActive(editorState, type, listNodes),
-      label: "Bullet List",
-      icon: (
-        <Icon name="format_list_bulleted" isPresentational shouldMirrorInRTL />
-      ),
+      label: 'Bullet List',
+      icon: <Icon name="format_list_bulleted" isPresentational shouldMirrorInRTL />,
     })
   }
 
   if (schema.nodes.orderedList) {
     const type = schema.nodes.orderedList
-    const groupIndex = getGroupIndex(controlGroupIndex, "orderedList")
+    const groupIndex = getGroupIndex(controlGroupIndex, 'orderedList')
     toolbarControls[groupIndex].push({
       action: createToggleListCommand(type),
       isActive: listIsActive(editorState, type, listNodes),
-      label: "Numbered List",
-      icon: (
-        <Icon name="format_list_numbered" isPresentational shouldMirrorInRTL />
-      ),
+      label: 'Numbered List',
+      icon: <Icon name="format_list_numbered" isPresentational shouldMirrorInRTL />,
     })
   }
 
   if (schema.nodes.orderedList || schema.nodes.bulletList) {
-    const groupIndex =
-      controlGroupIndex["orderedList"] ||
-      controlGroupIndex["bulletList"] ||
-      "ungrouped"
+    const groupIndex = controlGroupIndex.orderedList ?? controlGroupIndex.bulletList ?? 'ungrouped'
 
     toolbarControls[groupIndex].push(
       {
         action: createLiftListCommand(),
         disabled: liftListIsDisabled(editorState),
         isActive: false,
-        label: "Decrease indent",
-        icon: (
-          <Icon
-            name="format_indent_decrease"
-            isPresentational
-            shouldMirrorInRTL
-          />
-        ),
+        label: 'Decrease indent',
+        icon: <Icon name="format_indent_decrease" isPresentational shouldMirrorInRTL />,
       },
       {
         action: createIndentListCommand(),
         disabled: indentListIsDisabled(editorState),
         isActive: false,
-        label: "Increase indent",
-        icon: (
-          <Icon
-            name="format_indent_increase"
-            isPresentational
-            shouldMirrorInRTL
-          />
-        ),
-      }
+        label: 'Increase indent',
+        icon: <Icon name="format_indent_increase" isPresentational shouldMirrorInRTL />,
+      },
     )
   }
 
   if (schema.marks.link) {
     const type = schema.marks.link
-    const groupIndex = getGroupIndex(controlGroupIndex, "link")
+    const groupIndex = getGroupIndex(controlGroupIndex, 'link')
     toolbarControls[groupIndex].push({
       action: createToggleMarkCommand(type),
       disabled: editorState.selection.empty,
       isActive: false,
-      label: "Link",
+      label: 'Link',
       icon: <Icon name="add_link" isPresentational />,
     })
   }

package/src/RichTextEditor/RichTextEditor/utils/inputrules.ts

@@ -1,12 +1,9 @@
-import { bulletListRule, orderedListRule } from "../../utils/core"
-import {
-  ProseMirrorInputrules,
-  ProseMirrorModel,
-} from "../../utils/prosemirror"
+import { bulletListRule, orderedListRule } from '../../utils/core'
+import { ProseMirrorInputrules, ProseMirrorModel } from '../../utils/prosemirror'
 
 export const buildInputRules = (
-  schema: ProseMirrorModel.Schema
-): ReturnType<(typeof ProseMirrorInputrules)["inputRules"]> => {
+  schema: ProseMirrorModel.Schema,
+): ReturnType<(typeof ProseMirrorInputrules)['inputRules']> => {
   const { smartQuotes, ellipsis, emDash, inputRules } = ProseMirrorInputrules
   const rules = smartQuotes.concat(ellipsis, emDash)
 

package/src/RichTextEditor/RichTextEditor/utils/keymap.ts

@@ -5,21 +5,16 @@ import {
   ProseMirrorModel,
   ProseMirrorSchemaList,
   ProseMirrorState,
-} from "../../utils/prosemirror"
+} from '../../utils/prosemirror'
 
-type KeyBinding = {
-  [key: string]: ProseMirrorState.Command
-}
+type KeyBinding = Record<string, ProseMirrorState.Command>
 
 export const buildKeymap = (schema: ProseMirrorModel.Schema): KeyBinding => {
   const { redo, undo } = ProseMirrorHistory
   const { undoInputRule } = ProseMirrorInputrules
-  const { wrapInList, splitListItem, liftListItem, sinkListItem } =
-    ProseMirrorSchemaList
+  const { wrapInList, splitListItem, liftListItem, sinkListItem } = ProseMirrorSchemaList
 
-  const mac =
-    // eslint-disable-next-line ssr-friendly/no-dom-globals-in-module-scope
-    typeof navigator != "undefined" ? /Mac/.test(navigator.platform) : false
+  const mac = typeof navigator != 'undefined' ? navigator.platform.includes('Mac') : false
 
   const {
     chainCommands,
@@ -33,68 +28,67 @@ export const buildKeymap = (schema: ProseMirrorModel.Schema): KeyBinding => {
   } = ProseMirrorCommands
 
   const keys: KeyBinding = {
-    "Mod-z": undo,
-    "Shift-Mod-z": redo,
-    Backspace: undoInputRule,
-    "Alt-ArrowUp": joinUp,
-    "Alt-ArrowDown": joinDown,
-    "Mod-BracketLeft": lift,
-    Escape: selectParentNode,
+    'Mod-z': undo,
+    'Shift-Mod-z': redo,
+    'Backspace': undoInputRule,
+    'Alt-ArrowUp': joinUp,
+    'Alt-ArrowDown': joinDown,
+    'Mod-BracketLeft': lift,
+    'Escape': selectParentNode,
   }
 
   if (!mac) {
-    keys["Mod-y"] = redo
+    keys['Mod-y'] = redo
   }
 
   if (schema.marks.strong) {
     const type = schema.marks.strong
-    keys["Mod-b"] = toggleMark(type)
-    keys["Mod-B"] = toggleMark(type)
+    keys['Mod-b'] = toggleMark(type)
+    keys['Mod-B'] = toggleMark(type)
   }
 
   if (schema.marks.em) {
     const type = schema.marks.em
-    keys["Mod-i"] = toggleMark(type)
-    keys["Mod-I"] = toggleMark(type)
+    keys['Mod-i'] = toggleMark(type)
+    keys['Mod-I'] = toggleMark(type)
   }
 
   if (schema.marks.underline) {
     const type = schema.marks.underline
-    keys["Mod-u"] = toggleMark(type)
-    keys["Mod-U"] = toggleMark(type)
+    keys['Mod-u'] = toggleMark(type)
+    keys['Mod-U'] = toggleMark(type)
   }
 
   if (schema.nodes.hardBreak) {
     const br = schema.nodes.hardBreak
     const cmd = chainCommands(exitCode, (state, dispatch) => {
-      dispatch &&
-        dispatch(state.tr.replaceSelectionWith(br.create()).scrollIntoView())
+      dispatch?.(state.tr.replaceSelectionWith(br.create()).scrollIntoView())
       return true
     })
-    keys["Mod-Enter"] = cmd
-    keys["Shift-Enter"] = cmd
+    keys['Mod-Enter'] = cmd
+    keys['Shift-Enter'] = cmd
     if (mac) {
-      keys["Ctrl-Enter"] = cmd
+      keys['Ctrl-Enter'] = cmd
     }
   }
 
   if (schema.nodes.paragraph) {
-    keys["Shift-Ctrl-0"] = setBlockType(schema.nodes.paragraph)
+    keys['Shift-Ctrl-0'] = setBlockType(schema.nodes.paragraph)
   }
 
   if (schema.nodes.bulletList) {
-    keys["Shift-Ctrl-8"] = wrapInList(schema.nodes.bulletList)
+    keys['Shift-Ctrl-8'] = wrapInList(schema.nodes.bulletList)
   }
 
   if (schema.nodes.orderedList) {
-    keys["Shift-Ctrl-9"] = wrapInList(schema.nodes.orderedList)
+    keys['Shift-Ctrl-9'] = wrapInList(schema.nodes.orderedList)
   }
 
   if (schema.nodes.listItem) {
     const type = schema.nodes.listItem
-    keys["Enter"] = splitListItem(type)
-    keys["Mod-["] = liftListItem(type)
-    keys["Mod-]"] = sinkListItem(type)
+    keys.Enter = splitListItem(type)
+    keys['Mod-['] = liftListItem(type)
+    keys['Mod-]'] = sinkListItem(type)
   }
 
   return keys

package/src/RichTextEditor/_mixins.scss

@@ -1,6 +1,6 @@
-@import "~@kaizen/design-tokens/sass/spacing";
-@import "~@kaizen/design-tokens/sass/typography";
-@import "~@kaizen/design-tokens/sass/color";
+@import '~@kaizen/design-tokens/sass/spacing';
+@import '~@kaizen/design-tokens/sass/typography';
+@import '~@kaizen/design-tokens/sass/color';
 
 @mixin content-styles {
   font-family: $typography-paragraph-body-font-family;

package/src/RichTextEditor/constants.ts

@@ -1,10 +1,10 @@
-import { ToolbarControlTypes } from "./types"
+import { ToolbarControlTypes } from './types'
 
 export const TOOLBAR_CONTROLS: ToolbarControlTypes[] = [
-  "bold",
-  "italic",
-  "underline",
-  "orderedList",
-  "bulletList",
-  "link",
+  'bold',
+  'italic',
+  'underline',
+  'orderedList',
+  'bulletList',
+  'link',
 ]

package/src/RichTextEditor/index.ts

@@ -1,9 +1,9 @@
-export * from "./EditableRichTextContent"
-export * from "./RichTextContent"
-export * from "./RichTextEditor"
-export * from "./types"
-export * from "./utils/commands"
-export * from "./utils/core"
-export * from "./utils/plugins"
-export * from "./utils/prosemirror"
-export * from "./utils/schema"
+export * from './EditableRichTextContent'
+export * from './RichTextContent'
+export * from './RichTextEditor'
+export * from './types'
+export * from './utils/commands'
+export * from './utils/core'
+export * from './utils/plugins'
+export * from './utils/prosemirror'
+export * from './utils/schema'

package/src/RichTextEditor/types.ts

@@ -1,10 +1,10 @@
 export type ToolbarControlTypes =
-  | "bold"
-  | "italic"
-  | "underline"
-  | "orderedList"
-  | "bulletList"
-  | "link"
+  | 'bold'
+  | 'italic'
+  | 'underline'
+  | 'orderedList'
+  | 'bulletList'
+  | 'link'
 
 export type ToolbarItems = {
   name: ToolbarControlTypes
@@ -14,7 +14,7 @@ export type ToolbarItems = {
   group?: string
 }
 
-export type EditorContentArray = Array<{ [key: string]: any }>
+export type EditorContentArray = Record<string, any>[]
 
 export type EditorRows =
   | 1

package/src/RichTextEditor/utils/commands/addMark.spec.ts

@@ -1,19 +1,19 @@
-import { findByText, waitFor } from "@testing-library/dom"
-import { vi } from "vitest"
-import { createRichTextEditor } from "../core"
-import { addMark } from "./addMark"
+import { findByText, waitFor } from '@testing-library/dom'
+import { vi } from 'vitest'
+import { createRichTextEditor } from '../core'
+import { addMark } from './addMark'
 import {
   mockRangeForBoundingRect,
   simulateSelectionByText,
   simulateTextInsert,
-} from "./fixtures/helpers"
-import { testEditorState, testSchema } from "./fixtures/test-state"
-describe("addMark()", () => {
+} from './fixtures/helpers'
+import { testEditorState, testSchema } from './fixtures/test-state'
+describe('addMark()', () => {
   const onChange = vi.fn()
-  const attributes = { "aria-labelledby": "label-text-123" }
+  const attributes = { 'aria-labelledby': 'label-text-123' }
 
-  it("creates an empty wrapper of the given Mark type if no selection is provided", async () => {
-    const node = document.createElement("div")
+  it('creates an empty wrapper of the given Mark type if no selection is provided', async () => {
+    const node = document.createElement('div')
     const { dispatchTransaction } = createRichTextEditor({
       node,
       onChange,
@@ -21,21 +21,21 @@ describe("addMark()", () => {
       initialEditorState: testEditorState,
     })
 
-    expect(node.querySelectorAll("strong").length).toBe(0)
+    expect(node.querySelectorAll('strong').length).toBe(0)
     // adds the empty strong wrapper
     dispatchTransaction(addMark(testSchema.marks.strong))
     // inserts text into the strong wrapper
-    dispatchTransaction(simulateTextInsert("I will be strong"))
-    await findByText(node, "I will be strong")
+    dispatchTransaction(simulateTextInsert('I will be strong'))
+    await findByText(node, 'I will be strong')
 
     await waitFor(() => {
-      expect(node.querySelectorAll("strong").length).toBe(1)
+      expect(node.querySelectorAll('strong').length).toBe(1)
     })
   })
 
-  it("wraps the current selection in the given mark type", async () => {
+  it('wraps the current selection in the given mark type', async () => {
     mockRangeForBoundingRect()
-    const node = document.createElement("div")
+    const node = document.createElement('div')
     const { dispatchTransaction } = createRichTextEditor({
       node,
       onChange,
@@ -43,16 +43,16 @@ describe("addMark()", () => {
       initialEditorState: testEditorState,
     })
 
-    expect(node.querySelectorAll("strong").length).toBe(0)
+    expect(node.querySelectorAll('strong').length).toBe(0)
 
-    dispatchTransaction(simulateTextInsert("Selected "))
-    await findByText(node, "Selected Example content")
+    dispatchTransaction(simulateTextInsert('Selected '))
+    await findByText(node, 'Selected Example content')
 
-    dispatchTransaction(simulateSelectionByText("Selected"))
+    dispatchTransaction(simulateSelectionByText('Selected'))
     dispatchTransaction(addMark(testSchema.marks.strong))
 
     await waitFor(() => {
-      expect(node.querySelectorAll("strong").length).toBe(1)
+      expect(node.querySelectorAll('strong').length).toBe(1)
     })
   })
 })

package/src/RichTextEditor/utils/commands/addMark.ts

@@ -1,10 +1,9 @@
-import { EditorState, Transaction } from "prosemirror-state"
-import { CommandFactory } from "../core/types"
+import { EditorState, Transaction } from 'prosemirror-state'
+import { CommandFactory } from '../core/types'
 
 /** Wrap the users current selection in the given Mark type   */
 export const addMark: CommandFactory =
-  (type, attrs) =>
-  (state: EditorState, dispatch?: (tx: Transaction) => void) => {
+  (type, attrs) => (state: EditorState, dispatch?: (tx: Transaction) => void) => {
     const { tr, selection } = state
     const { $from, $to } = selection
     if (!dispatch) return false