slate/lib/models/schema.js

A completely customizable framework for building rich text editors.

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _debug = require('debug');

var _debug2 = _interopRequireDefault(_debug);

var _isPlainObject = require('is-plain-object');

var _isPlainObject2 = _interopRequireDefault(_isPlainObject);

var _mergeWith = require('lodash/mergeWith');

var _mergeWith2 = _interopRequireDefault(_mergeWith);

var _immutable = require('immutable');

var _coreSchemaRules = require('../constants/core-schema-rules');

var _coreSchemaRules2 = _interopRequireDefault(_coreSchemaRules);

var _modelTypes = require('../constants/model-types');

var _modelTypes2 = _interopRequireDefault(_modelTypes);

var _stack = require('./stack');

var _stack2 = _interopRequireDefault(_stack);

var _memoize = require('../utils/memoize');

var _memoize2 = _interopRequireDefault(_memoize);

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

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

/**
 * Validation failure reasons.
 *
 * @type {Object}
 */

var CHILD_KIND_INVALID = 'child_kind_invalid';
var CHILD_REQUIRED = 'child_required';
var CHILD_TYPE_INVALID = 'child_type_invalid';
var CHILD_UNKNOWN = 'child_unknown';
var NODE_DATA_INVALID = 'node_data_invalid';
var NODE_IS_VOID_INVALID = 'node_is_void_invalid';
var NODE_MARK_INVALID = 'node_mark_invalid';
var NODE_TEXT_INVALID = 'node_text_invalid';
var PARENT_KIND_INVALID = 'parent_kind_invalid';
var PARENT_TYPE_INVALID = 'parent_type_invalid';

/**
 * Debug.
 *
 * @type {Function}
 */

var debug = (0, _debug2.default)('slate:schema');

/**
 * Default properties.
 *
 * @type {Object}
 */

var DEFAULTS = {
  stack: _stack2.default.create(),
  document: {},
  blocks: {},
  inlines: {}
};

/**
 * Schema.
 *
 * @type {Schema}
 */

