npm - @portabletext/editor - Versions diffs - 2.7.2 → 2.8.1 - Mend

@portabletext/editor 2.7.2 → 2.8.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (72) hide show

package/lib/_chunks-cjs/selector.is-selecting-entire-blocks.cjs +3 -1
package/lib/_chunks-cjs/selector.is-selecting-entire-blocks.cjs.map +1 -1
package/lib/_chunks-cjs/selector.is-selection-expanded.cjs +10 -4
package/lib/_chunks-cjs/selector.is-selection-expanded.cjs.map +1 -1
package/lib/_chunks-cjs/util.merge-text-blocks.cjs +0 -1
package/lib/_chunks-cjs/util.merge-text-blocks.cjs.map +1 -1
package/lib/_chunks-cjs/util.slice-blocks.cjs +60 -9
package/lib/_chunks-cjs/util.slice-blocks.cjs.map +1 -1
package/lib/_chunks-dts/behavior.types.action.d.cts +149 -149
package/lib/_chunks-dts/behavior.types.action.d.ts +86 -86
package/lib/_chunks-es/selector.is-selecting-entire-blocks.js +4 -2
package/lib/_chunks-es/selector.is-selecting-entire-blocks.js.map +1 -1
package/lib/_chunks-es/selector.is-selection-expanded.js +10 -4
package/lib/_chunks-es/selector.is-selection-expanded.js.map +1 -1
package/lib/_chunks-es/util.merge-text-blocks.js +0 -1
package/lib/_chunks-es/util.merge-text-blocks.js.map +1 -1
package/lib/_chunks-es/util.slice-blocks.js +56 -8
package/lib/_chunks-es/util.slice-blocks.js.map +1 -1
package/lib/index.cjs +94 -131
package/lib/index.cjs.map +1 -1
package/lib/index.js +90 -128
package/lib/index.js.map +1 -1
package/lib/plugins/index.d.cts +3 -3
package/lib/selectors/index.d.cts +13 -3
package/lib/selectors/index.d.ts +13 -3
package/package.json +13 -14
package/src/behaviors/behavior.abstract.insert.ts +58 -1
package/src/behaviors/behavior.abstract.split.ts +0 -1
package/src/behaviors/behavior.core.annotations.ts +24 -2
package/src/behaviors/behavior.core.ts +1 -1
package/src/behaviors/behavior.types.event.ts +18 -18
package/src/converters/converter.portable-text.ts +0 -1
package/src/converters/converter.text-html.serialize.test.ts +27 -17
package/src/converters/converter.text-html.ts +0 -1
package/src/converters/converter.text-plain.test.ts +1 -1
package/src/converters/converter.text-plain.ts +0 -1
package/src/editor/Editable.tsx +0 -1
package/src/editor/plugins/createWithEditableAPI.ts +16 -0
package/src/internal-utils/parse-blocks.test.ts +23 -23
package/src/internal-utils/parse-blocks.ts +13 -24
package/src/internal-utils/test-editor.tsx +15 -21
package/src/operations/behavior.operation.annotation.add.ts +2 -13
package/src/operations/behavior.operation.block.set.ts +1 -1
package/src/operations/behavior.operation.block.unset.ts +2 -2
package/src/operations/behavior.operation.insert.block.ts +1 -1
package/src/operations/behavior.operations.ts +0 -18
package/src/plugins/plugin.internal.auto-close-brackets.test.tsx +25 -71
package/src/plugins/plugin.markdown.test.tsx +12 -30
package/src/selectors/selector.get-selected-value.test.ts +748 -0
package/src/selectors/selector.get-selected-value.ts +28 -7
package/src/selectors/selector.get-trimmed-selection.test.ts +0 -1
package/src/selectors/selector.is-active-annotation.test.ts +320 -0
package/src/selectors/selector.is-active-annotation.ts +24 -0
package/src/utils/util.merge-text-blocks.ts +1 -1
package/src/utils/util.slice-blocks.ts +36 -3
package/src/editor/__tests__/PortableTextEditor.test.tsx +0 -430
package/src/editor/__tests__/PortableTextEditorTester.tsx +0 -58
package/src/editor/__tests__/RangeDecorations.test.tsx +0 -213
package/src/editor/__tests__/insert-block.test.tsx +0 -224
package/src/editor/__tests__/self-solving.test.tsx +0 -183
package/src/editor/plugins/__tests__/withEditableAPIDelete.test.tsx +0 -298
package/src/editor/plugins/__tests__/withEditableAPIGetFragment.test.tsx +0 -177
package/src/editor/plugins/__tests__/withEditableAPIInsert.test.tsx +0 -538
package/src/editor/plugins/__tests__/withEditableAPISelectionsOverlapping.test.tsx +0 -162
package/src/editor/plugins/__tests__/withPortableTextLists.test.tsx +0 -65
package/src/editor/plugins/__tests__/withPortableTextMarkModel.test.tsx +0 -612
package/src/editor/plugins/__tests__/withPortableTextSelections.test.tsx +0 -103
package/src/editor/plugins/__tests__/withUndoRedo.test.tsx +0 -147
package/src/internal-utils/__tests__/valueNormalization.test.tsx +0 -79
package/src/operations/behavior.operation.insert-inline-object.ts +0 -59
package/src/operations/behavior.operation.insert-span.ts +0 -48
package/src/utils/util.slice-blocks.test.ts +0 -465

