@portabletext/editor 1.23.0 → 1.24.0

package/src/internal-utils/parse-blocks.ts

@@ -0,0 +1,136 @@
+import {
+  isPortableTextSpan,
+  isPortableTextTextBlock,
+  type PortableTextBlock,
+} from '@sanity/types'
+import type {EditorContext} from '../editor/editor-snapshot'
+import {isTypedObject} from './asserters'
+
+export function parseBlock({
+  context,
+  block,
+}: {
+  context: Pick<EditorContext, 'keyGenerator' | 'schema'>
+  block: unknown
+}): PortableTextBlock | undefined {
+  if (!isTypedObject(block)) {
+    return undefined
+  }
+
+  if (
+    block._type !== context.schema.block.name &&
+    !context.schema.blockObjects.some(
+      (blockObject) => blockObject.name === block._type,
+    )
+  ) {
+    return undefined
+  }
+
+  if (!isPortableTextTextBlock(block)) {
+    return {
+      ...block,
+      _key: context.keyGenerator(),
+    }
+  }
+
+  const markDefKeyMap = new Map<string, string>()
+  const markDefs = (block.markDefs ?? []).flatMap((markDef) => {
+    if (
+      context.schema.annotations.some(
+        (annotation) => annotation.name === markDef._type,
+      )
+    ) {
+      const _key = context.keyGenerator()
+      markDefKeyMap.set(markDef._key, _key)
+
+      return [
+        {
+          ...markDef,
+          _key,
+        },
+      ]
+    }
+
+    return []
+  })
+
+  const children = block.children.flatMap((child) => {
+    if (!isTypedObject(child)) {
+      return []
+    }
+
+    if (
+      child._type !== context.schema.span.name &&
+      !context.schema.inlineObjects.some(
+        (inlineObject) => inlineObject.name === child._type,
+      )
+    ) {
+      return []
+    }
+
+    if (!isPortableTextSpan(child)) {
+      return [
+        {
+          ...child,
+          _key: context.keyGenerator(),
+        },
+      ]
+    }
+
+    const marks = (child.marks ?? []).flatMap((mark) => {
+      if (markDefKeyMap.has(mark)) {
+        return [markDefKeyMap.get(mark)]
+      }
+
+      if (
+        context.schema.decorators.some((decorator) => decorator.value === mark)
+      ) {
+        return [mark]
+      }
+
+      return []
+    })
+
+    return [
+      {
+        ...child,
+        _key: context.keyGenerator(),
+        marks,
+      },
+    ]
+  })
+
+  const parsedBlock = {
+    ...block,
+    _key: context.keyGenerator(),
+    children:
+      children.length > 0
+        ? children
+        : [
+            {
+              _key: context.keyGenerator(),
+              _type: context.schema.span.name,
+              text: '',
+              marks: [],
+            },
+          ],
+    markDefs,
+  }
+
+  if (!context.schema.styles.find((style) => style.value === block.style)) {
+    const defaultStyle = context.schema.styles[0].value
+
+    if (defaultStyle !== undefined) {
+      parsedBlock.style = defaultStyle
+    } else {
+      delete parsedBlock.style
+    }
+  }
+
+  if (!context.schema.lists.find((list) => list.value === block.listItem)) {
+    delete parsedBlock.listItem
+    delete parsedBlock.level
+  }
+
+  return parsedBlock
+}

package/src/internal-utils/test-key-generator.ts

@@ -0,0 +1,9 @@
+export function createTestKeyGenerator() {
+  let index = 0
+
+  return function keyGenerator() {
+    const key = `k${index}`
+    index++
+    return key
+  }
+}

package/src/selectors/selector.get-selected-spans.test.ts