var Schema = function (_Record) {
  _inherits(Schema, _Record);

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

    return _possibleConstructorReturn(this, (Schema.__proto__ || Object.getPrototypeOf(Schema)).apply(this, arguments));
  }

  _createClass(Schema, [{
    key: 'getRule',


    /**
     * Get the rule for an `object`.
     *
     * @param {Mixed} object
     * @return {Object}
     */

    value: function getRule(object) {
      switch (object.kind) {
        case 'document':
          return this.document;
        case 'block':
          return this.blocks[object.type];
        case 'inline':
          return this.inlines[object.type];
      }
    }

    /**
     * Get a dictionary of the parent rule validations by child type.
     *
     * @return {Object|Null}
     */

  }, {
    key: 'getParentRules',
    value: function getParentRules() {
      var blocks = this.blocks,
          inlines = this.inlines;

      var parents = {};

      for (var key in blocks) {
        var rule = blocks[key];
        if (rule.parent == null) continue;
        parents[key] = rule;
      }

      for (var _key in inlines) {
        var _rule = inlines[_key];
        if (_rule.parent == null) continue;
        parents[_key] = _rule;
      }

      return Object.keys(parents).length == 0 ? null : parents;
    }

    /**
     * Fail validation by returning a normalizing change function.
     *
     * @param {String} reason
     * @param {Object} context
     * @return {Function}
     */

  }, {
    key: 'fail',
    value: function fail(reason, context) {
      var _this2 = this;

      return function (change) {
        debug('normalizing', { reason: reason, context: context });
        var rule = context.rule;

        var count = change.operations.length;
        if (rule.normalize) rule.normalize(change, reason, context);
        if (change.operations.length > count) return;
        _this2.normalize(change, reason, context);
      };
    }

    /**
     * Normalize an invalid value with `reason` and `context`.
     *
     * @param {Change} change
     * @param {String} reason
     * @param {Mixed} context
     */

  }, {
    key: 'normalize',
    value: function normalize(change, reason, context) {
      switch (reason) {
        case CHILD_KIND_INVALID:
        case CHILD_TYPE_INVALID:
        case CHILD_UNKNOWN:
          {
            var child = context.child,
                node = context.node;

            return child.kind == 'text' && node.kind == 'block' && node.nodes.size == 1 ? change.removeNodeByKey(node.key) : change.removeNodeByKey(child.key);
          }

        case CHILD_REQUIRED:
        case NODE_TEXT_INVALID:
        case PARENT_KIND_INVALID:
        case PARENT_TYPE_INVALID:
          {
            var _node = context.node;

            return _node.kind == 'document' ? _node.nodes.forEach(function (child) {
              return change.removeNodeByKey(child.key);
            }) : change.removeNodeByKey(_node.key);
          }

        case NODE_DATA_INVALID:
          {
            var _node2 = context.node,
                key = context.key;

            return _node2.data.get(key) === undefined && _node2.kind != 'document' ? change.removeNodeByKey(_node2.key) : change.setNodeByKey(_node2.key, { data: _node2.data.delete(key) });
          }

        case NODE_IS_VOID_INVALID:
          {
            var _node3 = context.node;

            return change.setNodeByKey(_node3.key, { isVoid: !_node3.isVoid });
          }

        case NODE_MARK_INVALID:
          {
            var _node4 = context.node,
                mark = context.mark;

            return _node4.getTexts().forEach(function (t) {
              return change.removeMarkByKey(t.key, 0, t.text.length, mark);
            });
          }
      }
    }

    /**
     * Validate a `node` with the schema, returning a function that will fix the
     * invalid node, or void if the node is valid.
     *
     * @param {Node} node
     * @return {Function|Void}
     */

  }, {
    key: 'validateNode',
    value: function validateNode(node) {
      var ret = this.stack.find('validateNode', node);
      if (ret) return ret;

      if (node.kind == 'text') return;

      var rule = this.getRule(node) || {};
      var parents = this.getParentRules();
      var ctx = { node: node, rule: rule };

      if (rule.isVoid != null) {
        if (node.isVoid != rule.isVoid) {
          return this.fail(NODE_IS_VOID_INVALID, ctx);
        }
      }

      if (rule.data != null) {
        for (var key in rule.data) {
          var fn = rule.data[key];
          var value = node.data.get(key);

          if (!fn(value)) {
            return this.fail(NODE_DATA_INVALID, _extends({}, ctx, { key: key, value: value }));
          }
        }
      }

      if (rule.marks != null) {
        var marks = node.getMarks().toArray();

        var _iteratorNormalCompletion = true;
        var _didIteratorError = false;
        var _iteratorError = undefined;

        try {
          for (var _iterator = marks[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
            var mark = _step.value;
            var _iteratorNormalCompletion2 = true;
            var _didIteratorError2 = false;
            var _iteratorError2 = undefined;

            try {
              for (var _iterator2 = rule.marks[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                var def = _step2.value;

                if (def.type != mark.type) {
                  return this.fail(NODE_MARK_INVALID, _extends({}, ctx, { mark: mark }));
                }
              }
            } catch (err) {
              _didIteratorError2 = true;
              _iteratorError2 = err;
            } finally {
              try {
                if (!_iteratorNormalCompletion2 && _iterator2.return) {
                  _iterator2.return();
                }
              } finally {
                if (_didIteratorError2) {
                  throw _iteratorError2;
                }
              }
            }
          }
        } catch (err) {
          _didIteratorError = true;
          _iteratorError = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion && _iterator.return) {
              _iterator.return();
            }
          } finally {
            if (_didIteratorError) {
              throw _iteratorError;
            }
          }
        }
      }

      if (rule.text != null) {
        var text = node.text;


        if (!rule.text.test(text)) {
          return this.fail(NODE_TEXT_INVALID, _extends({}, ctx, { text: text }));
        }
      }

      if (rule.nodes != null || parents != null) {
        var nextDef = function nextDef() {
          offset = offset == null ? null : 0;
          _def = defs.shift();
          min = _def && (_def.min == null ? 0 : _def.min);
          max = _def && (_def.max == null ? Infinity : _def.max);
          return !!_def;
        };

        var nextChild = function nextChild() {
          index = index == null ? 0 : index + 1;
          offset = offset == null ? 0 : offset + 1;
          child = children[index];
          if (max != null && offset == max) nextDef();
          return !!child;
        };

        var children = node.nodes.toArray();
        var defs = rule.nodes != null ? rule.nodes.slice() : [];

        var offset = void 0;
        var min = void 0;
        var index = void 0;
        var _def = void 0;
        var max = void 0;
        var child = void 0;

        if (rule.nodes != null) {
          nextDef();
        }

        while (nextChild()) {
          if (parents != null && child.kind != 'text' && child.type in parents) {
            var r = parents[child.type];

            if (r.parent.kinds != null && !r.parent.kinds.includes(node.kind)) {
              return this.fail(PARENT_KIND_INVALID, { node: child, parent: node, rule: r });
            }

            if (r.parent.types != null && !r.parent.types.includes(node.type)) {
              return this.fail(PARENT_TYPE_INVALID, { node: child, parent: node, rule: r });
            }
          }

          if (rule.nodes != null) {
            if (!_def) {
              return this.fail(CHILD_UNKNOWN, _extends({}, ctx, { child: child, index: index }));
            }

            if (_def.kinds != null && !_def.kinds.includes(child.kind)) {
              if (offset >= min && nextDef()) continue;
              return this.fail(CHILD_KIND_INVALID, _extends({}, ctx, { child: child, index: index }));
            }

            if (_def.types != null && !_def.types.includes(child.type)) {
              if (offset >= min && nextDef()) continue;
              return this.fail(CHILD_TYPE_INVALID, _extends({}, ctx, { child: child, index: index }));
            }
          }
        }

        if (rule.nodes != null) {
          while (min != null) {
            if (offset < min) {
              return this.fail(CHILD_REQUIRED, _extends({}, ctx, { index: index }));
            }

            nextDef();
          }
        }
      }
    }

    /**
     * Return a JSON representation of the schema.
     *
     * @return {Object}
     */

  }, {
    key: 'toJSON',
    value: function toJSON() {
      var object = {
        kind: this.kind,
        document: this.document,
        blocks: this.blocks,
        inlines: this.inlines
      };

      return object;
    }

    /**
     * Alias `toJS`.
     */

  }, {
    key: 'toJS',
    value: function toJS() {
      return this.toJSON();
    }
  }, {
    key: 'kind',


    /**
     * Get the kind.
     *
     * @return {String}
     */

    get: function get() {
      return 'schema';
    }
  }], [{
    key: 'create',


    /**
     * Create a new `Schema` with `attrs`.
     *
     * @param {Object|Schema} attrs
     * @return {Schema}
     */

    value: function create() {
      var attrs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      if (Schema.isSchema(attrs)) {
        return attrs;
      }

      if ((0, _isPlainObject2.default)(attrs)) {
        return Schema.fromJSON(attrs);
      }

      throw new Error('`Schema.create` only accepts objects or schemas, but you passed it: ' + attrs);
    }

    /**
     * Create a `Schema` from a JSON `object`.
     *
     * @param {Object} object
     * @return {Schema}
     */

  }, {
    key: 'fromJSON',
    value: function fromJSON(object) {
      if (Schema.isSchema(object)) {
        return object;
      }

      var plugins = object.plugins;


      if (object.rules) {
        throw new Error('Schemas in Slate have changed! They are no longer accept a `rules` property.');
      }

      if (object.nodes) {
        throw new Error('Schemas in Slate have changed! They are no longer accept a `nodes` property.');
      }

      if (!plugins) {
        plugins = [{ schema: object }];
      }

      var schema = resolveSchema(plugins);
      var stack = _stack2.default.create({ plugins: [].concat(_toConsumableArray(_coreSchemaRules2.default), _toConsumableArray(plugins)) });
      var ret = new Schema(_extends({}, schema, { stack: stack }));
      return ret;
    }

    /**
     * Alias `fromJS`.
     */

  }, {
    key: 'isSchema',


    /**
     * Check if `any` is a `Schema`.
     *
     * @param {Any} any
     * @return {Boolean}
     */

    value: function isSchema(any) {
      return !!(any && any[_modelTypes2.default.SCHEMA]);
    }
  }]);

  return Schema;
}((0, _immutable.Record)(DEFAULTS));

