@portabletext/editor 1.48.13 → 1.48.15

package/src/priority/priority.sort.test.ts

@@ -0,0 +1,319 @@
+import {describe, expect, test} from 'vitest'
+import {sortByPriority} from './priority.sort'
+import {createEditorPriority} from './priority.types'
+
+describe(sortByPriority.name, () => {
+  test('empty array', () => {
+    const result = sortByPriority([])
+    expect(result).toEqual([])
+  })
+
+  test('single item', () => {
+    const item = {priority: createEditorPriority({name: 'single'})}
+    const result = sortByPriority([item])
+    expect(result).toEqual([item])
+  })
+
+  test('two sets of priorities', () => {
+    const a = createEditorPriority({name: 'a'})
+    const b = createEditorPriority({
+      name: 'b',
+      reference: {priority: a, importance: 'higher'},
+    })
+    const b1 = createEditorPriority({
+      name: 'b1',
+      reference: {priority: b, importance: 'lower'},
+    })
+    const b2 = createEditorPriority({
+      name: 'b2',
+      reference: {priority: b, importance: 'lower'},
+    })
+    const c = createEditorPriority({
+      name: 'c',
+      reference: {priority: a, importance: 'higher'},
+    })
+    const c1 = createEditorPriority({
+      name: 'c1',
+      reference: {priority: c, importance: 'lower'},
+    })
+    const c2 = createEditorPriority({
+      name: 'c2',
+      reference: {priority: c, importance: 'lower'},
+    })
+
+    const items = [
+      {priority: c1},
+      {priority: c2},
+      {priority: a},
+      {priority: b1},
+      {priority: b2},
+      {priority: b},
+      {priority: c},
+    ]
+
+    expect(sortByPriority(items).map((item) => item.priority.name)).toEqual([
+      'b',
+      'c',
+      'b1',
+      'b2',
+      'c1',
+      'c2',
+      'a',
+    ])
+  })
+
+  test('sub-priorities', () => {
+    const a = createEditorPriority({name: 'a'})
+    const b = createEditorPriority({
+      name: 'b',
+      reference: {priority: a, importance: 'lower'},
+    })
+    const b1 = createEditorPriority({
+      name: 'b1',
+      reference: {priority: b, importance: 'lower'},
+    })
+    const b2 = createEditorPriority({
+      name: 'b2',
+      reference: {priority: b1, importance: 'higher'},
+    })
+
+    const items = [{priority: b2}, {priority: b1}, {priority: a}]
+
+    expect(sortByPriority(items).map((item) => item.priority.name)).toEqual([
+      'a',
+      'b2',
+      'b1',
+    ])
+  })
+
+  test('direct higher reference', () => {
+    const a = createEditorPriority({
+      name: 'a',
+    })
+    const b = createEditorPriority({
+      name: 'b',
+      reference: {priority: a, importance: 'higher'},
+    })
+
+    const items = [{priority: b}, {priority: a}]
+
+    expect(sortByPriority(items).map((item) => item.priority.name)).toEqual([
+      'b',
+      'a',
+    ])
+  })
+
+  test('direct lower reference', () => {
+    const a = createEditorPriority({name: 'a'})
+    const b = createEditorPriority({
+      name: 'b',
+      reference: {priority: a, importance: 'lower'},
+    })
+
+    const items = [{priority: b}, {priority: a}]
+
+    expect(sortByPriority(items).map((item) => item.priority.name)).toEqual([
+      'a',
+      'b',
+    ])
+  })
+
+  test('transitive references', () => {
+    const a = createEditorPriority({name: 'a'})
+    const b = createEditorPriority({
+      name: 'b',
+      reference: {priority: a, importance: 'lower'},
+    })
+    const c = createEditorPriority({
+      name: 'c',
+      reference: {priority: b, importance: 'higher'},
+    })
+
+    const items = [{priority: c}, {priority: b}, {priority: a}]
+
+    expect(sortByPriority(items).map((item) => item.priority.name)).toEqual([
+      'a',
+      'c',
+      'b',
+    ])
+  })
+
+  test('transitive references #2', () => {
+    const a = createEditorPriority({name: 'a'})
+    const b = createEditorPriority({
+      name: 'b',
+      reference: {priority: a, importance: 'higher'},
+    })
+    const c = createEditorPriority({
+      name: 'c',
+      reference: {priority: b, importance: 'lower'},
+    })
+
+    const items = [{priority: c}, {priority: b}, {priority: a}]
+
+    expect(sortByPriority(items).map((item) => item.priority.name)).toEqual([
+      'b',
+      'c',
+      'a',
+    ])
+  })
+
+  test('references to missing priorities', () => {
+    const a = createEditorPriority({name: 'a'})
+    const b = createEditorPriority({
+      name: 'b',
+      reference: {priority: a, importance: 'lower'},
+    })
+    const c = createEditorPriority({
+      name: 'c',
+      reference: {priority: b, importance: 'higher'},
+    })
+    const items = [{priority: a}, {priority: c}]
+
+    expect(sortByPriority(items).map((item) => item.priority.name)).toEqual([
+      'a',
+      'c',
+    ])
+  })
+
+  test('references to missing priorities #2', () => {
+    const a = createEditorPriority({name: 'a'})
+    const b = createEditorPriority({
+      name: 'b',
+      reference: {priority: a, importance: 'higher'},
+    })
+    const c = createEditorPriority({
+      name: 'c',
+      reference: {priority: b, importance: 'lower'},
+    })
+    const items = [{priority: a}, {priority: c}]
+
+    expect(sortByPriority(items).map((item) => item.priority.name)).toEqual([
+      'c',
+      'a',
+    ])
+  })
+
+  test('complex reference chains', () => {
+    const a = createEditorPriority({
+      name: 'a',
+    })
+    const b = createEditorPriority({
+      name: 'b',
+      reference: {priority: a, importance: 'lower'},
+    })
+    const c = createEditorPriority({
+      name: 'c',
+      reference: {priority: b, importance: 'higher'},
+    })
+    const d = createEditorPriority({
+      name: 'd',
+      reference: {priority: c, importance: 'lower'},
+    })
+
+    const items = [{priority: d}, {priority: c}, {priority: b}, {priority: a}]
+
+    const result = sortByPriority(items)
+    expect(result.map((item) => item.priority.name)).toEqual([
+      'a',
+      'c',
+      'd',
+      'b',
+    ])
+  })
+
+  test('complex reference chains #2', () => {
+    const a = createEditorPriority({
+      name: 'a',
+    })
+    const b = createEditorPriority({
+      name: 'b',
+      reference: {priority: a, importance: 'higher'},
+    })
+    const c = createEditorPriority({
+      name: 'c',
+      reference: {priority: b, importance: 'lower'},
+    })
+    const d = createEditorPriority({
+      name: 'd',
+      reference: {priority: c, importance: 'higher'},
+    })
+
+    const items = [{priority: d}, {priority: c}, {priority: b}, {priority: a}]
+
+    const result = sortByPriority(items)
+    expect(result.map((item) => item.priority.name)).toEqual([
+      'b',
+      'd',
+      'c',
+      'a',
+    ])
+  })
+
+  test('multiple independent chains', () => {
+    const a1 = createEditorPriority({name: 'a1'})
+    const a2 = createEditorPriority({
+      name: 'a2',
+      reference: {priority: a1, importance: 'lower'},
+    })
+
+    const b1 = createEditorPriority({name: 'b1'})
+    const b2 = createEditorPriority({
+      name: 'b2',
+      reference: {priority: b1, importance: 'lower'},
+    })
+
+    const items = [
+      {priority: a2},
+      {priority: b1},
+      {priority: a1},
+      {priority: b2},
+    ]
+
+    const result = sortByPriority(items)
+    const names = result.map((item) => item.priority.name)
+
+    // Verify that a1 comes before a2 and b1 comes before b2
+    expect(names.indexOf('a1')).toBeLessThan(names.indexOf('a2'))
+    expect(names.indexOf('b1')).toBeLessThan(names.indexOf('b2'))
+  })
+
+  test('cyclic references', () => {
+    const a = createEditorPriority({name: 'a'})
+    const b = createEditorPriority({
+      name: 'b',
+      reference: {priority: a, importance: 'lower'},
+    })
+    const c = createEditorPriority({
+      name: 'c',
+      reference: {priority: b, importance: 'lower'},
+    })
+    a.reference = {priority: c, importance: 'lower'}
+
+    const items = [{priority: a}, {priority: b}, {priority: c}]
+
+    expect(() => sortByPriority(items)).toThrow()
+  })
+
+  test('missing priorities', () => {
+    const a = createEditorPriority({name: 'a'})
+    const b = createEditorPriority({
+      name: 'b',
+      reference: {priority: a, importance: 'lower'},
+    })
+
+    const items = [
+      {name: 'd'},
+      {name: 'c'},
+      {priority: a, name: 'a'},
+      {priority: b, name: 'b'},
+    ]
+
+    expect(sortByPriority(items).map((item) => item.name)).toEqual([
+      'a',
+      'b',
+      'd',
+      'c',
+    ])
+  })
+})

