@effectful/transducers-loose/core.js

@effectful/transducers built with faster generators

"use strict";

exports.__esModule = true;
var _exportNames = {
  enter: true,
  leave: true,
  tok: true,
  produce: true,
  consume: true,
  reproduceNodes: true,
  resetFieldInfo: true,
  removeNulls: true,
  emitConst: true
};
exports.consume = consume;
exports.emitConst = emitConst;
exports.enter = enter;
exports.leave = leave;
exports.produce = produce;
exports.removeNulls = removeNulls;
exports.reproduceNodes = reproduceNodes;
exports.resetFieldInfo = resetFieldInfo;
exports.tok = tok;
var _types = require("./v2/types");
Object.keys(_types).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _types[key]) return;
  exports[key] = _types[key];
});
var M = require("@effectful/es-rt/opts/loose");
function enter(pos, type, value) {
  return {
    enter: true,
    leave: false,
    pos,
    type,
    value
  };
}
function leave(pos, type, value) {
  return {
    enter: false,
    leave: true,
    pos,
    type,
    value
  };
}
function tok(pos, type, value) {
  return {
    enter: true,
    leave: true,
    pos,
    type,
    value
  };
}

/**
 * converts AST `node` into a stream of tokens with initial position `pos`
 * and intial tag's value - `value`
 */
function produce(node, pos, value) {
  var _produce = function _produce1(node, pos, value) {
      var i,
        keys,
        ti,
        type,
        _i,
        v,
        __produce = M.generator(),
        loop,
        _loop,
        r,
        p;
      __produce.step = _produce_1;
      __produce.$step = 3;
      return __produce;
      function _produce_1(p) {
        var a, b, c, d;
        for (;;) {
          switch (__produce.$cur = __produce.$step) {
            case 3:
              value.node = node;
              if (node == null) {
                if (pos === _types.Tag.push) {
                  a = tok(pos, _types.Tag.Empty, {
                    node: null
                  });
                  __produce.$step = 8;
                  __produce.value = a;
                  return __produce;
                } else {
                  __produce.$step = 8;
                  __produce.$step = 8;
                  continue;
                }
              } else {
                if (Array.isArray(node)) {
                  b = enter(pos, _types.Tag.Array, value);
                  __produce.$step = 4;
                  __produce.value = b;
                  return __produce;
                } else {
                  if ((0, _types.isNode)(node)) {
                    keys = _types.VISITOR_KEYS[node.type];
                    ti = (0, _types.nodeInfo)(node);
                    type = ti.sym;
                    if (keys.length) {
                      c = enter(pos, type, value);
                      __produce.$step = 6;
                      __produce.value = c;
                      return __produce;
                    } else {
                      d = tok(pos, type, value);
                      __produce.$step = 8;
                      __produce.value = d;
                      return __produce;
                    }
                  } else {
                    __produce.$step = 8;
                    __produce.$step = 8;
                    continue;
                  }
                }
              }
            case 4:
              loop = M.iterator(node);
              __produce.$step = 5;
              __produce.$step = 5;
              continue;
            case 5:
              if (!(loop = loop.step()).done) {
                i = loop.value;
                a = _produce(i, _types.Tag.push, {});
                __produce.$step = 5;
                return __produce.$delegate(a);
              } else {
                b = leave(pos, _types.Tag.Array, value);
                __produce.$step = 8;
                __produce.value = b;
                return __produce;
              }
            case 6:
              _loop = M.iterator(keys);
              __produce.$step = 7;
              __produce.$step = 7;
              continue;
            case 7:
              if (!(_loop = _loop.step()).done) {
                _i = _loop.value;
                v = node[_i];
                if (v != null) {
                  a = _produce(node[_i], _types.Tag[_i] || _i, {});
                  __produce.$step = 7;
                  return __produce.$delegate(a);
                } else {
                  __produce.$step = 7;
                  __produce.$step = 7;
                  continue;
                }
              } else {
                b = leave(pos, type, value);
                __produce.$step = 8;
                __produce.value = b;
                return __produce;
              }
            case 8:
              __produce.$step = 0;
              __produce.value = void 0;
              __produce.done = true;
              return __produce;
            case 0:
              __produce.$step = 0;
              __produce.value = p;
              __produce.done = true;
              return __produce;
            case 1:
              __produce.$step = 0;
              throw p;
            case 2:
              return __produce.$redir(p);
            default:
              throw new Error("invalid state");
          }
        }
      }
    },
    produce = M.generator(),
    r,
    p;
  produce.step = produce_1;
  produce.$step = 3;
  return produce;
  function produce_1(p) {
    var a;
    switch (produce.$cur = produce.$step) {
      case 3:
        a = _produce(node, pos || _types.Tag.top, value || {});
        produce.$step = 4;
        return produce.$delegate(a);
      case 4:
        produce.$step = 0;
        produce.value = void 0;
        produce.done = true;
        return produce;
      case 0:
        produce.$step = 0;
        produce.value = p;
        produce.done = true;
        return produce;
      case 1:
        produce.$step = 0;
        throw p;
      case 2:
        return produce.$redir(p);
      default:
        throw new Error("invalid state");
    }
  }
}