/**
 * Resolve a set of schema rules from an array of `plugins`.
 *
 * @param {Array} plugins
 * @return {Object}
 */

Schema.fromJS = Schema.fromJSON;
function resolveSchema() {
  var plugins = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];

  var schema = {
    document: {},
    blocks: {},
    inlines: {}
  };

  plugins.slice().reverse().forEach(function (plugin) {
    if (!plugin.schema) return;

    if (plugin.schema.rules) {
      throw new Error('Schemas in Slate have changed! They are no longer accept a `rules` property.');
    }

    if (plugin.schema.nodes) {
      throw new Error('Schemas in Slate have changed! They are no longer accept a `nodes` property.');
    }

    var _plugin$schema = plugin.schema,
        _plugin$schema$docume = _plugin$schema.document,
        document = _plugin$schema$docume === undefined ? {} : _plugin$schema$docume,
        _plugin$schema$blocks = _plugin$schema.blocks,
        blocks = _plugin$schema$blocks === undefined ? {} : _plugin$schema$blocks,
        _plugin$schema$inline = _plugin$schema.inlines,
        inlines = _plugin$schema$inline === undefined ? {} : _plugin$schema$inline;

    var d = resolveDocumentRule(document);
    var bs = {};
    var is = {};

    for (var key in blocks) {
      bs[key] = resolveNodeRule('block', key, blocks[key]);
    }

    for (var _key2 in inlines) {
      is[_key2] = resolveNodeRule('inline', _key2, inlines[_key2]);
    }

    (0, _mergeWith2.default)(schema.document, d, customizer);
    (0, _mergeWith2.default)(schema.blocks, bs, customizer);
    (0, _mergeWith2.default)(schema.inlines, is, customizer);
  });

  return schema;
}

