@portabletext/plugin-one-line 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 - 2025 Sanity.io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# One-Line Plugin
+
+> 🤏 Restricts the Portable Text Editor to a single line

package/dist/index.cjs

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: !0 });
+var editor = require("@portabletext/editor"), behaviors = require("@portabletext/editor/behaviors"), selectors = require("@portabletext/editor/selectors"), utils = require("@portabletext/editor/utils"), react = require("react");
+function _interopNamespaceCompat(e) {
+  if (e && typeof e == "object" && "default" in e) return e;
+  var n = /* @__PURE__ */ Object.create(null);
+  return e && Object.keys(e).forEach(function(k) {
+    if (k !== "default") {
+      var d = Object.getOwnPropertyDescriptor(e, k);
+      Object.defineProperty(n, k, d.get ? d : {
+        enumerable: !0,
+        get: function() {
+          return e[k];
+        }
+      });
+    }
+  }), n.default = e, Object.freeze(n);
+}
+var selectors__namespace = /* @__PURE__ */ _interopNamespaceCompat(selectors), utils__namespace = /* @__PURE__ */ _interopNamespaceCompat(utils);
+const oneLineBehaviors = [
+  /**
+   * Hitting Enter on an expanded selection should just delete that selection
+   * without causing a line break.
+   */
+  behaviors.defineBehavior({
+    on: "insert.break",
+    guard: ({ snapshot }) => snapshot.context.selection && selectors__namespace.isSelectionExpanded(snapshot) ? { selection: snapshot.context.selection } : !1,
+    actions: [(_, { selection }) => [behaviors.execute({ type: "delete", at: selection })]]
+  }),
+  /**
+   * All other cases of `insert.break` should be aborted.
+   */
+  behaviors.defineBehavior({
+    on: "insert.break",
+    actions: []
+  }),
+  /**
+   * `insert.block` `before` or `after` is not allowed in a one-line editor.
+   */
+  behaviors.defineBehavior({
+    on: "insert.block",
+    guard: ({ event }) => event.placement === "before" || event.placement === "after",
+    actions: []
+  }),
+  /**
+   * An ordinary `insert.block` is acceptable if it's a text block. In that
+   * case it will get merged into the existing text block.
+   */
+  behaviors.defineBehavior({
+    on: "insert.block",
+    guard: ({ snapshot, event }) => !(!selectors__namespace.getFocusTextBlock(snapshot) || !utils__namespace.isTextBlock(snapshot.context, event.block)),
+    actions: [
+      ({ event }) => [
+        behaviors.execute({
+          type: "insert.block",
+          block: event.block,
+          placement: "auto",
+          select: "end"
+        })
+      ]
+    ]
+  }),
+  /**
+   * Fallback Behavior to avoid `insert.block` in case the Behaviors above all
+   * end up with a falsy guard.
+   */
+  behaviors.defineBehavior({
+    on: "insert.block",
+    actions: []
+  }),
+  /**
+   * If multiple blocks are inserted, then the non-text blocks are filtered out
+   * and the text blocks are merged into one block
+   */
+  behaviors.defineBehavior({
+    on: "insert.blocks",
+    guard: ({ snapshot, event }) => {
+      const textBlocks = event.blocks.filter(
+        (block) => utils__namespace.isTextBlock(snapshot.context, block)
+      );
+      return textBlocks.length === 0 ? !1 : textBlocks.reduce((targetBlock, incomingBlock) => utils__namespace.mergeTextBlocks({
+        context: snapshot.context,
+        targetBlock,
+        incomingBlock
+      }));
+    },
+    actions: [
+      // `insert.block` is raised so the Behavior above can handle the
+      // insertion
+      (_, block) => [behaviors.raise({ type: "insert.block", block, placement: "auto" })]
+    ]
+  }),
+  /**
+   * Fallback Behavior to avoid `insert.blocks` in case the Behavior above
+   * ends up with a falsy guard.
+   */
+  behaviors.defineBehavior({
+    on: "insert.blocks",
+    actions: []
+  })
+];
+function OneLinePlugin() {
+  const editor$1 = editor.useEditor();
+  return react.useEffect(() => {
+    const unregisterBehaviors = oneLineBehaviors.map(
+      (behavior) => editor$1.registerBehavior({ behavior })
+    );
+    return () => {
+      for (const unregisterBehavior of unregisterBehaviors)
+        unregisterBehavior();
+    };
+  }, [editor$1]), null;
+}
+exports.OneLinePlugin = OneLinePlugin;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../src/plugin.one-line.tsx"],"sourcesContent":["import {useEditor} from '@portabletext/editor'\nimport {defineBehavior, execute, raise} from '@portabletext/editor/behaviors'\nimport * as selectors from '@portabletext/editor/selectors'\nimport * as utils from '@portabletext/editor/utils'\nimport {useEffect} from 'react'\n\nconst oneLineBehaviors = [\n  /**\n   * Hitting Enter on an expanded selection should just delete that selection\n   * without causing a line break.\n   */\n  defineBehavior({\n    on: 'insert.break',\n    guard: ({snapshot}) =>\n      snapshot.context.selection && selectors.isSelectionExpanded(snapshot)\n        ? {selection: snapshot.context.selection}\n        : false,\n    actions: [(_, {selection}) => [execute({type: 'delete', at: selection})]],\n  }),\n  /**\n   * All other cases of `insert.break` should be aborted.\n   */\n  defineBehavior({\n    on: 'insert.break',\n    actions: [],\n  }),\n  /**\n   * `insert.block` `before` or `after` is not allowed in a one-line editor.\n   */\n  defineBehavior({\n    on: 'insert.block',\n    guard: ({event}) =>\n      event.placement === 'before' || event.placement === 'after',\n    actions: [],\n  }),\n  /**\n   * An ordinary `insert.block` is acceptable if it's a text block. In that\n   * case it will get merged into the existing text block.\n   */\n  defineBehavior({\n    on: 'insert.block',\n    guard: ({snapshot, event}) => {\n      const focusTextBlock = selectors.getFocusTextBlock(snapshot)\n\n      if (\n        !focusTextBlock ||\n        !utils.isTextBlock(snapshot.context, event.block)\n      ) {\n        return false\n      }\n\n      return true\n    },\n    actions: [\n      ({event}) => [\n        execute({\n          type: 'insert.block',\n          block: event.block,\n          placement: 'auto',\n          select: 'end',\n        }),\n      ],\n    ],\n  }),\n  /**\n   * Fallback Behavior to avoid `insert.block` in case the Behaviors above all\n   * end up with a falsy guard.\n   */\n  defineBehavior({\n    on: 'insert.block',\n    actions: [],\n  }),\n  /**\n   * If multiple blocks are inserted, then the non-text blocks are filtered out\n   * and the text blocks are merged into one block\n   */\n  defineBehavior({\n    on: 'insert.blocks',\n    guard: ({snapshot, event}) => {\n      const textBlocks = event.blocks.filter((block) =>\n        utils.isTextBlock(snapshot.context, block),\n      )\n\n      if (textBlocks.length === 0) {\n        return false\n      }\n\n      return textBlocks.reduce((targetBlock, incomingBlock) => {\n        return utils.mergeTextBlocks({\n          context: snapshot.context,\n          targetBlock,\n          incomingBlock,\n        })\n      })\n    },\n    actions: [\n      // `insert.block` is raised so the Behavior above can handle the\n      // insertion\n      (_, block) => [raise({type: 'insert.block', block, placement: 'auto'})],\n    ],\n  }),\n  /**\n   * Fallback Behavior to avoid `insert.blocks` in case the Behavior above\n   * ends up with a falsy guard.\n   */\n  defineBehavior({\n    on: 'insert.blocks',\n    actions: [],\n  }),\n]\n\n/**\n * @beta\n * Restrict the editor to one line. The plugin takes care of blocking\n * `insert.break` events and smart handling of other `insert.*` events.\n *\n * Place it with as high priority as possible to make sure other plugins don't\n * overwrite `insert.*` events before this plugin gets a chance to do so.\n */\nexport function OneLinePlugin() {\n  const editor = useEditor()\n\n  useEffect(() => {\n    const unregisterBehaviors = oneLineBehaviors.map((behavior) =>\n      editor.registerBehavior({behavior}),\n    )\n\n    return () => {\n      for (const unregisterBehavior of unregisterBehaviors) {\n        unregisterBehavior()\n      }\n    }\n  }, [editor])\n\n  return null\n}\n"],"names":["defineBehavior","selectors","execute","utils","raise","editor","useEditor","useEffect"],"mappings":";;;;;;;;;;;;;;;;;;;AAMA,MAAM,mBAAmB;AAAA;AAAA;AAAA;AAAA;AAAA,EAKvBA,yBAAe;AAAA,IACb,IAAI;AAAA,IACJ,OAAO,CAAC,EAAC,SAAQ,MACf,SAAS,QAAQ,aAAaC,qBAAU,oBAAoB,QAAQ,IAChE,EAAC,WAAW,SAAS,QAAQ,cAC7B;AAAA,IACN,SAAS,CAAC,CAAC,GAAG,EAAC,gBAAe,CAACC,kBAAQ,EAAC,MAAM,UAAU,IAAI,UAAU,CAAA,CAAC,CAAC;AAAA,EAAA,CACzE;AAAA;AAAA;AAAA;AAAA,EAIDF,yBAAe;AAAA,IACb,IAAI;AAAA,IACJ,SAAS,CAAA;AAAA,EAAC,CACX;AAAA;AAAA;AAAA;AAAA,EAIDA,yBAAe;AAAA,IACb,IAAI;AAAA,IACJ,OAAO,CAAC,EAAC,YACP,MAAM,cAAc,YAAY,MAAM,cAAc;AAAA,IACtD,SAAS,CAAA;AAAA,EAAC,CACX;AAAA;AAAA;AAAA;AAAA;AAAA,EAKDA,yBAAe;AAAA,IACb,IAAI;AAAA,IACJ,OAAO,CAAC,EAAC,UAAU,MAAA,MAIf,EAHqB,CAAAC,qBAAU,kBAAkB,QAAQ,KAIzD,CAACE,iBAAM,YAAY,SAAS,SAAS,MAAM,KAAK;AAAA,IAOpD,SAAS;AAAA,MACP,CAAC,EAAC,MAAA,MAAW;AAAA,QACXD,kBAAQ;AAAA,UACN,MAAM;AAAA,UACN,OAAO,MAAM;AAAA,UACb,WAAW;AAAA,UACX,QAAQ;AAAA,QACT,CAAA;AAAA,MAAA;AAAA,IACH;AAAA,EACF,CACD;AAAA;AAAA;AAAA;AAAA;AAAA,EAKDF,yBAAe;AAAA,IACb,IAAI;AAAA,IACJ,SAAS,CAAA;AAAA,EAAC,CACX;AAAA;AAAA;AAAA;AAAA;AAAA,EAKDA,yBAAe;AAAA,IACb,IAAI;AAAA,IACJ,OAAO,CAAC,EAAC,UAAU,YAAW;AACtB,YAAA,aAAa,MAAM,OAAO;AAAA,QAAO,CAAC,UACtCG,iBAAM,YAAY,SAAS,SAAS,KAAK;AAAA,MAC3C;AAEI,aAAA,WAAW,WAAW,IACjB,KAGF,WAAW,OAAO,CAAC,aAAa,kBAC9BA,iBAAM,gBAAgB;AAAA,QAC3B,SAAS,SAAS;AAAA,QAClB;AAAA,QACA;AAAA,MAAA,CACD,CACF;AAAA,IACH;AAAA,IACA,SAAS;AAAA;AAAA;AAAA,MAGP,CAAC,GAAG,UAAU,CAACC,gBAAM,EAAC,MAAM,gBAAgB,OAAO,WAAW,QAAO,CAAC;AAAA,IAAA;AAAA,EACxE,CACD;AAAA;AAAA;AAAA;AAAA;AAAA,EAKDJ,yBAAe;AAAA,IACb,IAAI;AAAA,IACJ,SAAS,CAAA;AAAA,EACV,CAAA;AACH;AAUO,SAAS,gBAAgB;AAC9B,QAAMK,WAASC,OAAAA,UAAU;AAEzB,SAAAC,MAAA,UAAU,MAAM;AACd,UAAM,sBAAsB,iBAAiB;AAAA,MAAI,CAAC,aAChDF,SAAO,iBAAiB,EAAC,SAAS,CAAA;AAAA,IACpC;AAEA,WAAO,MAAM;AACX,iBAAW,sBAAsB;AACZ,2BAAA;AAAA,IAEvB;AAAA,EAAA,GACC,CAACA,QAAM,CAAC,GAEJ;AACT;;"}

package/dist/index.d.cts

@@ -0,0 +1,11 @@
+/**
+ * @beta
+ * Restrict the editor to one line. The plugin takes care of blocking
+ * `insert.break` events and smart handling of other `insert.*` events.
+ *
+ * Place it with as high priority as possible to make sure other plugins don't
+ * overwrite `insert.*` events before this plugin gets a chance to do so.
+ */
+export declare function OneLinePlugin(): null
+
+export {}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @beta
+ * Restrict the editor to one line. The plugin takes care of blocking
+ * `insert.break` events and smart handling of other `insert.*` events.
+ *
+ * Place it with as high priority as possible to make sure other plugins don't
+ * overwrite `insert.*` events before this plugin gets a chance to do so.
+ */
+export declare function OneLinePlugin(): null
+
+export {}

package/dist/index.js

@@ -0,0 +1,103 @@
+import { useEditor } from "@portabletext/editor";
+import { defineBehavior, execute, raise } from "@portabletext/editor/behaviors";
+import * as selectors from "@portabletext/editor/selectors";
+import * as utils from "@portabletext/editor/utils";
+import { useEffect } from "react";
+const oneLineBehaviors = [
+  /**
+   * Hitting Enter on an expanded selection should just delete that selection
+   * without causing a line break.
+   */
+  defineBehavior({
+    on: "insert.break",
+    guard: ({ snapshot }) => snapshot.context.selection && selectors.isSelectionExpanded(snapshot) ? { selection: snapshot.context.selection } : !1,
+    actions: [(_, { selection }) => [execute({ type: "delete", at: selection })]]
+  }),
+  /**
+   * All other cases of `insert.break` should be aborted.
+   */
+  defineBehavior({
+    on: "insert.break",
+    actions: []
+  }),
+  /**
+   * `insert.block` `before` or `after` is not allowed in a one-line editor.
+   */
+  defineBehavior({
+    on: "insert.block",
+    guard: ({ event }) => event.placement === "before" || event.placement === "after",
+    actions: []
+  }),
+  /**
+   * An ordinary `insert.block` is acceptable if it's a text block. In that
+   * case it will get merged into the existing text block.
+   */
+  defineBehavior({
+    on: "insert.block",
+    guard: ({ snapshot, event }) => !(!selectors.getFocusTextBlock(snapshot) || !utils.isTextBlock(snapshot.context, event.block)),
+    actions: [
+      ({ event }) => [
+        execute({
+          type: "insert.block",
+          block: event.block,
+          placement: "auto",
+          select: "end"
+        })
+      ]
+    ]
+  }),
+  /**
+   * Fallback Behavior to avoid `insert.block` in case the Behaviors above all
+   * end up with a falsy guard.
+   */
+  defineBehavior({
+    on: "insert.block",
+    actions: []
+  }),
+  /**
+   * If multiple blocks are inserted, then the non-text blocks are filtered out
+   * and the text blocks are merged into one block
+   */
+  defineBehavior({
+    on: "insert.blocks",
+    guard: ({ snapshot, event }) => {
+      const textBlocks = event.blocks.filter(
+        (block) => utils.isTextBlock(snapshot.context, block)
+      );
+      return textBlocks.length === 0 ? !1 : textBlocks.reduce((targetBlock, incomingBlock) => utils.mergeTextBlocks({
+        context: snapshot.context,
+        targetBlock,
+        incomingBlock
+      }));
+    },
+    actions: [
+      // `insert.block` is raised so the Behavior above can handle the
+      // insertion
+      (_, block) => [raise({ type: "insert.block", block, placement: "auto" })]
+    ]
+  }),
+  /**
+   * Fallback Behavior to avoid `insert.blocks` in case the Behavior above
+   * ends up with a falsy guard.
+   */
+  defineBehavior({
+    on: "insert.blocks",
+    actions: []
+  })
+];
+function OneLinePlugin() {
+  const editor = useEditor();
+  return useEffect(() => {
+    const unregisterBehaviors = oneLineBehaviors.map(
+      (behavior) => editor.registerBehavior({ behavior })
+    );
+    return () => {
+      for (const unregisterBehavior of unregisterBehaviors)
+        unregisterBehavior();
+    };
+  }, [editor]), null;
+}
+export {
+  OneLinePlugin
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/plugin.one-line.tsx"],"sourcesContent":["import {useEditor} from '@portabletext/editor'\nimport {defineBehavior, execute, raise} from '@portabletext/editor/behaviors'\nimport * as selectors from '@portabletext/editor/selectors'\nimport * as utils from '@portabletext/editor/utils'\nimport {useEffect} from 'react'\n\nconst oneLineBehaviors = [\n  /**\n   * Hitting Enter on an expanded selection should just delete that selection\n   * without causing a line break.\n   */\n  defineBehavior({\n    on: 'insert.break',\n    guard: ({snapshot}) =>\n      snapshot.context.selection && selectors.isSelectionExpanded(snapshot)\n        ? {selection: snapshot.context.selection}\n        : false,\n    actions: [(_, {selection}) => [execute({type: 'delete', at: selection})]],\n  }),\n  /**\n   * All other cases of `insert.break` should be aborted.\n   */\n  defineBehavior({\n    on: 'insert.break',\n    actions: [],\n  }),\n  /**\n   * `insert.block` `before` or `after` is not allowed in a one-line editor.\n   */\n  defineBehavior({\n    on: 'insert.block',\n    guard: ({event}) =>\n      event.placement === 'before' || event.placement === 'after',\n    actions: [],\n  }),\n  /**\n   * An ordinary `insert.block` is acceptable if it's a text block. In that\n   * case it will get merged into the existing text block.\n   */\n  defineBehavior({\n    on: 'insert.block',\n    guard: ({snapshot, event}) => {\n      const focusTextBlock = selectors.getFocusTextBlock(snapshot)\n\n      if (\n        !focusTextBlock ||\n        !utils.isTextBlock(snapshot.context, event.block)\n      ) {\n        return false\n      }\n\n      return true\n    },\n    actions: [\n      ({event}) => [\n        execute({\n          type: 'insert.block',\n          block: event.block,\n          placement: 'auto',\n          select: 'end',\n        }),\n      ],\n    ],\n  }),\n  /**\n   * Fallback Behavior to avoid `insert.block` in case the Behaviors above all\n   * end up with a falsy guard.\n   */\n  defineBehavior({\n    on: 'insert.block',\n    actions: [],\n  }),\n  /**\n   * If multiple blocks are inserted, then the non-text blocks are filtered out\n   * and the text blocks are merged into one block\n   */\n  defineBehavior({\n    on: 'insert.blocks',\n    guard: ({snapshot, event}) => {\n      const textBlocks = event.blocks.filter((block) =>\n        utils.isTextBlock(snapshot.context, block),\n      )\n\n      if (textBlocks.length === 0) {\n        return false\n      }\n\n      return textBlocks.reduce((targetBlock, incomingBlock) => {\n        return utils.mergeTextBlocks({\n          context: snapshot.context,\n          targetBlock,\n          incomingBlock,\n        })\n      })\n    },\n    actions: [\n      // `insert.block` is raised so the Behavior above can handle the\n      // insertion\n      (_, block) => [raise({type: 'insert.block', block, placement: 'auto'})],\n    ],\n  }),\n  /**\n   * Fallback Behavior to avoid `insert.blocks` in case the Behavior above\n   * ends up with a falsy guard.\n   */\n  defineBehavior({\n    on: 'insert.blocks',\n    actions: [],\n  }),\n]\n\n/**\n * @beta\n * Restrict the editor to one line. The plugin takes care of blocking\n * `insert.break` events and smart handling of other `insert.*` events.\n *\n * Place it with as high priority as possible to make sure other plugins don't\n * overwrite `insert.*` events before this plugin gets a chance to do so.\n */\nexport function OneLinePlugin() {\n  const editor = useEditor()\n\n  useEffect(() => {\n    const unregisterBehaviors = oneLineBehaviors.map((behavior) =>\n      editor.registerBehavior({behavior}),\n    )\n\n    return () => {\n      for (const unregisterBehavior of unregisterBehaviors) {\n        unregisterBehavior()\n      }\n    }\n  }, [editor])\n\n  return null\n}\n"],"names":[],"mappings":";;;;;AAMA,MAAM,mBAAmB;AAAA;AAAA;AAAA;AAAA;AAAA,EAKvB,eAAe;AAAA,IACb,IAAI;AAAA,IACJ,OAAO,CAAC,EAAC,SAAQ,MACf,SAAS,QAAQ,aAAa,UAAU,oBAAoB,QAAQ,IAChE,EAAC,WAAW,SAAS,QAAQ,cAC7B;AAAA,IACN,SAAS,CAAC,CAAC,GAAG,EAAC,gBAAe,CAAC,QAAQ,EAAC,MAAM,UAAU,IAAI,UAAU,CAAA,CAAC,CAAC;AAAA,EAAA,CACzE;AAAA;AAAA;AAAA;AAAA,EAID,eAAe;AAAA,IACb,IAAI;AAAA,IACJ,SAAS,CAAA;AAAA,EAAC,CACX;AAAA;AAAA;AAAA;AAAA,EAID,eAAe;AAAA,IACb,IAAI;AAAA,IACJ,OAAO,CAAC,EAAC,YACP,MAAM,cAAc,YAAY,MAAM,cAAc;AAAA,IACtD,SAAS,CAAA;AAAA,EAAC,CACX;AAAA;AAAA;AAAA;AAAA;AAAA,EAKD,eAAe;AAAA,IACb,IAAI;AAAA,IACJ,OAAO,CAAC,EAAC,UAAU,MAAA,MAIf,EAHqB,CAAA,UAAU,kBAAkB,QAAQ,KAIzD,CAAC,MAAM,YAAY,SAAS,SAAS,MAAM,KAAK;AAAA,IAOpD,SAAS;AAAA,MACP,CAAC,EAAC,MAAA,MAAW;AAAA,QACX,QAAQ;AAAA,UACN,MAAM;AAAA,UACN,OAAO,MAAM;AAAA,UACb,WAAW;AAAA,UACX,QAAQ;AAAA,QACT,CAAA;AAAA,MAAA;AAAA,IACH;AAAA,EACF,CACD;AAAA;AAAA;AAAA;AAAA;AAAA,EAKD,eAAe;AAAA,IACb,IAAI;AAAA,IACJ,SAAS,CAAA;AAAA,EAAC,CACX;AAAA;AAAA;AAAA;AAAA;AAAA,EAKD,eAAe;AAAA,IACb,IAAI;AAAA,IACJ,OAAO,CAAC,EAAC,UAAU,YAAW;AACtB,YAAA,aAAa,MAAM,OAAO;AAAA,QAAO,CAAC,UACtC,MAAM,YAAY,SAAS,SAAS,KAAK;AAAA,MAC3C;AAEI,aAAA,WAAW,WAAW,IACjB,KAGF,WAAW,OAAO,CAAC,aAAa,kBAC9B,MAAM,gBAAgB;AAAA,QAC3B,SAAS,SAAS;AAAA,QAClB;AAAA,QACA;AAAA,MAAA,CACD,CACF;AAAA,IACH;AAAA,IACA,SAAS;AAAA;AAAA;AAAA,MAGP,CAAC,GAAG,UAAU,CAAC,MAAM,EAAC,MAAM,gBAAgB,OAAO,WAAW,QAAO,CAAC;AAAA,IAAA;AAAA,EACxE,CACD;AAAA;AAAA;AAAA;AAAA;AAAA,EAKD,eAAe;AAAA,IACb,IAAI;AAAA,IACJ,SAAS,CAAA;AAAA,EACV,CAAA;AACH;AAUO,SAAS,gBAAgB;AAC9B,QAAM,SAAS,UAAU;AAEzB,SAAA,UAAU,MAAM;AACd,UAAM,sBAAsB,iBAAiB;AAAA,MAAI,CAAC,aAChD,OAAO,iBAAiB,EAAC,SAAS,CAAA;AAAA,IACpC;AAEA,WAAO,MAAM;AACX,iBAAW,sBAAsB;AACZ,2BAAA;AAAA,IAEvB;AAAA,EAAA,GACC,CAAC,MAAM,CAAC,GAEJ;AACT;"}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@portabletext/plugin-one-line",
+  "version": "0.0.0",
+  "description": "🤏 Restricts the Portable Text Editor to a single line",
+  "keywords": [
+    "portabletext",
+    "plugin",
+    "one-line",
+    "behaviors"
+  ],
+  "homepage": "https://portabletext.org",
+  "bugs": {
+    "url": "https://github.com/portabletext/plugins/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/portabletext/plugins.git",
+    "directory": "plugins/one-line"
+  },
+  "license": "MIT",
+  "author": "Sanity.io <hello@sanity.io>",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "src",
+    "dist"
+  ],
+  "devDependencies": {
+    "@portabletext/editor": "^1.48.2",
+    "@types/react": "^19.1.2",
+    "react": "^19.1.0"
+  },
+  "peerDependencies": {
+    "@portabletext/editor": "^1.48.2",
+    "react": "^19.1.0"
+  },
+  "scripts": {
+    "build": "pkg-utils build --strict --check --clean",
+    "check:lint": "biome lint .",
+    "check:react-compiler": "eslint --cache --no-inline-config --no-eslintrc --ignore-pattern '**/__tests__/**' --ext .cjs,.mjs,.js,.jsx,.ts,.tsx --parser @typescript-eslint/parser --plugin react-compiler --plugin react-hooks --rule 'react-compiler/react-compiler: [warn]' --rule 'react-hooks/rules-of-hooks: [error]' --rule 'react-hooks/exhaustive-deps: [error]' src",
+    "check:types": "tsc",
+    "check:types:watch": "tsc --watch",
+    "clean": "del .turbo && del dist && del node_modules",
+    "dev": "pkg-utils watch",
+    "lint:fix": "biome lint --write ."
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './plugin.one-line'

package/src/plugin.one-line.tsx

@@ -0,0 +1,136 @@
+import {useEditor} from '@portabletext/editor'
+import {defineBehavior, execute, raise} from '@portabletext/editor/behaviors'
+import * as selectors from '@portabletext/editor/selectors'
+import * as utils from '@portabletext/editor/utils'
+import {useEffect} from 'react'
+
+const oneLineBehaviors = [
+  /**
+   * Hitting Enter on an expanded selection should just delete that selection
+   * without causing a line break.
+   */
+  defineBehavior({
+    on: 'insert.break',
+    guard: ({snapshot}) =>
+      snapshot.context.selection && selectors.isSelectionExpanded(snapshot)
+        ? {selection: snapshot.context.selection}
+        : false,
+    actions: [(_, {selection}) => [execute({type: 'delete', at: selection})]],
+  }),
+  /**
+   * All other cases of `insert.break` should be aborted.
+   */
+  defineBehavior({
+    on: 'insert.break',
+    actions: [],
+  }),
+  /**
+   * `insert.block` `before` or `after` is not allowed in a one-line editor.
+   */
+  defineBehavior({
+    on: 'insert.block',
+    guard: ({event}) =>
+      event.placement === 'before' || event.placement === 'after',
+    actions: [],
+  }),
+  /**
+   * An ordinary `insert.block` is acceptable if it's a text block. In that
+   * case it will get merged into the existing text block.
+   */
+  defineBehavior({
+    on: 'insert.block',
+    guard: ({snapshot, event}) => {
+      const focusTextBlock = selectors.getFocusTextBlock(snapshot)
+
+      if (
+        !focusTextBlock ||
+        !utils.isTextBlock(snapshot.context, event.block)
+      ) {
+        return false
+      }
+
+      return true
+    },
+    actions: [
+      ({event}) => [
+        execute({
+          type: 'insert.block',
+          block: event.block,
+          placement: 'auto',
+          select: 'end',
+        }),
+      ],
+    ],
+  }),
+  /**
+   * Fallback Behavior to avoid `insert.block` in case the Behaviors above all
+   * end up with a falsy guard.
+   */
+  defineBehavior({
+    on: 'insert.block',
+    actions: [],
+  }),
+  /**
+   * If multiple blocks are inserted, then the non-text blocks are filtered out
+   * and the text blocks are merged into one block
+   */
+  defineBehavior({
+    on: 'insert.blocks',
+    guard: ({snapshot, event}) => {
+      const textBlocks = event.blocks.filter((block) =>
+        utils.isTextBlock(snapshot.context, block),
+      )
+
+      if (textBlocks.length === 0) {
+        return false
+      }
+
+      return textBlocks.reduce((targetBlock, incomingBlock) => {
+        return utils.mergeTextBlocks({
+          context: snapshot.context,
+          targetBlock,
+          incomingBlock,
+        })
+      })
+    },
+    actions: [
+      // `insert.block` is raised so the Behavior above can handle the
+      // insertion
+      (_, block) => [raise({type: 'insert.block', block, placement: 'auto'})],
+    ],
+  }),
+  /**
+   * Fallback Behavior to avoid `insert.blocks` in case the Behavior above
+   * ends up with a falsy guard.
+   */
+  defineBehavior({
+    on: 'insert.blocks',
+    actions: [],
+  }),
+]
+
+/**
+ * @beta
+ * Restrict the editor to one line. The plugin takes care of blocking
+ * `insert.break` events and smart handling of other `insert.*` events.
+ *
+ * Place it with as high priority as possible to make sure other plugins don't
+ * overwrite `insert.*` events before this plugin gets a chance to do so.
+ */
+export function OneLinePlugin() {
+  const editor = useEditor()
+
+  useEffect(() => {
+    const unregisterBehaviors = oneLineBehaviors.map((behavior) =>
+      editor.registerBehavior({behavior}),
+    )
+
+    return () => {
+      for (const unregisterBehavior of unregisterBehaviors) {
+        unregisterBehavior()
+      }
+    }
+  }, [editor])
+
+  return null
+}