evaluateQueries method

void evaluateQueries(
  1. List<QueryNode> nodes
)

Reconciles the active queries with the program's Query statements.

Implementation

void evaluateQueries(List<QueryNode> nodes) {
  if (_disposed) return;
  final active = {for (final n in nodes) n.statementId};
  for (final sid
      in _queries.keys.where((k) => !active.contains(k)).toList()) {
    final q = _queries.remove(sid)!;
    q.timer?.cancel();
    _cleanup(q.cacheKey);
    if (q.prevCacheKey != null) _cleanup(q.prevCacheKey!);
  }
  for (final node in nodes) {
    if (!node.complete) continue;
    final cacheKey =
        '${node.toolName}::${_stable(node.args)}${node.deps != null ? '::${_stable(node.deps)}' : ''}';
    final existing = _queries[node.statementId];
    if (existing != null) {
      if (existing.cacheKey != cacheKey) {
        existing.prevCacheKey = existing.cacheKey;
      }
      existing
        ..node = node
        ..cacheKey = cacheKey;
    } else {
      _queries[node.statementId] = _Query(node, cacheKey);
    }
    final q = _queries[node.statementId]!;
    final entry = _cache[cacheKey];
    q.loading = entry?.inFlight ?? false;
    if (_call != null &&
        !(entry?.settled ?? false) &&
        !(entry?.inFlight ?? false)) {
      unawaited(_fetch(cacheKey, node.statementId));
    }
    final interval = node.refreshInterval ?? 0;
    if (!Js.strictEquals(interval, q.refreshInterval)) {
      q.timer?.cancel();
      q.timer = null;
      final seconds = Js.number(interval);
      if (seconds > 0 && (seconds * 1000).isFinite) {
        q.timer = Timer.periodic(
          Duration(milliseconds: math.max(1, (seconds * 1000).round())),
          (_) {
            if (_disposed || _call == null) return;
            if (!(_cache[q.cacheKey]?.inFlight ?? false)) {
              unawaited(_fetch(q.cacheKey, node.statementId));
            }
          },
        );
      }
      q.refreshInterval = interval;
    }
  }
  if (_rebuild()) _notify();
}