/**
 * Resolve a document rule `obj`.
 *
 * @param {Object} obj
 * @return {Object}
 */

function resolveDocumentRule(obj) {
  return _extends({
    data: {},
    nodes: null
  }, obj);
}

/**
 * Resolve a node rule with `type` from `obj`.
 *
 * @param {String} kind
 * @param {String} type
 * @param {Object} obj
 * @return {Object}
 */

function resolveNodeRule(kind, type, obj) {
  return _extends({
    data: {},
    isVoid: null,
    nodes: null,
    parent: null,
    text: null
  }, obj);
}

/**
 * A Lodash customizer for merging `kinds` and `types` arrays.
 *
 * @param {Mixed} target
 * @param {Mixed} source
 * @return {Array|Void}
 */

function customizer(target, source, key) {
  if (key == 'kinds' || key == 'types') {
    return target == null ? source : target.concat(source);
  }
}

/**
 * Attach a pseudo-symbol for type checking.
 */

Schema.prototype[_modelTypes2.default.SCHEMA] = true;

/**
 * Memoize read methods.
 */

(0, _memoize2.default)(Schema.prototype, ['getParentRules'], {
  takesArguments: true
});

/**
 * Export.
 *
 * @type {Schema}
 */

exports.default = Schema;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/models/schema.js"],"names":["CHILD_KIND_INVALID","CHILD_REQUIRED","CHILD_TYPE_INVALID","CHILD_UNKNOWN","NODE_DATA_INVALID","NODE_IS_VOID_INVALID","NODE_MARK_INVALID","NODE_TEXT_INVALID","PARENT_KIND_INVALID","PARENT_TYPE_INVALID","debug","DEFAULTS","stack","create","document","blocks","inlines","Schema","object","kind","type","parents","key","rule","parent","Object","keys","length","reason","context","change","count","operations","normalize","child","node","nodes","size","removeNodeByKey","forEach","data","get","undefined","setNodeByKey","delete","isVoid","mark","getTexts","removeMarkByKey","t","text","ret","find","getRule","getParentRules","ctx","fail","fn","value","marks","getMarks","toArray","def","test","nextDef","offset","defs","shift","min","max","Infinity","nextChild","index","children","slice","r","kinds","includes","types","toJSON","attrs","isSchema","fromJSON","Error","plugins","rules","schema","resolveSchema","any","SCHEMA","fromJS","reverse","plugin","d","resolveDocumentRule","bs","is","resolveNodeRule","customizer","obj","target","source","concat","prototype","takesArguments"],"mappings":"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","file":"schema.js","sourcesContent":["\nimport Debug from 'debug'\nimport isPlainObject from 'is-plain-object'\nimport mergeWith from 'lodash/mergeWith'\nimport { Record } from 'immutable'\n\nimport CORE_SCHEMA_RULES from '../constants/core-schema-rules'\nimport MODEL_TYPES from '../constants/model-types'\nimport Stack from './stack'\nimport memoize from '../utils/memoize'\n\n/**\n * Validation failure reasons.\n *\n * @type {Object}\n */\n\nconst CHILD_KIND_INVALID = 'child_kind_invalid'\nconst CHILD_REQUIRED = 'child_required'\nconst CHILD_TYPE_INVALID = 'child_type_invalid'\nconst CHILD_UNKNOWN = 'child_unknown'\nconst NODE_DATA_INVALID = 'node_data_invalid'\nconst NODE_IS_VOID_INVALID = 'node_is_void_invalid'\nconst NODE_MARK_INVALID = 'node_mark_invalid'\nconst NODE_TEXT_INVALID = 'node_text_invalid'\nconst PARENT_KIND_INVALID = 'parent_kind_invalid'\nconst PARENT_TYPE_INVALID = 'parent_type_invalid'\n\n/**\n * Debug.\n *\n * @type {Function}\n */\n\nconst debug = Debug('slate:schema')\n\n/**\n * Default properties.\n *\n * @type {Object}\n */\n\nconst DEFAULTS = {\n  stack: Stack.create(),\n  document: {},\n  blocks: {},\n  inlines: {},\n}\n\n/**\n * Schema.\n *\n * @type {Schema}\n */\n\nclass Schema extends Record(DEFAULTS) {\n\n  /**\n   * Create a new `Schema` with `attrs`.\n   *\n   * @param {Object|Schema} attrs\n   * @return {Schema}\n   */\n\n  static create(attrs = {}) {\n    if (Schema.isSchema(attrs)) {\n      return attrs\n    }\n\n    if (isPlainObject(attrs)) {\n      return Schema.fromJSON(attrs)\n    }\n\n    throw new Error(`\\`Schema.create\\` only accepts objects or schemas, but you passed it: ${attrs}`)\n  }\n\n  /**\n   * Create a `Schema` from a JSON `object`.\n   *\n   * @param {Object} object\n   * @return {Schema}\n   */\n\n  static fromJSON(object) {\n    if (Schema.isSchema(object)) {\n      return object\n    }\n\n    let { plugins } = object\n\n    if (object.rules) {\n      throw new Error('Schemas in Slate have changed! They are no longer accept a `rules` property.')\n    }\n\n    if (object.nodes) {\n      throw new Error('Schemas in Slate have changed! They are no longer accept a `nodes` property.')\n    }\n\n    if (!plugins) {\n      plugins = [{ schema: object }]\n    }\n\n    const schema = resolveSchema(plugins)\n    const stack = Stack.create({ plugins: [ ...CORE_SCHEMA_RULES, ...plugins ] })\n    const ret = new Schema({ ...schema, stack })\n    return ret\n  }\n\n  /**\n   * Alias `fromJS`.\n   */\n\n  static fromJS = Schema.fromJSON\n\n  /**\n   * Check if `any` is a `Schema`.\n   *\n   * @param {Any} any\n   * @return {Boolean}\n   */\n\n  static isSchema(any) {\n    return !!(any && any[MODEL_TYPES.SCHEMA])\n  }\n\n  /**\n   * Get the kind.\n   *\n   * @return {String}\n   */\n\n  get kind() {\n    return 'schema'\n  }\n\n  /**\n   * Get the rule for an `object`.\n   *\n   * @param {Mixed} object\n   * @return {Object}\n   */\n\n  getRule(object) {\n    switch (object.kind) {\n      case 'document': return this.document\n      case 'block': return this.blocks[object.type]\n      case 'inline': return this.inlines[object.type]\n    }\n  }\n\n  /**\n   * Get a dictionary of the parent rule validations by child type.\n   *\n   * @return {Object|Null}\n   */\n\n  getParentRules() {\n    const { blocks, inlines } = this\n    const parents = {}\n\n    for (const key in blocks) {\n      const rule = blocks[key]\n      if (rule.parent == null) continue\n      parents[key] = rule\n    }\n\n    for (const key in inlines) {\n      const rule = inlines[key]\n      if (rule.parent == null) continue\n      parents[key] = rule\n    }\n\n    return Object.keys(parents).length == 0 ? null : parents\n  }\n\n  /**\n   * Fail validation by returning a normalizing change function.\n   *\n   * @param {String} reason\n   * @param {Object} context\n   * @return {Function}\n   */\n\n  fail(reason, context) {\n    return (change) => {\n      debug(`normalizing`, { reason, context })\n      const { rule } = context\n      const count = change.operations.length\n      if (rule.normalize) rule.normalize(change, reason, context)\n      if (change.operations.length > count) return\n      this.normalize(change, reason, context)\n    }\n  }\n\n  /**\n   * Normalize an invalid value with `reason` and `context`.\n   *\n   * @param {Change} change\n   * @param {String} reason\n   * @param {Mixed} context\n   */\n\n  normalize(change, reason, context) {\n    switch (reason) {\n      case CHILD_KIND_INVALID:\n      case CHILD_TYPE_INVALID:\n      case CHILD_UNKNOWN: {\n        const { child, node } = context\n        return child.kind == 'text' && node.kind == 'block' && node.nodes.size == 1\n          ? change.removeNodeByKey(node.key)\n          : change.removeNodeByKey(child.key)\n      }\n\n      case CHILD_REQUIRED:\n      case NODE_TEXT_INVALID:\n      case PARENT_KIND_INVALID:\n      case PARENT_TYPE_INVALID: {\n        const { node } = context\n        return node.kind == 'document'\n          ? node.nodes.forEach(child => change.removeNodeByKey(child.key))\n          : change.removeNodeByKey(node.key)\n      }\n\n      case NODE_DATA_INVALID: {\n        const { node, key } = context\n        return node.data.get(key) === undefined && node.kind != 'document'\n          ? change.removeNodeByKey(node.key)\n          : change.setNodeByKey(node.key, { data: node.data.delete(key) })\n      }\n\n      case NODE_IS_VOID_INVALID: {\n        const { node } = context\n        return change.setNodeByKey(node.key, { isVoid: !node.isVoid })\n      }\n\n      case NODE_MARK_INVALID: {\n        const { node, mark } = context\n        return node.getTexts().forEach(t => change.removeMarkByKey(t.key, 0, t.text.length, mark))\n      }\n    }\n  }\n\n  /**\n   * Validate a `node` with the schema, returning a function that will fix the\n   * invalid node, or void if the node is valid.\n   *\n   * @param {Node} node\n   * @return {Function|Void}\n   */\n\n  validateNode(node) {\n    const ret = this.stack.find('validateNode', node)\n    if (ret) return ret\n\n    if (node.kind == 'text') return\n\n    const rule = this.getRule(node) || {}\n    const parents = this.getParentRules()\n    const ctx = { node, rule }\n\n    if (rule.isVoid != null) {\n      if (node.isVoid != rule.isVoid) {\n        return this.fail(NODE_IS_VOID_INVALID, ctx)\n      }\n    }\n\n    if (rule.data != null) {\n      for (const key in rule.data) {\n        const fn = rule.data[key]\n        const value = node.data.get(key)\n\n        if (!fn(value)) {\n          return this.fail(NODE_DATA_INVALID, { ...ctx, key, value })\n        }\n      }\n    }\n\n    if (rule.marks != null) {\n      const marks = node.getMarks().toArray()\n\n      for (const mark of marks) {\n        for (const def of rule.marks) {\n          if (def.type != mark.type) {\n            return this.fail(NODE_MARK_INVALID, { ...ctx, mark })\n          }\n        }\n      }\n    }\n\n    if (rule.text != null) {\n      const { text } = node\n\n      if (!rule.text.test(text)) {\n        return this.fail(NODE_TEXT_INVALID, { ...ctx, text })\n      }\n    }\n\n    if (rule.nodes != null || parents != null) {\n      const children = node.nodes.toArray()\n      const defs = rule.nodes != null ? rule.nodes.slice() : []\n\n      let offset\n      let min\n      let index\n      let def\n      let max\n      let child\n\n      function nextDef() {\n        offset = offset == null ? null : 0\n        def = defs.shift()\n        min = def && (def.min == null ? 0 : def.min)\n        max = def && (def.max == null ? Infinity : def.max)\n        return !!def\n      }\n\n      function nextChild() {\n        index = index == null ? 0 : index + 1\n        offset = offset == null ? 0 : offset + 1\n        child = children[index]\n        if (max != null && offset == max) nextDef()\n        return !!child\n      }\n\n      if (rule.nodes != null) {\n        nextDef()\n      }\n\n      while (nextChild()) {\n        if (parents != null && child.kind != 'text' && child.type in parents) {\n          const r = parents[child.type]\n\n          if (r.parent.kinds != null && !r.parent.kinds.includes(node.kind)) {\n            return this.fail(PARENT_KIND_INVALID, { node: child, parent: node, rule: r })\n          }\n\n          if (r.parent.types != null && !r.parent.types.includes(node.type)) {\n            return this.fail(PARENT_TYPE_INVALID, { node: child, parent: node, rule: r })\n          }\n        }\n\n        if (rule.nodes != null) {\n          if (!def) {\n            return this.fail(CHILD_UNKNOWN, { ...ctx, child, index })\n          }\n\n          if (def.kinds != null && !def.kinds.includes(child.kind)) {\n            if (offset >= min && nextDef()) continue\n            return this.fail(CHILD_KIND_INVALID, { ...ctx, child, index })\n          }\n\n          if (def.types != null && !def.types.includes(child.type)) {\n            if (offset >= min && nextDef()) continue\n            return this.fail(CHILD_TYPE_INVALID, { ...ctx, child, index })\n          }\n        }\n      }\n\n      if (rule.nodes != null) {\n        while (min != null) {\n          if (offset < min) {\n            return this.fail(CHILD_REQUIRED, { ...ctx, index })\n          }\n\n          nextDef()\n        }\n      }\n    }\n  }\n\n  /**\n   * Return a JSON representation of the schema.\n   *\n   * @return {Object}\n   */\n\n  toJSON() {\n    const object = {\n      kind: this.kind,\n      document: this.document,\n      blocks: this.blocks,\n      inlines: this.inlines,\n    }\n\n    return object\n  }\n\n  /**\n   * Alias `toJS`.\n   */\n\n  toJS() {\n    return this.toJSON()\n  }\n\n}\n\n/**\n * Resolve a set of schema rules from an array of `plugins`.\n *\n * @param {Array} plugins\n * @return {Object}\n */\n\nfunction resolveSchema(plugins = []) {\n  const schema = {\n    document: {},\n    blocks: {},\n    inlines: {},\n  }\n\n  plugins.slice().reverse().forEach((plugin) => {\n    if (!plugin.schema) return\n\n    if (plugin.schema.rules) {\n      throw new Error('Schemas in Slate have changed! They are no longer accept a `rules` property.')\n    }\n\n    if (plugin.schema.nodes) {\n      throw new Error('Schemas in Slate have changed! They are no longer accept a `nodes` property.')\n    }\n\n    const { document = {}, blocks = {}, inlines = {}} = plugin.schema\n    const d = resolveDocumentRule(document)\n    const bs = {}\n    const is = {}\n\n    for (const key in blocks) {\n      bs[key] = resolveNodeRule('block', key, blocks[key])\n    }\n\n    for (const key in inlines) {\n      is[key] = resolveNodeRule('inline', key, inlines[key])\n    }\n\n    mergeWith(schema.document, d, customizer)\n    mergeWith(schema.blocks, bs, customizer)\n    mergeWith(schema.inlines, is, customizer)\n  })\n\n  return schema\n}\n\n/**\n * Resolve a document rule `obj`.\n *\n * @param {Object} obj\n * @return {Object}\n */\n\nfunction resolveDocumentRule(obj) {\n  return {\n    data: {},\n    nodes: null,\n    ...obj,\n  }\n}\n\n/**\n * Resolve a node rule with `type` from `obj`.\n *\n * @param {String} kind\n * @param {String} type\n * @param {Object} obj\n * @return {Object}\n */\n\nfunction resolveNodeRule(kind, type, obj) {\n  return {\n    data: {},\n    isVoid: null,\n    nodes: null,\n    parent: null,\n    text: null,\n    ...obj,\n  }\n}\n\n/**\n * A Lodash customizer for merging `kinds` and `types` arrays.\n *\n * @param {Mixed} target\n * @param {Mixed} source\n * @return {Array|Void}\n */\n\nfunction customizer(target, source, key) {\n  if (key == 'kinds' || key == 'types') {\n    return target == null ? source : target.concat(source)\n  }\n}\n\n/**\n * Attach a pseudo-symbol for type checking.\n */\n\nSchema.prototype[MODEL_TYPES.SCHEMA] = true\n\n/**\n * Memoize read methods.\n */\n\nmemoize(Schema.prototype, [\n  'getParentRules',\n], {\n  takesArguments: true,\n})\n\n/**\n * Export.\n *\n * @type {Schema}\n */\n\nexport default Schema\n"]}