@portabletext/plugin-markdown-shortcuts 1.1.4 → 1.3.0

package/src/rule.blockquote.ts

@@ -0,0 +1,53 @@
+import type {EditorSchema} from '@portabletext/editor'
+import {raise} from '@portabletext/editor/behaviors'
+import {getPreviousInlineObject} from '@portabletext/editor/selectors'
+import {defineInputRule} from '@portabletext/plugin-input-rule'
+
+export function createBlockquoteRule(config: {
+  blockquoteStyle: (context: {schema: EditorSchema}) => string | undefined
+}) {
+  return defineInputRule({
+    on: /^> /,
+    guard: ({snapshot, event}) => {
+      const style = config.blockquoteStyle({
+        schema: snapshot.context.schema,
+      })
+
+      if (!style) {
+        return false
+      }
+
+      const previousInlineObject = getPreviousInlineObject(snapshot)
+
+      if (previousInlineObject) {
+        return false
+      }
+
+      const match = event.matches.at(0)
+
+      if (!match) {
+        return false
+      }
+
+      return {style, match}
+    },
+    actions: [
+      ({event}, {style, match}) => [
+        raise({
+          type: 'block.unset',
+          props: ['listItem', 'level'],
+          at: event.focusTextBlock.path,
+        }),
+        raise({
+          type: 'block.set',
+          props: {style},
+          at: event.focusTextBlock.path,
+        }),
+        raise({
+          type: 'delete',
+          at: match.targetOffsets,
+        }),
+      ],
+    ],
+  })
+}

package/src/rule.heading.ts

@@ -0,0 +1,59 @@
+import type {EditorSchema} from '@portabletext/editor'
+import {raise} from '@portabletext/editor/behaviors'
+import {getPreviousInlineObject} from '@portabletext/editor/selectors'
+import {defineInputRule} from '@portabletext/plugin-input-rule'
+
+export function createHeadingRule(config: {
+  headingStyle: (context: {
+    schema: EditorSchema
+    level: number
+  }) => string | undefined
+}) {
+  return defineInputRule({
+    on: /^#+ /,
+    guard: ({snapshot, event}) => {
+      const previousInlineObject = getPreviousInlineObject(snapshot)
+
+      if (previousInlineObject) {
+        return false
+      }
+
+      const match = event.matches.at(0)
+
+      if (!match) {
+        return false
+      }
+
+      const level = match.text.length - 1
+
+      const style = config.headingStyle({
+        schema: snapshot.context.schema,
+        level,
+      })
+
+      if (!style) {
+        return false
+      }
+
+      return {match, style}
+    },
+    actions: [
+      ({event}, {match, style}) => [
+        raise({
+          type: 'block.unset',
+          props: ['listItem', 'level'],
+          at: event.focusTextBlock.path,
+        }),
+        raise({
+          type: 'block.set',
+          props: {style},
+          at: event.focusTextBlock.path,
+        }),
+        raise({
+          type: 'delete',
+          at: match.targetOffsets,
+        }),
+      ],
+    ],
+  })
+}

package/src/rule.horizontal-rule.ts

@@ -0,0 +1,61 @@
+import type {EditorSchema} from '@portabletext/editor'
+import {raise} from '@portabletext/editor/behaviors'
+import {getPreviousInlineObject} from '@portabletext/editor/selectors'
+import {defineInputRule} from '@portabletext/plugin-input-rule'
+
+export function createHorizontalRuleRule(config: {
+  horizontalRuleObject: (context: {
+    schema: EditorSchema
+  }) => {name: string; value?: {[prop: string]: unknown}} | undefined
+}) {
+  return defineInputRule({
+    on: /^(---)|^(—-)|^(___)|^(\*\*\*)/,
+    guard: ({snapshot, event}) => {
+      const hrObject = config.horizontalRuleObject({
+        schema: snapshot.context.schema,
+      })
+
+      if (!hrObject) {
+        // If no horizontal rule object is provided, then we can safely skip
+        // this rule.
+        return false
+      }
+
+      const previousInlineObject = getPreviousInlineObject(snapshot)
+
+      if (previousInlineObject) {
+        // Input Rules only look at the plain text of the text block. This
+        // means that the RegExp is matched even if there is a leading inline
+        // object.
+        return false
+      }
+
+      // In theory, an Input Rule could return multiple matches. But in this
+      // case we only expect one match.
+      const match = event.matches.at(0)
+
+      if (!match) {
+        return false
+      }
+
+      return {hrObject, match}
+    },
+    actions: [
+      (_, {hrObject, match}) => [
+        raise({
+          type: 'insert.block',
+          block: {
+            _type: hrObject.name,
+            ...(hrObject.value ?? {}),
+          },
+          placement: 'before',
+          select: 'none',
+        }),
+        raise({
+          type: 'delete',
+          at: match.targetOffsets,
+        }),
+      ],
+    ],
+  })
+}