package/src/priority/priority.sort.ts

@@ -0,0 +1,121 @@
+import type {EditorPriority} from './priority.types'
+
+export function sortByPriority<
+  T extends {
+    priority?: EditorPriority
+  },
+>(items: Array<T>): Array<T> {
+  if (items.length === 0) {
+    return []
+  }
+
+  // Separate items with and without priority
+  const itemsWithPriority = items.filter(
+    (item): item is T & {priority: EditorPriority} =>
+      item.priority !== undefined,
+  )
+  const itemsWithoutPriority = items.filter(
+    (item) => item.priority === undefined,
+  )
+
+  if (itemsWithPriority.length === 0) {
+    return items
+  }
+
+  // Create a map of items by their priority ID
+  const itemsByPriorityId = new Map(
+    itemsWithPriority.map((item) => [item.priority.id, item]),
+  )
+
+  // Build the dependency graph
+  const graph = new Map<string, Set<string>>()
+  const inDegree = new Map<string, number>()
+
+  // Helper function to ensure a node exists in the graph
+  function ensureNode(id: string) {
+    if (!graph.has(id)) {
+      graph.set(id, new Set())
+      inDegree.set(id, 0)
+    }
+  }
+
+  // Initialize graph and in-degree for all items
+  for (const item of itemsWithPriority) {
+    const id = item.priority.id
+    ensureNode(id)
+  }
+
+  // Helper function to add an edge to the graph
+  function addEdge(fromId: string, toId: string) {
+    if (!graph.has(fromId) || !graph.has(toId)) return
+    graph.get(fromId)?.add(toId)
+    inDegree.set(toId, (inDegree.get(toId) ?? 0) + 1)
+  }
+
+  // Add edges based on references
+  for (const item of itemsWithPriority) {
+    const id = item.priority.id
+    const visited = new Set<string>()
+    let ref = item.priority.reference
+
+    while (ref) {
+      const refId = ref.priority.id
+      ensureNode(refId)
+
+      // Check for cyclic reference
+      if (visited.has(refId)) {
+        throw new Error('Circular dependency detected in priorities')
+      }
+      visited.add(refId)
+
+      if (ref.importance === 'higher') {
+        // Reference must come before current item
+        addEdge(id, refId)
+      } else {
+        // Current item must come before reference
+        addEdge(refId, id)
+      }
+
+      ref = ref.priority.reference
+    }
+  }
+
+  const queue: string[] = []
+
+  // Find all nodes with no incoming edges
+  for (const [id, degree] of inDegree) {
+    if (degree === 0) {
+      queue.push(id)
+    }
+  }
+
+  const result: T[] = []
+
+  // Perform topological sort
+  while (queue.length > 0) {
+    const currentId = queue.shift()!
+    const currentItem = itemsByPriorityId.get(currentId)
+    if (currentItem) {
+      result.push(currentItem)
+    }
+
+    // Decrease in-degree of neighbors
+    for (const neighborId of graph.get(currentId) ?? []) {
+      const newDegree = (inDegree.get(neighborId) ?? 0) - 1
+      inDegree.set(neighborId, newDegree)
+      if (newDegree === 0) {
+        queue.push(neighborId)
+      }
+    }
+  }
+
+  // Add any remaining items that weren't processed
+  for (const item of itemsWithPriority) {
+    if (!result.includes(item)) {
+      result.push(item)
+    }
+  }
+
+  // Append items without priority at the end in their original order
+  return [...result, ...itemsWithoutPriority]
+}

