@atlaskit/editor-wikimarkup-transformer 9.5.3

package/dist/cjs/parser/tokenize/monospace.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.monospace = void 0;
+
+var _ = require("./");
+
+var _commonFormatter = require("./common-formatter");
+
+var _text = require("../text");
+
+var monospace = function monospace(_ref) {
+  var input = _ref.input,
+      position = _ref.position,
+      schema = _ref.schema,
+      context = _ref.context;
+
+  /**
+   * The following token types will be ignored in parsing
+   * the content
+   */
+  var ignoreTokenTypes = [_.TokenType.ADF_MACRO, _.TokenType.ANCHOR_MACRO, _.TokenType.CODE_MACRO, _.TokenType.QUOTE_MACRO, _.TokenType.NOFORMAT_MACRO, _.TokenType.PANEL_MACRO, _.TokenType.COLOR_MACRO, _.TokenType.LOREM_MACRO, _.TokenType.QUOTE, _.TokenType.STRING, _.TokenType.ISSUE_KEY, _.TokenType.LINK_FORMAT, _.TokenType.LINK_TEXT, _.TokenType.MEDIA, _.TokenType.HEADING, _.TokenType.LIST, _.TokenType.TABLE, _.TokenType.RULER, _.TokenType.HARD_BREAK, _.TokenType.DOUBLE_DASH_SYMBOL, _.TokenType.TRIPLE_DASH_SYMBOL, _.TokenType.QUADRUPLE_DASH_SYMBOL, _.TokenType.STRONG, _.TokenType.MONOSPACE, _.TokenType.SUPERSCRIPT, _.TokenType.SUBSCRIPT, _.TokenType.EMPHASIS, _.TokenType.CITATION, _.TokenType.DELETED, _.TokenType.INSERTED, _.TokenType.EMOJI, _.TokenType.FORCE_LINE_BREAK]; // Add code mark to each text
+
+  var contentDecorator = function contentDecorator(n) {
+    var mark = schema.marks.code.create(); // We don't want to mix `code` mark with others
+
+    if (n.type.name === 'text' && n.marks.length) {
+      return n;
+    }
+
+    return n.mark([mark]);
+  };
+
+  var rawContentProcessor = function rawContentProcessor(raw, length) {
+    var content = (0, _text.parseString)({
+      ignoreTokenTypes: ignoreTokenTypes,
+      schema: schema,
+      context: context,
+      input: raw
+    });
+    var decoratedContent = content.map(contentDecorator);
+    return {
+      type: 'pmnode',
+      nodes: decoratedContent,
+      length: length
+    };
+  };
+
+  return (0, _commonFormatter.commonFormatter)(input, position, schema, {
+    opening: '{{',
+    closing: '}}',
+    context: context,
+    rawContentProcessor: rawContentProcessor
+  });
+};
+
+exports.monospace = monospace;

package/dist/cjs/parser/tokenize/noformat-macro.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.noformatMacro = void 0;
+
+var _commonMacro = require("./common-macro");
+
+var _attrs = require("../utils/attrs");
+
+var _title = require("../utils/title");
+
+var noformatMacro = function noformatMacro(_ref) {
+  var input = _ref.input,
+      position = _ref.position,
+      schema = _ref.schema,
+      context = _ref.context;
+  return (0, _commonMacro.commonMacro)(input.substring(position), schema, {
+    keyword: 'noformat',
+    paired: true,
+    context: context,
+    rawContentProcessor: rawContentProcessor
+  });
+};
+
+exports.noformatMacro = noformatMacro;
+
+var rawContentProcessor = function rawContentProcessor(rawAttrs, rawContent, length, schema, _context) {
+  var output = [];
+  var codeBlock = schema.nodes.codeBlock;
+  var parsedAttrs = (0, _attrs.parseAttrs)(rawAttrs);
+  var trimedContent = rawContent.replace(/^\s+|\s+$/g, '');
+  var textNode = trimedContent.length ? schema.text(trimedContent) : undefined;
+
+  if (parsedAttrs.title) {
+    output.push((0, _title.title)(parsedAttrs.title, schema));
+  }
+
+  output.push(codeBlock.createChecked({}, textNode));
+  return {
+    type: 'pmnode',
+    nodes: output,
+    length: length
+  };
+};

package/dist/cjs/parser/tokenize/panel-macro.js