/**
 * converts stream of tokens into AST node
 */
function consume(s) {
  var stack, i, ti, node, _node;
  stack = [{}];
  var loop = M.iterator(s);
  for (; !(loop = loop.step()).done;) {
    i = loop.value;
    ti = (0, _types.typeInfo)(i);
    if (i.type == null || ti.kind === "ctrl") continue;
    if (i.enter) {
      if (i.type === _types.Tag.Array) stack.unshift([]);
      //TODO: another step to handle nulls
      else if (i.type === _types.Tag.Null) {
        if (i.pos !== _types.Tag.push) stack[0][(0, _types.symName)(i.pos)] = null;
        continue;
      } else {
        if (i.value != null) {
          if (ti.esType != null) i.value.node.type = ti.esType;
          if (ti.fields) Object.assign(i.value.node, ti.fields);
        }
        node = i.type === _types.Tag.Empty ? null : i.value.node;
        stack.unshift(node);
      }
    }
    if (i.leave) {
      _node = stack.shift();
      if (i.pos === _types.Tag.push) {
        stack[0].push(_node);
      } else stack[0][(0, _types.symName)(i.pos)] = _node;
    }
  }
  return stack[0];
}

/**
 * unwraps tokens formerly folded into Node sub-token
 */
function reproduceNodes(s) {
  var i,
    reproduceNodes = M.generator(),
    loop,
    r,
    p;
  reproduceNodes.step = reproduceNodes_1;
  reproduceNodes.$step = 3;
  return reproduceNodes;
  function reproduceNodes_1(p) {
    var a;
    for (;;) {
      switch (reproduceNodes.$cur = reproduceNodes.$step) {
        case 3:
          loop = M.iterator(s);
          reproduceNodes.$step = 4;
          reproduceNodes.$step = 4;
          continue;
        case 4:
          if (!(loop = loop.step()).done) {
            i = loop.value;
            if (i.type === _types.Tag.Node) {
              if (i.enter) {
                a = produce(i.value.node, i.pos);
                reproduceNodes.$step = 4;
                return reproduceNodes.$delegate(a);
              } else {
                reproduceNodes.$step = 4;
                reproduceNodes.value = i;
                return reproduceNodes;
              }
            } else {
              reproduceNodes.$step = 4;
              reproduceNodes.$step = 4;
              continue;
            }
          } else {
            reproduceNodes.$step = 0;
            reproduceNodes.value = void 0;
            reproduceNodes.done = true;
            return reproduceNodes;
          }
        case 0:
          reproduceNodes.$step = 0;
          reproduceNodes.value = p;
          reproduceNodes.done = true;
          return reproduceNodes;
        case 1:
          reproduceNodes.$step = 0;
          throw p;
        case 2:
          return reproduceNodes.$redir(p);
        default:
          throw new Error("invalid state");
      }
    }
  }
}

/**
 * Resets `fieldInfo` field in each `value`.
 * The field descripts AST node context.
 */
