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

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

@@ -0,0 +1,214 @@
+import {
+  defineTextBlockInputRule
+} from "./chunk-DYFRBXUX.js";
+import {
+  defineTextBlockEnterRule
+} from "./chunk-ASTUC4KT.js";
+
+// src/code-block/code-block.ts
+import { union } from "@prosekit/core";
+
+// src/code-block/code-block-commands.ts
+import {
+  defineCommands,
+  insertNode,
+  setBlockType,
+  setNodeAttrs,
+  toggleNode
+} from "@prosekit/core";
+function defineCodeBlockCommands() {
+  return defineCommands({
+    setCodeBlock: (attrs) => {
+      return setBlockType({ type: "codeBlock", attrs });
+    },
+    insertCodeBlock: (attrs) => {
+      return insertNode({ type: "codeBlock", attrs });
+    },
+    toggleCodeBlock: (attrs) => {
+      return toggleNode({ type: "codeBlock", attrs });
+    },
+    setCodeBlockAttrs: (attrs) => {
+      return setNodeAttrs({ type: "codeBlock", attrs });
+    }
+  });
+}
+
+// src/code-block/code-block-input-rule.ts
+function defineCodeBlockInputRule() {
+  return defineTextBlockInputRule({
+    regex: /^```(\S*)\s$/,
+    type: "codeBlock",
+    attrs: getAttrs
+  });
+}
+function defineCodeBlockEnterRule() {
+  return defineTextBlockEnterRule({
+    regex: /^```(\S*)$/,
+    type: "codeBlock",
+    attrs: getAttrs
+  });
+}
+function getAttrs(match) {
+  return { language: match[1] || "" };
+}
+
+// src/code-block/code-block-keymap.ts
+import { defaultBlockAt, defineKeymap } from "@prosekit/core";
+import { TextSelection } from "@prosekit/pm/state";
+function defineCodeBlockKeymap() {
+  return defineKeymap({
+    Enter: existCodeBlock
+  });
+}
+var existCodeBlock = (state, dispatch) => {
+  if (!state.selection.empty) {
+    return false;
+  }
+  const { $head } = state.selection;
+  const parent = $head.parent;
+  if (parent.isTextblock && parent.type.spec.code && $head.parentOffset === parent.content.size && parent.textContent.endsWith("\n\n")) {
+    const grandParent = $head.node(-1);
+    const insertIndex = $head.indexAfter(-1);
+    const type = defaultBlockAt(grandParent.contentMatchAt(insertIndex));
+    if (!type || !grandParent.canReplaceWith(insertIndex, insertIndex, type)) {
+      return false;
+    }
+    if (dispatch) {
+      const { tr } = state;
+      tr.delete($head.pos - 2, $head.pos);
+      const pos = tr.selection.$head.after();
+      const node = type.createAndFill();
+      if (node) {
+        tr.replaceWith(pos, pos, node);
+        tr.setSelection(TextSelection.near(tr.doc.resolve(pos), 1));
+        dispatch(tr.scrollIntoView());
+      }
+    }
+    return true;
+  }
+  return false;
+};
+
+// src/code-block/code-block-spec.ts
+import { defineNodeSpec } from "@prosekit/core";
+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 }, ["code", 0]];
+    }
+  });
+}
+
+// src/code-block/code-block.ts
+function defineCodeBlock() {
+  return union([
+    defineCodeBlockSpec(),
+    defineCodeBlockInputRule(),
+    defineCodeBlockEnterRule(),
+    defineCodeBlockKeymap(),
+    defineCodeBlockCommands()
+  ]);
+}
+
+// src/code-block/code-block-highlight.ts
+import { definePlugin } from "@prosekit/core";
+import { createHighlightPlugin } from "prosemirror-highlight";
+function defineCodeBlockHighlight({
+  parser
+}) {
+  return definePlugin(
+    createHighlightPlugin({ parser, nodeTypes: ["codeBlock"] })
+  );
+}
+
+// src/code-block/shiki-parser.ts
+import { createParser } from "prosemirror-highlight/shiki";
+function createHighlighterLoader() {
+  let highlighterPromise;
+  let highlighter;
+  const loadLangs = /* @__PURE__ */ new Set();
+  return function highlighterLoader(lang, options) {
+    if (!highlighterPromise) {
+      highlighterPromise = import("./shiki-import-25BJYIO2.js").then(({ getHighlighter }) => {
+        return getHighlighter(options);
+      }).then((h) => {
+        highlighter = h;
+      });
+      return { promise: highlighterPromise };
+    }
+    if (!highlighter) {
+      return { promise: highlighterPromise };
+    }
+    if (!loadLangs.has(lang)) {
+      const promise = highlighter.loadLanguage(lang).then(() => {
+        loadLangs.add(lang);
+      }).catch((error) => {
+        console.warn(`Failed to load language '${lang}'`, error);
+      });
+      return { promise };
+    }
+    return { highlighter };
+  };
+}
+function createLazyParser(highlighterOptions) {
+  let parser;
+  const highlighterLoader = createHighlighterLoader();
+  return function lazyParser(options) {
+    const language = options.language || "";
+    const { highlighter, promise } = highlighterLoader(
+      language,
+      highlighterOptions
+    );
+    if (!highlighter) {
+      return promise || [];
+    }
+    if (!parser) {
+      parser = createParser(highlighter);
+    }
+    return parser(options);
+  };
+}
+
+// src/code-block/code-block-shiki.ts
+function defineCodeBlockShiki({
+  themes = ["one-dark-pro"],
+  langs = ["text"],
+  langAlias = {}
+} = {}) {
+  const parser = createLazyParser({ themes, langs, langAlias });
+  return defineCodeBlockHighlight({ parser });
+}
+
+// src/code-block/shiki-bundle.ts
+import {
+  bundledLanguagesInfo,
+  bundledThemesInfo
+} from "shiki";
+export {
+  defineCodeBlock,
+  defineCodeBlockCommands,
+  defineCodeBlockEnterRule,
+  defineCodeBlockHighlight,
+  defineCodeBlockInputRule,
+  defineCodeBlockShiki,
+  defineCodeBlockSpec,
+  bundledLanguagesInfo as shikiBundledLanguagesInfo,
+  bundledThemesInfo as shikiBundledThemesInfo
+};

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-drop-cursor.d.ts

