@kerebron/extension-basic-editor 0.4.28 → 0.4.30

package/src/NodeDefinitionTerm.ts

@@ -0,0 +1,19 @@
+import { NodeSpec } from 'prosemirror-model';
+import { Node } from '@kerebron/editor';
+
+export class NodeDefinitionTerm extends Node {
+  override name = 'dt';
+  requires = ['dl'];
+
+  override getNodeSpec(): NodeSpec {
+    return {
+      content: 'inline*',
+      group: 'block',
+      parseDOM: [{ tag: 'dt' }],
+      defining: true,
+      toDOM() {
+        return ['dt', 0];
+      },
+    };
+  }
+}

package/src/NodeDocument.ts

@@ -0,0 +1,22 @@
+import { NodeSpec, SchemaSpec } from 'prosemirror-model';
+import { Node } from '@kerebron/editor';
+
+export class NodeDocument extends Node {
+  override name = 'doc';
+
+  override getNodeSpec(): NodeSpec {
+    return {
+      content: 'block+',
+      marks: 'code em strong link bookmark', // TODO: why is it necessary for convertCodeParagraphsToCodeBlocks?
+      EMPTY_DOC: {
+        'type': this.name,
+        'content': [
+          {
+            'type': 'paragraph',
+            'content': [],
+          },
+        ],
+      },
+    };
+  }
+}

package/src/NodeDocumentCode.ts

@@ -0,0 +1,33 @@
+import { NodeSpec } from 'prosemirror-model';
+
+import { Node } from '@kerebron/editor';
+
+export class NodeDocumentCode extends Node {
+  override name = 'doc_code';
+
+  override getNodeSpec(): NodeSpec {
+    return {
+      content: 'code_block',
+      defaultAttrs: {
+        'lang': this.config.lang || null,
+      },
+      EMPTY_DOC: {
+        'type': this.name,
+        'content': [
+          {
+            'type': 'code_block',
+            'attrs': {
+              'lang': this.config.lang || null,
+            },
+            'content': [
+              // {
+              //   "type": "text",
+              // "text": ""
+              // }
+            ],
+          },
+        ],
+      },
+    };
+  }
+}

package/src/NodeFrontmatter.ts

@@ -0,0 +1,19 @@
+import { NodeSpec, NodeType } from 'prosemirror-model';
+import { Node } from '@kerebron/editor';
+
+export class NodeFrontmatter extends Node {
+  override name = 'frontmatter';
+  requires = ['doc'];
+
+  override getNodeSpec(): NodeSpec {
+    return {
+      content: 'inline*',
+      group: 'block',
+      defining: true,
+      parseDOM: [{ tag: 'pre' }],
+      toDOM() {
+        return ['pre', 0];
+      },
+    };
+  }
+}

package/src/NodeHardBreak.ts

@@ -0,0 +1,92 @@
+import type { NodeSpec, NodeType } from 'prosemirror-model';
+import { type CoreEditor, Node } from '@kerebron/editor';
+import {
+  type CommandFactories,
+  type CommandShortcuts,
+} from '@kerebron/editor/commands';
+import { firstCommand } from '@kerebron/editor/commands';
+
+export class NodeHardBreak extends Node {
+  override name = 'br';
+  requires = ['doc'];
+
+  options = {
+    keepMarks: true,
+  };
+
+  override getNodeSpec(): NodeSpec {
+    return {
+      inline: true,
+      group: 'inline',
+      selectable: false,
+      linebreakReplacement: true,
+      parseDOM: [{ tag: 'br' }],
+      toDOM() {
+        return ['br'];
+      },
+    };
+  }
+
+  override getCommandFactories(
+    editor: CoreEditor,
+    type: NodeType,
+  ): Partial<CommandFactories> {
+    // TODO: refactor commands
+    // const comm2: Command = (state: EditorState, dispatch?: (tr: Transaction) => void) => {
+    //   const { selection, storedMarks } = state
+
+    //   if (selection.$from.parent.type.spec.isolating) {
+    //       return false
+    //   }
+
+    //   const { keepMarks } = this.options
+    //   // const { splittableMarks } = editor.extensionManager
+    //   const splittableMarks = [];
+    //   const marks = storedMarks
+    //       || (selection.$to.parentOffset && selection.$from.marks())
+
+    //   return editor.chain()
+    //     .insertContent({ type: this.name })
+    //     .command(({ tr, dispatch }) => {
+    //         if (dispatch && marks && keepMarks) {
+    //           for (const mark of marks) {
+    //             console.log('mteset', mark.type);
+    //           }
+    //             const filteredMarks = marks
+    //                 .filter(mark => splittableMarks.includes(mark.type.name))
+
+    //             tr.ensureMarks(filteredMarks)
+    //         }
+
+    //         return true
+    //     })
+    //     .run();
+    // }
+
+    const setHardBreak = firstCommand(
+      editor.run.exitCode,
+      // comm2
+    );
+
+    return {
+      'setHardBreak': () => setHardBreak,
+    };
+  }
+
+  override getKeyboardShortcuts(): Partial<CommandShortcuts> {
+    // https://stackoverflow.com/a/73619128
+    const mac = typeof navigator != 'undefined'
+      ? /Mac|iP(hone|[oa]d)/.test(navigator?.platform)
+      : false;
+
+    const shortcuts: Partial<CommandShortcuts> = {
+      'Ctrl-Enter': 'setHardBreak',
+    };
+    if (mac) {
+      shortcuts['Mod-Enter'] = 'setHardBreak';
+      shortcuts['Shift-Enter'] = 'setHardBreak';
+    }
+
+    return shortcuts;
+  }
+}

package/src/NodeHeading.ts

