@vericus/slate-kit-align/lib/slate-kit-align.cjs.js

Plugins to provide a way to align blocks on slate

exports.__esModule = true;
exports.default = void 0;

var _slateKitUtilsRegisterHelpers = _interopRequireDefault(require("@vericus/slate-kit-utils-register-helpers"));

var _immutable = require("immutable");

var _slate = require("slate");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

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, descriptor.key, descriptor);
  }
}

function _createClass(Constructor, protoProps, staticProps) {
  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
  if (staticProps) _defineProperties(Constructor, staticProps);
  return Constructor;
}

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

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 _objectSpread2(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) {
        _defineProperty(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;
}

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
    }
  });
  if (superClass) _setPrototypeOf(subClass, superClass);
}

function _getPrototypeOf(o) {
  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
    return o.__proto__ || Object.getPrototypeOf(o);
  };
  return _getPrototypeOf(o);
}

function _setPrototypeOf(o, p) {
  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
    o.__proto__ = p;
    return o;
  };

  return _setPrototypeOf(o, p);
}

function _isNativeReflectConstruct() {
  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
  if (Reflect.construct.sham) return false;
  if (typeof Proxy === "function") return true;

  try {
    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
    return true;
  } catch (e) {
    return false;
  }
}

function _assertThisInitialized(self) {
  if (self === void 0) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }

  return self;
}

function _possibleConstructorReturn(self, call) {
  if (call && (typeof call === "object" || typeof call === "function")) {
    return call;
  }

  return _assertThisInitialized(self);
}

