@portabletext/editor 3.3.3 → 3.3.4

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

@@ -1,319 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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

@@ -1,24 +0,0 @@
-import {defaultKeyGenerator} from '../utils/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/selectors/_exports/index.ts

@@ -1 +0,0 @@
-export * from '../index'