@@ -0,0 +1,2 @@
+export { defineDropCursor } from './_tsup-dts-rollup';
+export { DropCursorOptions } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-drop-cursor.js

@@ -0,0 +1,9 @@
+// src/drop-cursor/index.ts
+import { definePlugin } from "@prosekit/core";
+import { dropCursor } from "prosemirror-dropcursor";
+function defineDropCursor(options) {
+  return definePlugin(() => dropCursor(options));
+}
+export {
+  defineDropCursor
+};

package/dist/prosekit-extensions-enter-rule.d.ts

@@ -0,0 +1,5 @@
+export { defineEnterRule } from './_tsup-dts-rollup';
+export { defineTextBlockEnterRule } from './_tsup-dts-rollup';
+export { EnterRuleHandler } from './_tsup-dts-rollup';
+export { EnterRuleOptions } from './_tsup-dts-rollup';
+export { TextBlockEnterRuleOptions } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-enter-rule.js

@@ -0,0 +1,8 @@
+import {
+  defineEnterRule,
+  defineTextBlockEnterRule
+} from "./chunk-ASTUC4KT.js";
+export {
+  defineEnterRule,
+  defineTextBlockEnterRule
+};

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,87 @@
+import {
+  defineTextBlockInputRule
+} from "./chunk-DYFRBXUX.js";
+
 // src/heading/index.ts
 import {
-  addInputRule,
-  addNodeSpec,
-  defineExtension,
-  getNodeType
+  defineCommands,
+  defineKeymap,
+  defineNodeSpec,
+  insertNode,
+  setBlockType,
+  toggleNode,
+  union,
+  withSkipCodeBlock
 } 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 defineHeadingKeymap() {
+  return defineKeymap({
+    "mod-1": toggleHeadingKeybinding(1),
+    "mod-2": toggleHeadingKeybinding(2),
+    "mod-3": toggleHeadingKeybinding(3),
+    "mod-4": toggleHeadingKeybinding(4),
+    "mod-5": toggleHeadingKeybinding(5),
+    "mod-6": toggleHeadingKeybinding(6)
+  });
+}
+function toggleHeadingKeybinding(level) {
+  return withSkipCodeBlock(toggleNode({ type: "heading", attrs: { level } }));
+}
+function defineHeadingInputRule() {
+  return defineTextBlockInputRule({
+    regex: /^(#{1,6})\s$/,
+    type: "heading",
+    attrs: (match) => {
+      var _a, _b;
+      const level = (_b = (_a = match[1]) == null ? void 0 : _a.length) != null ? _b : 1;
+      return { level };
     }
   });
 }
-function addHeadingInputRule() {
-  return addInputRule(({ 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];
+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,49 @@
+// 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,
+    draggable: 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-input-rule.d.ts

@@ -0,0 +1,3 @@
+export { defineInputRule } from './_tsup-dts-rollup';
+export { defineTextBlockInputRule } from './_tsup-dts-rollup';
+export { defineWrappingInputRule } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-input-rule.js

@@ -0,0 +1,10 @@
+import {
+  defineInputRule,
+  defineTextBlockInputRule,
+  defineWrappingInputRule
+} from "./chunk-DYFRBXUX.js";
+export {
+  defineInputRule,
+  defineTextBlockInputRule,
+  defineWrappingInputRule
+};

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,6 @@
+export { defineLinkSpec } from './_tsup-dts-rollup';
+export { defineLinkCommands } from './_tsup-dts-rollup';
+export { defineLinkInputRule } from './_tsup-dts-rollup';
+export { defineLinkEnterRule } from './_tsup-dts-rollup';
+export { defineLink } from './_tsup-dts-rollup';
+export { LinkAttrs } from './_tsup-dts-rollup';