@portabletext/editor 3.3.3 → 3.3.4

package/src/converters/converter.portable-text.ts

@@ -1,75 +0,0 @@
-import {getSelectedValue} from '../selectors/selector.get-selected-value'
-import {parseBlock} from '../utils/parse-blocks'
-import {defineConverter} from './converter.types'
-
-export const converterPortableText = defineConverter({
-  mimeType: 'application/x-portable-text',
-  serialize: ({snapshot, event}) => {
-    const selection = snapshot.context.selection
-
-    if (!selection) {
-      return {
-        type: 'serialization.failure',
-        mimeType: 'application/x-portable-text',
-        originEvent: event.originEvent,
-        reason: 'No selection',
-      }
-    }
-
-    const blocks = getSelectedValue(snapshot)
-
-    if (blocks.length === 0) {
-      return {
-        type: 'serialization.failure',
-        mimeType: 'application/x-portable-text',
-        reason: 'No blocks serialized',
-        originEvent: event.originEvent,
-      }
-    }
-
-    return {
-      type: 'serialization.success',
-      data: JSON.stringify(blocks),
-      mimeType: 'application/x-portable-text',
-      originEvent: event.originEvent,
-    }
-  },
-  deserialize: ({snapshot, event}) => {
-    const blocks = JSON.parse(event.data)
-
-    if (!Array.isArray(blocks)) {
-      return {
-        type: 'deserialization.failure',
-        mimeType: 'application/x-portable-text',
-        reason: 'Data is not an array',
-      }
-    }
-
-    const parsedBlocks = blocks.flatMap((block) => {
-      const parsedBlock = parseBlock({
-        context: snapshot.context,
-        block,
-        options: {
-          normalize: false,
-          removeUnusedMarkDefs: true,
-          validateFields: false,
-        },
-      })
-      return parsedBlock ? [parsedBlock] : []
-    })
-
-    if (parsedBlocks.length === 0 && blocks.length > 0) {
-      return {
-        type: 'deserialization.failure',
-        mimeType: 'application/x-portable-text',
-        reason: 'No blocks were parsed',
-      }
-    }
-
-    return {
-      type: 'deserialization.success',
-      data: parsedBlocks,
-      mimeType: 'application/x-portable-text',
-    }
-  },
-})

package/src/converters/converter.text-html.deserialize.test.ts

