@kerebron/editor 0.4.28 → 0.4.29

package/src/plugins/input-rules/mod.ts

@@ -0,0 +1,2 @@
+export * from './InputRulesPlugin.js';
+export * from './rulebuilders.js';

package/src/plugins/input-rules/rulebuilders.ts

@@ -0,0 +1,88 @@
+import { canJoin, findWrapping } from 'prosemirror-transform';
+import { Attrs, Fragment, Node, NodeType, Slice } from 'prosemirror-model';
+
+import { InputRule } from './InputRulesPlugin.js';
+
+/// Build an input rule for automatically wrapping a textblock when a
+/// given string is typed. The `regexp` argument is
+/// directly passed through to the `InputRule` constructor. You'll
+/// probably want the regexp to start with `^`, so that the pattern can
+/// only occur at the start of a textblock.
+///
+/// `nodeType` is the type of node to wrap in. If it needs attributes,
+/// you can either pass them directly, or pass a function that will
+/// compute them from the regular expression match.
+///
+/// By default, if there's a node with the same type above the newly
+/// wrapped node, the rule will try to [join](#transform.Transform.join) those
+/// two nodes. You can pass a join predicate, which takes a regular
+/// expression match and the node before the wrapped node, and can
+/// return a boolean to indicate whether a join should happen.
+export function wrappingInputRule(
+  regexp: RegExp,
+  nodeType: NodeType,
+  getAttrs: Attrs | null | ((matches: RegExpMatchArray) => Attrs | null) = null,
+  joinPredicate?: (match: RegExpMatchArray, node: Node) => boolean,
+) {
+  return new InputRule(regexp, (state, match, start, end) => {
+    const attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+    const tr = state.tr.delete(start, end);
+    const $start = tr.doc.resolve(start);
+    const range = $start.blockRange();
+    const wrapping = range && findWrapping(range, nodeType, attrs);
+    if (!wrapping) return null;
+    tr.wrap(range!, wrapping);
+    const before = tr.doc.resolve(start - 1).nodeBefore;
+    if (
+      before && before.type == nodeType && canJoin(tr.doc, start - 1) &&
+      (!joinPredicate || joinPredicate(match, before))
+    ) {
+      tr.join(start - 1);
+    }
+    return tr;
+  });
+}
+
+/// Build an input rule that changes the type of a textblock when the
+/// matched text is typed into it. You'll usually want to start your
+/// regexp with `^` to that it is only matched at the start of a
+/// textblock. The optional `getAttrs` parameter can be used to compute
+/// the new node's attributes, and works the same as in the
+/// `wrappingInputRule` function.
+export function textblockTypeInputRule(
+  regexp: RegExp,
+  nodeType: NodeType,
+  getAttrs: Attrs | null | ((match: RegExpMatchArray) => Attrs | null) = null,
+) {
+  return new InputRule(regexp, (state, match, start, end) => {
+    const $start = state.doc.resolve(start);
+    const attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+    if (
+      !$start.node(-1).canReplaceWith(
+        $start.index(-1),
+        $start.indexAfter(-1),
+        nodeType,
+      )
+    ) return null;
+    return state.tr
+      .delete(start, end)
+      .setBlockType(start, start, nodeType, attrs);
+  });
+}
+
+export function replaceInlineNode(
+  regexp: RegExp,
+  nodeType: NodeType,
+  getAttrs: Attrs | null | ((matches: RegExpMatchArray) => Attrs | null) = null,
+) {
+  return new InputRule(regexp, (state, match, start, end) => {
+    const attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+    const node = nodeType.createAndFill(attrs);
+    const slice = new Slice(Fragment.from(node), 0, 0);
+
+    const tr = state.tr;
+    const from = tr.mapping.map(start);
+    const to = tr.mapping.map(end);
+    return tr.replace(from, to, slice);
+  });
+}

package/src/plugins/keymap/keymap.ts

