@contember/react-slate-editor-base 2.1.0-alpha.30 → 2.1.0-alpha.36

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@contember/react-slate-editor-base",
   "license": "Apache-2.0",
-  "version": "2.1.0-alpha.30",
+  "version": "2.1.0-alpha.36",
   "type": "module",
   "sideEffects": false,
   "main": "./dist/production/index.js",
@@ -30,26 +30,26 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/contember/interface.git",
+    "url": "git+https://github.com/contember/contember.git",
     "directory": "packages/react-slate-editor-base"
   },
   "dependencies": {
-    "@contember/react-binding": "2.1.0-alpha.30",
-    "@contember/utilities": "2.1.0-alpha.30",
-    "@radix-ui/primitive": "^1.1.0",
-    "@radix-ui/react-slot": "^1.1.0",
-    "is-hotkey": "^0.2.0",
-    "slate": "^0.103.0",
-    "slate-history": "^0.109.0",
-    "slate-react": "^0.110.1"
+    "@contember/react-binding": "workspace:*",
+    "@contember/utilities": "workspace:*",
+    "@radix-ui/primitive": "catalog:",
+    "@radix-ui/react-slot": "catalog:",
+    "is-hotkey": "catalog:",
+    "slate": "catalog:",
+    "slate-history": "catalog:",
+    "slate-react": "catalog:"
   },
   "peerDependencies": {
-    "react": "^18 || ^19",
-    "react-dom": "^18 || ^19"
+    "react": "catalog:",
+    "react-dom": "catalog:"
   },
   "devDependencies": {
-    "@types/is-hotkey": "^0.1.10",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1"
+    "@types/is-hotkey": "catalog:",
+    "react": "catalog:",
+    "react-dom": "catalog:"
   }
 }

package/src/components/RichTextEditor.tsx