@@ -1,406 +0,0 @@
-import {compileSchemaDefinitionToPortableTextMemberSchemaTypes} from '@portabletext/sanity-bridge'
-import {
-  compileSchema,
-  defineSchema,
-  type SchemaDefinition,
-} from '@portabletext/schema'
-import {describe, expect, test} from 'vitest'
-import {createTestSnapshot} from '../internal-utils/create-test-snapshot'
-import {createConverterTextHtml} from './converter.text-html'
-
-function createSnapshot(schema: SchemaDefinition) {
-  return createTestSnapshot({
-    context: {
-      converters: [],
-      schema: compileSchema(schema),
-    },
-  })
-}
-
-const decoratedParagraph =
-  '<p><em>foo <code><strong>bar</strong> baz</code></em></p>'
-const image = '<img src="https://exampe.com/image.jpg" alt="Example image">'
-const paragraphWithLink = '<p>fizz <a href="https://example.com">buzz</a></p>'
-const unorderedList = '<ul><li>foo</li><li>bar</li></ul>'
-const orderedList = '<ol><li>foo</li><li>bar</li></ol>'
-const nestedList = '<ol><li>foo<ul><li>bar</li></ul></li></ol>'
-
-describe(createConverterTextHtml.name, () => {
-  test('paragraph with unknown decorators', () => {
-    const converterTextHtml = createConverterTextHtml(
-      compileSchemaDefinitionToPortableTextMemberSchemaTypes(defineSchema({})),
-    )
-
-    expect(
-      converterTextHtml.deserialize({
-        snapshot: createSnapshot(defineSchema({})),
-        event: {
-          type: 'deserialize',
-          data: decoratedParagraph,
-        },
-      }),
-    ).toMatchObject({
-      data: [
-        {
-          _key: 'k0',
-          _type: 'block',
-          children: [
-            {
-              _key: 'k1',
-              _type: 'span',
-              marks: [],
-              text: 'foo bar baz',
-            },
-          ],
-          markDefs: [],
-          style: 'normal',
-        },
-      ],
-    })
-  })
-
-  test('paragraph with known decorators', () => {
-    const converterTextHtml = createConverterTextHtml(
-      compileSchemaDefinitionToPortableTextMemberSchemaTypes(
-        defineSchema({
-          decorators: [{name: 'strong'}, {name: 'em'}, {name: 'code'}],
-        }),
-      ),
-    )
-
-    expect(
-      converterTextHtml.deserialize({
-        snapshot: createSnapshot(
-          defineSchema({
-            decorators: [{name: 'strong'}, {name: 'em'}, {name: 'code'}],
-          }),
-        ),
-        event: {
-          type: 'deserialize',
-          data: decoratedParagraph,
-        },
-      }),
-    ).toMatchObject({
-      data: [
-        {
-          _key: 'k0',
-          _type: 'block',
-          children: [
-            {
-              _key: 'k1',
-              _type: 'span',
-              marks: ['em'],
-              text: 'foo ',
-            },
-            {
-              _key: 'k2',
-              _type: 'span',
-              marks: ['em', 'code', 'strong'],
-              text: 'bar',
-            },
-            {
-              _key: 'k3',
-              _type: 'span',
-              marks: ['em', 'code'],
-              text: ' baz',
-            },
-          ],
-          markDefs: [],
-          style: 'normal',
-        },
-      ],
-    })
-  })
-
-  test('image', () => {
-    const converterTextHtml = createConverterTextHtml(
-      compileSchemaDefinitionToPortableTextMemberSchemaTypes(
-        defineSchema({
-          blockObjects: [{name: 'image'}],
-        }),
-      ),
-    )
-    expect(
-      converterTextHtml.deserialize({
-        snapshot: createSnapshot(
-          defineSchema({
-            blockObjects: [{name: 'image'}],
-          }),
-        ),
-        event: {
-          type: 'deserialize',
-          data: image,
-        },
-      }),
-    ).toMatchObject({
-      type: 'deserialization.failure',
-    })
-  })
-
-  test('paragraph with unknown link', () => {
-    const converterTextHtml = createConverterTextHtml(
-      compileSchemaDefinitionToPortableTextMemberSchemaTypes(defineSchema({})),
-    )
-
-    expect(
-      converterTextHtml.deserialize({
-        snapshot: createSnapshot(defineSchema({})),
-        event: {
-          type: 'deserialize',
-          data: paragraphWithLink,
-        },
-      }),
-    ).toMatchObject({
-      data: [
-        {
-          _key: 'k0',
-          _type: 'block',
-          children: [
-            {
-              _key: 'k1',
-              _type: 'span',
-              marks: [],
-              text: 'fizz buzz (https://example.com)',
-            },
-          ],
-          markDefs: [],
-          style: 'normal',
-        },
-      ],
-    })
-  })
-
-  test('paragraph with known link', () => {
-    const converterTextHtml = createConverterTextHtml(
-      compileSchemaDefinitionToPortableTextMemberSchemaTypes(
-        defineSchema({
-          annotations: [
-            {name: 'link', fields: [{name: 'href', type: 'string'}]},
-          ],
-        }),
-      ),
-    )
-
-    expect(
-      converterTextHtml.deserialize({
-        snapshot: createSnapshot(
-          defineSchema({
-            annotations: [
-              {name: 'link', fields: [{name: 'href', type: 'string'}]},
-            ],
-          }),
-        ),
-        event: {
-          type: 'deserialize',
-          data: paragraphWithLink,
-        },
-      }),
-    ).toMatchObject({
-      data: [
-        {
-          _key: 'k1',
-          _type: 'block',
-          children: [
-            {
-              _key: 'k2',
-              _type: 'span',
-              marks: [],
-              text: 'fizz ',
-            },
-            {
-              _key: 'k3',
-              _type: 'span',
-              marks: ['k0'],
-              text: 'buzz',
-            },
-          ],
-          markDefs: [
-            {
-              _key: 'k0',
-              _type: 'link',
-              href: 'https://example.com',
-            },
-          ],
-          style: 'normal',
-        },
-      ],
-    })
-  })
-
-  test('unordered list', () => {
-    const converterTextHtml = createConverterTextHtml(
-      compileSchemaDefinitionToPortableTextMemberSchemaTypes(
-        defineSchema({
-          lists: [{name: 'bullet'}],
-        }),
-      ),
-    )
-
-    expect(
-      converterTextHtml.deserialize({
-        snapshot: createSnapshot(
-          defineSchema({
-            lists: [{name: 'bullet'}],
-          }),
-        ),
-        event: {
-          type: 'deserialize',
-          data: unorderedList,
-        },
-      }),
-    ).toMatchObject({
-      data: [
-        {
-          _key: 'k0',
-          _type: 'block',
-          children: [
-            {
-              _key: 'k1',
-              _type: 'span',
-              marks: [],
-              text: 'foo',
-            },
-          ],
-          level: 1,
-          listItem: 'bullet',
-          markDefs: [],
-          style: 'normal',
-        },
-        {
-          _key: 'k2',
-          _type: 'block',
-          children: [
-            {
-              _key: 'k3',
-              _type: 'span',
-              marks: [],
-              text: 'bar',
-            },
-          ],
-          level: 1,
-          listItem: 'bullet',
-          markDefs: [],
-          style: 'normal',
-        },
-      ],
-    })
-  })
-
-  test('ordered list', () => {
-    const converterTextHtml = createConverterTextHtml(
-      compileSchemaDefinitionToPortableTextMemberSchemaTypes(
-        defineSchema({
-          lists: [{name: 'number'}],
-        }),
-      ),
-    )
-
-    expect(
-      converterTextHtml.deserialize({
-        snapshot: createSnapshot(
-          defineSchema({
-            lists: [{name: 'number'}],
-          }),
-        ),
-        event: {
-          type: 'deserialize',
-          data: orderedList,
-        },
-      }),
-    ).toMatchObject({
-      data: [
-        {
-          _key: 'k0',
-          _type: 'block',
-          children: [
-            {
-              _key: 'k1',
-              _type: 'span',
-              marks: [],
-              text: 'foo',
-            },
-          ],
-          level: 1,
-          listItem: 'number',
-          markDefs: [],
-          style: 'normal',
-        },
-        {
-          _key: 'k2',
-          _type: 'block',
-          children: [
-            {
-              _key: 'k3',
-              _type: 'span',
-              marks: [],
-              text: 'bar',
-            },
-          ],
-          level: 1,
-          listItem: 'number',
-          markDefs: [],
-          style: 'normal',
-        },
-      ],
-    })
-  })
-
-  test('nested list', () => {
-    const converterTextHtml = createConverterTextHtml(
-      compileSchemaDefinitionToPortableTextMemberSchemaTypes(
-        defineSchema({
-          lists: [{name: 'bullet'}, {name: 'number'}],
-        }),
-      ),
-    )
-
-    expect(
-      converterTextHtml.deserialize({
-        snapshot: createSnapshot(
-          defineSchema({
-            lists: [{name: 'bullet'}, {name: 'number'}],
-          }),
-        ),
-        event: {
-          type: 'deserialize',
-          data: nestedList,
-        },
-      }),
-    ).toMatchObject({
-      data: [
-        {
-          _key: 'k0',
-          _type: 'block',
-          children: [
-            {
-              _key: 'k1',
-              _type: 'span',
-              marks: [],
-              text: 'foo',
-            },
-          ],
-          level: 1,
-          listItem: 'number',
-          markDefs: [],
-          style: 'normal',
-        },
-        {
-          _key: 'k2',
-          _type: 'block',
-          children: [
-            {
-              _key: 'k3',
-              _type: 'span',
-              marks: [],
-              text: 'bar',
-            },
-          ],
-          level: 2,
-          listItem: 'bullet',
-          markDefs: [],
-          style: 'normal',
-        },
-      ],
-    })
-  })
-})

