@portabletext/editor 1.23.0 → 1.25.0

package/src/behaviors/behavior.core.annotations.ts

@@ -0,0 +1,29 @@
+import * as selectors from '../selectors'
+import {defineBehavior, raise} from './behavior.types'
+
+const toggleAnnotationOff = defineBehavior({
+  on: 'annotation.toggle',
+  guard: ({context, event}) =>
+    selectors.isActiveAnnotation(event.annotation.name)({context}),
+  actions: [
+    ({event}) => [
+      raise({type: 'annotation.remove', annotation: event.annotation}),
+    ],
+  ],
+})
+
+const toggleAnnotationOn = defineBehavior({
+  on: 'annotation.toggle',
+  guard: ({context, event}) =>
+    !selectors.isActiveAnnotation(event.annotation.name)({context}),
+  actions: [
+    ({event}) => [
+      raise({type: 'annotation.add', annotation: event.annotation}),
+    ],
+  ],
+})
+
+export const coreAnnotationBehaviors = {
+  toggleAnnotationOff,
+  toggleAnnotationOn,
+}

package/src/behaviors/behavior.core.block-objects.ts

@@ -2,7 +2,7 @@ import {isPortableTextTextBlock} from '@sanity/types'
 import {isHotkey} from '../internal-utils/is-hotkey'
 import * as selectors from '../selectors'
 import {isEmptyTextBlock} from '../utils/util.is-empty-text-block'