@@ -0,0 +1,117 @@
+import { Plugin } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+
+import type { Command } from '../../commands/types.js';
+import { base, keyName } from './w3c-keyname.js';
+
+const mac = typeof navigator != 'undefined' &&
+  /Mac|iP(hone|[oa]d)/.test(navigator?.platform);
+const windows = typeof navigator != 'undefined' &&
+  /Win/.test(navigator?.platform);
+
+function normalizeKeyName(name: string) {
+  let parts = name.split(/-(?!$)/), result = parts[parts.length - 1];
+  if (result == 'Space') result = ' ';
+  let alt, ctrl, shift, 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)) shift = true;
+    else if (/^mod$/i.test(mod)) {
+      if (mac) 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 (shift) result = 'Shift-' + result;
+  return result;
+}
+
+function normalize(map: { [key: string]: Command }) {
+  let copy: { [key: string]: Command } = Object.create(null);
+  for (let prop in map) copy[normalizeKeyName(prop)] = map[prop];
+  return copy;
+}
+
+function modifiers(name: string, event: KeyboardEvent, shift = true) {
+  if (event.altKey) name = 'Alt-' + name;
+  if (event.ctrlKey) name = 'Ctrl-' + name;
+  if (event.metaKey) name = 'Meta-' + name;
+  if (shift && event.shiftKey) name = 'Shift-' + name;
+  return name;
+}
+
+/// Create a keymap plugin for the given set of bindings.
+///
+/// Bindings should map key names to [command](#commands)-style
+/// functions, which will be called with `(EditorState, dispatch,
+/// EditorView)` arguments, and should return true when they've handled
+/// the key. Note that the view argument isn't part of the command
+/// protocol, but can be used as an escape hatch if a binding needs to
+/// directly interact with the UI.
+///
+/// Key names may be strings like `"Shift-Ctrl-Enter"`—a key
+/// identifier prefixed with zero or more modifiers. Key identifiers
+/// are based on the strings that can appear in
+/// [`KeyEvent.key`](https:///developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key).
+/// Use lowercase letters to refer to letter keys (or uppercase letters
+/// if you want shift to be held). You may use `"Space"` as an alias
+/// for the `" "` name.
+///
+/// Modifiers can be given in any order. `Shift-` (or `s-`), `Alt-` (or
+/// `a-`), `Ctrl-` (or `c-` or `Control-`) and `Cmd-` (or `m-` or
+/// `Meta-`) are recognized. For characters that are created by holding
+/// shift, the `Shift-` prefix is implied, and should not be added
+/// explicitly.
+///
+/// You can use `Mod-` as a shorthand for `Cmd-` on Mac and `Ctrl-` on
+/// other platforms.
+///
+/// You can add multiple keymap plugins to an editor. The order in
+/// which they appear determines their precedence (the ones early in
+/// the array get to dispatch first).
+export class KeymapPlugin extends Plugin {
+  constructor(bindings: { [key: string]: Command }) {
+    super({ props: { handleKeyDown: keydownHandler(bindings) } });
+  }
+}
+
+/// Given a set of bindings (using the same format as
+/// [`keymap`](#keymap.keymap)), return a [keydown
+/// handler](#view.EditorProps.handleKeyDown) that handles them.
+export function keydownHandler(
+  bindings: { [key: string]: Command },
+): (view: EditorView, event: KeyboardEvent) => boolean {
+  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;
+    // A character key
+    if (name.length == 1 && name != ' ') {
+      if (event.shiftKey) {
+        // In case the name was already modified by shift, try looking
+        // it up without its shift modifier
+        let noShift = map[modifiers(name, event, false)];
+        if (noShift && noShift(view.state, view.dispatch, view)) return true;
+      }
+      if (
+        (event.altKey || event.metaKey || event.ctrlKey) &&
+        // Ctrl-Alt may be used for AltGr on Windows
+        !(windows && event.ctrlKey && event.altKey) &&
+        (baseName = base[event.keyCode]) && baseName != name
+      ) {
+        // Try falling back to the keyCode when there's a modifier
+        // active or the character produced isn't ASCII, and our table
+        // produces a different name from the the keyCode. See #668,
+        // #1060, #1529.
+        let fromCode = map[modifiers(baseName, event)];
+        if (fromCode && fromCode(view.state, view.dispatch, view)) return true;
+      }
+    }
+    return false;
+  };
+}

package/src/plugins/keymap/mod.ts

@@ -0,0 +1 @@
+export * from './keymap.js';

package/src/plugins/keymap/w3c-keyname.ts

@@ -0,0 +1,123 @@
+export const base: Record<number, string> = {
+  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: "'",
+};
+
+export const shift: Record<number, string> = {
+  48: ')',
+  49: '!',
+  50: '@',
+  51: '#',
+  52: '$',
+  53: '%',
+  54: '^',
+  55: '&',
+  56: '*',
+  57: '(',
+  59: ':',
+  61: '+',
+  173: '_',
+  186: ':',
+  187: '+',
+  188: '<',
+  189: '_',
+  190: '>',
+  191: '?',
+  192: '~',
+  219: '{',
+  220: '|',
+  221: '}',
+  222: '"',
+};
+
+const mac = typeof navigator != 'undefined' && /Mac/.test(navigator.platform);
+const ie = typeof navigator != 'undefined' &&
+  /MSIE \d|Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(navigator.userAgent);
+
+// Fill in the digit keys
+for (let i = 0; i < 10; i++) base[48 + i] = base[96 + i] = String(i);
+
+// The function keys
+for (let i = 1; i <= 24; i++) base[i + 111] = 'F' + i;
+
+// And the alphabetic keys
+for (let i = 65; i <= 90; i++) {
+  base[i] = String.fromCharCode(i + 32);
+  shift[i] = String.fromCharCode(i);
+}
+
+// For each code that doesn't have a shift-equivalent, copy the base name
+for (const code in base) {
+  if (!shift.hasOwnProperty(code)) shift[code] = base[code];
+}
+
+export function keyName(event: KeyboardEvent) {
+  // On macOS, keys held with Shift and Cmd don't reflect the effect of Shift in `.key`.
+  // On IE, shift effect is never included in `.key`.
+  const ignoreKey =
+    mac && event.metaKey && event.shiftKey && !event.ctrlKey && !event.altKey ||
+    ie && event.shiftKey && event.key && event.key.length == 1 ||
+    event.key == 'Unidentified';
+  let name: string = (!ignoreKey && event.key) ||
+    (event.shiftKey ? shift : base)[event.keyCode] ||
+    event.key || 'Unidentified';
+  // Edge sometimes produces wrong names (Issue #3)
+  if (name == 'Esc') name = 'Escape';
+  if (name == 'Del') name = 'Delete';
+  // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/8860571/
+  if (name == 'Left') name = 'ArrowLeft';
+  if (name == 'Up') name = 'ArrowUp';
+  if (name == 'Right') name = 'ArrowRight';
+  if (name == 'Down') name = 'ArrowDown';
+  return name;
+}

package/src/search/mod.ts

@@ -0,0 +1,2 @@
+export * from './query.js';
+export * from './search.js';