@@ -0,0 +1,76 @@
+import type { NodeSpec, NodeType } from 'prosemirror-model';
+
+import { type CoreEditor, Node } from '@kerebron/editor';
+import {
+  type CommandFactories,
+  type CommandShortcuts,
+} from '@kerebron/editor/commands';
+import {
+  type InputRule,
+  textblockTypeInputRule,
+} from '@kerebron/editor/plugins/input-rules';
+
+const maxLevel = 6;
+
+export class NodeHeading extends Node {
+  override name = 'heading';
+  requires = ['doc'];
+
+  override getNodeSpec(): NodeSpec {
+    return {
+      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];
+      },
+    };
+  }
+
+  override getInputRules(type: NodeType): InputRule[] {
+    /// Given a node type and a maximum level, creates an input rule that
+    /// turns up to that number of `#` characters followed by a space at
+    /// the start of a textblock into a heading whose level corresponds to
+    /// the number of `#` signs.
+    return [
+      textblockTypeInputRule(
+        new RegExp('^(#{1,' + maxLevel + '})\\s$'),
+        type,
+        (match) => ({ level: match[1].length }),
+      ),
+    ];
+  }
+
+  override getCommandFactories(
+    editor: CoreEditor,
+    type: NodeType,
+  ): Partial<CommandFactories> {
+    const commands: Partial<CommandFactories> = {};
+
+    for (let i = 1; i <= maxLevel; i++) {
+      commands['setHeading' + i] = () =>
+        editor.commandFactories.setBlockType(type, { level: i });
+    }
+
+    return commands;
+  }
+
+  override getKeyboardShortcuts(): Partial<CommandShortcuts> {
+    const keys: Partial<CommandShortcuts> = {};
+
+    for (let i = 1; i <= maxLevel; i++) {
+      keys['Shift-Ctrl-' + i] = 'setHeading' + i;
+    }
+
+    return keys;
+  }
+}

package/src/NodeHorizontalRule.ts

@@ -0,0 +1,43 @@
+import type { NodeSpec, NodeType } from 'prosemirror-model';
+import { type CoreEditor, Node } from '@kerebron/editor';
+import type {
+  CommandFactories,
+  CommandShortcuts,
+} from '@kerebron/editor/commands';
+
+export class NodeHorizontalRule extends Node {
+  override name = 'hr';
+  requires = ['doc'];
+
+  override getNodeSpec(): NodeSpec {
+    return {
+      group: 'block',
+      parseDOM: [{ tag: 'hr' }],
+      toDOM() {
+        return ['hr'];
+      },
+    };
+  }
+
+  override getCommandFactories(
+    editor: CoreEditor,
+    type: NodeType,
+  ): Partial<CommandFactories> {
+    return {
+      'setHorizontalRule': () => (state, dispatch) => {
+        if (dispatch) {
+          dispatch(
+            state.tr.replaceSelectionWith(type.create()).scrollIntoView(),
+          );
+        }
+        return true;
+      },
+    };
+  }
+
+  override getKeyboardShortcuts(): Partial<CommandShortcuts> {
+    return {
+      'Mod-_': 'setHorizontalRule',
+    };
+  }
+}

package/src/NodeImage.ts

@@ -0,0 +1,36 @@
+import { type NodeSpec } from 'prosemirror-model';
+import { Node } from '@kerebron/editor';
+
+export class NodeImage extends Node {
+  override name = 'image';
+  requires = ['doc'];
+
+  override getNodeSpec(): NodeSpec {
+    return {
+      inline: true,
+      attrs: {
+        src: {},
+        alt: { default: null },
+        title: { default: null },
+      },
+      group: 'inline',
+      draggable: true,
+      parseDOM: [
+        {
+          tag: 'img[src]',
+          getAttrs(dom: HTMLElement) {
+            return {
+              src: dom.getAttribute('src'),
+              title: dom.getAttribute('title'),
+              alt: dom.getAttribute('alt'),
+            };
+          },
+        },
+      ],
+      toDOM(node) {
+        const { src, alt, title } = node.attrs;
+        return ['img', { src, alt, title }];
+      },
+    };
+  }
+}

package/src/NodeInlineShortCode.ts

@@ -0,0 +1,55 @@
+import { Node as PmNode, NodeSpec, NodeType } from 'prosemirror-model';
+import { Node } from '@kerebron/editor';
+import {
+  type InputRule,
+  replaceInlineNode,
+  textblockTypeInputRule,
+  wrappingInputRule,
+} from '@kerebron/editor/plugins/input-rules';
+
+export function fixCharacters(text: string) {
+  return text
+    .replace(/’/g, "'")
+    .replace(/“/g, '"')
+    .replace(/”/g, '"')
+    // deno-lint-ignore no-control-regex
+    .replace(/\x0b/g, ' ')
+    .replace(/\u201d/g, '"')
+    .replace(/\u201c/g, '"');
+}
+
+export class NodeInlineShortCode extends Node {
+  override name = 'shortcode-inline';
+  requires = ['doc'];
+
+  override getNodeSpec(): NodeSpec {
+    return {
+      inline: true,
+      group: 'inline',
+      selectable: true,
+      attrs: {
+        content: {},
+      },
+      atom: true,
+      parseDOM: [{ tag: 'span.kb-shortcode-inline' }],
+      toDOM(node) {
+        return ['span', { class: 'kb-shortcode-inline' }, node.attrs.content];
+      },
+    };
+  }
+
+  override getInputRules(type: NodeType): InputRule[] {
+    return [
+      replaceInlineNode(
+        /\{\{[^}]+\}\}/,
+        type,
+        (match: RegExpMatchArray) => {
+          const content = fixCharacters(
+            match[0].substring(2, match[0].length - 2),
+          );
+          return { content };
+        },
+      ),
+    ];
+  }
+}