@portabletext/editor 3.3.2 → 3.3.4

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

@@ -1,87 +0,0 @@
-import {htmlToBlocks} from '@portabletext/block-tools'
-import {toHTML} from '@portabletext/to-html'
-import type {PortableTextBlock} from '@sanity/types'
-import {getSelectedValue} from '../selectors/selector.get-selected-value'
-import type {PortableTextMemberSchemaTypes} from '../types/editor'
-import {parseBlock} from '../utils/parse-blocks'
-import {defineConverter} from './converter.types'
-
-export function createConverterTextHtml(
-  legacySchema: PortableTextMemberSchemaTypes,
-) {
-  return defineConverter({
-    mimeType: 'text/html',
-    serialize: ({snapshot, event}) => {
-      const selection = snapshot.context.selection
-
-      if (!selection) {
-        return {
-          type: 'serialization.failure',
-          mimeType: 'text/html',
-          originEvent: event.originEvent,
-          reason: 'No selection',
-        }
-      }
-
-      const blocks = getSelectedValue(snapshot)
-
-      const html = toHTML(blocks, {
-        onMissingComponent: false,
-        components: {
-          unknownType: ({children}) =>
-            children !== undefined ? `${children}` : '',
-        },
-      })
-
-      if (html === '') {
-        return {
-          type: 'serialization.failure',
-          mimeType: 'text/html',
-          originEvent: event.originEvent,
-          reason: 'Serialized HTML is empty',
-        }
-      }
-
-      return {
-        type: 'serialization.success',
-        data: html,
-        mimeType: 'text/html',
-        originEvent: event.originEvent,
-      }
-    },
-    deserialize: ({snapshot, event}) => {
-      const blocks = htmlToBlocks(event.data, legacySchema.portableText, {
-        keyGenerator: snapshot.context.keyGenerator,
-        unstable_whitespaceOnPasteMode:
-          legacySchema.block.options.unstable_whitespaceOnPasteMode,
-      }) as Array<PortableTextBlock>
-
-      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) {
-        return {
-          type: 'deserialization.failure',
-          mimeType: 'text/html',
-          reason: 'No blocks deserialized',
-        }
-      }
-
-      return {
-        type: 'deserialization.success',
-        data: parsedBlocks,
-        mimeType: 'text/html',
-      }
-    },
-  })
-}

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

@@ -1,67 +0,0 @@
-import {
-  markdownToPortableText,
-  portableTextToMarkdown,
-} from '@portabletext/markdown'
-import {getSelectedValue} from '../selectors/selector.get-selected-value'
-import {parseBlock} from '../utils/parse-blocks'
-import {defineConverter} from './converter.types'
-
-export const converterTextMarkdown = defineConverter({
-  mimeType: 'text/markdown',
-  serialize: ({snapshot, event}) => {
-    const selection = snapshot.context.selection
-
-    if (!selection) {
-      return {
-        type: 'serialization.failure',
-        mimeType: 'text/markdown',
-        reason: 'No selection',
-        originEvent: event.originEvent,
-      }
-    }
-
-    const blocks = getSelectedValue(snapshot)
-
-    const markdown = portableTextToMarkdown(blocks)
-
-    return {
-      type: 'serialization.success',
-      data: markdown,
-      mimeType: 'text/markdown',
-      originEvent: event.originEvent,
-    }
-  },
-  deserialize: ({snapshot, event}) => {
-    const blocks = markdownToPortableText(event.data, {
-      keyGenerator: snapshot.context.keyGenerator,
-      schema: snapshot.context.schema,
-    })
-
-    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) {
-      return {
-        type: 'deserialization.failure',
-        mimeType: 'text/markdown',
-        reason: 'No blocks deserialized',
-      }
-    }
-
-    return {
-      type: 'deserialization.success',
-      data: parsedBlocks,
-      mimeType: 'text/markdown',
-    }
-  },
-})

