prosekit 0.0.0-next-20230627094841

package/dist/chunk-NAWSCY5F.js

@@ -0,0 +1,166 @@
+import {
+  ProseKitError,
+  addPlugin
+} from "./chunk-2MVHS73Q.js";
+import {
+  Decoration,
+  DecorationSet
+} from "./chunk-UWHQRU5N.js";
+import {
+  Plugin,
+  PluginKey
+} from "./chunk-UTNVEPBA.js";
+
+// ../extension-suggestion/src/is-valid.ts
+function defaultIsValid({ state }) {
+  return state.selection.empty && !isInsideCode(state.selection.$from);
+}
+function isInsideCode($pos) {
+  for (let d = $pos.depth; d > 0; d--) {
+    if ($pos.node(d).type.spec.code) {
+      return true;
+    }
+  }
+  return $pos.marks().some((mark) => mark.type.name === "code");
+}
+
+// ../extension-suggestion/src/plugin.ts
+var pluginKey = new PluginKey("prosemirror-prediction");
+function getPluginState(state) {
+  return pluginKey.getState(state);
+}
+function getTrMeta(tr) {
+  return tr.getMeta(pluginKey);
+}
+function setTrMeta(tr, meta) {
+  return tr.setMeta(pluginKey, meta);
+}
+function createPredictionPlugin(options) {
+  if (options.rules.length === 0) {
+    throw new ProseKitError(
+      "You can't create a prediction plugin without rules"
+    );
+  }
+  const { onMatch, onDeactivate, isValid = defaultIsValid } = options;
+  return new Plugin({
+    key: pluginKey,
+    state: {
+      init: () => {
+        return { active: false, ignore: null, matching: null };
+      },
+      apply: (tr, prevValue, oldState, newState) => {
+        var _a;
+        const meta = getTrMeta(tr);
+        if (!tr.docChanged && oldState.selection.eq(newState.selection) && !meta) {
+          return prevValue;
+        }
+        if (meta) {
+          return meta;
+        }
+        if (!isValid({ state: newState })) {
+          return { active: false, ignore: null, matching: null };
+        }
+        const nextValue = calcPluginState(newState, options.rules);
+        if (nextValue.active && prevValue.ignore != null && ((_a = nextValue.matching) == null ? void 0 : _a.from) === prevValue.ignore) {
+          return prevValue;
+        }
+        return nextValue;
+      }
+    },
+    view: () => ({
+      update: (view, prevState) => {
+        const prevPluginState = getPluginState(prevState);
+        const currPluginState = getPluginState(view.state);
+        if ((currPluginState == null ? void 0 : currPluginState.active) && currPluginState.matching && currPluginState.matching.from !== currPluginState.ignore) {
+          const { from, to } = currPluginState.matching;
+          const dismiss = () => {
+            view.dispatch(
+              setTrMeta(view.state.tr, {
+                active: false,
+                ignore: from,
+                matching: null
+              })
+            );
+          };
+          const textContent = view.state.doc.textBetween(from, to, "\uFFFC");
+          const deleteMatch = () => {
+            if (view.state.doc.textBetween(from, to, "\uFFFC") === textContent) {
+              view.dispatch(view.state.tr.delete(from, to));
+            }
+          };
+          onMatch({
+            rule: currPluginState.matching.rule,
+            match: currPluginState.matching.match,
+            matchAfter: currPluginState.matching.matchAfter,
+            state: view.state,
+            dismiss,
+            deleteMatch
+          });
+        } else if (prevPluginState == null ? void 0 : prevPluginState.active) {
+          onDeactivate();
+        }
+      }
+    }),
+    props: {
+      decorations: (state) => {
+        const pluginState = getPluginState(state);
+        if ((pluginState == null ? void 0 : pluginState.active) && pluginState.matching) {
+          const { from, to } = pluginState.matching;
+          const deco = Decoration.inline(from, to, {
+            class: "prosemirror-prediction-match",
+            style: "background-color: lightblue"
+          });
+          return DecorationSet.create(state.doc, [deco]);
+        }
+        return null;
+      }
+    }
+  });
+}
+function calcPluginState(state, rules) {
+  const { $anchor } = state.selection;
+  const matchAfter = rules.some((rule) => rule.matchAfter);
+  const parentOffset = $anchor.parentOffset;
+  const textBefore = $anchor.parent.textBetween(
+    Math.max(0, parentOffset - MAX_MATCH),
+    parentOffset,
+    null,
+    "\uFFFC"
+  );
+  const textAfter = matchAfter ? $anchor.parent.textBetween(
+    parentOffset,
+    Math.min(parentOffset + MAX_MATCH, $anchor.parent.content.size),
+    null
+  ) : "";
+  for (const rule of rules) {
+    const match = textBefore.match(rule.match);
+    const matchAfter2 = rule.matchAfter ? textAfter.match(rule.matchAfter) : null;
+    if (match && match.index != null) {
+      const from = $anchor.pos - textBefore.length + match.index;
+      const to = $anchor.pos + (matchAfter2 ? matchAfter2[0].length : 0);
+      return {
+        active: true,
+        ignore: null,
+        matching: {
+          rule,
+          from,
+          to,
+          match,
+          matchAfter: matchAfter2
+        }
+      };
+    }
+  }
+  return { active: false };
+}
+var MAX_MATCH = 200;
+
+// ../extension-suggestion/src/index.ts
+function addSuggestion(options) {
+  const plugin = createPredictionPlugin(options);
+  return addPlugin({ plugins: [plugin] });
+}
+
+export {
+  addSuggestion
+};