package/src/converters/converter.text-html.serialize.test.ts

@@ -1,246 +0,0 @@
-import {compileSchemaDefinitionToPortableTextMemberSchemaTypes} from '@portabletext/sanity-bridge'
-import {
-  compileSchema,
-  defineSchema,
-  type SchemaDefinition,
-} from '@portabletext/schema'
-import type {PortableTextBlock, PortableTextTextBlock} from '@sanity/types'
-import {describe, expect, test} from 'vitest'
-import {createTestSnapshot} from '../internal-utils/create-test-snapshot'
-import type {EditorSelection} from '../types/editor'
-import {createConverterTextHtml} from './converter.text-html'
-
-const decoratedParagraph: PortableTextTextBlock = {
-  _key: 'k0',
-  _type: 'block',
-  children: [
-    {
-      _key: 'k1',
-      _type: 'span',
-      marks: ['em'],
-      text: 'foo ',
-    },
-    {
-      _key: 'k2',
-      _type: 'span',
-      marks: ['em', 'code', 'strong'],
-      text: 'bar',
-    },
-    {
-      _key: 'k3',
-      _type: 'span',
-      marks: ['em', 'code'],
-      text: ' baz',
-    },
-  ],
-  markDefs: [],
-  style: 'normal',
-}
-const image: PortableTextBlock = {
-  _type: 'image',
-  _key: 'b2',
-  src: 'https://example.com/image.jpg',
-  alt: 'Example',
-}
-const b2: PortableTextTextBlock = {
-  _type: 'block',
-  _key: 'b3',
-  children: [
-    {
-      _type: 'span',
-      _key: 'b3c1',
-      text: 'baz',
-    },
-  ],
-}
-const paragraphWithInlineBlock: PortableTextTextBlock = {
-  _type: 'block',
-  _key: 'b4',
-  children: [
-    {
-      _type: 'span',
-      _key: 'b4c1',
-      text: 'fizz ',
-    },
-    {
-      _type: 'stock-ticker',
-      _key: 'b4c2',
-      symbol: 'AAPL',
-    },
-    {
-      _type: 'span',
-      _key: 'b4c3',
-      text: ' buzz',
-    },
-  ],
-}
-
-function createSnapshot(schema: SchemaDefinition, selection: EditorSelection) {
-  return createTestSnapshot({
-    context: {
-      converters: [],
-      schema: compileSchema(schema),
-      selection,
-      value: [decoratedParagraph, image, b2, paragraphWithInlineBlock],
-    },
-  })
-}
-
-const converterTextHtml = createConverterTextHtml(
-  compileSchemaDefinitionToPortableTextMemberSchemaTypes(defineSchema({})),
-)
-
-describe(converterTextHtml.serialize.name, () => {
-  test('paragraph with decorators', () => {
-    expect(
-      converterTextHtml.serialize({
-        snapshot: createSnapshot(
-          defineSchema({
-            decorators: [{name: 'em'}, {name: 'code'}, {name: 'strong'}],
-          }),
-          {
-            anchor: {
-              path: [
-                {_key: decoratedParagraph._key},
-                'children',
-                {_key: decoratedParagraph.children[0]._key},
-              ],
-              offset: 0,
-            },
-            focus: {
-              path: [
-                {_key: decoratedParagraph._key},
-                'children',
-                {_key: decoratedParagraph.children[2]._key},
-              ],
-              offset: 4,
-            },
-          },
-        ),
-        event: {
-          type: 'serialize',
-          originEvent: 'clipboard.copy',
-        },
-      }),
-    ).toMatchObject({
-      data: '<p><em>foo <code><strong>bar</strong> baz</code></em></p>',
-    })
-  })
-
-  test('image', () => {
-    expect(
-      converterTextHtml.serialize({
-        snapshot: createSnapshot(defineSchema({}), {
-          anchor: {
-            path: [{_key: image._key}],
-            offset: 0,
-          },
-          focus: {
-            path: [{_key: image._key}],
-            offset: 0,
-          },
-        }),
-        event: {
-          type: 'serialize',
-          originEvent: 'clipboard.copy',
-        },
-      }),
-    ).toMatchObject({
-      type: 'serialization.failure',
-    })
-  })
-
-  test('inline object', () => {
-    expect(
-      converterTextHtml.serialize({
-        snapshot: createSnapshot(defineSchema({}), {
-          anchor: {
-            path: [
-              {_key: paragraphWithInlineBlock._key},
-              'children',
-              {_key: paragraphWithInlineBlock.children[0]._key},
-            ],
-            offset: 0,
-          },
-          focus: {
-            path: [
-              {_key: paragraphWithInlineBlock._key},
-              'children',
-              {_key: paragraphWithInlineBlock.children[2]._key},
-            ],
-            offset: 4,
-          },
-        }),
-        event: {
-          type: 'serialize',
-          originEvent: 'clipboard.copy',
-        },
-      }),
-    ).toMatchObject({
-      data: '<p>fizz  buz</p>',
-    })
-  })
-
-  test('lists', () => {
-    expect(
-      converterTextHtml.serialize({
-        snapshot: createTestSnapshot({
-          context: {
-            schema: compileSchema(
-              defineSchema({
-                lists: [{name: 'bullet'}, {name: 'number'}],
-              }),
-            ),
-            converters: [],
-            value: [
-              {
-                _key: 'k0',
-                _type: 'block',
-                children: [
-                  {
-                    _key: 'k1',
-                    _type: 'span',
-                    marks: [],
-                    text: 'foo',
-                  },
-                ],
-                level: 1,
-                listItem: 'number',
-              },
-              {
-                _key: 'k2',
-                _type: 'block',
-                children: [
-                  {
-                    _key: 'k3',
-                    _type: 'span',
-                    marks: [],
-                    text: 'bar',
-                  },
-                ],
-                level: 2,
-                listItem: 'bullet',
-              },
-            ],
-            selection: {
-              anchor: {
-                path: [{_key: 'k0'}, 'children', {_key: 'k1'}],
-                offset: 0,
-              },
-              focus: {
-                path: [{_key: 'k2'}, 'children', {_key: 'k3'}],
-                offset: 3,
-              },
-            },
-          },
-        }),
-        event: {
-          type: 'serialize',
-          originEvent: 'clipboard.copy',
-        },
-      }),
-    ).toMatchObject({
-      data: '<ol><li>foo<ul><li>bar</li></ul></li></ol>',
-    })
-  })
-})