@lobehub/editor 1.0.0

package/es/plugins/list/plugin/index.js

@@ -0,0 +1,193 @@
+var _class;
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { $createListNode, $isListItemNode, $isListNode, ListItemNode, ListNode, registerList, registerListStrictIndentTransform } from '@lexical/list';
+import { $getNearestNodeOfType } from '@lexical/utils';
+import { cx } from 'antd-style';
+import { $createParagraphNode, $getSelection, $isRangeSelection, $isRootNode, $isTextNode, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_LOW, INDENT_CONTENT_COMMAND, INSERT_TAB_COMMAND, KEY_BACKSPACE_COMMAND, KEY_TAB_COMMAND, OUTDENT_CONTENT_COMMAND } from 'lexical';
+import { KernelPlugin } from "../../../editor-kernel/plugin";
+import { IMarkdownShortCutService } from "../../markdown";
+import { $indentOverTab, listReplace } from "../utils";
+var ORDERED_LIST_REGEX = /^(\s*)(\d+)\.\s/;
+var UNORDERED_LIST_REGEX = /^(\s*)[*+-]\s/;
+var CHECK_LIST_REGEX = /^(\s*)(?:-\s)?\s?(\[(\s|x)?])\s/i;
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+
+export var ListPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
+  _inherits(ListPlugin, _KernelPlugin);
+  var _super = _createSuper(ListPlugin);
+  function ListPlugin(kernel, config) {
+    var _kernel$requireServic, _kernel$requireServic2, _kernel$requireServic3, _kernel$requireServic4, _kernel$requireServic5;
+    var _this;
+    _classCallCheck(this, ListPlugin);
+    _this = _super.call(this);
+    // Register the list nodes
+    _this.kernel = kernel;
+    kernel.registerNodes([ListNode, ListItemNode]);
+    // Register themes for list nodes
+    kernel.registerThemes({
+      // Define themes for list nodes here
+      list: {
+        listitem: 'editor_listItem',
+        nested: {
+          listitem: 'editor_listItemNested'
+        },
+        ol: cx('editor_listOrdered', config === null || config === void 0 ? void 0 : config.theme),
+        olDepth: ['editor_listOrdered dp1', 'editor_listOrdered dp2', 'editor_listOrdered dp3', 'editor_listOrdered dp4', 'editor_listOrdered dp5'],
+        ul: cx('editor_listUnordered', config === null || config === void 0 ? void 0 : config.theme)
+      }
+    });
+    (_kernel$requireServic = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic === void 0 || _kernel$requireServic.registerMarkdownShortCut({
+      regExp: UNORDERED_LIST_REGEX,
+      replace: listReplace('bullet'),
+      type: 'element'
+    });
+    (_kernel$requireServic2 = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic2 === void 0 || _kernel$requireServic2.registerMarkdownShortCut({
+      regExp: ORDERED_LIST_REGEX,
+      replace: listReplace('number'),
+      type: 'element'
+    });
+    (_kernel$requireServic3 = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic3 === void 0 || _kernel$requireServic3.registerMarkdownShortCut({
+      regExp: CHECK_LIST_REGEX,
+      replace: listReplace('check'),
+      type: 'element'
+    });
+    (_kernel$requireServic4 = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic4 === void 0 || _kernel$requireServic4.registerMarkdownWriter(ListNode.getType(), function (ctx, node) {
+      if ($isListNode(node)) {
+        ctx.wrap('', '\n');
+      }
+    });
+    var getLevel = function getLevel(node) {
+      if (!node) return 0;
+      if ($isRootNode(node.getParent())) {
+        return 0;
+      }
+      var parent = node.getParent();
+      if (!parent) {
+        return 0;
+      }
+      return getLevel($getNearestNodeOfType(parent, ListNode)) + 1;
+    };
+    (_kernel$requireServic5 = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic5 === void 0 || _kernel$requireServic5.registerMarkdownWriter(ListItemNode.getType(), function (ctx, node) {
+      var parent = node.getParent();
+      if ($isListItemNode(node) && $isListNode(parent)) {
+        if ($isListNode(node.getFirstChild())) {
+          return;
+        }
+        var level = getLevel(parent);
+        var prefix = '    '.repeat(level);
+        switch (parent.getListType()) {
+          case 'bullet':
+            {
+              ctx.wrap(prefix + '- ', '\n');
+              break;
+            }
+          case 'number':
+            {
+              ctx.wrap("".concat(prefix).concat(node.getValue(), ". "), '\n');
+              break;
+            }
+          case 'check':
+            {
+              ctx.wrap("".concat(prefix, "[").concat(node.getChecked() ? 'x' : ' ', "] "), '\n');
+              break;
+            }
+          default:
+            {
+              break;
+            }
+        }
+      }
+    });
+    return _this;
+  }
+  _createClass(ListPlugin, [{
+    key: "onInit",
+    value: function onInit(editor) {
+      this.register(registerList(editor));
+      this.register(registerListStrictIndentTransform(editor));
+      this.registerClears(editor.registerCommand(KEY_TAB_COMMAND, function (event) {
+        var selection = $getSelection();
+        if (!$isRangeSelection(selection)) {
+          return false;
+        }
+        event.preventDefault();
+        var command = $indentOverTab(selection) ? event.shiftKey ? OUTDENT_CONTENT_COMMAND : INDENT_CONTENT_COMMAND : INSERT_TAB_COMMAND;
+        return editor.dispatchCommand(command, undefined);
+      }, COMMAND_PRIORITY_EDITOR), editor.registerCommand(KEY_BACKSPACE_COMMAND, function (event) {
+        var _listItemNode$getPare;
+        var selection = $getSelection();
+        if (!$isRangeSelection(selection) || !selection.isCollapsed()) {
+          return false;
+        }
+        var anchor = selection.anchor;
+        if (anchor.offset !== 0) {
+          return false;
+        }
+        var anchorNode = anchor.getNode();
+        var listItemNode;
+        if ($isTextNode(anchorNode)) {
+          // Do not handle non-leading text nodes
+          if (anchorNode.getPreviousSibling()) {
+            return false;
+          }
+          var parent = anchorNode.getParentOrThrow();
+          if (!$isListItemNode(parent)) {
+            return false;
+          }
+          listItemNode = parent;
+        }
+        if (!listItemNode || !$isRootNode((_listItemNode$getPare = listItemNode.getParent()) === null || _listItemNode$getPare === void 0 ? void 0 : _listItemNode$getPare.getParent())) {
+          return false;
+        }
+        var listNode = listItemNode.getParentOrThrow();
+        queueMicrotask(function () {
+          editor.update(function () {
+            // Add null check since listItemNode might be undefined in this closure
+            if (!listItemNode) return;
+            var newlistNode;
+            var isFirst = listItemNode.getPreviousSibling() === null;
+            if (isFirst) {
+              var _p = listItemNode.replace($createParagraphNode(), true);
+              _p.select(0, 0);
+              return;
+            }
+            var next = listItemNode.getNextSibling();
+            if (next) {
+              newlistNode = $createListNode(listNode.getListType(), listItemNode.getValue());
+            }
+            while (next && newlistNode) {
+              next.remove();
+              newlistNode.append(next);
+              next = next.getNextSibling();
+            }
+            var p = listItemNode.replace($createParagraphNode(), true);
+            p.remove();
+            listNode.insertAfter(p);
+            if (newlistNode) {
+              p.insertAfter(newlistNode);
+            }
+            p.select(0, 0);
+          });
+        });
+        event.stopImmediatePropagation();
+        event.preventDefault();
+        return true;
+      }, COMMAND_PRIORITY_LOW));
+    }
+  }]);
+  return ListPlugin;
+}(KernelPlugin), _defineProperty(_class, "pluginName", 'ListPlugin'), _class);

package/es/plugins/list/react/ReactListPlugin.d.ts

@@ -0,0 +1,4 @@
+import { type FC } from 'react';
+import { ReactListPluginProps } from './type';
+declare const ReactListPlugin: FC<ReactListPluginProps>;
+export default ReactListPlugin;

package/es/plugins/list/react/ReactListPlugin.js

@@ -0,0 +1,29 @@
+'use client';
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { useLayoutEffect } from 'react';
+import { useLexicalComposerContext } from "../../../editor-kernel/react/react-context";
+import { MarkdownPlugin } from "../../markdown";
+import { ListPlugin } from "../plugin";
+import { useStyles } from "./style";
+var ReactListPlugin = function ReactListPlugin() {
+  var _useLexicalComposerCo = useLexicalComposerContext(),
+    _useLexicalComposerCo2 = _slicedToArray(_useLexicalComposerCo, 1),
+    editor = _useLexicalComposerCo2[0];
+  var _useStyles = useStyles(),
+    styles = _useStyles.styles;
+  useLayoutEffect(function () {
+    editor.registerPlugin(MarkdownPlugin);
+    editor.registerPlugin(ListPlugin, {
+      theme: styles
+    });
+  }, []);
+  return null;
+};
+ReactListPlugin.displayName = 'ReactListPlugin';
+export default ReactListPlugin;

package/es/plugins/list/react/index.d.ts

@@ -0,0 +1,2 @@
+export { default as ReactListPlugin } from './ReactListPlugin';
+export type * from './type';

package/es/plugins/list/react/index.js

@@ -0,0 +1 @@
+export { default as ReactListPlugin } from "./ReactListPlugin";

package/es/plugins/list/react/style.d.ts

@@ -0,0 +1 @@
+export declare const useStyles: (props?: unknown) => import("antd-style").ReturnStyles<import("antd-style").SerializedStyles>;

package/es/plugins/list/react/style.js

@@ -0,0 +1,7 @@
+var _templateObject;
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+import { createStyles } from 'antd-style';
+export var useStyles = createStyles(function (_ref) {
+  var css = _ref.css;
+  return css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n    .editor_listUnordered&,\n    .editor_listOrdered& {\n      margin-block: calc(var(--lobe-markdown-margin-multiple) * 0.5em);\n      margin-inline-start: 1em;\n      padding-inline-start: 0;\n      list-style-position: outside;\n\n      > .editor_listUnordered,\n      > ol {\n        margin-block: 0;\n      }\n\n      > .editor_listItem {\n        margin-inline-start: 1em;\n      }\n    }\n\n    .editor_listOrdered& {\n      list-style: auto;\n    }\n\n    .editor_listUnordered& {\n      list-style-type: none;\n\n      > .editor_listItem:not(:has(ul)) {\n        &::before {\n          content: '-';\n          display: inline-block;\n          margin-inline: -1em 0.5em;\n          opacity: 0.5;\n        }\n      }\n    }\n\n    .editor_listItem {\n      margin-block: calc(var(--lobe-markdown-margin-multiple) * 0.33em);\n      font-family: var(--listitem-marker-font-family);\n      font-size: var(--listitem-marker-font-size);\n      background-color: var(--listitem-marker-background-color);\n\n      &::marker {\n        font-family: var(--listitem-marker-font-family);\n        font-size: var(--listitem-marker-font-size);\n        color: var(--listitem-marker-color);\n        background-color: var(--listitem-marker-background-color);\n      }\n\n      p {\n        display: inline;\n      }\n\n      .editor_listUnordered,\n      .editor_listOrdered {\n        margin: 0;\n      }\n    }\n\n    .editor_listItemNested {\n      list-style-type: none;\n    }\n  "])));
+});

package/es/plugins/list/react/type.d.ts

@@ -0,0 +1,3 @@
+export interface ReactListPluginProps {
+    className?: string;
+}

package/es/plugins/list/react/type.js

@@ -0,0 +1 @@
+export {};

package/es/plugins/list/utils/index.d.ts

@@ -0,0 +1,5 @@
+import { ListType } from '@lexical/list';
+import { RangeSelection } from 'lexical';
+import { ElementTransformer } from "../../markdown/service/shortcut";
+export declare const listReplace: (listType: ListType) => ElementTransformer['replace'];
+export declare function $indentOverTab(selection: RangeSelection): boolean;

package/es/plugins/list/utils/index.js

@@ -0,0 +1,88 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+import { $createListItemNode, $createListNode, $isListNode } from '@lexical/list';
+import { $filter, $getNearestBlockElementAncestorOrThrow } from '@lexical/utils';
+import { $createRangeSelection, $isBlockElementNode, $normalizeSelection__EXPERIMENTAL } from 'lexical';
+// Amount of spaces that define indentation level
+// TODO: should be an option
+var LIST_INDENT_SIZE = 4;
+function getIndent(whitespaces) {
+  var tabs = whitespaces.match(/\t/g);
+  var spaces = whitespaces.match(/ /g);
+  var indent = 0;
+  if (tabs) {
+    indent += tabs.length;
+  }
+  if (spaces) {
+    indent += Math.floor(spaces.length / LIST_INDENT_SIZE);
+  }
+  return indent;
+}
+export var listReplace = function listReplace(listType) {
+  return function (parentNode, children, match, isImport) {
+    var previousNode = parentNode.getPreviousSibling();
+    var nextNode = parentNode.getNextSibling();
+    var listItem = $createListItemNode(listType === 'check' ? match[3] === 'x' : undefined);
+    if ($isListNode(nextNode) && nextNode.getListType() === listType) {
+      var firstChild = nextNode.getFirstChild();
+      if (firstChild !== null) {
+        firstChild.insertBefore(listItem);
+      } else {
+        // should never happen, but let's handle gracefully, just in case.
+        nextNode.append(listItem);
+      }
+      parentNode.remove();
+    } else if ($isListNode(previousNode) && previousNode.getListType() === listType) {
+      previousNode.append(listItem);
+      parentNode.remove();
+    } else {
+      var list = $createListNode(listType, listType === 'number' ? Number(match[2]) : undefined);
+      list.append(listItem);
+      parentNode.replace(list);
+    }
+    listItem.append.apply(listItem, _toConsumableArray(children));
+    if (!isImport) {
+      listItem.select(0, 0);
+    }
+    var indent = getIndent(match[1]);
+    if (indent) {
+      listItem.setIndent(indent);
+    }
+  };
+};
+export function $indentOverTab(selection) {
+  // const handled = new Set();
+  var nodes = selection.getNodes();
+  var canIndentBlockNodes = $filter(nodes, function (node) {
+    if ($isBlockElementNode(node) && node.canIndent()) {
+      return node;
+    }
+    return null;
+  });
+  // 1. If selection spans across canIndent block nodes: indent
+  if (canIndentBlockNodes.length > 0) {
+    return true;
+  }
+  // 2. If first (anchor/focus) is at block start: indent
+  var anchor = selection.anchor;
+  var focus = selection.focus;
+  var first = focus.isBefore(anchor) ? focus : anchor;
+  var firstNode = first.getNode();
+  var firstBlock = $getNearestBlockElementAncestorOrThrow(firstNode);
+  if (firstBlock.canIndent()) {
+    var firstBlockKey = firstBlock.getKey();
+    var selectionAtStart = $createRangeSelection();
+    selectionAtStart.anchor.set(firstBlockKey, 0, 'element');
+    selectionAtStart.focus.set(firstBlockKey, 0, 'element');
+    selectionAtStart = $normalizeSelection__EXPERIMENTAL(selectionAtStart);
+    if (selectionAtStart.anchor.is(first)) {
+      return true;
+    }
+  }
+  // 3. Else: tab
+  return false;
+}

package/es/plugins/markdown/data-source/markdown-data-source.d.ts

@@ -0,0 +1,10 @@
+import { LexicalEditor } from 'lexical';
+import { DataSource } from "../../../editor-kernel";
+import { MarkdownShortCutService } from '../service/shortcut';
+export default class MarkdownDataSource extends DataSource {
+    protected dataType: string;
+    protected markdownService: MarkdownShortCutService;
+    constructor(dataType: string, markdownService: MarkdownShortCutService);
+    read(): void;
+    write(editor: LexicalEditor): any;
+}

package/es/plugins/markdown/data-source/markdown-data-source.js

@@ -0,0 +1,64 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import { $getRoot, $isElementNode } from 'lexical';
+import { DataSource } from "../../../editor-kernel";
+import { MarkdownWriterContext } from "./markdown-writer-context";
+var MarkdownDataSource = /*#__PURE__*/function (_DataSource) {
+  _inherits(MarkdownDataSource, _DataSource);
+  var _super = _createSuper(MarkdownDataSource);
+  function MarkdownDataSource(dataType, markdownService) {
+    var _this;
+    _classCallCheck(this, MarkdownDataSource);
+    _this = _super.call(this, dataType);
+    _this.dataType = dataType;
+    _this.markdownService = markdownService;
+    return _this;
+  }
+  _createClass(MarkdownDataSource, [{
+    key: "read",
+    value: function read() {
+      throw new Error('MarkdownDataSource not implemented yet!');
+    }
+  }, {
+    key: "write",
+    value: function write(editor) {
+      var _this2 = this;
+      return editor.getEditorState().read(function () {
+        var rootNode = $getRoot();
+        var rootCtx = new MarkdownWriterContext();
+        var processChild = function processChild(parentCtx, child) {
+          var writer = _this2.markdownService.markdownWriters[child.getType()];
+          var currentCtx = parentCtx;
+          if ($isElementNode(child)) {
+            currentCtx = currentCtx.newChild();
+          }
+          if (writer) {
+            writer(currentCtx, child);
+          }
+          if ($isElementNode(child)) {
+            child.getChildren().forEach(function (child) {
+              return processChild(currentCtx, child);
+            });
+          }
+        };
+        rootNode.getChildren().forEach(function (child) {
+          return processChild(rootCtx, child);
+        });
+        return rootCtx.toString();
+      });
+    }
+  }]);
+  return MarkdownDataSource;
+}(DataSource);
+export { MarkdownDataSource as default };

package/es/plugins/markdown/data-source/markdown-writer-context.d.ts

@@ -0,0 +1,12 @@
+import { IMarkdownWriterContext } from '../service/shortcut';
+export declare class MarkdownWriterContext implements IMarkdownWriterContext {
+    private before;
+    private after;
+    private children;
+    private processor?;
+    appendLine(line: string): void;
+    newChild(): MarkdownWriterContext;
+    wrap(before: string, after: string): void;
+    addProcessor(processor: (before: string, content: string, after: string) => string): void;
+    toString(): string;
+}

package/es/plugins/markdown/data-source/markdown-writer-context.js

@@ -0,0 +1,51 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+export var MarkdownWriterContext = /*#__PURE__*/function () {
+  function MarkdownWriterContext() {
+    _classCallCheck(this, MarkdownWriterContext);
+    _defineProperty(this, "before", '');
+    _defineProperty(this, "after", '');
+    _defineProperty(this, "children", []);
+    _defineProperty(this, "processor", void 0);
+  }
+  _createClass(MarkdownWriterContext, [{
+    key: "appendLine",
+    value: function appendLine(line) {
+      this.children.push(line);
+    }
+  }, {
+    key: "newChild",
+    value: function newChild() {
+      var child = new MarkdownWriterContext();
+      this.children.push(child);
+      return child;
+    }
+  }, {
+    key: "wrap",
+    value: function wrap(before, after) {
+      this.before = before;
+      this.after = after;
+    }
+  }, {
+    key: "addProcessor",
+    value: function addProcessor(processor) {
+      this.processor = processor;
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      var content = this.before + this.children.map(function (child) {
+        return child.toString();
+      }).join('') + this.after;
+      return this.processor ? this.processor(this.before, this.children.map(function (child) {
+        return child.toString();
+      }).join(''), this.after) : content;
+    }
+  }]);
+  return MarkdownWriterContext;
+}();

package/es/plugins/markdown/index.d.ts

@@ -0,0 +1,2 @@
+export { MarkdownPlugin } from './plugin';
+export { IMarkdownShortCutService } from './service/shortcut';

package/es/plugins/markdown/index.js

@@ -0,0 +1,2 @@
+export { MarkdownPlugin } from "./plugin";
+export { IMarkdownShortCutService } from "./service/shortcut";

package/es/plugins/markdown/plugin/index.d.ts

@@ -0,0 +1,4 @@
+import { IEditorPluginConstructor } from "../../../types";
+export interface MarkdownPluginOptions {
+}
+export declare const MarkdownPlugin: IEditorPluginConstructor<MarkdownPluginOptions>;

package/es/plugins/markdown/plugin/index.js

@@ -0,0 +1,122 @@
+var _class;
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { $isCodeNode } from '@lexical/code';
+import { $getNodeByKey, $getSelection, $isRangeSelection, $isTextNode, COLLABORATION_TAG, COMMAND_PRIORITY_CRITICAL, HISTORIC_TAG, KEY_ENTER_COMMAND } from 'lexical';
+import { KernelPlugin } from "../../../editor-kernel/plugin";
+import MarkdownDataSource from "../data-source/markdown-data-source";
+import { IMarkdownShortCutService, MarkdownShortCutService } from "../service/shortcut";
+import { canContainTransformableMarkdown } from "../utils";
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+
+export var MarkdownPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
+  _inherits(MarkdownPlugin, _KernelPlugin);
+  var _super = _createSuper(MarkdownPlugin);
+  function MarkdownPlugin(kernel) {
+    var _this;
+    _classCallCheck(this, MarkdownPlugin);
+    _this = _super.call(this);
+    _defineProperty(_assertThisInitialized(_this), "service", new MarkdownShortCutService());
+    _this.kernel = kernel;
+    kernel.registerService(IMarkdownShortCutService, _this.service);
+    // @todo To be implemented
+    kernel.registerDataSource(new MarkdownDataSource('markdown', _this.service));
+    return _this;
+  }
+  _createClass(MarkdownPlugin, [{
+    key: "onInit",
+    value: function onInit(editor) {
+      var _this2 = this;
+      this.register(editor.registerUpdateListener(function (_ref) {
+        var tags = _ref.tags,
+          dirtyLeaves = _ref.dirtyLeaves,
+          editorState = _ref.editorState,
+          prevEditorState = _ref.prevEditorState;
+        // Ignore updates from collaboration and undo/redo (as changes already calculated)
+        if (tags.has(COLLABORATION_TAG) || tags.has(HISTORIC_TAG)) {
+          return;
+        }
+
+        // If editor is still composing (i.e. backticks) we must wait before the user confirms the key
+        if (editor.isComposing()) {
+          return;
+        }
+        var selection = editorState.read($getSelection);
+        var prevSelection = prevEditorState.read($getSelection);
+
+        // We expect selection to be a collapsed range and not match previous one (as we want
+        // to trigger transforms only as user types)
+        if (!$isRangeSelection(prevSelection) || !$isRangeSelection(selection) || !selection.isCollapsed() || selection.is(prevSelection)) {
+          return;
+        }
+        var anchorKey = selection.anchor.key;
+        var anchorOffset = selection.anchor.offset;
+        var anchorNode = editorState._nodeMap.get(anchorKey);
+        if (!$isTextNode(anchorNode) || !dirtyLeaves.has(anchorKey) || anchorOffset !== 1 && anchorOffset > prevSelection.anchor.offset + 1) {
+          return;
+        }
+        editor.update(function () {
+          if (!canContainTransformableMarkdown(anchorNode)) {
+            return;
+          }
+          var parentNode = anchorNode.getParent();
+          if (parentNode === null || $isCodeNode(parentNode)) {
+            return;
+          }
+          _this2.service.runTransformers(parentNode, anchorNode, selection.anchor.offset);
+        });
+      }));
+      this.register(editor.registerCommand(KEY_ENTER_COMMAND, function (payload) {
+        var ret = editor.read(function () {
+          var selection = $getSelection();
+          if (!$isRangeSelection(selection) || !selection.isCollapsed()) {
+            return false;
+          }
+          var anchorKey = selection.anchor.key;
+          var anchorNode = $getNodeByKey(anchorKey);
+          if (!anchorNode) return false;
+          return {
+            anchorNode: anchorNode,
+            offset: selection.anchor.offset
+          };
+        });
+        if (!ret) return false;
+        var anchorNode = ret.anchorNode,
+          offset = ret.offset;
+        if (!canContainTransformableMarkdown(anchorNode)) {
+          return false;
+        }
+        var parentNode = anchorNode.getParent();
+        if (parentNode === null || $isCodeNode(parentNode)) {
+          return false;
+        }
+        if (_this2.service.testTransformers(parentNode, anchorNode, offset, 'enter')) {
+          queueMicrotask(function () {
+            editor.update(function () {
+              _this2.service.runTransformers(parentNode, anchorNode, offset, 'enter');
+            });
+          });
+          payload === null || payload === void 0 || payload.stopPropagation();
+          payload === null || payload === void 0 || payload.stopImmediatePropagation();
+          payload === null || payload === void 0 || payload.preventDefault();
+          return true;
+        }
+        return false;
+      }, COMMAND_PRIORITY_CRITICAL));
+    }
+  }]);
+  return MarkdownPlugin;
+}(KernelPlugin), _defineProperty(_class, "pluginName", 'MarkdownPlugin'), _class);