evaluate function

Object? evaluate(
  1. Ast node,
  2. EvaluationContext ctx, [
  3. IsReactiveProp? reactive
])

lang-core evaluate. reactive is lang-core's schema context: present when evaluating props for rendering.

Implementation

Object? evaluate(Ast node, EvaluationContext ctx, [IsReactiveProp? reactive]) {
  switch (node) {
    case StrNode(:final value):
      return value;
    case NumNode(:final value):
      return value;
    case BoolNode(:final value):
      return value;
    case NullNode() || PlaceholderNode():
      return null;
    case ValueNode(:final value):
      return value;
    case StateRefNode(:final name):
      return ctx.extraScope?[name] ?? ctx.getState(name);
    case RefNode(:final name):
      return ctx.resolveRef(name);
    case RuntimeRefNode(:final name):
      return ctx.resolveRef(name);
    case ArrNode(:final elements):
      return [for (final e in elements) evaluate(e, ctx)];
    case ObjNode(:final entries):
      return Js.object([
        for (final (k, v) in entries) MapEntry(k, evaluate(v, ctx)),
      ]);
    case CompNode():
      return _evaluateCall(node, ctx, reactive);
    case BinOpNode(:final op, :final left, :final right):
      if (op == '&&') {
        final l = evaluate(left, ctx);
        return Js.truthy(l) ? evaluate(right, ctx) : l;
      }
      if (op == '||') {
        final l = evaluate(left, ctx);
        return Js.truthy(l) ? l : evaluate(right, ctx);
      }
      final l = evaluate(left, ctx);
      final r = evaluate(right, ctx);
      switch (op) {
        case '+':
          if (l is String || r is String) {
            return Js.string(l ?? '') + Js.string(r ?? '');
          }
          return Js.toNumber(l).toDouble() + Js.toNumber(r).toDouble();
        case '-':
          return Js.toNumber(l).toDouble() - Js.toNumber(r).toDouble();
        case '*':
          return Js.toNumber(l).toDouble() * Js.toNumber(r).toDouble();
        case '/':
          final d = Js.toNumber(r);
          return d == 0 ? 0 : Js.toNumber(l) / d;
        case '%':
          final d = Js.toNumber(r);
          return d == 0 ? 0 : Js.toNumber(l).toDouble().remainder(d.toDouble());
        case '==':
          return Js.looseEquals(l, r);
        case '!=':
          return !Js.looseEquals(l, r);
        case '>':
          return Js.toNumber(l) > Js.toNumber(r);
        case '<':
          return Js.toNumber(l) < Js.toNumber(r);
        case '>=':
          return Js.toNumber(l) >= Js.toNumber(r);
        case '<=':
          return Js.toNumber(l) <= Js.toNumber(r);
      }
      return null;
    case UnaryOpNode(:final op, :final operand):
      if (op == '!') return !Js.truthy(evaluate(operand, ctx));
      if (op == '-') return -Js.toNumber(evaluate(operand, ctx)).toDouble();
      return null;
    case TernaryNode(:final condition, :final then, :final otherwise):
      return Js.truthy(evaluate(condition, ctx))
          ? evaluate(then, ctx)
          : evaluate(otherwise, ctx);
    case MemberNode(:final object, :final field):
      final obj = evaluate(object, ctx);
      if (obj == null) return null;
      // A list plucks the field from every item.
      if (obj is List && field != 'length') {
        return [for (final item in obj) Js.property(item, field)];
      }
      return Js.property(obj, field);
    case IndexNode(:final object, :final index):
      final obj = evaluate(object, ctx);
      final idx = evaluate(index, ctx);
      if (obj == null || idx == null) return null;
      return Js.property(
        obj,
        obj is List ? Js.numberToString(Js.toNumber(idx)) : Js.string(idx),
      );
    case AssignNode(:final target, :final value):
      return ReactiveAssign(target, value);
  }
}