@@ -0,0 +1,106 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.panelMacro = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _commonMacro = require("./common-macro");
+
+var _text = require("../text");
+
+var _attrs = require("../utils/attrs");
+
+var _normalize = require("../utils/normalize");
+
+var _panelType = require("../utils/panel-type");
+
+var _title = require("../utils/title");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var allowedNodeType = ['paragraph', 'heading', 'orderedList', 'bulletList'];
+
+var panelMacro = function panelMacro(_ref) {
+  var input = _ref.input,
+      position = _ref.position,
+      schema = _ref.schema,
+      context = _ref.context;
+  return (0, _commonMacro.commonMacro)(input.substring(position), schema, {
+    keyword: 'panel',
+    paired: true,
+    context: context,
+    rawContentProcessor: rawContentProcessor
+  });
+};
+
+exports.panelMacro = panelMacro;
+
+var rawContentProcessor = function rawContentProcessor(rawAttrs, rawContent, length, schema, context) {
+  var output = [];
+  var parsedAttrs = (0, _attrs.parseAttrs)(rawAttrs);
+
+  var nodeAttrs = _objectSpread(_objectSpread({}, parsedAttrs), {}, {
+    panelType: (0, _panelType.getPanelType)(parsedAttrs)
+  });
+
+  var parsedContent = (0, _text.parseString)({
+    schema: schema,
+    context: context,
+    ignoreTokenTypes: [],
+    input: rawContent
+  });
+  var normalizedContent = (0, _normalize.normalizePMNodes)(parsedContent, schema);
+  var contentBuffer = parsedAttrs.title ? [(0, _title.title)(parsedAttrs.title, schema)] : [];
+
+  var _iterator = _createForOfIteratorHelper(normalizedContent),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var n = _step.value;
+
+      if (allowedNodeType.indexOf(n.type.name) !== -1) {
+        contentBuffer.push(n);
+      } else {
+        var _panelNode = schema.nodes.panel.createChecked(nodeAttrs, contentBuffer.length ? contentBuffer : schema.nodes.paragraph.createChecked());
+
+        contentBuffer = [];
+        output.push(_panelNode);
+        output.push(n);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  if (contentBuffer.length > 0) {
+    var panelNode = schema.nodes.panel.createChecked(nodeAttrs, contentBuffer);
+    output.push(panelNode);
+  }
+
+  return {
+    type: 'pmnode',
+    nodes: output.length ? output : [emptyPanel(schema)],
+    length: length
+  };
+};
+
+function emptyPanel(schema) {
+  var p = schema.nodes.paragraph.createChecked();
+  return schema.nodes.panel.createChecked({}, p);
+}

package/dist/cjs/parser/tokenize/quadruple-dash-symbol.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.quadrupleDashSymbol = void 0;
+var MULTI_DASH_REGEX = /^-{4,}(\s|$)/;
+
+var quadrupleDashSymbol = function quadrupleDashSymbol(_ref) {
+  var input = _ref.input,
+      position = _ref.position;
+  // This won't be a ruler because ruler has been checked at leadingKeywordMapping
+  var match = input.substring(position).match(MULTI_DASH_REGEX);
+
+  if (!match) {
+    return {
+      type: 'text',
+      text: '----',
+      length: 4
+    };
+  }
+
+  return {
+    type: 'text',
+    text: input.substr(position, match[0].length),
+    length: match[0].length
+  };
+};
+
+exports.quadrupleDashSymbol = quadrupleDashSymbol;

package/dist/cjs/parser/tokenize/quote-macro.js

@@ -0,0 +1,166 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.rawContentProcessor = exports.quoteMacro = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _commonMacro = require("./common-macro");
+
+var _text = require("../utils/text");
+
+var _normalize = require("../utils/normalize");
+
+var _text2 = require("../text");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+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; }
+
+var quoteMacro = function quoteMacro(_ref) {
+  var input = _ref.input,
+      position = _ref.position,
+      schema = _ref.schema,
+      context = _ref.context;
+  return (0, _commonMacro.commonMacro)(input.substring(position), schema, {
+    keyword: 'quote',
+    paired: true,
+    rawContentProcessor: rawContentProcessor,
+    context: context
+  });
+};
+
+exports.quoteMacro = quoteMacro;
+
+var rawContentProcessor = function rawContentProcessor(_rawAttrs, rawContent, length, schema, context) {
+  if (!rawContent.length) {
+    var emptyQuote = emptyBlockquote(schema);
+    return {
+      type: 'pmnode',
+      nodes: [emptyQuote],
+      length: length
+    };
+  }
+
+  var parsedContent = (0, _text2.parseString)({
+    schema: schema,
+    context: context,
+    ignoreTokenTypes: [],
+    input: rawContent
+  });
+  var normalizedContent = (0, _normalize.normalizePMNodes)(parsedContent, schema);
+  return {
+    type: 'pmnode',
+    nodes: sanitize(normalizedContent, schema),
+    length: length
+  };
+};
+
+exports.rawContentProcessor = rawContentProcessor;
+
+function emptyBlockquote(schema) {
+  var p = schema.nodes.paragraph.createChecked({}, []);
+  return schema.nodes.blockquote.createChecked({}, p);
+}
+
+function sanitize(nodes, schema) {
+  var output = [];
+  var contentBuffer = [];
+
+  var _iterator = _createForOfIteratorHelper(nodes),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var n = _step.value;
+
+      switch (n.type.name) {
+        case 'paragraph':
+          {
+            /**
+             * blockquote is happy with paragraph
+             */
+            contentBuffer.push(n);
+            break;
+          }
+
+        case 'heading':
+          {
+            /**
+             * If a heading is inside a list item
+             * - h1. Bold, Uppercase
+             * - h2. Bold, Italic
+             * - h3. Bold
+             * - h4. Bold, Gray
+             * - h5. Gray, Italic
+             * - h6. Gray
+             */
+            contentBuffer.push(transformHeading(n, schema));
+            break;
+          }
+
+        default:
+          /**
+           * Anything else should be lifted
+           */
+          if (contentBuffer.length) {
+            var _blockquote = schema.nodes.blockquote.createChecked({}, contentBuffer);
+
+            output.push(_blockquote);
+            contentBuffer = [];
+          }
+
+          output.push(n);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  if (contentBuffer.length) {
+    var blockquote = schema.nodes.blockquote.createChecked({}, contentBuffer);
+    output.push(blockquote);
+  }
+
+  return output;
+}
+
+function transformHeading(heading, schema) {
+  var contentBuffer = [];
+  heading.content.forEach(function (n) {
+    var strong = schema.marks.strong.create();
+    var italic = schema.marks.em.create();
+    var gray = schema.marks.textColor.create({
+      color: '#97a0af'
+    });
+
+    if (n.type.name === 'text') {
+      if (n.text && heading.attrs.level === 1) {
+        n.text = n.text.toUpperCase();
+      }
+
+      if (heading.attrs.level <= 4 && !(0, _text.hasAnyOfMarks)(n, ['strong', 'code'])) {
+        n = n.mark([].concat((0, _toConsumableArray2.default)(n.marks), [strong]));
+      }
+
+      if ((heading.attrs.level === 5 || heading.attrs.level === 2) && !(0, _text.hasAnyOfMarks)(n, ['em', 'code'])) {
+        n = n.mark([].concat((0, _toConsumableArray2.default)(n.marks), [italic]));
+      }
+
+      if (heading.attrs.level > 3 && !(0, _text.hasAnyOfMarks)(n, ['textColor', 'code'])) {
+        n = n.mark([].concat((0, _toConsumableArray2.default)(n.marks), [gray]));
+      }
+    }
+
+    contentBuffer.push(n);
+  });
+  return schema.nodes.paragraph.createChecked({}, contentBuffer);
+}

package/dist/cjs/parser/tokenize/ruler.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ruler = void 0;
+
+var _rule = require("../nodes/rule");
+
+var RULER_REGEX = /^-{4,5}(\s|$)/;
+
+var ruler = function ruler(_ref) {
+  var input = _ref.input,
+      position = _ref.position,
+      schema = _ref.schema;
+  var match = input.substring(position).match(RULER_REGEX);
+
+  if (match) {
+    return {
+      type: 'pmnode',
+      nodes: (0, _rule.createRuleNode)(schema),
+      length: match[0].length
+    };
+  }
+
+  return {
+    type: 'text',
+    text: input.substring(position, 1),
+    length: 1
+  };
+};
+
+exports.ruler = ruler;