package/src/priority/priority.types.ts

@@ -0,0 +1,24 @@
+import {defaultKeyGenerator} from '../editor/key-generator'
+
+export type EditorPriority = {
+  id: string
+  name?: string
+  reference?: {
+    priority: EditorPriority
+    importance: 'higher' | 'lower'
+  }
+}
+
+export function createEditorPriority(config?: {
+  name?: string
+  reference?: {
+    priority: EditorPriority
+    importance: 'higher' | 'lower'
+  }
+}): EditorPriority {
+  return {
+    id: defaultKeyGenerator(),
+    name: config?.name,
+    reference: config?.reference,
+  }
+}

package/src/behavior-actions/behavior.action.delete.backward.ts

@@ -1,7 +0,0 @@
-import type {BehaviorActionImplementation} from './behavior.actions'
-
-export const deleteBackwardActionImplementation: BehaviorActionImplementation<
-  'delete.backward'
-> = ({action}) => {
-  action.editor.deleteBackward(action.unit)
-}

package/src/behavior-actions/behavior.action.delete.block.ts

@@ -1,24 +0,0 @@
-import {Transforms} from 'slate'
-import {toSlateRange} from '../internal-utils/ranges'
-import type {BehaviorActionImplementation} from './behavior.actions'
-
-export const deleteBlockActionImplementation: BehaviorActionImplementation<
-  'delete.block'
-> = ({action}) => {
-  const range = toSlateRange(
-    {
-      anchor: {path: action.at, offset: 0},
-      focus: {path: action.at, offset: 0},
-    },
-    action.editor,
-  )
-
-  if (!range) {
-    console.error('Unable to find Slate range from selection points')
-    return
-  }
-
-  Transforms.removeNodes(action.editor, {
-    at: range,
-  })
-}