package/dist/chunk-S64NFSV2.js

@@ -0,0 +1,236 @@
+import {
+  flip,
+  inline,
+  offset,
+  shift,
+  size
+} from "./chunk-CDGN4JUS.js";
+import {
+  b,
+  blockComponentStyles,
+  e,
+  n,
+  r,
+  s,
+  t
+} from "./chunk-CG5B6PMC.js";
+import {
+  addSuggestion
+} from "./chunk-NAWSCY5F.js";
+import {
+  ProseKitError
+} from "./chunk-2MVHS73Q.js";
+import {
+  __decorateClass
+} from "./chunk-S65R2BUY.js";
+
+// ../lit/src/utils/is-menu.ts
+function isMenu(element) {
+  var _a, _b;
+  return ((_a = element == null ? void 0 : element.tagName) == null ? void 0 : _a.toLowerCase()) === "prosekit-menu" || ["menu"].includes((_b = element == null ? void 0 : element.getAttribute("role")) != null ? _b : "");
+}
+
+// ../lit/src/elements/popover-suggestion/controller.ts
+var PopoverSuggestionController = class {
+  constructor(host, editor, rules, onContext) {
+    this.host = host;
+    this.editor = editor;
+    this.rules = rules;
+    this.onContext = onContext;
+    this.connected = false;
+    this.reference = null;
+    this.removeExtension = null;
+    if (!editor) {
+      throw new ProseKitError("Missing 'editor' property");
+    }
+    if (!rules) {
+      throw new ProseKitError("Missing 'rules' property");
+    }
+    this.host.addController(this);
+  }
+  hostUpdated() {
+    var _a;
+    if (this.connected)
+      return;
+    this.connected = true;
+    const editor = this.editor;
+    if (!editor) {
+      throw new ProseKitError("Missing 'editor' property");
+    }
+    if (!this.rules) {
+      throw new ProseKitError("Missing 'rules' property");
+    }
+    const extension = addSuggestion({
+      rules: this.rules,
+      onMatch: ({ dismiss, deleteMatch, match, matchAfter }) => {
+        var _a2, _b;
+        const span = editor.view.dom.querySelector(
+          ".prosemirror-prediction-match"
+        );
+        if (span) {
+          this.reference = span;
+        }
+        const matchText = match[0] + ((_a2 = matchAfter == null ? void 0 : matchAfter[0]) != null ? _a2 : "");
+        (_b = this.onContext) == null ? void 0 : _b.call(this, {
+          active: true,
+          query: matchText,
+          onDismiss: () => {
+            dismiss();
+          },
+          onSubmit: () => {
+            deleteMatch();
+          }
+        });
+      },
+      onDeactivate: () => {
+        this.reference = null;
+        setTimeout(() => {
+          var _a2;
+          (_a2 = this.onContext) == null ? void 0 : _a2.call(this, {
+            active: false
+          });
+        });
+      }
+    });
+    (_a = this.removeExtension) == null ? void 0 : _a.call(this);
+    this.removeExtension = editor.use(extension);
+  }
+  hostDisconnected() {
+    var _a;
+    this.connected = false;
+    (_a = this.removeExtension) == null ? void 0 : _a.call(this);
+    this.removeExtension = null;
+  }
+};
+
+// ../lit/src/elements/popover-suggestion/options.ts
+var defaultDetectOverflowOptions = {
+  // Make sure the popover is always at least 8px away from the boundary
+  padding: 8
+};
+var defaultPopoverOptions = {
+  placement: "bottom-end",
+  middleware: [
+    offset(({ rects }) => ({
+      // Put the popover at the bottom right corner
+      alignmentAxis: -rects.floating.width,
+      // Move down the popover by 4px
+      mainAxis: 4
+    })),
+    size({
+      apply: ({ availableHeight, elements }) => {
+        const style = {
+          // Minimum acceptable height is 100px.
+          // `flip` will then take over.
+          maxHeight: `${Math.max(100, availableHeight)}px`,
+          overflowY: "auto"
+        };
+        Object.assign(elements.floating.style, style);
+      },
+      ...defaultDetectOverflowOptions
+    }),
+    // Flip the popover to the top if it's overflowing the viewport
+    flip({
+      fallbackStrategy: "initialPlacement",
+      fallbackAxisSideDirection: "start",
+      crossAxis: false,
+      ...defaultDetectOverflowOptions
+    }),
+    shift({
+      ...defaultDetectOverflowOptions
+    }),
+    // Use the text caret as the reference point
+    inline()
+  ]
+};
+
+// ../lit/src/elements/popover-suggestion/popover-suggestion.ts
+var PopoverSuggestion = class extends s {
+  /** @hidden */
+  constructor() {
+    super();
+    this.popoverOptions = defaultPopoverOptions;
+    this.context = { active: false };
+  }
+  /** @hidden */
+  firstUpdated() {
+    setTimeout(() => {
+      this.controller = new PopoverSuggestionController(
+        this,
+        this.editor,
+        this.rules,
+        (context) => {
+          var _a;
+          (_a = this.onContext) == null ? void 0 : _a.call(this, context);
+          this.context = context;
+          requestAnimationFrame(() => {
+            var _a2, _b;
+            (_b = (_a2 = this.queryMenu()) == null ? void 0 : _a2.ensureFocusedItem) == null ? void 0 : _b.call(_a2);
+          });
+        }
+      );
+    });
+  }
+  /** @hidden */
+  get active() {
+    var _a;
+    return !!((_a = this.controller) == null ? void 0 : _a.reference);
+  }
+  /** @hidden */
+  queryMenu() {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.defaultSlot) == null ? void 0 : _a.assignedElements({ flatten: true })) == null ? void 0 : _b.find(isMenu)) != null ? _c : null;
+  }
+  /** @hidden */
+  render() {
+    var _a, _b;
+    return b`
+      <prosekit-popover
+        .active=${this.active}
+        .reference=${(_b = (_a = this.controller) == null ? void 0 : _a.reference) != null ? _b : void 0}
+        .options=${this.popoverOptions}
+      >
+        <slot
+          @menu-dismiss=${() => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = this.context) == null ? void 0 : _a2.onDismiss) == null ? void 0 : _b2.call(_a2);
+    }}
+          @menu-select=${() => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = this.context) == null ? void 0 : _a2.onSubmit) == null ? void 0 : _b2.call(_a2);
+    }}
+        ></slot>
+      </prosekit-popover>
+    `;
+  }
+};
+/** @hidden */
+PopoverSuggestion.styles = blockComponentStyles;
+__decorateClass([
+  n({ attribute: false })
+], PopoverSuggestion.prototype, "editor", 2);
+__decorateClass([
+  n({ attribute: false })
+], PopoverSuggestion.prototype, "popoverOptions", 2);
+__decorateClass([
+  n({ attribute: false })
+], PopoverSuggestion.prototype, "rules", 2);
+__decorateClass([
+  t()
+], PopoverSuggestion.prototype, "context", 2);
+__decorateClass([
+  n({ attribute: false })
+], PopoverSuggestion.prototype, "onContext", 2);
+__decorateClass([
+  t()
+], PopoverSuggestion.prototype, "controller", 2);
+__decorateClass([
+  r("slot")
+], PopoverSuggestion.prototype, "defaultSlot", 2);
+PopoverSuggestion = __decorateClass([
+  e("prosekit-popover-suggestion")
+], PopoverSuggestion);
+
+export {
+  PopoverSuggestion
+};