package/src/converters/converter.text-plain.test.ts

@@ -1,245 +0,0 @@
-import {compileSchemaDefinitionToPortableTextMemberSchemaTypes} from '@portabletext/sanity-bridge'
-import {
-  compileSchema,
-  defineSchema,
-  type SchemaDefinition,
-} from '@portabletext/schema'
-import type {PortableTextBlock, PortableTextTextBlock} from '@sanity/types'
-import {expect, test} from 'vitest'
-import {createTestSnapshot} from '../internal-utils/create-test-snapshot'
-import type {EditorSelection} from '../types/editor'
-import {createConverterTextPlain} from './converter.text-plain'
-
-const b1: PortableTextTextBlock = {
-  _type: 'block',
-  _key: 'b1',
-  children: [
-    {
-      _type: 'span',
-      _key: 'b1c1',
-      text: 'foo',
-    },
-    {
-      _type: 'span',
-      _key: 'b1c2',
-      text: 'bar',
-    },
-  ],
-}
-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',
-    },
-  ],
-}
-const b4: 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,
-  selection,
-}: {
-  schema: SchemaDefinition
-  selection: EditorSelection
-}) {
-  return createTestSnapshot({
-    context: {
-      converters: [],
-      schema: compileSchema(schema),
-      selection,
-      value: [b1, b2, b3, b4],
-    },
-  })
-}
-
-const converterTextPlain = createConverterTextPlain(
-  compileSchemaDefinitionToPortableTextMemberSchemaTypes(defineSchema({})),
-)
-
-test(converterTextPlain.serialize.name, () => {
-  expect(
-    converterTextPlain.serialize({
-      snapshot: createSnapshot({
-        schema: defineSchema({}),
-        selection: {
-          anchor: {
-            path: [{_key: b3._key}, 'children', {_key: b3.children[0]._key}],
-            offset: 0,
-          },
-          focus: {
-            path: [{_key: b4._key}, 'children', {_key: b4.children[0]._key}],
-            offset: 4,
-          },
-        },
-      }),
-      event: {
-        type: 'serialize',
-        originEvent: 'clipboard.copy',
-      },
-    }),
-  ).toMatchObject({
-    data: 'baz\n\nfizz',
-  })
-
-  expect(
-    converterTextPlain.serialize({
-      snapshot: createSnapshot({
-        schema: defineSchema({}),
-        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,
-          },
-        },
-      }),
-      event: {
-        type: 'serialize',
-        originEvent: 'clipboard.copy',
-      },
-    }),
-  ).toMatchObject({
-    data: 'foobar\n\nbaz',
-  })
-
-  expect(
-    converterTextPlain.serialize({
-      snapshot: createSnapshot({
-        schema: defineSchema({}),
-        selection: {
-          anchor: {
-            path: [{_key: b2._key}],
-            offset: 0,
-          },
-          focus: {
-            path: [{_key: b2._key}],
-            offset: 0,
-          },
-        },
-      }),
-      event: {
-        type: 'serialize',
-        originEvent: 'clipboard.copy',
-      },
-    }),
-  ).toMatchObject({
-    data: '',
-  })
-
-  expect(
-    converterTextPlain.serialize({
-      snapshot: createSnapshot({
-        schema: defineSchema({
-          blockObjects: [
-            {
-              name: 'image',
-            },
-          ],
-        }),
-        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,
-          },
-        },
-      }),
-      event: {
-        type: 'serialize',
-        originEvent: 'clipboard.copy',
-      },
-    }),
-  ).toMatchObject({
-    data: 'foobar\n\nbaz',
-  })
-
-  expect(
-    converterTextPlain.serialize({
-      snapshot: createSnapshot({
-        schema: defineSchema({}),
-        selection: {
-          anchor: {
-            path: [{_key: b4._key}, 'children', {_key: b4.children[0]._key}],
-            offset: 0,
-          },
-          focus: {
-            path: [{_key: b4._key}, 'children', {_key: b4.children[2]._key}],
-            offset: 4,
-          },
-        },
-      }),
-      event: {
-        type: 'serialize',
-        originEvent: 'clipboard.copy',
-      },
-    }),
-  ).toMatchObject({
-    data: 'fizzbuzz',
-  })
-
-  expect(
-    converterTextPlain.serialize({
-      snapshot: createSnapshot({
-        schema: defineSchema({
-          inlineObjects: [
-            {
-              name: 'stock-ticker',
-            },
-          ],
-        }),
-        selection: {
-          anchor: {
-            path: [{_key: b4._key}, 'children', {_key: b4.children[0]._key}],
-            offset: 0,
-          },
-          focus: {
-            path: [{_key: b4._key}, 'children', {_key: b4.children[2]._key}],
-            offset: 4,
-          },
-        },
-      }),
-      event: {
-        type: 'serialize',
-        originEvent: 'clipboard.copy',
-      },
-    }),
-  ).toMatchObject({
-    data: 'fizzbuzz',
-  })
-})

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

