mezzanine/lib/type/type-container.js

Fantasy land union types with pattern matching

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

var _ramda = require('ramda');
var _toFastProps = require('../to-fast-props');var _toFastProps2 = _interopRequireDefault(_toFastProps);
var _fixtures = require('./fixtures');
var _config = require('../config');
var _descriptor = require('./descriptor');

require('./index.h');
var _props = require('../utils/props');
var _virtualStack = require('../virtual-stack');
var _properties = require('./properties');function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { default: obj };}


















































function isType(pred, uniqMark, isMono, stack) {
  var needTransform = stack.length !== 0;
  return function checkIsType(obj) {
    var val = obj;
    if (needTransform === true) {
      var initial = (0, _virtualStack.getInitialValue)(stack, val);
      if (initial.succ === false) return false;
      val = initial.val;
    }
    var data = (0, _descriptor.transformInput)(val, isMono);
    if (data == null) return false;
    if (isMono && (0, _fixtures.isMezzanine)(data.value) && data.value.ಠ_ಠ === uniqMark)
    return true;
    return pred(data);
  };
}

var newUniqMark = name => Symbol(name);


var generalInjectableProps = {
  clone: (_, Static) => () => {
    var { name, typeName, desc, func, stack } = Static;
    return makeContainer(name, typeName, desc, func, stack);
  },
  //$FlowIssue
  [_config.typeMark]: {
    get: () => true,
    enumerable: false } };



var staticInjectableProps = {
  //$FlowIssue
  [Symbol.hasInstance]: Static => val => Static.is(val),
  stackUpdate: Static =>
  newStack => {
    var { name, typeName, desc, func } = Static;
    return makeContainer(name, typeName, desc, func, newStack);
  } };


var fullStaticProps = (0, _props.injector)([
generalInjectableProps,
staticInjectableProps, _properties.fantasyOnClass]);



var fullInstanceProps = (0, _props.injector)([
generalInjectableProps, _properties.instanceInjectableProps, _properties.fantasyInstance]);




function makeContainer(
name,
typeName,
descriptor,
func,
stack = []
//$FlowIssue
) {
  var desc =
  typeof descriptor !== 'object' ||
  descriptor == null ?
  { value: descriptor } :
  descriptor;
  var keys = Object.keys(desc);
  var pred = (0, _descriptor.createPred)(desc);
  var isMono = keys.length === 1 && keys[0] === 'value';
  var uniqMark = newUniqMark(name);
  var checkIs = isType(pred, uniqMark, isMono, stack);

  function RecordFn(arg) {
    //$FlowIssue
    if (new.target == null)
    return new RecordFn(arg);
    var obj = (0, _virtualStack.applyStack)(stack, arg);
    var data = (0, _descriptor.transformInput)(obj, isMono);
    if (data == null) {
      throw new TypeError(`${name}{isMono: ${isMono.toString()}}: No value recieved`);
    }
    if (isMono && (0, _fixtures.isMezzanine)(data.value) && data.value.ಠ_ಠ === uniqMark) return data.value;
    if (!pred(data)) {
      var mono = isMono.toString();
      var keysList = Object.keys(data).toString();
      var valuesList = (0, _ramda.values)(data).toString();
      var message = `${name}{isMono: ${mono}}: Unsafe pattern mismatch\nKeys: ${keysList}\nValues: ${valuesList}`;
      throw new TypeError(message);
    }

    var dataResult = (0, _descriptor.createBuilder)(desc, data);
    // console.log(data, obj, dataResult)
    for (var _iterator = keys, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {var _ref;if (_isArray) {if (_i >= _iterator.length) break;_ref = _iterator[_i++];} else {_i = _iterator.next();if (_i.done) break;_ref = _i.value;}var key = _ref;
      this[key] = dataResult[key];
      // console.log(this[key])
    }
    fullInnerInstProps(this, RecordFn);
    fullInstanceProps(this, RecordFn);
    (0, _toFastProps2.default)(this);
  }
  var generalProps = {
    ಠ_ಠ: {
      value: uniqMark,
      enumerable: false },

    type: {
      value: name,
      enumerable: true },

    keys: {
      value: keys,
      enumerable: false },

    isMono: {
      get: () => isMono,
      enumerable: false },

    is: {
      value: checkIs,
      enumerable: true } };


  var staticProps = {
    name: {
      value: name,
      enumerable: false },

    typeName: {
      value: typeName,
      enumerable: false },

    desc: {
      value: descriptor,
      enumerable: false },

    func: {
      value: func,
      enumerable: false },

    stack: {
      value: stack,
      enumerable: false } };


  var instProps = {
    typeName: {
      value: typeName,
      enumerable: true } };


  var fullInnerStaticProps = (0, _props.injector)([
  generalProps,
  staticProps]);

  var userMeth = getUserMethods(func);
  var fullInnerInstProps = (0, _props.injector)([
  generalProps,
  instProps,
  userMeth]);

  fullInnerStaticProps(RecordFn, RecordFn);
  fullStaticProps(RecordFn, RecordFn);
  return RecordFn;
}
var getUserMethods = func =>
Object.getOwnPropertyNames(func)
//$FlowIssue
.concat(Object.getOwnPropertySymbols(func)).
map(key => [key, {
  value: func[key],
  enumerable: true,
  writable: true,
  inject: true }]);exports.default =



makeContainer;
//# sourceMappingURL=type-container.js.map