package/src/behavior-actions/behavior.action.delete.forward.ts

@@ -1,7 +0,0 @@
-import type {BehaviorActionImplementation} from './behavior.actions'
-
-export const deleteForwardActionImplementation: BehaviorActionImplementation<
-  'delete.forward'
-> = ({action}) => {
-  action.editor.deleteForward(action.unit)
-}

package/src/behavior-actions/behavior.action.insert.text.ts

@@ -1,17 +0,0 @@
-import {Transforms} from 'slate'
-import type {BehaviorActionImplementation} from './behavior.actions'
-
-export const insertTextActionImplementation: BehaviorActionImplementation<
-  'insert.text'
-> = ({action}) => {
-  if (action.editor.marks) {
-    Transforms.insertNodes(action.editor, {
-      text: action.text,
-      ...action.editor.marks,
-    })
-  } else {
-    Transforms.insertText(action.editor, action.text)
-  }
-
-  action.editor.marks = null
-}

package/src/behavior-actions/behavior.action.move.backward.ts

@@ -1,12 +0,0 @@
-import {Transforms} from 'slate'
-import type {BehaviorActionImplementation} from './behavior.actions'
-
-export const moveBackwardActionImplementation: BehaviorActionImplementation<
-  'move.backward'
-> = ({action}) => {
-  Transforms.move(action.editor, {
-    unit: 'character',
-    distance: action.distance,
-    reverse: true,
-  })
-}

package/src/behavior-actions/behavior.action.move.block.ts

@@ -1,16 +0,0 @@
-import {Transforms} from 'slate'
-import {toSlatePath} from '../internal-utils/paths'
-import type {BehaviorActionImplementation} from './behavior.actions'
-
-export const moveBlockActionImplementation: BehaviorActionImplementation<
-  'move.block'
-> = ({action}) => {
-  const at = [toSlatePath(action.at, action.editor)[0]]
-  const to = [toSlatePath(action.to, action.editor)[0]]
-
-  Transforms.moveNodes(action.editor, {
-    at,
-    to,
-    mode: 'highest',
-  })
-}

package/src/behavior-actions/behavior.action.move.forward.ts

@@ -1,11 +0,0 @@
-import {Transforms} from 'slate'
-import type {BehaviorActionImplementation} from './behavior.actions'
-
-export const moveForwardActionImplementation: BehaviorActionImplementation<
-  'move.forward'
-> = ({action}) => {
-  Transforms.move(action.editor, {
-    unit: 'character',
-    distance: action.distance,
-  })
-}

package/src/behavior-actions/behavior.action.select.ts

@@ -1,15 +0,0 @@
-import {Transforms} from 'slate'
-import {toSlateRange} from '../internal-utils/ranges'
-import type {BehaviorActionImplementation} from './behavior.actions'
-
-export const selectActionImplementation: BehaviorActionImplementation<
-  'select'
-> = ({action}) => {
-  const newSelection = toSlateRange(action.at, action.editor)
-
-  if (newSelection) {
-    Transforms.select(action.editor, newSelection)
-  } else {
-    Transforms.deselect(action.editor)
-  }
-}