package/src/rule.ordered-list.ts

@@ -0,0 +1,56 @@
+import type {EditorSchema} from '@portabletext/editor'
+import {raise} from '@portabletext/editor/behaviors'
+import {getPreviousInlineObject} from '@portabletext/editor/selectors'
+import {defineInputRule} from '@portabletext/plugin-input-rule'
+
+export function createOrderedListRule(config: {
+  orderedList: (context: {schema: EditorSchema}) => string | undefined
+}) {
+  return defineInputRule({
+    on: /^1\. /,
+    guard: ({snapshot, event}) => {
+      const orderedList = config.orderedList({
+        schema: snapshot.context.schema,
+      })
+
+      if (!orderedList) {
+        return false
+      }
+
+      const previousInlineObject = getPreviousInlineObject(snapshot)
+
+      if (previousInlineObject) {
+        return false
+      }
+
+      const match = event.matches.at(0)
+
+      if (!match) {
+        return false
+      }
+
+      return {match, orderedList}
+    },
+    actions: [
+      ({event}, {match, orderedList}) => [
+        raise({
+          type: 'block.unset',
+          props: ['style'],
+          at: event.focusTextBlock.path,
+        }),
+        raise({
+          type: 'block.set',
+          props: {
+            listItem: orderedList,
+            level: event.focusTextBlock.node.level ?? 1,
+          },
+          at: event.focusTextBlock.path,
+        }),
+        raise({
+          type: 'delete',
+          at: match.targetOffsets,
+        }),
+      ],
+    ],
+  })
+}

package/src/rule.unordered-list.ts

@@ -0,0 +1,56 @@
+import type {EditorSchema} from '@portabletext/editor'
+import {raise} from '@portabletext/editor/behaviors'
+import {getPreviousInlineObject} from '@portabletext/editor/selectors'
+import {defineInputRule} from '@portabletext/plugin-input-rule'
+
+export function createUnorderedListRule(config: {
+  unorderedList: (context: {schema: EditorSchema}) => string | undefined
+}) {
+  return defineInputRule({
+    on: /^(-|\*) /,
+    guard: ({snapshot, event}) => {
+      const unorderedList = config.unorderedList({
+        schema: snapshot.context.schema,
+      })
+
+      if (!unorderedList) {
+        return false
+      }
+
+      const previousInlineObject = getPreviousInlineObject(snapshot)
+
+      if (previousInlineObject) {
+        return false
+      }
+
+      const match = event.matches.at(0)
+
+      if (!match) {
+        return false
+      }
+
+      return {match, unorderedList}
+    },
+    actions: [
+      ({event}, {match, unorderedList}) => [
+        raise({
+          type: 'block.unset',
+          props: ['style'],
+          at: event.focusTextBlock.path,
+        }),
+        raise({
+          type: 'block.set',
+          props: {
+            listItem: unorderedList,
+            level: event.focusTextBlock.node.level ?? 1,
+          },
+          at: event.focusTextBlock.path,
+        }),
+        raise({
+          type: 'delete',
+          at: match.targetOffsets,
+        }),
+      ],
+    ],
+  })
+}