@@ -26,6 +26,7 @@ export const RichTextEditor: FunctionComponent<RichTextEditorProps> = Component(
 
 		const desugaredField = useMemo(
 			() => QueryLanguage.desugarRelativeSingleField(props, environment),
+			// biome-ignore lint/correctness/useExhaustiveDependencies: props is stable via Component HOC
 			[environment, props],
 		)
 		const fieldAccessor = useMemo(() => entity.getField<string>(desugaredField), [entity, desugaredField])
@@ -33,7 +34,6 @@ export const RichTextEditor: FunctionComponent<RichTextEditorProps> = Component(
 		// The cache is questionable, really.
 		const [contemberFieldElementCache] = useState(() => new WeakMap<FieldAccessor<string>, SlateElement[]>())
 
-
 		const [editor] = useState(() => {
 			const { editor } = createEditor({
 				plugins: props.plugins,
@@ -120,4 +120,3 @@ export const RichTextEditor: FunctionComponent<RichTextEditorProps> = Component(
 	),
 	'RichTextEditor',
 )
-

package/src/components/triggers/EditorGenericTrigger.tsx

@@ -13,7 +13,6 @@ export interface EditorGenericTriggerProps {
 }
 
 export const EditorGenericTrigger = ({ toggle, isActive, shouldDisplay, ...props }: EditorGenericTriggerProps) => {
-
 	const editor = useSlate()
 	const onClick = () => {
 		toggle({ editor })

package/src/editor/createEditor.ts

@@ -5,7 +5,6 @@ import { createElement, FunctionComponent, ReactNode } from 'react'
 import { EntityAccessor } from '@contember/react-binding'
 import { Environment } from '@contember/react-binding'
 
-
 export interface CreateEditorPublicOptions {
 	plugins?: EditorPlugin[]
 }

package/src/editor/createEditorWithEssentials.tsx

@@ -1,5 +1,15 @@
 import { createElement, isValidElement, ReactElement } from 'react'
-import { createEditor, Descendant, Editor, Element as SlateElement, Node as SlateNode, Path, Range as SlateRange, Text as SlateText, Transforms } from 'slate'
+import {
+	createEditor,
+	Descendant,
+	Editor,
+	Element as SlateElement,
+	Node as SlateNode,
+	Path,
+	Range as SlateRange,
+	Text as SlateText,
+	Transforms,
+} from 'slate'
 import * as Slate from 'slate'
 import { withHistory } from 'slate-history'
 import { ReactEditor, withReact } from 'slate-react'
@@ -46,10 +56,10 @@ export const createEditorWithEssentials = ({ defaultElementType }: { defaultElem
 		isElementActive: <E extends SlateElement>(elementType: E['type'], suchThat?: Partial<E>) => {
 			return (
 				elements.get(elementType)?.isActive?.({ editor, suchThat })
-				?? Array.from(Editor.nodes(editor, {
-					match: node => SlateElement.isElement(node) && ContemberEditor.isElementType(node, elementType, suchThat),
-					voids: false,
-				})).length > 0
+					?? Array.from(Editor.nodes(editor, {
+							match: node => SlateElement.isElement(node) && ContemberEditor.isElementType(node, elementType, suchThat),
+							voids: false,
+						})).length > 0
 			)
 		},
 
@@ -101,8 +111,7 @@ export const createEditorWithEssentials = ({ defaultElementType }: { defaultElem
 		},
 
 		serializeNodes: (nodes, errorMessage) => ContemberEditor.serializeNodes(editor, nodes, errorMessage),
-		deserializeNodes: (serializedNodes, errorMessage) =>
-			ContemberEditor.permissivelyDeserializeNodes(editor, serializedNodes, errorMessage),
+		deserializeNodes: (serializedNodes, errorMessage) => ContemberEditor.permissivelyDeserializeNodes(editor, serializedNodes, errorMessage),
 
 		upgradeFormatBySingleVersion: (node, oldVersion) => {
 			if (SlateElement.isElement(node)) {
@@ -148,7 +157,6 @@ export const createEditorWithEssentials = ({ defaultElementType }: { defaultElem
 				}
 			}
 
-
 			// Inline void nodes cannot be deleted by default: https://github.com/ianstormtaylor/slate/issues/3456
 			// This is a hack to get around this issue. The problem is that when an inline void node is selected, Slate's
 			// beforeInput handler doesn't get triggered. However, when we put the caret right after the inline void
@@ -172,14 +180,13 @@ export const createEditorWithEssentials = ({ defaultElementType }: { defaultElem
 				}
 				const [node, nodePath] = voidEntry
 				if (editor.isInline(node)) {
-					const adjacentPoint =
-						e.key === 'Backspace'
-							? Editor.point(editor, Path.next(nodePath), {
-								edge: 'start',
-							  })
-							: Editor.point(editor, Path.previous(nodePath), {
-								edge: 'end',
-							  })
+					const adjacentPoint = e.key === 'Backspace'
+						? Editor.point(editor, Path.next(nodePath), {
+							edge: 'start',
+						})
+						: Editor.point(editor, Path.previous(nodePath), {
+							edge: 'end',
+						})
 					Transforms.select(editor, adjacentPoint)
 				}
 			}

package/src/editor/methods/addMarks.ts

@@ -1,4 +1,4 @@
-import { Editor as SlateEditor, Editor, Text as SlateText } from 'slate'
+import { Editor, Editor as SlateEditor, Text as SlateText } from 'slate'
 import { TextSpecifics } from '../../types/editor'
 
 export const addMarks = <T extends SlateText, E extends SlateEditor>(editor: E, marks: TextSpecifics<T>) => {

package/src/editor/methods/closest.ts

@@ -1,4 +1,4 @@
-import { Editor as SlateEditor, Editor, Element, Location, NodeEntry, Text } from 'slate'
+import { Editor, Editor as SlateEditor, Element, Location, NodeEntry, Text } from 'slate'
 
 export const closest = <E extends SlateEditor>(
 	editor: E,

package/src/editor/methods/closestBlockEntry.ts

@@ -1,4 +1,4 @@
-import { Editor as SlateEditor, Editor, Location, Element } from 'slate'
+import { Editor, Editor as SlateEditor, Element, Location } from 'slate'
 import { closest } from './closest'
 
 export const closestBlockEntry = <E extends SlateEditor>(

package/src/editor/methods/hasMarks.ts

@@ -16,10 +16,12 @@ export const hasMarks = <T extends SlateText, E extends SlateEditor>(
 		return false
 	}
 
-	for (const [text] of SlateNode.texts(editor, {
-		from,
-		to,
-	})) {
+	for (
+		const [text] of SlateNode.texts(editor, {
+			from,
+			to,
+		})
+	) {
 		for (const markName in marks) {
 			if (!(markName in text) || text[markName] !== (marks as any)[markName]) {
 				return false

package/src/editor/methods/removeMarks.ts

@@ -1,4 +1,4 @@
-import { Editor as SlateEditor, Editor, Text as SlateText } from 'slate'
+import { Editor, Editor as SlateEditor, Text as SlateText } from 'slate'
 import { TextSpecifics } from '../../types/editor'
 
 export const removeMarks = <T extends SlateText, E extends SlateEditor>(editor: E, marks: TextSpecifics<T>) => {

package/src/editor/methods/toLatestFormat.ts

@@ -18,9 +18,7 @@ export const toLatestFormat = <E extends SlateEditor>(
 		for (; formatNumber < editor.formatVersion; formatNumber++) {
 			potentiallyOldNode = {
 				formatVersion: formatNumber + 1,
-				children: potentiallyOldNode.children.map(oldChild =>
-					editor.upgradeFormatBySingleVersion(oldChild, formatNumber),
-				) as SlateElement[],
+				children: potentiallyOldNode.children.map(oldChild => editor.upgradeFormatBySingleVersion(oldChild, formatNumber)) as SlateElement[],
 			}
 		}
 		return potentiallyOldNode
@@ -28,8 +26,8 @@ export const toLatestFormat = <E extends SlateEditor>(
 		const genericMessage = `Failed to upgrade editor format from version ${formatNumber}.`
 		if (e instanceof RangeError) {
 			throw new BindingError(
-				`${genericMessage}\nDetected a stack overflow. ` +
-					`Perhaps you incorrectly implemented 'upgradeFormatBySingleVersion'?`,
+				`${genericMessage}\nDetected a stack overflow. `
+					+ `Perhaps you incorrectly implemented 'upgradeFormatBySingleVersion'?`,
 			)
 		}
 		throw new BindingError(genericMessage)

package/src/internal/hooks/useRichTextFieldNodes.ts

@@ -21,17 +21,16 @@ export const useRichTextFieldNodes = ({
 		throw new BindingError(`RichTextField: the underlying field does not contain a string value.`)
 	}
 
-	const elements: Descendant[] =
-		fieldValue === null || fieldValue === ''
-			? [editor.createDefaultElement([{ text: '' }])]
-			: [
-				editor.createDefaultElement(
-					editor.deserializeNodes(
-						fieldValue,
-						`RichTextField: the underlying field contains invalid JSON.`,
-					) as Descendant[],
-				),
-			  ]
+	const elements: Descendant[] = fieldValue === null || fieldValue === ''
+		? [editor.createDefaultElement([{ text: '' }])]
+		: [
+			editor.createDefaultElement(
+				editor.deserializeNodes(
+					fieldValue,
+					`RichTextField: the underlying field contains invalid JSON.`,
+				) as Descendant[],
+			),
+		]
 	contemberFieldElementCache.set(fieldAccessor, elements)
 
 	return elements

package/src/internal/utils/EditorPasteUtils.ts

@@ -8,8 +8,8 @@ export class EditorPasteUtils {
 		let ignoring = false
 		let forProcessing = Array.from(allNodes)
 		if (
-			(forProcessing.length === 1 && forProcessing[0].nodeName === 'SPAN') ||
-				(forProcessing.length === 2 && forProcessing[0].nodeName === 'SPAN' && forProcessing[1].nodeName === 'O:P')
+			(forProcessing.length === 1 && forProcessing[0].nodeName === 'SPAN')
+			|| (forProcessing.length === 2 && forProcessing[0].nodeName === 'SPAN' && forProcessing[1].nodeName === 'O:P')
 		) {
 			forProcessing = Array.from(forProcessing[0].childNodes)
 		}
@@ -32,7 +32,7 @@ export class EditorPasteUtils {
 		return nodes
 	}
 
-	public static flattenNodesWithType(withType: NodesWithType[], defaultElementFactory: EditorDefaultElementFactory): NodesWithType  {
+	public static flattenNodesWithType(withType: NodesWithType[], defaultElementFactory: EditorDefaultElementFactory): NodesWithType {
 		const withTypeFiltered = withType.filter((item): item is Exclude<NodesWithType, null> => item !== null)
 		const containsBlock = withTypeFiltered.find(({ elements }) => elements !== undefined) !== undefined
 

package/src/plugins/attributes/alignment/alignButton.ts

@@ -10,7 +10,7 @@ export const createAlignHandler = (direction: AlignDirection): {
 	isActive?: (args: { editor: Editor }) => boolean
 	shouldDisplay?: (args: { editor: Editor }) => boolean
 	toggle: (args: { editor: Editor }) => void
-}	=> ({
+} => ({
 	shouldDisplay: ({ editor }) => {
 		return Array.from(Editor.nodes(editor, { match: it => isAlignTarget(editor, it, direction) })).length > 0
 	},
@@ -25,6 +25,3 @@ export const createAlignHandler = (direction: AlignDirection): {
 		})
 	},
 })
-
-
-

package/src/plugins/behaviour/paste/HtmlDeserializer.ts

@@ -42,13 +42,12 @@ export class HtmlDeserializer {
 
 			// Block
 			const attrs = this.processWithAttributeProcessor(childNode, cumulativeTextAttrs)
-			const result =
-				childNode instanceof HTMLElement
-					? this.processBlockPaste(
-						childNode,
-						cumulativeTextAttrs,
-					)
-					: null
+			const result = childNode instanceof HTMLElement
+				? this.processBlockPaste(
+					childNode,
+					cumulativeTextAttrs,
+				)
+				: null
 			if (result !== null) {
 				processed.push(...(Array.isArray(result) ? result : [result]).map(element => ({ element })))
 			} else {
@@ -66,8 +65,8 @@ export class HtmlDeserializer {
 						...(deserializedChildren === null
 							? []
 							: deserializedChildren.texts !== undefined
-								? deserializedChildren.texts.map(text => ({ text, isWhiteSpace }))
-								: deserializedChildren.elements.map(element => ({ element }))),
+							? deserializedChildren.texts.map(text => ({ text, isWhiteSpace }))
+							: deserializedChildren.elements.map(element => ({ element }))),
 					)
 				}
 			}
@@ -87,9 +86,7 @@ export class HtmlDeserializer {
 					} else if (item.element !== undefined) {
 						return [item.element]
 					}
-					{
-						return []
-					}
+					return []
 				}),
 			}
 		} else {
@@ -114,7 +111,6 @@ export class HtmlDeserializer {
 		return result?.texts ?? result?.elements ?? []
 	}
 
-
 	private deserializeTextNode(node: Node, cumulativeTextAttrs: TextAttrs): Descendant[] | null {
 		if (node.nodeType === Node.TEXT_NODE) {
 			const text = node.textContent ?? ''
@@ -157,7 +153,7 @@ export class HtmlDeserializer {
 			return {}
 		}
 		return this.plugins.reduce(
-			(cta, plugin) => plugin.processAttributesPaste?.({ element, cumulativeTextAttrs, deserializer: this  }) ?? cta,
+			(cta, plugin) => plugin.processAttributesPaste?.({ element, cumulativeTextAttrs, deserializer: this }) ?? cta,
 			cumulativeTextAttrs,
 		)
 	}
@@ -166,8 +162,7 @@ export class HtmlDeserializer {
 		if (ignoredElements.includes(element.tagName)) {
 			return []
 		}
-		const next: HtmlDeserializerNextCallback = (list, cta) =>
-			this.deserializeBlocks(Array.from(list), { ...cumulativeTextAttrs, ...cta })
+		const next: HtmlDeserializerNextCallback = (list, cta) => this.deserializeBlocks(Array.from(list), { ...cumulativeTextAttrs, ...cta })
 
 		for (const plugin of this.plugins) {
 			const result = plugin.processBlockPaste?.({ element, next, cumulativeTextAttrs, deserializer: this }) ?? null

package/src/plugins/behaviour/paste/createMarkHtmlDeserializer.ts

@@ -1,6 +1,10 @@
 import { HtmlDeserializerPlugin } from '../../../types/htmlDeserializer'
 
-export const createMarkHtmlDeserializer = (markType: string, tagMatcher: (el: HTMLElement) => boolean, attributeMatcher: (el: HTMLElement) => boolean): HtmlDeserializerPlugin => ({
+export const createMarkHtmlDeserializer = (
+	markType: string,
+	tagMatcher: (el: HTMLElement) => boolean,
+	attributeMatcher: (el: HTMLElement) => boolean,
+): HtmlDeserializerPlugin => ({
 	processAttributesPaste: ({ element, cumulativeTextAttrs: cta }) => {
 		return attributeMatcher(element) ? { ...cta, [markType]: true } : cta
 	},

package/src/plugins/behaviour/paste/withPaste.ts

@@ -3,7 +3,6 @@ import { EditorPlugin } from '../../../types/plugins'
 import { HtmlDeserializer } from './HtmlDeserializer'
 import { HtmlDeserializerPlugin } from '../../../types/htmlDeserializer'
 
-
 export const withPaste = (editor: Editor) => {
 	const { insertData } = editor
 	const htmlDeserializer = new HtmlDeserializer(editor.createDefaultElement, [])

package/src/plugins/element/anchors/AnchorElement.ts

@@ -1,4 +1,4 @@
-import { Editor as SlateEditor, Editor, Element as SlateElement, Node as SlateNode, Path, Range as SlateRange, Transforms } from 'slate'
+import { Editor, Editor as SlateEditor, Element as SlateElement, Node as SlateNode, Path, Range as SlateRange, Transforms } from 'slate'
 import { AnchorModifications } from './AnchorModifications'
 import { EditorElementPlugin, ElementRenderer } from '../../../types'
 
@@ -17,7 +17,6 @@ export const isAnchorElementActive = (editor: Editor) => {
 	return !!link
 }
 
-
 export const anchorElementPlugin = ({ render }: { render: ElementRenderer<AnchorElement> }): EditorElementPlugin<AnchorElement> => ({
 	type: anchorElementType,
 	isInline: true,

package/src/plugins/element/anchors/AnchorHtmlDeserializer.ts

@@ -1,6 +1,6 @@
 import { HtmlDeserializerPlugin } from '../../../types'
 
-export const anchorHtmlDeserializer: HtmlDeserializerPlugin  = {
+export const anchorHtmlDeserializer: HtmlDeserializerPlugin = {
 	processInlinePaste: ({ element, next, cumulativeTextAttrs }) => {
 		if (element.tagName === 'A' && element.getAttribute('href')) {
 			const href = element.getAttribute('href')

package/src/plugins/element/headings/HeadingElement.ts

@@ -23,7 +23,6 @@ export const ejectHeadingElement = (editor: Editor, elementPath: SlatePath) => {
 	Transforms.setNodes(editor, { type: editor.defaultElementType }, { at: elementPath })
 }
 
-
 export const headingElementPlugin = ({ render }: { render: ElementRenderer<HeadingElement> }): EditorElementPlugin<HeadingElement> => ({
 	type: headingElementType,
 	render,

package/src/plugins/element/headings/withHeadings.ts

@@ -1,12 +1,6 @@
 import { Editor, Editor as SlateEditor, Element as SlateElement, Point, Range as SlateRange, Transforms } from 'slate'
 import { ContemberEditor } from '../../../editor'
-import {
-	ejectHeadingElement,
-	HeadingElement,
-	headingElementPlugin,
-	headingElementType,
-	isHeadingElement,
-} from './HeadingElement'
+import { ejectHeadingElement, HeadingElement, headingElementPlugin, headingElementType, isHeadingElement } from './HeadingElement'
 import { headingHtmlDeserializer } from './HeadingHtmlDeserializer'
 import { ElementRenderer } from '../../../types'
 
@@ -17,7 +11,6 @@ export const withHeadings = ({ render }: { render: ElementRenderer<HeadingElemen
 		deleteBackward,
 	} = editor
 
-
 	editor.registerElement(headingElementPlugin({ render }))
 	editor.htmlDeserializer.registerPlugin(headingHtmlDeserializer)
 
@@ -69,8 +62,6 @@ export const withHeadings = ({ render }: { render: ElementRenderer<HeadingElemen
 		)
 	}
 
-
-
 	editor.insertBreak = () => {
 		SlateEditor.withoutNormalizing(editor, () => {
 			insertBreak()

package/src/plugins/element/horizonalRules/HorizontalRuleElement.ts

@@ -1,4 +1,4 @@
-import { Editor as SlateEditor, Editor, Element as SlateElement, Node as SlateNode, Range as SlateRange, Transforms } from 'slate'
+import { Editor, Editor as SlateEditor, Element as SlateElement, Node as SlateNode, Range as SlateRange, Transforms } from 'slate'
 import { EditorElementPlugin, ElementRenderer } from '../../../types'
 
 export const horizontalRuleElementType = 'horizontalRule' as const
@@ -16,7 +16,9 @@ export const isHorizontalRuleElementActive = (editor: Editor) => {
 	return !!hr
 }
 
-export const horizontalRuleElementPlugin = ({ render }: { render: ElementRenderer<HorizontalRuleElement> }): EditorElementPlugin<HorizontalRuleElement> => ({
+export const horizontalRuleElementPlugin = (
+	{ render }: { render: ElementRenderer<HorizontalRuleElement> },
+): EditorElementPlugin<HorizontalRuleElement> => ({
 	type: horizontalRuleElementType,
 	render,
 	isVoid: true,

package/src/plugins/element/horizonalRules/withHorizontalRules.ts

@@ -34,8 +34,7 @@ export const withHorizontalRules = ({ render }: { render: ElementRenderer<Horizo
 			let closestBlockEntry: NodeEntry | undefined = Editor.above(editor, {
 				at: focusPoint,
 				mode: 'lowest',
-				match: matchedNode =>
-					SlateElement.isElement(matchedNode) && !editor.isInline(matchedNode) && editor.isDefaultElement(matchedNode),
+				match: matchedNode => SlateElement.isElement(matchedNode) && !editor.isInline(matchedNode) && editor.isDefaultElement(matchedNode),
 			})
 			if (!closestBlockEntry) {
 				return

package/src/plugins/element/lists/ListElement.ts

@@ -7,7 +7,8 @@ import { isListItemElement } from './ListItemElement'
 export const isListElement = <T extends UnorderedListElement | OrderedListElement>(
 	element: Node,
 	suchThat?: Partial<T>,
-): element is T => isOrderedListElement(element, suchThat as Partial<OrderedListElement>) || isUnorderedListElement(element, suchThat as Partial<UnorderedListElement>)
+): element is T =>
+	isOrderedListElement(element, suchThat as Partial<OrderedListElement>) || isUnorderedListElement(element, suchThat as Partial<UnorderedListElement>)
 
 export const getParentListElement = (editor: Editor): Element | undefined => {
 	const closestNonDefaultEntry = ContemberEditor.closest(editor, {

package/src/plugins/element/lists/ListHtmlDeserializer.ts

@@ -23,7 +23,9 @@ const defaultGetListElementProperties = (text: string): ListElementProperties =>
 	}
 }
 
-export const listHtmlDeserializerFactory = ({ getListElementProperties = defaultGetListElementProperties }: ListHtmlDeserializerOptions = {}): HtmlDeserializerPlugin => ({
+export const listHtmlDeserializerFactory = (
+	{ getListElementProperties = defaultGetListElementProperties }: ListHtmlDeserializerOptions = {},
+): HtmlDeserializerPlugin => ({
 	processBlockPaste: ({ element, next, cumulativeTextAttrs }) => {
 		if (element.tagName === 'UL') {
 			return [{ type: unorderedListElementType, children: next(element.childNodes, cumulativeTextAttrs) }]

package/src/plugins/element/lists/ListItemElement.ts

@@ -1,4 +1,4 @@
-import { Editor as SlateEditor, Editor, Element as SlateElement, Node as SlateNode, Transforms } from 'slate'
+import { Editor, Editor as SlateEditor, Element as SlateElement, Node as SlateNode, Transforms } from 'slate'
 import { ContemberEditor } from '../../../editor'
 import { isListElement } from './ListElement'
 import { EditorElementPlugin, ElementRenderer } from '../../../types'
@@ -15,7 +15,6 @@ export const isListItemElement = (
 	suchThat?: Partial<ListItemElement>,
 ): element is ListItemElement => ContemberEditor.isElementType(element, listItemElementType, suchThat)
 
-
 export const listItemElementPlugin = ({ render }: { render: ElementRenderer<ListItemElement> }): EditorElementPlugin<ListItemElement> => ({
 	type: listItemElementType,
 	render,

package/src/plugins/element/lists/UnorderedListElement.ts

@@ -17,7 +17,9 @@ export const isUnorderedListElement = (
 	suchThat?: Partial<UnorderedListElement>,
 ): element is UnorderedListElement => ContemberEditor.isElementType(element, unorderedListElementType, suchThat)
 
-export const unorderedListElementPlugin = ({ render }: { render: ElementRenderer<UnorderedListElement> }): EditorElementPlugin<UnorderedListElement> => ({
+export const unorderedListElementPlugin = (
+	{ render }: { render: ElementRenderer<UnorderedListElement> },
+): EditorElementPlugin<UnorderedListElement> => ({
 	type: unorderedListElementType,
 	render,
 	isActive: ({ editor, suchThat }) => {

package/src/plugins/element/lists/transforms/indentListItem.ts

@@ -1,12 +1,4 @@
-import {
-	Editor,
-	Element as SlateElement,
-	Node as SlateNode,
-	NodeEntry,
-	Path as SlatePath,
-	Text,
-	Transforms,
-} from 'slate'
+import { Editor, Element as SlateElement, Node as SlateNode, NodeEntry, Path as SlatePath, Text, Transforms } from 'slate'
 import { ContemberEditor } from '../../../../editor'
 import type { ListItemElement } from '../ListItemElement'
 import type { OrderedListElement } from '../OrderedListElement'
@@ -33,9 +25,8 @@ export const indentListItem = (
 		let [previousListItem, previousListItemPath] = previousListEntry
 
 		const lastPreviousListItemChild = previousListItem.children[previousListItem.children.length - 1]
-		const previousEndsWithCompatibleList =
-			SlateElement.isElement(lastPreviousListItemChild) &&
-			ContemberEditor.isElementType(
+		const previousEndsWithCompatibleList = SlateElement.isElement(lastPreviousListItemChild)
+			&& ContemberEditor.isElementType(
 				lastPreviousListItemChild,
 				parentListElement.type,
 				ContemberEditor.elementToSpecifics(parentListElement) as any,

package/src/plugins/element/lists/withLists.ts

@@ -1,12 +1,4 @@
-import {
-	Editor,
-	Element as SlateElement,
-	Node as SlateNode,
-	Path as SlatePath,
-	Range as SlateRange,
-	Text,
-	Transforms,
-} from 'slate'
+import { Editor, Element as SlateElement, Node as SlateNode, Path as SlatePath, Range as SlateRange, Text, Transforms } from 'slate'
 import { ContemberEditor } from '../../../editor'
 import { isListItemElement, ListItemElement, listItemElementPlugin } from './ListItemElement'
 import { OrderedListElement, orderedListElementPlugin } from './OrderedListElement'
@@ -20,7 +12,8 @@ export const withLists = ({ renderListItem, renderUnorderedList, renderOrderedLi
 	renderListItem: ElementRenderer<ListItemElement>
 	renderOrderedList: ElementRenderer<OrderedListElement>
 	renderUnorderedList: ElementRenderer<UnorderedListElement>
-}) => <E extends Editor>(editor: E): E => {
+}) =>
+<E extends Editor>(editor: E): E => {
 	const {
 		insertBreak,
 		onKeyDown,
@@ -123,9 +116,9 @@ export const withLists = ({ renderListItem, renderUnorderedList, renderOrderedLi
 		onKeyDown: event => {
 			// TODO this should also work for expanded selections
 			if (
-				(event.key !== 'Tab' && event.key !== 'Enter') ||
-				!editor.selection ||
-				!SlateRange.isCollapsed(editor.selection)
+				(event.key !== 'Tab' && event.key !== 'Enter')
+				|| !editor.selection
+				|| !SlateRange.isCollapsed(editor.selection)
 			) {
 				return onKeyDown(event)
 			}
@@ -142,7 +135,7 @@ export const withLists = ({ renderListItem, renderUnorderedList, renderOrderedLi
 
 			if (event.key === 'Tab') {
 				if (editor.isDefaultElement(closestBlockElement)) {
-					[closestBlockElement, closestBlockPath] = Editor.parent(editor, closestBlockPath)
+					;[closestBlockElement, closestBlockPath] = Editor.parent(editor, closestBlockPath)
 				}
 				if (!isListItemElement(closestBlockElement)) {
 					return onKeyDown(event)
@@ -196,7 +189,5 @@ export const withLists = ({ renderListItem, renderUnorderedList, renderOrderedLi
 		},
 	})
 
-
-
 	return editor
 }

package/src/plugins/element/paragraphs/ParagraphElement.ts

@@ -1,4 +1,4 @@
-import { Editor as SlateEditor, Editor, Element as SlateElement, Node as SlateNode, Transforms } from 'slate'
+import { Editor, Editor as SlateEditor, Element as SlateElement, Node as SlateNode, Transforms } from 'slate'
 import { ContemberEditor } from '../../../editor'
 import { AlignDirection } from '../../attributes'
 import { EditorElementPlugin, ElementRenderer } from '../../../types'
@@ -17,7 +17,7 @@ export const isParagraphElement = (
 	suchThat?: Partial<ParagraphElement>,
 ): element is ParagraphElement => ContemberEditor.isElementType(element, paragraphElementType, suchThat)
 
-export const paragraphElementPlugin = ({ render }: {render: ElementRenderer<ParagraphElement>}): EditorElementPlugin<ParagraphElement> => ({
+export const paragraphElementPlugin = ({ render }: { render: ElementRenderer<ParagraphElement> }): EditorElementPlugin<ParagraphElement> => ({
 	type: paragraphElementType,
 	render,
 	canContainAnyBlocks: false,

package/src/plugins/element/paragraphs/ParagraphHtmlDeserializer.ts

@@ -2,8 +2,11 @@ import { paragraphElementType } from './ParagraphElement'
 import { HtmlDeserializerPlugin } from '../../../types'
 
 export const paragraphHtmlDeserializer: HtmlDeserializerPlugin = {
-	processBlockPaste: ({ element, next, cumulativeTextAttrs }) => element.nodeName === 'P' ? {
-		type: paragraphElementType,
-		children: next(element.childNodes, cumulativeTextAttrs),
-	} : null,
+	processBlockPaste: ({ element, next, cumulativeTextAttrs }) =>
+		element.nodeName === 'P'
+			? {
+				type: paragraphElementType,
+				children: next(element.childNodes, cumulativeTextAttrs),
+			}
+			: null,
 }