@@ -6,6 +6,7 @@ test(getSelectedSpans.name, () => {
   function snapshot(selection: EditorSelection): EditorSnapshot {
     return {
       context: {
+        converters: [],
         schema: {} as EditorSchema,
         keyGenerator: () => '',
         activeDecorators: [],

package/src/selectors/selector.get-selection-text.test.ts

@@ -6,6 +6,7 @@ test(getSelectionText.name, () => {
   function snapshot(selection: EditorSelection): EditorSnapshot {
     return {
       context: {
+        converters: [],
         schema: {} as EditorSchema,
         keyGenerator: () => '',
         activeDecorators: [],

package/src/selectors/selector.is-active-decorator.test.ts

@@ -7,6 +7,7 @@ test(isActiveDecorator.name, () => {
   function snapshot(selection: EditorSelection): EditorSnapshot {
     return {
       context: {
+        converters: [],
         schema: {} as EditorSchema,
         keyGenerator: () => '',
         activeDecorators: [],

package/src/utils/util.slice-blocks.test.ts

@@ -134,6 +134,24 @@ describe(sliceBlocks.name, () => {
     ).toEqual([b2])
   })
 
+  test('starting selection on a block object', () => {
+    expect(
+      sliceBlocks({
+        blocks,
+        selection: {
+          anchor: {
+            path: [{_key: b2._key}],
+            offset: 0,
+          },
+          focus: {
+            path: [{_key: b3._key}, 'children', {_key: b3.children[0]._key}],
+            offset: 3,
+          },
+        },
+      }),
+    ).toEqual([b2, b3])
+  })
+
   test('ending selection on a block object', () => {
     expect(
       sliceBlocks({
@@ -254,4 +272,73 @@ describe(sliceBlocks.name, () => {
       },
     ])
   })
+
+  test('starting on inline object', () => {
+    expect(
+      sliceBlocks({
+        blocks,
+        selection: {
+          anchor: {
+            path: [{_key: b4._key}, 'children', {_key: b4.children[1]._key}],
+            offset: 0,
+          },
+          focus: {
+            path: [{_key: b4._key}, 'children', {_key: b4.children[2]._key}],
+            offset: 4,
+          },
+        },
+      }),
+    ).toEqual([
+      {
+        ...b4,
+        children: [b4.children[1], b4.children[2]],
+      },
+    ])
+  })
+
+  test('ending on inline object', () => {
+    expect(
+      sliceBlocks({
+        blocks,
+        selection: {
+          anchor: {
+            path: [{_key: b4._key}, 'children', {_key: b4.children[0]._key}],
+            offset: 0,
+          },
+          focus: {
+            path: [{_key: b4._key}, 'children', {_key: b4.children[1]._key}],
+            offset: 0,
+          },
+        },
+      }),
+    ).toEqual([
+      {
+        ...b4,
+        children: [b4.children[0], b4.children[1]],
+      },
+    ])
+  })
+
+  test('starting and ending on inline object', () => {
+    expect(
+      sliceBlocks({
+        blocks,
+        selection: {
+          anchor: {
+            path: [{_key: b4._key}, 'children', {_key: b4.children[1]._key}],
+            offset: 0,
+          },
+          focus: {
+            path: [{_key: b4._key}, 'children', {_key: b4.children[1]._key}],
+            offset: 0,
+          },
+        },
+      }),
+    ).toEqual([
+      {
+        ...b4,
+        children: [b4.children[1]],
+      },
+    ])
+  })
 })

package/src/utils/util.slice-blocks.ts

@@ -47,8 +47,20 @@ export function sliceBlocks({
   }
 
   for (const block of blocks) {
+    if (!isPortableTextTextBlock(block)) {
+      if (block._key === startBlockKey && block._key === endBlockKey) {
+        startBlock = block
+        break
+      }
+    }
+
     if (block._key === startBlockKey) {
-      if (isPortableTextTextBlock(block) && startChildKey) {
+      if (!isPortableTextTextBlock(block)) {
+        startBlock = block
+        continue
+      }
+
+      if (startChildKey) {
         for (const child of block.children) {
           if (child._key === startChildKey) {
             if (isPortableTextSpan(child)) {
@@ -66,17 +78,17 @@ export function sliceBlocks({
                   },
                 ],
               }
-              continue
+            } else {
+              startBlock = {
+                ...block,
+                children: [child],
+              }
             }
 
-            startBlock = {
-              ...block,
-              children: [child],
+            if (startChildKey === endChildKey) {
+              break
             }
-          }
-
-          if (startChildKey === endChildKey) {
-            break
+            continue
           }
 
           if (startBlock && isPortableTextTextBlock(startBlock)) {
@@ -107,7 +119,12 @@ export function sliceBlocks({
     }
 
     if (block._key === endBlockKey) {
-      if (isPortableTextTextBlock(block) && endBlockKey) {
+      if (!isPortableTextTextBlock(block)) {
+        endBlock = block
+        break
+      }
+
+      if (endChildKey) {
         endBlock = {
           ...block,
           children: [],

package/src/editor/plugins/__tests__/createWithInsertData.test.tsx

@@ -1,181 +0,0 @@
-import {isPortableTextSpan, isPortableTextTextBlock} from '@sanity/types'
-import type {Descendant} from 'slate'
-import {describe, expect, it} from 'vitest'
-import {exportedForTesting} from '../createWithInsertData'
-
-const initialValue = [
-  {
-    _key: 'a',
-    _type: 'myTestBlockType',
-    children: [
-      {
-        _key: 'a1',
-        _type: 'span',
-        marks: ['link1'],
-        text: 'Block A',
-      },
-      {
-        _key: 'a2',
-        _type: 'span',
-        marks: ['colour1'],
-        text: 'Block B',
-      },
-    ],
-    markDefs: [
-      {
-        _key: 'link1',
-        _type: 'link',
-        href: 'google.com',
-        newTab: false,
-      },
-      {
-        _key: 'colour1',
-        _type: 'color',
-        color: 'red',
-      },
-    ],
-    style: 'normal',
-  },
-] satisfies Array<Descendant>
-
-describe('plugin: createWithInsertData _regenerateKeys', () => {
-  it('has MarkDefs that are allowed annotations', async () => {
-    const {_regenerateKeys} = exportedForTesting
-    let keyCursor = 0
-
-    const generatedValue = _regenerateKeys(
-      {
-        isTextBlock: isPortableTextTextBlock,
-        isTextSpan: isPortableTextSpan,
-      },
-      initialValue,
-      () => {
-        keyCursor++
-        return `k${keyCursor}`
-      },
-      'span',
-      {
-        annotations: [
-          {
-            name: 'color',
-            jsonType: 'object',
-            fields: [],
-            __experimental_search: [],
-          },
-          {
-            name: 'link',
-            jsonType: 'object',
-            fields: [],
-            __experimental_search: [],
-          },
-        ],
-      },
-    )
-
-    // the keys are not important here as it's not what we are testing here
-    expect(generatedValue).toStrictEqual([
-      {
-        _key: 'k3',
-        _type: 'myTestBlockType',
-        children: [
-          {_key: 'k4', _type: 'span', marks: ['k1'], text: 'Block A'},
-          {
-            _key: 'k5',
-            _type: 'span',
-            marks: ['k2'],
-            text: 'Block B',
-          },
-        ],
-        markDefs: [
-          {_key: 'k1', _type: 'link', href: 'google.com', newTab: false},
-          {_key: 'k2', _type: 'color', color: 'red'},
-        ],
-        style: 'normal',
-      },
-    ])
-  })
-
-  it('removes MarkDefs when no annotations are allowed', async () => {
-    const {_regenerateKeys} = exportedForTesting
-    let keyCursor = 0
-
-    const generatedValue = _regenerateKeys(
-      {
-        isTextBlock: isPortableTextTextBlock,
-        isTextSpan: isPortableTextSpan,
-      },
-      initialValue,
-      () => {
-        keyCursor++
-        return `k${keyCursor}`
-      },
-      'span',
-      {annotations: []},
-    )
-
-    // orphaned children marks are removed later in the normalize function
-    expect(generatedValue).toStrictEqual([
-      {
-        _key: 'k1',
-        _type: 'myTestBlockType',
-        children: [
-          {_key: 'a1', _type: 'span', marks: ['link1'], text: 'Block A'},
-          {
-            _key: 'a2',
-            _type: 'span',
-            marks: ['colour1'],
-            text: 'Block B',
-          },
-        ],
-        style: 'normal',
-      },
-    ])
-  })
-
-  it('updates MarkDefs when one annotations is allowed but one is not allowed', async () => {
-    const {_regenerateKeys} = exportedForTesting
-    let keyCursor = 0
-
-    const generatedValue = _regenerateKeys(
-      {
-        isTextBlock: isPortableTextTextBlock,
-        isTextSpan: isPortableTextSpan,
-      },
-      initialValue,
-      () => {
-        keyCursor++
-        return `k${keyCursor}`
-      },
-      'span',
-      {
-        annotations: [
-          {
-            name: 'color',
-            jsonType: 'object',
-            fields: [],
-            __experimental_search: [],
-          },
-        ],
-      },
-    )
-
-    // orphaned children marks are removed later in the normalize function
-    expect(generatedValue).toStrictEqual([
-      {
-        _key: 'k1',
-        _type: 'myTestBlockType',
-        children: [
-          {_key: 'a1', _type: 'span', marks: ['link1'], text: 'Block A'},
-          {
-            _key: 'a2',
-            _type: 'span',
-            marks: ['colour1'],
-            text: 'Block B',
-          },
-        ],
-        markDefs: [{_key: 'colour1', _type: 'color', color: 'red'}],
-        style: 'normal',
-      },
-    ])
-  })
-})