kontainer-js/core/Visitor.js

A media file format generator/parser that exposes a React-like API.

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.DumpVisitor = exports.ElementVisitor = exports.Visitor = undefined;

var _get2 = require('babel-runtime/helpers/get');

var _get3 = _interopRequireDefault(_get2);

var _keys = require('babel-runtime/core-js/object/keys');

var _keys2 = _interopRequireDefault(_keys);

var _typeof2 = require('babel-runtime/helpers/typeof');

var _typeof3 = _interopRequireDefault(_typeof2);

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _inherits2 = require('babel-runtime/helpers/inherits');

var _inherits3 = _interopRequireDefault(_inherits2);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _MediaFormat = require('./MediaFormat');

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

// Base class for the Visitor pattern.

var Visitor = exports.Visitor = function () {
  function Visitor() {
    (0, _classCallCheck3.default)(this, Visitor);

    this.stack = [];
    this.offset = 0;
    this.results = [];
  }

  // This method will be called when entering a node.


  (0, _createClass3.default)(Visitor, [{
    key: 'enter',
    value: function enter(type, props) {
      this.stack.push({ type: type, props: props, children: [] });
    }

    // This method will be called when exiting a node.
    // The return value will be stored in the children property of the parent node.

  }, {
    key: 'exit',
    value: function exit() {
      var stack = this.stack;
      var _stack = stack[stack.length - 1];
      var type = _stack.type;
      var props = _stack.props;
      var children = _stack.children;

      var result = this.visit(type, props, children);
      stack.pop();
      if (result) {
        if (stack.length > 0) {
          stack[stack.length - 1].children.push(result);
        } else {
          this.results.push(result);
        }
      }
    }
  }, {
    key: 'visit',
    value: function visit(type, props, children) {
      // Implement this in a subclass
      return null;
    }

    // You can attach any data to the current stack.
    // Usually, this is called within enter() method.

  }, {
    key: 'setData',
    value: function setData(data) {
      var len = this.stack.length;
      if (len > 0) {
        this.stack[len - 1].userData = data;
      }
    }

    // Usually, this is called within exit() method.

  }, {
    key: 'getData',
    value: function getData() {
      var len = this.stack.length;
      if (len === 0) {
        return null;
      }
      return this.stack[len - 1].userData;
    }
  }, {
    key: 'depth',
    value: function depth() {
      return this.stack.length - 1;
    }
  }]);
  return Visitor;
}();

var ElementVisitor = exports.ElementVisitor = function (_Visitor) {
  (0, _inherits3.default)(ElementVisitor, _Visitor);

  function ElementVisitor() {
    (0, _classCallCheck3.default)(this, ElementVisitor);
    return (0, _possibleConstructorReturn3.default)(this, (0, _getPrototypeOf2.default)(ElementVisitor).call(this));
  }

  (0, _createClass3.default)(ElementVisitor, [{
    key: 'visit',
    value: function visit(type, props, children) {
      return _MediaFormat.createElement.apply(undefined, [type, props].concat((0, _toConsumableArray3.default)(children)));
    }
  }]);
  return ElementVisitor;
}(Visitor);

function formatBuffer(v) {
  if (global && global.Buffer) {
    return '[Buffer length=' + v.length + ']';
  }
  return v + '';
}

function isBuffer(v) {
  if (global && global.Buffer) {
    return v instanceof global.Buffer;
  }
  return v instanceof ArrayBuffer;
}

function padding(num) {
  var str = '';
  for (var i = 0; i < num; i++) {
    str += '\t';
  }
  return str;
}

function formatValue(v) {
  if (v instanceof Date) {
    return v + '';
  } else if (isBuffer(v)) {
    return formatBuffer(v);
  } else if ((typeof v === 'undefined' ? 'undefined' : (0, _typeof3.default)(v)) === 'object') {
    var _ret = function () {
      var arr = [];
      (0, _keys2.default)(v).forEach(function (key) {
        arr.push(key + ': ' + formatValue(v[key]));
      });
      return {
        v: '{' + arr.join(', ') + '}'
      };
    }();

    if ((typeof _ret === 'undefined' ? 'undefined' : (0, _typeof3.default)(_ret)) === "object") return _ret.v;
  } else if (typeof v === 'string') {
    return '"' + v + '"';
  }
  return v;
}

function formatArray(a) {
  if (a.length > 100) {
    return '[array of length=' + a.length + ']';
  }
  var arr = [];
  a.forEach(function (v) {
    if (v instanceof Array) {
      arr.push(formatArray(v));
    } else {
      arr.push(formatValue(v));
    }
  });
  return '[' + arr.join(', ') + ']';
}

var DumpVisitor = exports.DumpVisitor = function (_Visitor2) {
  (0, _inherits3.default)(DumpVisitor, _Visitor2);

  function DumpVisitor() {
    (0, _classCallCheck3.default)(this, DumpVisitor);
    return (0, _possibleConstructorReturn3.default)(this, (0, _getPrototypeOf2.default)(DumpVisitor).call(this));
  }

  (0, _createClass3.default)(DumpVisitor, [{
    key: 'enter',
    value: function enter(type, props) {
      (0, _get3.default)((0, _getPrototypeOf2.default)(DumpVisitor.prototype), 'enter', this).call(this, type, props);
      var depth = this.depth();
      console.log(padding(depth) + '[' + type.COMPACT_NAME + '] >>>> start');
      (0, _keys2.default)(props).forEach(function (key) {
        var value = props[key];
        if (value instanceof Array) {
          value = formatArray(value);
        } else {
          value = formatValue(value);
        }
        console.log(padding(depth) + '\t' + key + ': ' + value);
      });
    }
  }, {
    key: 'visit',
    value: function visit(type) {
      var depth = this.depth();
      console.log(padding(depth) + '[' + type.COMPACT_NAME + '] <<<< end');
    }
  }]);
  return DumpVisitor;
}(Visitor);