function _createSuper(Derived) {
  var hasNativeReflectConstruct = _isNativeReflectConstruct();

  return function () {
    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 _toConsumableArray(arr) {
  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
}

function _arrayWithoutHoles(arr) {
  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
}

function _iterableToArray(iter) {
  if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
}

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 _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.");
}

var defaultOption = {
  floatBlocks: [],
  textBlocks: ["paragraph", "heading-one", "heading-two", "heading-three", "heading-four", "blockquote"],
  alignments: ["left", "right", "center", "justify"],
  dataField: "textAlign",
  label: "align"
};

var Options = /*#__PURE__*/function (_Record) {
  _inherits(Options, _Record);

  var _super = _createSuper(Options);

  function Options() {
    _classCallCheck(this, Options);

    return _super.apply(this, arguments);
  }

  _createClass(Options, null, [{
    key: "create",
    value: function create(option) {
      var options = _objectSpread2(_objectSpread2(_objectSpread2({}, defaultOption), option), {}, {
        floatBlocks: [].concat(_toConsumableArray(defaultOption.floatBlocks), _toConsumableArray(option.floatBlocks ? option.floatBlocks : [])),
        alignments: [].concat(_toConsumableArray(defaultOption.alignments), _toConsumableArray(option.alignments ? option.alignments : [])),
        textBlocks: [].concat(_toConsumableArray(defaultOption.textBlocks), _toConsumableArray(option.textBlocks ? option.textBlocks : []))
      });

      return new Options(options);
    }
  }]);

  return Options;
}((0, _immutable.Record)(defaultOption));

function getAlignBlocksInBlock(opts, node) {
  if (!node || !_slate.Block.isBlock(node)) return [];
  var textBlocks = opts.textBlocks,
      floatBlocks = opts.floatBlocks;

  if (node.isLeafBlock()) {
    if (textBlocks.includes(node.type) || floatBlocks.includes(node.type)) {
      return [node];
    }

    return [];
  }

  return node.nodes.reduce(function (alignBlocks, block) {
    return [].concat(_toConsumableArray(alignBlocks), _toConsumableArray(getAlignBlocksInBlock(opts, block)));
  }, []);
}

function getAlignBlocks(opts, editor) {
  var maybeAlignBlocks = editor.getHighestSelectedBlocks();
  if (maybeAlignBlocks.size === 0) return [];
  return (0, _immutable.List)(maybeAlignBlocks).reduce(function (alignBlocks, block) {
    return [].concat(_toConsumableArray(alignBlocks), _toConsumableArray(getAlignBlocksInBlock(opts, block)));
  }, []);
}

function getAlignment(opts, block) {
  var dataField = opts.dataField;
  return block && block.data.get(dataField) || "left";
}

function isAligned(opts, editor, alignment) {
  var alignBlocks = editor.getAlignBlocks(opts);
  return alignBlocks.length !== 0 && alignBlocks.every(function (block) {
    return block && editor.getAlignment(block) === alignment;
  });
}

function isAlignable(opts, editor) {
  return editor.getAlignBlocks().length !== 0;
}

function createUtils(opts) {
  return {
    getAlignBlocks: function getAlignBlocks$1(editor) {
      return getAlignBlocks(opts, editor);
    },
    getAlignBlocksInBlock: function getAlignBlocksInBlock$1(editor, node) {
      return getAlignBlocksInBlock(opts, node);
    },
    getAlignment: function getAlignment$1(editor, block) {
      return getAlignment(opts, block);
    },
    isAligned: function isAligned$1(editor, alignment) {
      return isAligned(opts, editor, alignment);
    },
    isAlignable: function isAlignable$1(editor) {
      return isAlignable(opts, editor);
    }
  };
}

function removeAlign(opts) {
  var dataField = opts.dataField;
  return function (editor, align) {
    var value = editor.value;
    editor.withoutNormalizing(function () {
      editor.getAlignBlocks(value).filter(function (n) {
        return align && n.data && n.data.get(dataField) === align;
      }).forEach(function (n) {
        return editor.setNodeByKey(n.key, {
          data: n.data["delete"](dataField)
        });
      });
    });
  };
}

function setAlign(opts) {
  var dataField = opts.dataField;
  return function (editor, align) {
    var value = editor.value;
    var alignments = opts.alignments;
    if (!alignments || !alignments.includes(align)) return;
    editor.withoutNormalizing(function () {
      editor.getAlignBlocks(value).forEach(function (n) {
        editor.setNodeByKey(n.key, {
          data: n.data.set(dataField, align)
        });
      });
    });
  };
}

function createCommands(opts) {
  return {
    removeAlign: removeAlign(opts),
    setAlign: setAlign(opts)
  };
}

function createProps(opts) {
  var floatBlocks = opts.floatBlocks,
      textBlocks = opts.textBlocks;
  return function (props) {
    if (!props.node || props.node.object !== "block" || !(textBlocks.includes(props.node.type) || floatBlocks.includes(props.node.type))) {
      return props;
    }

    var alignment = props.editor.getAlignment(props.node);
    var style = props.attributes && props.attributes.style || {};

    if (textBlocks.includes(props.node.type)) {
      style = _objectSpread2(_objectSpread2({}, style), {}, {
        textAlign: alignment
      });
    }

    if (floatBlocks.includes(props.node.type)) {
      style = _objectSpread2(_objectSpread2({}, style), {}, {
        "float": alignment
      });
    }

    return _objectSpread2(_objectSpread2({}, props), {}, {
      attributes: _objectSpread2(_objectSpread2({}, props.attributes), {}, {
        style: style
      })
    });
  };
}

function createSchema(opts) {
  var floatBlocks = opts.floatBlocks,
      textBlocks = opts.textBlocks,
      dataField = opts.dataField,
      alignments = opts.alignments;
  var alignBlocks = [].concat(_toConsumableArray(floatBlocks), _toConsumableArray(textBlocks));
  return {
    blocks: alignBlocks.reduce(function (acc, block) {
      return _objectSpread2(_objectSpread2({}, acc), {}, _defineProperty({}, block, {
        data: _defineProperty({}, dataField, function (align) {
          return !align || align && alignments.includes(align);
        }),
        normalize: function normalize(editor, error) {
          if (error.code === "node_data_invalid") {
            editor.withoutNormalizing(function () {
              if (!_slate.Text.isText(error.node)) {
                editor.setNodeByKey(error.node.key, {
                  data: error.node.data["delete"](dataField)
                });
              }
            });
          }
        }
      }));
    }, {})
  };
}

var tagTextAlign = ["div", "p", "h1", "h2", "h3", "h4", "h5", "h6"];
var tagFloat = ["div", "p", "h1", "h2", "h3", "img"];
var tagNames = [].concat(tagTextAlign, tagFloat);
var alignments = ["left", "center", "right", "justify"];

function getData(el, dataField) {
  if (!dataField || !el.tagName || !tagNames.includes(el.tagName.toLowerCase())) {
    return {};
  }

  if (el.style && typeof el.style.textAlign === "string") {
    var align = el.style.textAlign;

    if (align && alignments.includes(align)) {
      return {
        data: _defineProperty({}, dataField, align)
      };
    }
  }

  if (el.getAttribute("align")) {
    var _align = el.getAttribute("align");

    if (_align && alignments.includes(_align)) {
      return {
        data: _defineProperty({}, dataField, _align)
      };
    }
  }

  if (el.style && typeof el.style.cssFloat === "string" && el.style.cssFloat !== "clear") {
    var _align2 = el.style.cssFloat;

    if (_align2 && alignments.includes(_align2)) {
      return {
        data: _defineProperty({}, dataField, _align2)
      };
    }
  }

  return {};
}

function createStyle(opts) {
  var dataField = opts.dataField;
  return {
    getData: function getData$1(_editor, el) {
      return getData(el, dataField);
    }
  };
}

function createAlignPlugin() {
  var pluginOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  var options = Options.create(pluginOptions);
  var queries = createUtils(options);
  var commands = createCommands(options);
  var props = createProps(options);
  var schema = createSchema(options);

  var _createStyle = createStyle(options),
      getData = _createStyle.getData;

  return [(0, _slateKitUtilsRegisterHelpers.default)({
    props: props,
    getData: getData,
    options: options
  }), {
    queries: queries,
    commands: commands,
    schema: schema
  }];
}

var _default = createAlignPlugin; 

exports.default = _default;