@prosekit/extensions 0.0.0-next-20230709094459 → 0.0.0-next-20231120040948

package/dist/prosekit-extensions-blockquote.js

@@ -1,23 +1,21 @@
 // src/blockquote/index.ts
-import { addNodeSpec, defineExtension } from "@prosekit/core";
-function addBlockquoteSpec() {
-  return addNodeSpec({
+import { defineNodeSpec, union } from "@prosekit/core";
+function defineBlockquoteSpec() {
+  return defineNodeSpec({
     name: "blockquote",
-    spec: {
-      content: "block+",
-      group: "block",
-      defining: true,
-      parseDOM: [{ tag: "blockquote" }],
-      toDOM() {
-        return ["blockquote", 0];
-      }
+    content: "block+",
+    group: "block",
+    defining: true,
+    parseDOM: [{ tag: "blockquote" }],
+    toDOM() {
+      return ["blockquote", 0];
     }
   });
 }
-function addBlockquote() {
-  return defineExtension([addBlockquoteSpec()]);
+function defineBlockquote() {
+  return union([defineBlockquoteSpec()]);
 }
 export {
-  addBlockquote,
-  addBlockquoteSpec
+  defineBlockquote,
+  defineBlockquoteSpec
 };

package/dist/prosekit-extensions-bold.d.ts

@@ -1,20 +1,4 @@
-import * as _prosekit_core from '@prosekit/core';
-
-declare function addBoldSpec(): _prosekit_core.Extension<{
-    MARKS: "bold";
-}>;
-declare function addBoldCommands(): _prosekit_core.Extension<{
-    COMMAND_ARGS: {
-        toggleBold: [];
-    };
-}>;
-declare function addBoldKeymap(): _prosekit_core.Extension<_prosekit_core.ExtensionTyping<string, string, _prosekit_core.CommandArgs>>;
-/** @public */
-declare function addBold(): _prosekit_core.Extension<{
-    MARKS: "bold";
-    COMMAND_ARGS: {
-        toggleBold: [];
-    };
-}>;
-
-export { addBold, addBoldCommands, addBoldKeymap, addBoldSpec };
+export { defineBoldSpec } from './_tsup-dts-rollup';
+export { defineBoldCommands } from './_tsup-dts-rollup';
+export { defineBoldKeymap } from './_tsup-dts-rollup';
+export { defineBold } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-bold.js

@@ -1,56 +1,54 @@
 // src/bold/index.ts
 import {
-  addCommands,
-  addKeymap,
-  addMarkSpec,
-  defineExtension,
+  defineCommands,
+  defineKeymap,
+  defineMarkSpec,
+  union,
   toggleMark
 } from "@prosekit/core";
-function addBoldSpec() {
-  return addMarkSpec({
+function defineBoldSpec() {
+  return defineMarkSpec({
     name: "bold",
-    spec: {
-      parseDOM: [
-        { tag: "strong" },
-        // This works around a Google Docs misbehavior where
-        // pasted content will be inexplicably wrapped in `<b>`
-        // tags with a font-weight normal.
-        {
-          tag: "b",
-          getAttrs: (node) => {
-            return typeof node !== "string" && node.style.fontWeight !== "normal" && null;
-          }
-        },
-        { style: "font-weight=400", clearMark: (m) => m.type.name == "strong" },
-        {
-          style: "font-weight",
-          getAttrs: (value) => {
-            return typeof value === "string" && /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null;
-          }
+    parseDOM: [
+      { tag: "strong" },
+      // This works around a Google Docs misbehavior where
+      // pasted content will be inexplicably wrapped in `<b>`
+      // tags with a font-weight normal.
+      {
+        tag: "b",
+        getAttrs: (node) => {
+          return typeof node !== "string" && node.style.fontWeight !== "normal" && null;
+        }
+      },
+      { style: "font-weight=400", clearMark: (m) => m.type.name == "strong" },
+      {
+        style: "font-weight",
+        getAttrs: (value) => {
+          return typeof value === "string" && /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null;
         }
-      ],
-      toDOM() {
-        return ["em", 0];
       }
+    ],
+    toDOM() {
+      return ["strong", 0];
     }
   });
 }
-function addBoldCommands() {
-  return addCommands({
+function defineBoldCommands() {
+  return defineCommands({
     toggleBold: () => toggleMark({ type: "bold" })
   });
 }
-function addBoldKeymap() {
-  return addKeymap({
+function defineBoldKeymap() {
+  return defineKeymap({
     "Mod-b": toggleMark({ type: "bold" })
   });
 }
-function addBold() {
-  return defineExtension([addBoldSpec(), addBoldCommands(), addBoldKeymap()]);
+function defineBold() {
+  return union([defineBoldSpec(), defineBoldCommands(), defineBoldKeymap()]);
 }
 export {
-  addBold,
-  addBoldCommands,
-  addBoldKeymap,
-  addBoldSpec
+  defineBold,
+  defineBoldCommands,
+  defineBoldKeymap,
+  defineBoldSpec
 };

package/dist/prosekit-extensions-code-block.d.ts

@@ -0,0 +1,5 @@
+export { defineCodeBlockSpec } from './_tsup-dts-rollup';
+export { defineCodeBlockInputRule } from './_tsup-dts-rollup';
+export { defineCodeBlockCommands } from './_tsup-dts-rollup';
+export { defineCodeBlock } from './_tsup-dts-rollup';
+export { CodeBlockAttrs_alias_1 as CodeBlockAttrs } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-code-block.js

@@ -0,0 +1,118 @@
+// src/code-block/index.ts
+import {
+  defineCommands,
+  defineInputRule,
+  defineNodeSpec,
+  union,
+  getNodeType
+} from "@prosekit/core";
+import { textblockTypeInputRule } from "@prosekit/pm/inputrules";
+
+// src/code-block/code-block-highlight.ts
+import { definePlugin } from "@prosekit/core";
+import { PluginKey, ProseMirrorPlugin } from "@prosekit/pm/state";
+import { DecorationSet } from "@prosekit/pm/view";
+import { getHighlightDecorations } from "prosemirror-highlightjs";
+function defineCodeBlockHighlight(options) {
+  const hljs = options.hljs;
+  const plugin = new ProseMirrorPlugin({
+    key,
+    state: {
+      init(_config, state) {
+        const decorations = hljs ? getHighlightDecorations(
+          state.doc,
+          hljs,
+          blockTypes,
+          languageExtractor
+        ) : [];
+        return DecorationSet.create(state.doc, decorations);
+      },
+      apply(tr, set) {
+        if (!tr.docChanged) {
+          return set.map(tr.mapping, tr.doc);
+        }
+        const decorations = hljs ? getHighlightDecorations(tr.doc, hljs, blockTypes, languageExtractor) : [];
+        return DecorationSet.create(tr.doc, decorations);
+      }
+    },
+    props: {
+      decorations(state) {
+        return key.getState(state);
+      }
+    }
+  });
+  return definePlugin(plugin);
+}
+var key = new PluginKey("prosekit-code-block-highlight");
+var blockTypes = ["codeBlock"];
+function languageExtractor(node) {
+  return node.attrs.language || "javascript";
+}
+
+// src/code-block/index.ts
+function defineCodeBlockSpec() {
+  return defineNodeSpec({
+    name: "codeBlock",
+    content: "text*",
+    group: "block",
+    code: true,
+    defining: true,
+    marks: "",
+    attrs: { language: { default: "" } },
+    parseDOM: [
+      {
+        tag: "pre",
+        preserveWhitespace: "full",
+        getAttrs: (node) => ({
+          language: node.getAttribute("data-language") || ""
+        })
+      }
+    ],
+    toDOM(node) {
+      const attrs = node.attrs;
+      return [
+        "pre",
+        { "data-language": attrs.language, class: "hljs" },
+        ["code", 0]
+      ];
+    }
+  });
+}
+function defineCodeBlockInputRule() {
+  return defineInputRule(({ schema }) => {
+    const nodeType = getNodeType(schema, "codeBlock");
+    const getAttrs = (match) => {
+      return { language: match[1] || "" };
+    };
+    return textblockTypeInputRule(/^```(\S*)\s$/, nodeType, getAttrs);
+  });
+}
+function defineCodeBlockCommands() {
+  return defineCommands({
+    setCodeBlockLanguage: (language) => (state, dispatch) => {
+      const pos = state.selection.$from.before();
+      const codeBlock = state.doc.nodeAt(pos);
+      if (!codeBlock || codeBlock.type.name !== "codeBlock") {
+        return false;
+      }
+      const { tr } = state;
+      tr.setNodeMarkup(pos, void 0, { language });
+      dispatch == null ? void 0 : dispatch(tr);
+      return true;
+    }
+  });
+}
+function defineCodeBlock(options) {
+  return union([
+    defineCodeBlockSpec(),
+    defineCodeBlockInputRule(),
+    defineCodeBlockHighlight({ hljs: options == null ? void 0 : options.hljs }),
+    defineCodeBlockCommands()
+  ]);
+}
+export {
+  defineCodeBlock,
+  defineCodeBlockCommands,
+  defineCodeBlockInputRule,
+  defineCodeBlockSpec
+};

package/dist/prosekit-extensions-code.d.ts

@@ -1,16 +1,4 @@
-import * as _prosekit_core from '@prosekit/core';
-
-/**
- * @public
- */
-declare function addCodeSpec(): _prosekit_core.Extension<{
-    MARKS: "code";
-}>;
-/**
- * @public
- */
-declare function addCode(): _prosekit_core.Extension<{
-    MARKS: "code";
-}>;
-
-export { addCode, addCodeSpec };
+export { defineCodeSpec } from './_tsup-dts-rollup';
+export { defineCodeCommands } from './_tsup-dts-rollup';
+export { defineItalicKeymap } from './_tsup-dts-rollup';
+export { defineCode } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-code.js

@@ -1,20 +1,36 @@
 // src/code/index.ts
-import { addMarkSpec, defineExtension } from "@prosekit/core";
-function addCodeSpec() {
-  return addMarkSpec({
+import {
+  defineCommands,
+  defineKeymap,
+  defineMarkSpec,
+  toggleMark,
+  union
+} from "@prosekit/core";
+function defineCodeSpec() {
+  return defineMarkSpec({
     name: "code",
-    spec: {
-      parseDOM: [{ tag: "code" }],
-      toDOM() {
-        return ["code", 0];
-      }
+    parseDOM: [{ tag: "code" }],
+    toDOM() {
+      return ["code", 0];
     }
   });
 }
-function addCode() {
-  return defineExtension([addCodeSpec()]);
+function defineCodeCommands() {
+  return defineCommands({
+    toggleCode: () => toggleMark({ type: "code" })
+  });
+}
+function defineItalicKeymap() {
+  return defineKeymap({
+    "Mod-e": toggleMark({ type: "code" })
+  });
+}
+function defineCode() {
+  return union([defineCodeSpec(), defineCodeCommands(), defineItalicKeymap()]);
 }
 export {
-  addCode,
-  addCodeSpec
+  defineCode,
+  defineCodeCommands,
+  defineCodeSpec,
+  defineItalicKeymap
 };

package/dist/prosekit-extensions-heading.d.ts

@@ -1,15 +1,6 @@
-import * as _prosekit_core from '@prosekit/core';
-
-interface HeadingAttrs {
-    level: number;
-}
-declare function addHeadingSpec(): _prosekit_core.Extension<{
-    NODES: "heading";
-}>;
-declare function addHeadingInputRule(): _prosekit_core.Extension<_prosekit_core.ExtensionTyping<string, string, _prosekit_core.CommandArgs>>;
-/** @public */
-declare function addHeading(): _prosekit_core.Extension<{
-    NODES: "heading";
-}>;
-
-export { HeadingAttrs, addHeading, addHeadingInputRule, addHeadingSpec };
+export { defineHeadingSpec } from './_tsup-dts-rollup';
+export { defineHeadingKeymap } from './_tsup-dts-rollup';
+export { defineHeadingInputRule } from './_tsup-dts-rollup';
+export { defineHeadingCommands } from './_tsup-dts-rollup';
+export { defineHeading } from './_tsup-dts-rollup';
+export { HeadingAttrs } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-heading.js

@@ -1,53 +1,81 @@
 // src/heading/index.ts
 import {
-  addInputRule,
-  addNodeSpec,
-  defineExtension,
-  getNodeType
+  defineCommands,
+  defineInputRule,
+  defineKeymap,
+  defineNodeSpec,
+  getNodeType,
+  insertNode,
+  setBlockType,
+  toggleNode,
+  union
 } from "@prosekit/core";
 import { textblockTypeInputRule } from "@prosekit/pm/inputrules";
-function addHeadingSpec() {
-  return addNodeSpec({
+function defineHeadingSpec() {
+  return defineNodeSpec({
     name: "heading",
-    spec: {
-      attrs: { level: { default: 1 } },
-      content: "inline*",
-      group: "block",
-      defining: true,
-      parseDOM: [
-        { tag: "h1", attrs: { level: 1 } },
-        { tag: "h2", attrs: { level: 2 } },
-        { tag: "h3", attrs: { level: 3 } },
-        { tag: "h4", attrs: { level: 4 } },
-        { tag: "h5", attrs: { level: 5 } },
-        { tag: "h6", attrs: { level: 6 } }
-      ],
-      toDOM(node) {
-        return [`h${node.attrs.level}`, 0];
-      }
+    attrs: { level: { default: 1 } },
+    content: "inline*",
+    group: "block",
+    defining: true,
+    parseDOM: [
+      { tag: "h1", attrs: { level: 1 } },
+      { tag: "h2", attrs: { level: 2 } },
+      { tag: "h3", attrs: { level: 3 } },
+      { tag: "h4", attrs: { level: 4 } },
+      { tag: "h5", attrs: { level: 5 } },
+      { tag: "h6", attrs: { level: 6 } }
+    ],
+    toDOM(node) {
+      return [`h${node.attrs.level}`, 0];
     }
   });
 }
-function addHeadingInputRule() {
-  return addInputRule(({ schema }) => {
+function defineHeadingKeymap() {
+  return defineKeymap({
+    "mod-1": toggleNode({ type: "heading", attrs: { level: 1 } }),
+    "mod-2": toggleNode({ type: "heading", attrs: { level: 2 } }),
+    "mod-3": toggleNode({ type: "heading", attrs: { level: 3 } }),
+    "mod-4": toggleNode({ type: "heading", attrs: { level: 4 } }),
+    "mod-5": toggleNode({ type: "heading", attrs: { level: 5 } }),
+    "mod-6": toggleNode({ type: "heading", attrs: { level: 6 } })
+  });
+}
+function defineHeadingInputRule() {
+  return defineInputRule(({ schema }) => {
     const nodeSpec = getNodeType(schema, "heading");
-    const inputRule = textblockTypeInputRule(
-      /^(#{1,6})\s/,
-      nodeSpec,
-      (match) => {
-        var _a, _b;
-        const level = (_b = (_a = match[1]) == null ? void 0 : _a.length) != null ? _b : 1;
-        return { level };
-      }
-    );
-    return [inputRule];
+    return textblockTypeInputRule(/^(#{1,6})\s/, nodeSpec, (match) => {
+      var _a, _b;
+      const level = (_b = (_a = match[1]) == null ? void 0 : _a.length) != null ? _b : 1;
+      return { level };
+    });
+  });
+}
+function defineHeadingCommands() {
+  return defineCommands({
+    setHeading: (attrs) => {
+      return setBlockType({ type: "heading", attrs });
+    },
+    insertHeading: (attrs) => {
+      return insertNode({ type: "heading", attrs });
+    },
+    toggleHeading: (attrs) => {
+      return toggleNode({ type: "heading", attrs });
+    }
   });
 }
-function addHeading() {
-  return defineExtension([addHeadingSpec(), addHeadingInputRule()]);
+function defineHeading() {
+  return union([
+    defineHeadingSpec(),
+    defineHeadingInputRule(),
+    defineHeadingKeymap(),
+    defineHeadingCommands()
+  ]);
 }
 export {
-  addHeading,
-  addHeadingInputRule,
-  addHeadingSpec
+  defineHeading,
+  defineHeadingCommands,
+  defineHeadingInputRule,
+  defineHeadingKeymap,
+  defineHeadingSpec
 };

package/dist/prosekit-extensions-image.d.ts

@@ -0,0 +1,4 @@
+export { defineImageSpec } from './_tsup-dts-rollup';
+export { defineImageCommands } from './_tsup-dts-rollup';
+export { defineImage } from './_tsup-dts-rollup';
+export { ImageAttrs } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-image.js

@@ -0,0 +1,48 @@
+// src/image/index.ts
+import {
+  defineCommands,
+  defineNodeSpec,
+  insertNode,
+  union
+} from "@prosekit/core";
+function defineImageSpec() {
+  return defineNodeSpec({
+    name: "image",
+    attrs: {
+      src: { default: null }
+    },
+    group: "block",
+    defining: true,
+    parseDOM: [
+      {
+        tag: "img[src]",
+        getAttrs: (element) => {
+          if (typeof element === "string") {
+            return { src: null };
+          }
+          const src = element.getAttribute("src") || null;
+          return { src };
+        }
+      }
+    ],
+    toDOM(node) {
+      const attrs = node.attrs;
+      return ["img", attrs];
+    }
+  });
+}
+function defineImageCommands() {
+  return defineCommands({
+    insertImage: (attrs) => {
+      return insertNode({ type: "image", attrs });
+    }
+  });
+}
+function defineImage() {
+  return union([defineImageSpec(), defineImageCommands()]);
+}
+export {
+  defineImage,
+  defineImageCommands,
+  defineImageSpec
+};

package/dist/prosekit-extensions-italic.d.ts

@@ -1,20 +1,4 @@
-import * as _prosekit_core from '@prosekit/core';
-
-declare function addItalicSpec(): _prosekit_core.Extension<{
-    MARKS: "italic";
-}>;
-declare function addItalicCommands(): _prosekit_core.Extension<{
-    COMMAND_ARGS: {
-        toggleItalic: [];
-    };
-}>;
-declare function addItalicKeymap(): _prosekit_core.Extension<_prosekit_core.ExtensionTyping<string, string, _prosekit_core.CommandArgs>>;
-/** @public */
-declare function addItalic(): _prosekit_core.Extension<{
-    MARKS: "italic";
-    COMMAND_ARGS: {
-        toggleItalic: [];
-    };
-}>;
-
-export { addItalic, addItalicCommands, addItalicKeymap, addItalicSpec };
+export { defineItalicSpec } from './_tsup-dts-rollup';
+export { defineItalicCommands } from './_tsup-dts-rollup';
+export { defineItalicKeymap_alias_1 as defineItalicKeymap } from './_tsup-dts-rollup';
+export { defineItalic } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-italic.js

@@ -1,50 +1,48 @@
 // src/italic/index.ts
 import {
-  addCommands,
-  addKeymap,
-  addMarkSpec,
-  defineExtension,
+  defineCommands,
+  defineKeymap,
+  defineMarkSpec,
+  union,
   toggleMark
 } from "@prosekit/core";
-function addItalicSpec() {
-  return addMarkSpec({
+function defineItalicSpec() {
+  return defineMarkSpec({
     name: "italic",
-    spec: {
-      parseDOM: [
-        { tag: "i" },
-        { tag: "em" },
-        { style: "font-style=italic" },
-        {
-          style: "font-style=normal",
-          clearMark: (m) => m.type.name === "italic"
-        }
-      ],
-      toDOM() {
-        return ["em", 0];
+    parseDOM: [
+      { tag: "i" },
+      { tag: "em" },
+      { style: "font-style=italic" },
+      {
+        style: "font-style=normal",
+        clearMark: (m) => m.type.name === "italic"
       }
+    ],
+    toDOM() {
+      return ["em", 0];
     }
   });
 }
-function addItalicCommands() {
-  return addCommands({
+function defineItalicCommands() {
+  return defineCommands({
     toggleItalic: () => toggleMark({ type: "italic" })
   });
 }
-function addItalicKeymap() {
-  return addKeymap({
+function defineItalicKeymap() {
+  return defineKeymap({
     "Mod-i": toggleMark({ type: "italic" })
   });
 }
-function addItalic() {
-  return defineExtension([
-    addItalicSpec(),
-    addItalicCommands(),
-    addItalicKeymap()
+function defineItalic() {
+  return union([
+    defineItalicSpec(),
+    defineItalicCommands(),
+    defineItalicKeymap()
   ]);
 }
 export {
-  addItalic,
-  addItalicCommands,
-  addItalicKeymap,
-  addItalicSpec
+  defineItalic,
+  defineItalicCommands,
+  defineItalicKeymap,
+  defineItalicSpec
 };

package/dist/prosekit-extensions-link.d.ts

@@ -0,0 +1,4 @@
+export { defineLinkSpec } from './_tsup-dts-rollup';
+export { defineLinkCommands } from './_tsup-dts-rollup';
+export { defineLink } from './_tsup-dts-rollup';
+export { LinkAttrs } from './_tsup-dts-rollup';