@@ -1,126 +0,0 @@
-import {htmlToBlocks} from '@portabletext/block-tools'
-import {isTextBlock} from '@portabletext/schema'
-import type {PortableTextBlock} from '@sanity/types'
-import {getSelectedValue} from '../selectors/selector.get-selected-value'
-import type {PortableTextMemberSchemaTypes} from '../types/editor'
-import {parseBlock} from '../utils/parse-blocks'
-import {defineConverter} from './converter.types'
-
-export function createConverterTextPlain(
-  legacySchema: PortableTextMemberSchemaTypes,
-) {
-  return defineConverter({
-    mimeType: 'text/plain',
-    serialize: ({snapshot, event}) => {
-      const selection = snapshot.context.selection
-
-      if (!selection) {
-        return {
-          type: 'serialization.failure',
-          mimeType: 'text/plain',
-          originEvent: event.originEvent,
-          reason: 'No selection',
-        }
-      }
-
-      const blocks = getSelectedValue(snapshot)
-
-      const data = blocks
-        .map((block) => {
-          if (isTextBlock(snapshot.context, block)) {
-            return block.children
-              .map((child) => {
-                if (child._type === snapshot.context.schema.span.name) {
-                  return child.text
-                }
-
-                return event.originEvent === 'drag.dragstart'
-                  ? `[${
-                      snapshot.context.schema.inlineObjects.find(
-                        (inlineObjectType) =>
-                          inlineObjectType.name === child._type,
-                      )?.title ?? 'Object'
-                    }]`
-                  : ''
-              })
-              .join('')
-          }
-
-          return event.originEvent === 'drag.dragstart'
-            ? `[${
-                snapshot.context.schema.blockObjects.find(
-                  (blockObjectType) => blockObjectType.name === block._type,
-                )?.title ?? 'Object'
-              }]`
-            : ''
-        })
-        .filter((block) => block !== '')
-        .join('\n\n')
-
-      return {
-        type: 'serialization.success',
-        data,
-        mimeType: 'text/plain',
-        originEvent: event.originEvent,
-      }
-    },
-    deserialize: ({snapshot, event}) => {
-      const html = escapeHtml(event.data)
-        .split(/\n{2,}/)
-        .map((line) =>
-          line
-            ? `<p>${line.replace(/(?:\r\n|\r|\n)/g, '<br/>')}</p>`
-            : '<p></p>',
-        )
-        .join('')
-
-      const textToHtml = `<html><body>${html}</body></html>`
-
-      const blocks = htmlToBlocks(textToHtml, legacySchema.portableText, {
-        keyGenerator: snapshot.context.keyGenerator,
-      }) as Array<PortableTextBlock>
-
-      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) {
-        return {
-          type: 'deserialization.failure',
-          mimeType: 'text/plain',
-          reason: 'No blocks deserialized',
-        }
-      }
-
-      return {
-        type: 'deserialization.success',
-        data: parsedBlocks,
-        mimeType: 'text/plain',
-      }
-    },
-  })
-}
-
-const entityMap: Record<string, string> = {
-  '&': '&amp;',
-  '<': '&lt;',
-  '>': '&gt;',
-  '"': '&quot;',
-  "'": '&#39;',
-  '/': '&#x2F;',
-  '`': '&#x60;',
-  '=': '&#x3D;',
-}
-
-function escapeHtml(str: string) {
-  return String(str).replace(/[&<>"'`=/]/g, (s: string) => entityMap[s])
-}

package/src/converters/converter.types.ts

@@ -1,72 +0,0 @@
-import type {PortableTextBlock} from '@sanity/types'
-import type {EditorSnapshot} from '../editor/editor-snapshot'
-import type {MIMEType} from '../internal-utils/mime-type'
-import type {PickFromUnion} from '../type-utils'
-
-export type Converter<TMIMEType extends MIMEType = MIMEType> = {
-  mimeType: TMIMEType
-  serialize: Serializer<TMIMEType>
-  deserialize: Deserializer<TMIMEType>
-}
-
-export function defineConverter<TMIMEType extends MIMEType>(
-  converter: Converter<TMIMEType>,
-): Converter<TMIMEType> {
-  return converter
-}
-
-export type ConverterEvent<TMIMEType extends MIMEType = MIMEType> =
-  | {
-      type: 'serialize'
-      originEvent: 'clipboard.copy' | 'clipboard.cut' | 'drag.dragstart'
-    }
-  | {
-      type: 'serialization.failure'
-      mimeType: TMIMEType
-      originEvent: 'clipboard.copy' | 'clipboard.cut' | 'drag.dragstart'
-      reason: string
-    }
-  | {
-      type: 'serialization.success'
-      data: string
-      mimeType: TMIMEType
-      originEvent: 'clipboard.copy' | 'clipboard.cut' | 'drag.dragstart'
-    }
-  | {
-      type: 'deserialize'
-      data: string
-    }
-  | {
-      type: 'deserialization.failure'
-      mimeType: TMIMEType
-      reason: string
-    }
-  | {
-      type: 'deserialization.success'
-      data: Array<PortableTextBlock>
-      mimeType: TMIMEType
-    }
-
-export type Serializer<TMIMEType extends MIMEType> = ({
-  snapshot,
-  event,
-}: {
-  snapshot: EditorSnapshot
-  event: PickFromUnion<ConverterEvent<TMIMEType>, 'type', 'serialize'>
-}) => PickFromUnion<
-  ConverterEvent<TMIMEType>,
-  'type',
-  'serialization.success' | 'serialization.failure'
->
-
-export type Deserializer<TMIMEType extends MIMEType> = ({
-  snapshot,
-  event,
-}: {
-  snapshot: EditorSnapshot
-  event: PickFromUnion<ConverterEvent<TMIMEType>, 'type', 'deserialize'>
-}) => PickFromUnion<
-  ConverterEvent<TMIMEType>,
-  'type',
-  'deserialization.success' | 'deserialization.failure'
->

package/src/converters/converters.core.ts

@@ -1,18 +0,0 @@
-import type {PortableTextMemberSchemaTypes} from '../types/editor'
-import {converterJson} from './converter.json'
-import {converterPortableText} from './converter.portable-text'
-import {createConverterTextHtml} from './converter.text-html'
-import {converterTextMarkdown} from './converter.text-markdown'
-import {createConverterTextPlain} from './converter.text-plain'
-
-export function createCoreConverters(
-  legacySchema: PortableTextMemberSchemaTypes,
-) {
-  return [
-    converterJson,
-    converterPortableText,
-    converterTextMarkdown,
-    createConverterTextHtml(legacySchema),
-    createConverterTextPlain(legacySchema),
-  ]
-}