package/src/selectors/selector.get-selected-value.test.ts ADDED Viewed

@@ -0,0 +1,748 @@
+import {compileSchema, defineSchema} from '@portabletext/schema'
+import {createTestKeyGenerator} from '@portabletext/test'
+import type {PortableTextBlock, PortableTextTextBlock} from '@sanity/types'
+import {describe, expect, test} from 'vitest'
+import {getSelectedValue} from '.'
+import {createTestSnapshot} from '../internal-utils/create-test-snapshot'
+const b1: PortableTextTextBlock = {
+  _type: 'block',
+  _key: 'b1',
+  children: [
+    {
+      _type: 'span',
+      _key: 'b1c1',
+      text: 'foo',
+      marks: [],
+    },
+    {
+      _type: 'span',
+      _key: 'b1c2',
+      text: 'bar',
+      marks: [],
+    },
+  ],
+  markDefs: [],
+  style: 'normal',
+}
+const b2: PortableTextBlock = {
+  _type: 'image',
+  _key: 'b2',
+  src: 'https://example.com/image.jpg',
+  alt: 'Example',
+}
+const b3: PortableTextTextBlock = {
+  _type: 'block',
+  _key: 'b3',
+  children: [
+    {
+      _type: 'span',
+      _key: 'b3c1',
+      text: 'baz',
+      marks: [],
+    },
+  ],
+  markDefs: [],
+  style: 'normal',
+}
+const b4: PortableTextTextBlock = {
+  _type: 'block',
+  _key: 'b4',
+  children: [
+    {
+      _type: 'span',
+      _key: 'b4c1',
+      text: 'fizz',
+      marks: [],
+    },
+    {
+      _type: 'stock-ticker',
+      _key: 'b4c2',
+      symbol: 'AAPL',
+    },
+    {
+      _type: 'span',
+      _key: 'b4c3',
+      text: 'buzz',
+      marks: [],
+    },
+  ],
+  markDefs: [],
+  style: 'normal',
+}
+const schema = compileSchema(
+  defineSchema({
+    blockObjects: [{name: 'image'}],
+    inlineObjects: [{name: 'stock-ticker'}],
+  }),
+)
+const blocks: Array<PortableTextBlock> = [b1, b2, b3, b4]
+describe(getSelectedValue.name, () => {
+  test('sensible defaults', () => {
+    expect(
+      getSelectedValue(
+        createTestSnapshot({
+          context: {
+            schema,
+            selection: null,
+            value: [],
+          },
+        }),
+      ),
+    ).toEqual([])
+    expect(
+      getSelectedValue(
+        createTestSnapshot({
+          context: {
+            schema,
+            selection: null,
+            value: [],
+          },
+        }),
+      ),
+    ).toEqual([])
+  })
+  test('slicing a single block', () => {
+    expect(
+      getSelectedValue(
+        createTestSnapshot({
+          context: {
+            schema,
+            selection: {
+              anchor: {
+                path: [
+                  {_key: b1._key},
+                  'children',
+                  {_key: b1.children[0]._key},
+                ],
+                offset: 0,
+              },
+              focus: {
+                path: [
+                  {_key: b1._key},
+                  'children',
+                  {_key: b1.children[0]._key},
+                ],
+                offset: 3,
+              },
+            },
+            value: blocks,
+          },
+        }),
+      ),
+    ).toEqual([
+      {
+        ...b1,
+        children: [b1.children[0]],
+      },
+    ])
+  })
+  test('slicing a single span', () => {
+    expect(
+      getSelectedValue(
+        createTestSnapshot({
+          context: {
+            schema,
+            selection: {
+              anchor: {
+                path: [
+                  {_key: b1._key},
+                  'children',
+                  {_key: b1.children[0]._key},
+                ],
+                offset: 1,
+              },
+              focus: {
+                path: [
+                  {_key: b1._key},
+                  'children',
+                  {_key: b1.children[0]._key},
+                ],
+                offset: 2,
+              },
+            },
+            value: blocks,
+          },
+        }),
+      ),
+    ).toEqual([
+      {
+        ...b1,
+        children: [
+          {
+            ...b1.children[0],
+            text: 'o',
+          },
+        ],
+      },
+    ])
+  })
+  test('starting and ending selection on a block object', () => {
+    expect(
+      getSelectedValue(
+        createTestSnapshot({
+          context: {
+            schema,
+            selection: {
+              anchor: {
+                path: [{_key: b2._key}],
+                offset: 0,
+              },
+              focus: {
+                path: [{_key: b2._key}],
+                offset: 0,
+              },
+            },
+            value: blocks,
+          },
+        }),
+      ),
+    ).toEqual([b2])
+  })
+  test('starting selection on a block object', () => {
+    expect(
+      getSelectedValue(
+        createTestSnapshot({
+          context: {
+            schema,
+            selection: {
+              anchor: {
+                path: [{_key: b2._key}],
+                offset: 0,
+              },
+              focus: {
+                path: [
+                  {_key: b3._key},
+                  'children',
+                  {_key: b3.children[0]._key},
+                ],
+                offset: 3,
+              },
+            },
+            value: blocks,
+          },
+        }),
+      ),
+    ).toEqual([b2, b3])
+  })
+  test('ending selection on a block object', () => {
+    expect(
+      getSelectedValue(
+        createTestSnapshot({
+          context: {
+            schema,
+            selection: {
+              anchor: {
+                path: [
+                  {_key: b1._key},
+                  'children',
+                  {_key: b1.children[0]._key},
+                ],
+                offset: 3,
+              },
+              focus: {
+                path: [{_key: b2._key}],
+                offset: 0,
+              },
+            },
+            value: blocks,
+          },
+        }),
+      ),
+    ).toEqual([
+      {
+        ...b1,
+        children: [
+          {
+            ...b1.children[0],
+            text: '',
+          },
+          ...b1.children.slice(1),
+        ],
+      },
+      blocks[1],
+    ])
+  })
+  test('slicing across block object', () => {
+    expect(
+      getSelectedValue(
+        createTestSnapshot({
+          context: {
+            schema,
+            selection: {
+              anchor: {
+                path: [
+                  {_key: b1._key},
+                  'children',
+                  {_key: b1.children[0]._key},
+                ],
+                offset: 0,
+              },
+              focus: {
+                path: [
+                  {_key: b3._key},
+                  'children',
+                  {_key: b3.children[0]._key},
+                ],
+                offset: 3,
+              },
+            },
+            value: blocks,
+          },
+        }),
+      ),
+    ).toEqual([b1, b2, b3])
+  })
+  test('starting and ending mid-span', () => {
+    expect(
+      getSelectedValue(
+        createTestSnapshot({
+          context: {
+            schema,
+            selection: {
+              anchor: {
+                path: [
+                  {_key: b3._key},
+                  'children',
+                  {_key: b3.children[0]._key},
+                ],
+                offset: 2,
+              },
+              focus: {
+                path: [
+                  {_key: b4._key},
+                  'children',
+                  {_key: b4.children[0]._key},
+                ],
+                offset: 1,
+              },
+            },
+            value: blocks,
+          },
+        }),
+      ),
+    ).toEqual([
+      {
+        ...b3,
+        children: [
+          {
+            ...b3.children[0],
+            text: 'z',
+          },
+        ],
+      },
+      {
+        ...b4,
+        children: [
+          {
+            ...b4.children[0],
+            text: 'f',
+          },
+        ],
+      },
+    ])
+  })
+  test('starting mid-span and ending end-span', () => {
+    expect(
+      getSelectedValue(
+        createTestSnapshot({
+          context: {
+            schema,
+            selection: {
+              anchor: {
+                path: [
+                  {_key: b3._key},
+                  'children',
+                  {_key: b3.children[0]._key},
+                ],
+                offset: 2,
+              },
+              focus: {
+                path: [
+                  {_key: b4._key},
+                  'children',
+                  {_key: b4.children[0]._key},
+                ],
+                offset: 4,
+              },
+            },
+            value: blocks,
+          },
+        }),
+      ),
+    ).toEqual([
+      {
+        ...b3,
+        children: [
+          {
+            ...b3.children[0],
+            text: 'z',
+          },
+        ],
+      },
+      {
+        ...b4,
+        children: [
+          {
+            ...b4.children[0],
+          },
+        ],
+      },
+    ])
+  })
+  test('starting on inline object', () => {
+    expect(
+      getSelectedValue(
+        createTestSnapshot({
+          context: {
+            schema,
+            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,
+              },
+            },
+            value: blocks,
+          },
+        }),
+      ),
+    ).toEqual([
+      {
+        ...b4,
+        children: [b4.children[1], b4.children[2]],
+      },
+    ])
+  })
+  test('ending on inline object', () => {
+    expect(
+      getSelectedValue(
+        createTestSnapshot({
+          context: {
+            schema,
+            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,
+              },
+            },
+            value: blocks,
+          },
+        }),
+      ),
+    ).toEqual([
+      {
+        ...b4,
+        children: [b4.children[0], b4.children[1]],
+      },
+    ])
+  })
+  test('starting and ending on inline object', () => {
+    expect(
+      getSelectedValue(
+        createTestSnapshot({
+          context: {
+            schema,
+            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,
+              },
+            },
+            value: blocks,
+          },
+        }),
+      ),
+    ).toEqual([
+      {
+        ...b4,
+        children: [b4.children[1]],
+      },
+    ])
+  })
+  test('slicing text block with custom props', () => {
+    expect(
+      getSelectedValue(
+        createTestSnapshot({
+          context: {
+            schema,
+            selection: {
+              anchor: {
+                path: [{_key: 'b0'}, 'children', {_key: 's0'}],
+                offset: 7,
+              },
+              focus: {
+                path: [{_key: 'b0'}, 'children', {_key: 's0'}],
+                offset: 12,
+              },
+            },
+            value: [
+              {
+                _key: 'b0',
+                _type: 'block',
+                children: [
+                  {_key: 's0', _type: 'span', text: 'Hello, world!', marks: []},
+                ],
+                markDefs: [],
+                style: 'normal',
+                _map: {},
+              },
+            ],
+          },
+        }),
+      ),
+    ).toEqual([
+      {
+        _key: 'b0',
+        _type: 'block',
+        children: [{_key: 's0', _type: 'span', text: 'world', marks: []}],
+        markDefs: [],
+        style: 'normal',
+        _map: {},
+      },
+    ])
+  })
+  test('slicing span with custom props', () => {
+    expect(
+      getSelectedValue(
+        createTestSnapshot({
+          context: {
+            schema,
+            selection: {
+              anchor: {
+                path: [{_key: 'b0'}, 'children', {_key: 's0'}],
+                offset: 7,
+              },
+              focus: {
+                path: [{_key: 'b0'}, 'children', {_key: 's0'}],
+                offset: 12,
+              },
+            },
+            value: [
+              {
+                _key: 'b0',
+                _type: 'block',
+                children: [
+                  {
+                    _key: 's0',
+                    _type: 'span',
+                    text: 'Hello, world!',
+                    _map: {},
+                    marks: [],
+                  },
+                ],
+                markDefs: [],
+                style: 'normal',
+              },
+            ],
+          },
+        }),
+      ),
+    ).toEqual([
+      {
+        _key: 'b0',
+        _type: 'block',
+        children: [
+          {_key: 's0', _type: 'span', text: 'world', _map: {}, marks: []},
+        ],
+        markDefs: [],
+        style: 'normal',
+      },
+    ])
+  })
+  test('filters out unused markDefs', () => {
+    const keyGenerator = createTestKeyGenerator()
+    const linkAKey = keyGenerator()
+    const linkBKey = keyGenerator()
+    const block0Key = keyGenerator()
+    const bazKey = keyGenerator()
+    const block4Key = keyGenerator()
+    const oneMoreLineKey = keyGenerator()
+    const value = [
+      {
+        _type: 'block',
+        _key: block0Key,
+        children: [
+          {
+            _type: 'span',
+            _key: keyGenerator(),
+            text: 'foo ',
+            marks: [],
+          },
+          {
+            _type: 'span',
+            _key: keyGenerator(),
+            text: 'bar',
+            marks: [linkAKey],
+          },
+          {
+            _type: 'span',
+            _key: bazKey,
+            text: ' baz',
+            marks: [],
+          },
+        ],
+        markDefs: [
+          {
+            _type: 'link',
+            _key: linkAKey,
+            href: 'https://example.com',
+          },
+        ],
+        style: 'normal',
+      },
+      {
+        _key: keyGenerator(),
+        _type: 'image',
+      },
+      {
+        _key: keyGenerator(),
+        _type: 'block',
+        children: [
+          {
+            _type: 'span',
+            _key: keyGenerator(),
+            text: 'fizz',
+            marks: ['strong'],
+          },
+          {
+            _type: 'span',
+            _key: keyGenerator(),
+            text: ' buzz',
+            marks: [linkBKey],
+          },
+        ],
+        markDefs: [
+          {
+            _type: 'link',
+            _key: linkBKey,
+            href: 'https://example.com',
+          },
+        ],
+        style: 'normal',
+      },
+      {
+        _key: keyGenerator(),
+        _type: 'break',
+      },
+      {
+        _key: block4Key,
+        _type: 'block',
+        children: [
+          {
+            _type: 'span',
+            _key: oneMoreLineKey,
+            text: 'one more line',
+          },
+        ],
+        style: 'normal',
+        markDefs: [],
+      },
+    ]
+    const snapshot = createTestSnapshot({
+      context: {
+        value,
+        keyGenerator,
+        schema: compileSchema(
+          defineSchema({
+            annotations: [
+              {name: 'link', fields: [{name: 'href', type: 'string'}]},
+            ],
+            decorators: [{name: 'strong'}],
+          }),
+        ),
+        selection: {
+          anchor: {
+            path: [{_key: block0Key}, 'children', {_key: bazKey}],
+            offset: 0,
+          },
+          focus: {
+            path: [{_key: block4Key}, 'children', {_key: oneMoreLineKey}],
+            offset: 3,
+          },
+        },
+      },
+    })
+    expect(getSelectedValue(snapshot)).toEqual([
+      {
+        ...value[0],
+        children: [
+          {
+            _type: 'span',
+            _key: bazKey,
+            text: ' baz',
+            marks: [],
+          },
+        ],
+        markDefs: [],
+      },
+      value[1],
+      value[2],
+      value[3],
+      {
+        ...value[4],
+        children: [
+          {
+            _type: 'span',
+            _key: oneMoreLineKey,
+            text: 'one',
+            marks: [],
+          },
+        ],
+      },
+    ])
+  })
+})