package/dist/chunk-S65R2BUY.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+
+export {
+  __decorateClass
+};

package/dist/chunk-T2V5UU6H.js

@@ -0,0 +1,204 @@
+import {
+  Plugin
+} from "./chunk-UTNVEPBA.js";
+
+// ../../node_modules/.pnpm/w3c-keyname@2.2.6/node_modules/w3c-keyname/index.es.js
+var base = {
+  8: "Backspace",
+  9: "Tab",
+  10: "Enter",
+  12: "NumLock",
+  13: "Enter",
+  16: "Shift",
+  17: "Control",
+  18: "Alt",
+  20: "CapsLock",
+  27: "Escape",
+  32: " ",
+  33: "PageUp",
+  34: "PageDown",
+  35: "End",
+  36: "Home",
+  37: "ArrowLeft",
+  38: "ArrowUp",
+  39: "ArrowRight",
+  40: "ArrowDown",
+  44: "PrintScreen",
+  45: "Insert",
+  46: "Delete",
+  59: ";",
+  61: "=",
+  91: "Meta",
+  92: "Meta",
+  106: "*",
+  107: "+",
+  108: ",",
+  109: "-",
+  110: ".",
+  111: "/",
+  144: "NumLock",
+  145: "ScrollLock",
+  160: "Shift",
+  161: "Shift",
+  162: "Control",
+  163: "Control",
+  164: "Alt",
+  165: "Alt",
+  173: "-",
+  186: ";",
+  187: "=",
+  188: ",",
+  189: "-",
+  190: ".",
+  191: "/",
+  192: "`",
+  219: "[",
+  220: "\\",
+  221: "]",
+  222: "'"
+};
+var shift = {
+  48: ")",
+  49: "!",
+  50: "@",
+  51: "#",
+  52: "$",
+  53: "%",
+  54: "^",
+  55: "&",
+  56: "*",
+  57: "(",
+  59: ":",
+  61: "+",
+  173: "_",
+  186: ":",
+  187: "+",
+  188: "<",
+  189: "_",
+  190: ">",
+  191: "?",
+  192: "~",
+  219: "{",
+  220: "|",
+  221: "}",
+  222: '"'
+};
+var chrome = typeof navigator != "undefined" && /Chrome\/(\d+)/.exec(navigator.userAgent);
+var gecko = typeof navigator != "undefined" && /Gecko\/\d+/.test(navigator.userAgent);
+var mac = typeof navigator != "undefined" && /Mac/.test(navigator.platform);
+var ie = typeof navigator != "undefined" && /MSIE \d|Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(navigator.userAgent);
+var brokenModifierNames = mac || chrome && +chrome[1] < 57;
+for (i = 0; i < 10; i++)
+  base[48 + i] = base[96 + i] = String(i);
+var i;
+for (i = 1; i <= 24; i++)
+  base[i + 111] = "F" + i;
+var i;
+for (i = 65; i <= 90; i++) {
+  base[i] = String.fromCharCode(i + 32);
+  shift[i] = String.fromCharCode(i);
+}
+var i;
+for (code in base)
+  if (!shift.hasOwnProperty(code))
+    shift[code] = base[code];
+var code;
+function keyName(event) {
+  var ignoreKey = brokenModifierNames && (event.ctrlKey || event.altKey || event.metaKey) || ie && event.shiftKey && event.key && event.key.length == 1 || event.key == "Unidentified";
+  var name = !ignoreKey && event.key || (event.shiftKey ? shift : base)[event.keyCode] || event.key || "Unidentified";
+  if (name == "Esc")
+    name = "Escape";
+  if (name == "Del")
+    name = "Delete";
+  if (name == "Left")
+    name = "ArrowLeft";
+  if (name == "Up")
+    name = "ArrowUp";
+  if (name == "Right")
+    name = "ArrowRight";
+  if (name == "Down")
+    name = "ArrowDown";
+  return name;
+}
+
+// ../../node_modules/.pnpm/prosemirror-keymap@1.2.2/node_modules/prosemirror-keymap/dist/index.js
+var mac2 = typeof navigator != "undefined" ? /Mac|iP(hone|[oa]d)/.test(navigator.platform) : false;
+function normalizeKeyName(name) {
+  let parts = name.split(/-(?!$)/), result = parts[parts.length - 1];
+  if (result == "Space")
+    result = " ";
+  let alt, ctrl, shift2, meta;
+  for (let i = 0; i < parts.length - 1; i++) {
+    let mod = parts[i];
+    if (/^(cmd|meta|m)$/i.test(mod))
+      meta = true;
+    else if (/^a(lt)?$/i.test(mod))
+      alt = true;
+    else if (/^(c|ctrl|control)$/i.test(mod))
+      ctrl = true;
+    else if (/^s(hift)?$/i.test(mod))
+      shift2 = true;
+    else if (/^mod$/i.test(mod)) {
+      if (mac2)
+        meta = true;
+      else
+        ctrl = true;
+    } else
+      throw new Error("Unrecognized modifier name: " + mod);
+  }
+  if (alt)
+    result = "Alt-" + result;
+  if (ctrl)
+    result = "Ctrl-" + result;
+  if (meta)
+    result = "Meta-" + result;
+  if (shift2)
+    result = "Shift-" + result;
+  return result;
+}
+function normalize(map) {
+  let copy = /* @__PURE__ */ Object.create(null);
+  for (let prop in map)
+    copy[normalizeKeyName(prop)] = map[prop];
+  return copy;
+}
+function modifiers(name, event, shift2 = true) {
+  if (event.altKey)
+    name = "Alt-" + name;
+  if (event.ctrlKey)
+    name = "Ctrl-" + name;
+  if (event.metaKey)
+    name = "Meta-" + name;
+  if (shift2 && event.shiftKey)
+    name = "Shift-" + name;
+  return name;
+}
+function keymap(bindings) {
+  return new Plugin({ props: { handleKeyDown: keydownHandler(bindings) } });
+}
+function keydownHandler(bindings) {
+  let map = normalize(bindings);
+  return function(view, event) {
+    let name = keyName(event), baseName, direct = map[modifiers(name, event)];
+    if (direct && direct(view.state, view.dispatch, view))
+      return true;
+    if (name.length == 1 && name != " ") {
+      if (event.shiftKey) {
+        let noShift = map[modifiers(name, event, false)];
+        if (noShift && noShift(view.state, view.dispatch, view))
+          return true;
+      }
+      if ((event.shiftKey || event.altKey || event.metaKey || name.charCodeAt(0) > 127) && (baseName = base[event.keyCode]) && baseName != name) {
+        let fromCode = map[modifiers(baseName, event)];
+        if (fromCode && fromCode(view.state, view.dispatch, view))
+          return true;
+      }
+    }
+    return false;
+  };
+}
+
+export {
+  keymap,
+  keydownHandler
+};

package/dist/chunk-TWIMWRRZ.js

@@ -0,0 +1,57 @@
+import {
+  addInputRule,
+  addNodeSpec,
+  defineExtension,
+  getNodeType
+} from "./chunk-2MVHS73Q.js";
+import {
+  textblockTypeInputRule
+} from "./chunk-JMNJUDT7.js";
+
+// ../extension-heading/src/index.ts
+function addHeadingSpec() {
+  return addNodeSpec({
+    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];
+      }
+    }
+  });
+}
+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 addHeading() {
+  return defineExtension([addHeadingSpec(), addHeadingInputRule()]);
+}
+
+export {
+  addHeadingSpec,
+  addHeadingInputRule,
+  addHeading
+};