-import {defineBehavior} from './behavior.types'
+import {defineBehavior, raise} from './behavior.types'
 
 const arrowDownOnLonelyBlockObject = defineBehavior({
   on: 'key.down',
@@ -13,7 +13,7 @@ const arrowDownOnLonelyBlockObject = defineBehavior({
 
     return isArrowDown && focusBlockObject && !nextBlock
   },
-  actions: [() => [{type: 'insert.text block', placement: 'after'}]],
+  actions: [() => [raise({type: 'insert.text block', placement: 'after'})]],
 })
 
 const arrowUpOnLonelyBlockObject = defineBehavior({
@@ -27,8 +27,8 @@ const arrowUpOnLonelyBlockObject = defineBehavior({
   },
   actions: [
     () => [
-      {type: 'insert.text block', placement: 'before'},
-      {type: 'select.previous block'},
+      raise({type: 'insert.text block', placement: 'before'}),
+      raise({type: 'select.previous block'}),
     ],
   ],
 })
@@ -41,7 +41,7 @@ const breakingBlockObject = defineBehavior({
 
     return collapsedSelection && focusBlockObject !== undefined
   },
-  actions: [() => [{type: 'insert.text block', placement: 'after'}]],
+  actions: [() => [raise({type: 'insert.text block', placement: 'after'})]],
 })
 
 const deletingEmptyTextBlockAfterBlockObject = defineBehavior({
@@ -66,17 +66,17 @@ const deletingEmptyTextBlockAfterBlockObject = defineBehavior({
   },
   actions: [
     (_, {focusTextBlock, previousBlock}) => [
-      {
+      raise({
         type: 'delete.block',
         blockPath: focusTextBlock.path,
-      },
-      {
+      }),
+      raise({
         type: 'select',
         selection: {
           anchor: {path: previousBlock.path, offset: 0},
           focus: {path: previousBlock.path, offset: 0},
         },
-      },
+      }),
     ],
   ],
 })
@@ -103,17 +103,17 @@ const deletingEmptyTextBlockBeforeBlockObject = defineBehavior({
   },
   actions: [
     (_, {focusTextBlock, nextBlock}) => [
-      {
+      raise({
         type: 'delete.block',
         blockPath: focusTextBlock.path,
-      },
-      {
+      }),
+      raise({
         type: 'select',
         selection: {
           anchor: {path: nextBlock.path, offset: 0},
           focus: {path: nextBlock.path, offset: 0},
         },
-      },
+      }),
     ],
   ],
 })

package/src/behaviors/behavior.core.decorators.ts

@@ -1,7 +1,26 @@
 import {isHotkey} from '../internal-utils/is-hotkey'
+import * as selectors from '../selectors'
 import {defineBehavior, raise} from './behavior.types'
 
 export const coreDecoratorBehaviors = {
+  toggleDecoratorOff: defineBehavior({
+    on: 'decorator.toggle',
+    guard: ({context, event}) =>
+      selectors.isActiveDecorator(event.decorator)({context}),
+    actions: [
+      ({event}) => [
+        raise({type: 'decorator.remove', decorator: event.decorator}),
+      ],
+    ],
+  }),
+  toggleDecoratorOn: defineBehavior({
+    on: 'decorator.toggle',
+    guard: ({context, event}) =>
+      !selectors.isActiveDecorator(event.decorator)({context}),
+    actions: [
+      ({event}) => [raise({type: 'decorator.add', decorator: event.decorator})],
+    ],
+  }),
   strongShortcut: defineBehavior({
     on: 'key.down',
     guard: ({context, event}) =>

package/src/behaviors/behavior.core.deserialize.ts

@@ -0,0 +1,46 @@
+import {defineBehavior, raise} from './behavior.types'
+
+export const coreDeserializeBehavior = defineBehavior({
+  on: 'deserialize',
+  guard: ({context, event}) => {
+    const deserializeEvents = context.converters.flatMap((converter) => {
+      const data = event.dataTransfer.getData(converter.mimeType)
+
+      if (!data) {
+        return []
+      }
+
+      return [
+        converter.deserialize({context, event: {type: 'deserialize', data}}),
+      ]
+    })
+
+    const firstSuccess = deserializeEvents.find(
+      (deserializeEvent) => deserializeEvent.type === 'deserialization.success',
+    )
+
+    if (!firstSuccess) {
+      return {
+        type: 'deserialization.failure',
+        mimeType: '*/*',
+        reason: deserializeEvents
+          .map((deserializeEvent) =>
+            deserializeEvent.type === 'deserialization.failure'
+              ? deserializeEvent.reason
+              : '',
+          )
+          .join(', '),
+      } as const
+    }
+
+    return firstSuccess
+  },
+  actions: [
+    ({event}, deserializeEvent) => [
+      raise({
+        ...deserializeEvent,
+        dataTransfer: event.dataTransfer,
+      }),
+    ],
+  ],
+})

package/src/behaviors/behavior.core.lists.ts

@@ -2,10 +2,38 @@ import {createGuards} from '../behavior-actions/behavior.guards'
 import {isHotkey} from '../internal-utils/is-hotkey'
 import * as selectors from '../selectors'
 import {isEmptyTextBlock} from '../utils/util.is-empty-text-block'
-import {defineBehavior} from './behavior.types'
+import {defineBehavior, raise} from './behavior.types'
 
 const MAX_LIST_LEVEL = 10
 
+const toggleListItemOff = defineBehavior({
+  on: 'list item.toggle',
+  guard: ({context, event}) =>
+    selectors.isActiveListItem(event.listItem)({context}),
+  actions: [
+    ({event}) => [
+      raise({
+        type: 'list item.remove',
+        listItem: event.listItem,
+      }),
+    ],
+  ],
+})
+
+const toggleListItemOn = defineBehavior({
+  on: 'list item.toggle',
+  guard: ({context, event}) =>
+    !selectors.isActiveListItem(event.listItem)({context}),
+  actions: [
+    ({event}) => [
+      raise({
+        type: 'list item.add',
+        listItem: event.listItem,
+      }),
+    ],
+  ],
+})
+
 const clearListOnBackspace = defineBehavior({
   on: 'delete.backward',
   guard: ({context}) => {
@@ -29,11 +57,11 @@ const clearListOnBackspace = defineBehavior({
   },
   actions: [
     (_, {focusTextBlock}) => [
-      {
+      raise({
         type: 'text block.unset',
         props: ['listItem', 'level'],
         at: focusTextBlock.path,
-      },
+      }),
     ],
   ],
 })
@@ -65,11 +93,11 @@ const unindentListOnBackspace = defineBehavior({
   },
   actions: [
     (_, {focusTextBlock, level}) => [
-      {
+      raise({
         type: 'text block.set',
         level,
         at: focusTextBlock.path,
-      },
+      }),
     ],
   ],
 })
@@ -92,11 +120,11 @@ const clearListOnEnter = defineBehavior({
   },
   actions: [
     (_, {focusListBlock}) => [
-      {
+      raise({
         type: 'text block.unset',
         props: ['listItem', 'level'],
         at: focusListBlock.path,
-      },
+      }),
     ],
   ],
 })
@@ -131,14 +159,16 @@ const indentListOnTab = defineBehavior({
   },
   actions: [
     (_, {selectedListBlocks}) =>
-      selectedListBlocks.map((selectedListBlock) => ({
-        type: 'text block.set',
-        level: Math.min(
-          MAX_LIST_LEVEL,
-          Math.max(1, selectedListBlock.node.level + 1),
-        ),
-        at: selectedListBlock.path,
-      })),
+      selectedListBlocks.map((selectedListBlock) =>
+        raise({
+          type: 'text block.set',
+          level: Math.min(
+            MAX_LIST_LEVEL,
+            Math.max(1, selectedListBlock.node.level + 1),
+          ),
+          at: selectedListBlock.path,
+        }),
+      ),
   ],
 })
 
@@ -172,18 +202,22 @@ const unindentListOnShiftTab = defineBehavior({
   },
   actions: [
     (_, {selectedListBlocks}) =>
-      selectedListBlocks.map((selectedListBlock) => ({
-        type: 'text block.set',
-        level: Math.min(
-          MAX_LIST_LEVEL,
-          Math.max(1, selectedListBlock.node.level - 1),
-        ),
-        at: selectedListBlock.path,
-      })),
+      selectedListBlocks.map((selectedListBlock) =>
+        raise({
+          type: 'text block.set',
+          level: Math.min(
+            MAX_LIST_LEVEL,
+            Math.max(1, selectedListBlock.node.level - 1),
+          ),
+          at: selectedListBlock.path,
+        }),
+      ),
   ],
 })
 
 export const coreListBehaviors = {
+  toggleListItemOff,
+  toggleListItemOn,
   clearListOnBackspace,
   unindentListOnBackspace,
   clearListOnEnter,

package/src/behaviors/behavior.core.serialize.ts

@@ -0,0 +1,44 @@
+import {defineBehavior, raise} from './behavior.types'
+
+export const coreSerializeBehaviors = {
+  'serialize': defineBehavior({
+    on: 'serialize',
+    guard: ({context, event}) => {
+      if (context.converters.length === 0) {
+        return false
+      }
+
+      const serializeEvents = context.converters.map((converter) =>
+        converter.serialize({context, event}),
+      )
+
+      if (serializeEvents.length === 0) {
+        return false
+      }
+
+      return serializeEvents
+    },
+    actions: [
+      ({event}, serializeEvents) =>
+        serializeEvents.map((serializeEvent) =>
+          raise({
+            ...serializeEvent,
+            dataTransfer: event.dataTransfer,
+          }),
+        ),
+    ],
+  }),
+  'serialization.success': defineBehavior({
+    on: 'serialization.success',
+    actions: [
+      ({event}) => [
+        raise({
+          type: 'data transfer.set',
+          data: event.data,
+          dataTransfer: event.dataTransfer,
+          mimeType: event.mimeType,
+        }),
+      ],
+    ],
+  }),
+}

package/src/behaviors/behavior.core.style.ts

@@ -0,0 +1,19 @@
+import * as selectors from '../selectors'
+import {defineBehavior, raise} from './behavior.types'
+
+const toggleStyleOff = defineBehavior({
+  on: 'style.toggle',
+  guard: ({context, event}) => selectors.isActiveStyle(event.style)({context}),
+  actions: [({event}) => [raise({type: 'style.remove', style: event.style})]],
+})
+
+const toggleStyleOn = defineBehavior({
+  on: 'style.toggle',
+  guard: ({context, event}) => !selectors.isActiveStyle(event.style)({context}),
+  actions: [({event}) => [raise({type: 'style.add', style: event.style})]],
+})
+
+export const coreStyleBehaviors = {
+  toggleStyleOff,
+  toggleStyleOn,
+}

package/src/behaviors/behavior.core.ts

@@ -1,6 +1,10 @@
+import {coreAnnotationBehaviors} from './behavior.core.annotations'
 import {coreBlockObjectBehaviors} from './behavior.core.block-objects'
 import {coreDecoratorBehaviors} from './behavior.core.decorators'
+import {coreDeserializeBehavior} from './behavior.core.deserialize'
 import {coreListBehaviors} from './behavior.core.lists'
+import {coreSerializeBehaviors} from './behavior.core.serialize'
+import {coreStyleBehaviors} from './behavior.core.style'
 import {defineBehavior} from './behavior.types'
 
 const softReturn = defineBehavior({
@@ -13,20 +17,31 @@ const softReturn = defineBehavior({
  */
 export const coreBehaviors = [
   softReturn,
+  coreAnnotationBehaviors.toggleAnnotationOff,
+  coreAnnotationBehaviors.toggleAnnotationOn,
+  coreDecoratorBehaviors.toggleDecoratorOff,
+  coreDecoratorBehaviors.toggleDecoratorOn,
   coreDecoratorBehaviors.strongShortcut,
   coreDecoratorBehaviors.emShortcut,
   coreDecoratorBehaviors.underlineShortcut,
   coreDecoratorBehaviors.codeShortcut,
+  coreDeserializeBehavior,
   coreBlockObjectBehaviors.arrowDownOnLonelyBlockObject,
   coreBlockObjectBehaviors.arrowUpOnLonelyBlockObject,
   coreBlockObjectBehaviors.breakingBlockObject,
   coreBlockObjectBehaviors.deletingEmptyTextBlockAfterBlockObject,
   coreBlockObjectBehaviors.deletingEmptyTextBlockBeforeBlockObject,
+  coreListBehaviors.toggleListItemOff,
+  coreListBehaviors.toggleListItemOn,
   coreListBehaviors.clearListOnBackspace,
   coreListBehaviors.unindentListOnBackspace,
   coreListBehaviors.clearListOnEnter,
   coreListBehaviors.indentListOnTab,
   coreListBehaviors.unindentListOnShiftTab,
+  coreSerializeBehaviors.serialize,
+  coreSerializeBehaviors['serialization.success'],
+  coreStyleBehaviors.toggleStyleOff,
+  coreStyleBehaviors.toggleStyleOn,
 ]
 
 /**
@@ -34,7 +49,11 @@ export const coreBehaviors = [
  */
 export const coreBehavior = {
   softReturn,
+  annotation: coreAnnotationBehaviors,
   decorators: coreDecoratorBehaviors,
+  deserialize: coreDeserializeBehavior,
   blockObjects: coreBlockObjectBehaviors,
   lists: coreListBehaviors,
+  ...coreSerializeBehaviors,
+  style: coreSerializeBehaviors,
 }