function resetFieldInfo(s) {
  var stack,
    i,
    f,
    ti,
    resetFieldInfo = M.generator(),
    loop,
    r,
    p;
  resetFieldInfo.step = resetFieldInfo_1;
  resetFieldInfo.$step = 3;
  return resetFieldInfo;
  function resetFieldInfo_1(p) {
    for (;;) {
      switch (resetFieldInfo.$cur = resetFieldInfo.$step) {
        case 3:
          stack = [];
          loop = M.iterator(s);
          resetFieldInfo.$step = 4;
          resetFieldInfo.$step = 4;
          continue;
        case 4:
          if (!(loop = loop.step()).done) {
            i = loop.value;
            if (i.enter) {
              f = stack[stack.length - 1];
              if (f && f.fieldsMap) {
                f = i.value.fieldInfo = f.fieldsMap.get(i.pos);
              }
              ti = f && f.ti || (0, _types.typeInfo)(i);
              switch (ti.kind) {
                case "array":
                  {
                    stack.push(i.value.fieldInfo);
                    break;
                  }
                case "node":
                  {
                    // babel validator hacks
                    // TODO: own model description
                    switch (i.type) {
                      case _types.Tag.ArrayPattern:
                        {
                          ti = f && f.declVar ? _types.arrayPattern : _types.arrayAssignmentPattern;
                          break;
                        }
                      case _types.Tag.ObjectPattern:
                        {
                          ti = f && f.declVar ? _types.objectPattern : _types.objectAssignmentPattern;
                          break;
                        }
                      case _types.Tag.RestElement:
                        {
                          ti = f && f.declVar ? _types.restElement : _types.restElementAssignment;
                          break;
                        }
                      case _types.Tag.AssignmentExpression:
                        {
                          ti = i.value.node.operator === "=" ? _types.assignmentOpEq : _types.assignmentOpDefault;
                          break;
                        }
                      case _types.Tag.ObjectProperty:
                        {
                          if (i.value.node.computed) {
                            ti = ti.propAlt;
                          } else {
                            if (f && f.declVar) {
                              ti = _types.assignmentProperty;
                            }
                          }
                          break;
                        }
                      case _types.Tag.AssignmentPattern:
                        {
                          if (!f || !f.declVar) {
                            ti = (0, _types.symInfo)(_types.Tag.AssignmentExpression);
                          }
                          break;
                        }
                      case _types.Tag.MemberExpression:
                      case _types.Tag.ObjectMethod:
                      case _types.Tag.ClassProperty:
                      case _types.Tag.ClassMethod:
                      case _types.Tag.ClassPrivateMethod:
                      case _types.Tag.ClassPrivateProperty:
                        {
                          if (i.value.node.computed) {
                            ti = ti.propAlt;
                          }
                          break;
                        }
                    }
                    stack.push(ti);
                    break;
                  }
                default:
                  {
                    stack.push(false);
                  }
              }
            }
            if (i.leave) {
              stack.pop();
            }
            resetFieldInfo.$step = 4;
            resetFieldInfo.value = i;
            return resetFieldInfo;
          } else {
            resetFieldInfo.$step = 0;
            resetFieldInfo.value = void 0;
            resetFieldInfo.done = true;
            return resetFieldInfo;
          }
        case 0:
          resetFieldInfo.$step = 0;
          resetFieldInfo.value = p;
          resetFieldInfo.done = true;
          return resetFieldInfo;
        case 1:
          resetFieldInfo.$step = 0;
          throw p;
        default:
          throw new Error("invalid state");
      }
    }
  }
}

/** interprets `Tag.Null` tokens by changing AST accordingly */
function removeNulls(s) {
  var stack,
    i,
    removeNulls = M.generator(),
    loop,
    r,
    p;
  removeNulls.step = removeNulls_1;
  removeNulls.$step = 3;
  return removeNulls;
  function removeNulls_1(p) {
    for (;;) {
      switch (removeNulls.$cur = removeNulls.$step) {
        case 3:
          stack = [];
          loop = M.iterator(s);
          removeNulls.$step = 4;
          removeNulls.$step = 4;
          continue;
        case 4:
          if (!(loop = loop.step()).done) {
            i = loop.value;
            if (i.type === _types.Tag.Null && i.pos !== _types.Tag.push) {
              if (i.enter && stack[0]) {
                stack[0][(0, _types.symName)(i.pos)] = null;
              }
              removeNulls.$step = 4;
              removeNulls.$step = 4;
              continue;
            } else {
              removeNulls.$step = 5;
              removeNulls.value = i;
              return removeNulls;
            }
          } else {
            removeNulls.$step = 0;
            removeNulls.value = void 0;
            removeNulls.done = true;
            return removeNulls;
          }
        case 5:
          if (i.enter) {
            stack.unshift(i.value.node);
          }
          if (i.leave) {
            stack.shift();
          }
          removeNulls.$step = 4;
          removeNulls.$step = 4;
          continue;
        case 0:
          removeNulls.$step = 0;
          removeNulls.value = p;
          removeNulls.done = true;
          return removeNulls;
        case 1:
          removeNulls.$step = 0;
          throw p;
        default:
          throw new Error("invalid state");
      }
    }
  }
}

/** converts compile time constant into a list of tokens */
function emitConst(pos, ...args) {
  var value,
    ival,
    aval,
    j,
    _ival,
    _aval,
    name,
    pval,
    val,
    _emitConst = M.generator(),
    loop,
    _loop,
    loop1,
    r,
    p;
  _emitConst.step = emitConst_1;
  _emitConst.$step = 3;
  return _emitConst;
  function emitConst_1(p) {
    var a, b, c, d, e, f, g, h;
    for (;;) {
      switch (_emitConst.$cur = _emitConst.$step) {
        case 3:
          loop = M.iterator(args);
          _emitConst.$step = 4;
          _emitConst.$step = 4;
          continue;
        case 4:
          if (!(loop = loop.step()).done) {
            value = loop.value;
            switch (typeof value) {
              case "number":
                a = tok(pos, _types.Tag.NumericLiteral, {
                  node: {
                    value
                  }
                });
                _emitConst.$step = 4;
                _emitConst.value = a;
                return _emitConst;
              case "string":
                b = tok(pos, _types.Tag.StringLiteral, {
                  node: {
                    value
                  }
                });
                _emitConst.$step = 4;
                _emitConst.value = b;
                return _emitConst;
              case "boolean":
                c = tok(pos, _types.Tag.BooleanLiteral, {
                  node: {
                    value
                  }
                });
                _emitConst.$step = 4;
                _emitConst.value = c;
                return _emitConst;
              case "object":
                if (value === null) {
                  d = tok(pos, _types.Tag.NullLiteral, {
                    node: {}
                  });
                  _emitConst.$step = 4;
                  _emitConst.value = d;
                  return _emitConst;
                } else {
                  if (value.emitConstMethod) {
                    e = value.emitConstMethod(pos);
                    _emitConst.$step = 4;
                    return _emitConst.$delegate(e);
                  } else {
                    if (Array.isArray(value)) {
                      ival = {
                        node: {}
                      };
                      aval = {
                        node: []
                      };
                      f = enter(pos, _types.Tag.ArrayExpression, ival);
                      _emitConst.$step = 5;
                      _emitConst.value = f;
                      return _emitConst;
                    } else {
                      _ival = {
                        node: {}
                      };
                      _aval = {
                        node: []
                      };
                      g = enter(pos, _types.Tag.ObjectExpression, _ival);
                      _emitConst.$step = 9;
                      _emitConst.value = g;
                      return _emitConst;
                    }
                  }
                }
              default:
                val = {
                  node: {
                    operator: "void"
                  }
                };
                h = enter(pos, _types.Tag.UnaryExpression, val);
                _emitConst.$step = 16;
                _emitConst.value = h;
                return _emitConst;
            }
          } else {
            _emitConst.$step = 0;
            _emitConst.value = void 0;
            _emitConst.done = true;
            return _emitConst;
          }
        case 5:
          a = enter(_types.Tag.elements, _types.Tag.Array, aval);
          _emitConst.$step = 6;
          _emitConst.value = a;
          return _emitConst;
        case 6:
          _loop = M.iterator(value);
          _emitConst.$step = 7;
          _emitConst.$step = 7;
          continue;
        case 7:
          if (!(_loop = _loop.step()).done) {
            j = _loop.value;
            a = emitConst(_types.Tag.push, j);
            _emitConst.$step = 7;
            return _emitConst.$delegate(a);
          } else {
            b = leave(_types.Tag.elements, _types.Tag.Array, aval);
            _emitConst.$step = 8;
            _emitConst.value = b;
            return _emitConst;
          }
        case 8:
          a = leave(pos, _types.Tag.ArrayExpression, ival);
          _emitConst.$step = 4;
          _emitConst.value = a;
          return _emitConst;
        case 9:
          a = enter(_types.Tag.properties, _types.Tag.Array, _aval);
          _emitConst.$step = 10;
          _emitConst.value = a;
          return _emitConst;
        case 10:
          loop1 = M.forInIterator(value);
          _emitConst.$step = 11;
          _emitConst.$step = 11;
          continue;
        case 11:
          if (!(loop1 = loop1.step()).done) {
            name = loop1.value;
            pval = {
              node: {}
            };
            a = enter(_types.Tag.push, _types.Tag.ObjectProperty, pval);
            _emitConst.$step = 12;
            _emitConst.value = a;
            return _emitConst;
          } else {
            b = leave(_types.Tag.properties, _types.Tag.Array, _aval);
            _emitConst.$step = 15;
            _emitConst.value = b;
            return _emitConst;
          }
        case 12:
          a = tok(_types.Tag.key, _types.Tag.Identifier, {
            node: {
              name
            }
          });
          _emitConst.$step = 13;
          _emitConst.value = a;
          return _emitConst;
        case 13:
          a = emitConst(_types.Tag.value, value[name]);
          _emitConst.$step = 14;
          return _emitConst.$delegate(a);
        case 14:
          a = leave(_types.Tag.push, _types.Tag.ObjectProperty, pval);
          _emitConst.$step = 11;
          _emitConst.value = a;
          return _emitConst;
        case 15:
          a = leave(pos, _types.Tag.ObjectExpression, _ival);
          _emitConst.$step = 4;
          _emitConst.value = a;
          return _emitConst;
        case 16:
          a = tok(_types.Tag.argument, _types.Tag.NumericLiteral, {
            node: {
              value: "0"
            }
          });
          _emitConst.$step = 17;
          _emitConst.value = a;
          return _emitConst;
        case 17:
          a = leave(pos, _types.Tag.UnaryExpression, val);
          _emitConst.$step = 4;
          _emitConst.value = a;
          return _emitConst;
        case 0:
          _emitConst.$step = 0;
          _emitConst.value = p;
          _emitConst.done = true;
          return _emitConst;
        case 1:
          _emitConst.$step = 0;
          throw p;
        case 2:
          return _emitConst.$redir(p);
        default:
          throw new Error("invalid state");
      }
    }
  }
}