private static function fromFlatMapImpl()

in src/router/PrefixMatching/PrefixMap.php [55:141]
82 lines of code
13 McCabe index (conditional complexity)

  private static function fromFlatMapImpl(
    vec<(vec<Node>, T)> $entries,
  ): PrefixMap<T> {
    $literals = dict[];
    $prefixes = vec[];
    $regexps = vec[];
    foreach ($entries as list($nodes, $responder)) {
      if (C\is_empty($nodes)) {
        $literals[''] = $responder;
        continue;
      }
      $node = C\firstx($nodes);
      $nodes = Vec\drop($nodes, 1);
      if ($node is LiteralNode) {
        if (C\is_empty($nodes)) {
          $literals[$node->getText()] = $responder;
        } else {
          $prefixes[] = tuple($node->getText(), $nodes, $responder);
        }
        continue;
      }

      if ($node is ParameterNode && $node->getRegexp() === null) {
        $next = C\first($nodes);
        if (
          $next is LiteralNode &&
          $next->getText() !== '' &&
          $next->getText()[0] === '/'
        ) {
          $regexps[] = tuple($node->asRegexp('#'), $nodes, $responder);

          continue;
        }
      }
      $regexps[] = tuple(
        Vec\concat(vec[$node], $nodes)
          |> Vec\map($$, $n ==> $n->asRegexp('#'))
          |> Str\join($$, ''),
        vec[],
        $responder,
      );
    }

    $by_first = Dict\group_by($prefixes, $entry ==> $entry[0]);
    list($prefix_length, $grouped) = self::groupByCommonPrefix(
      Keyset\keys($by_first),
    );
    $prefixes = Dict\map_with_key(
      $grouped,
      ($prefix, $keys) ==> Vec\map(
        $keys,
        $key ==> Vec\map(
          $by_first[$key],
          $row ==> {
            list($text, $nodes, $responder) = $row;
            if ($text === $prefix) {
              return tuple($nodes, $responder);
            }
            $suffix = Str\slice($text, $prefix_length);
            return tuple(
              Vec\concat(vec[new LiteralNode($suffix)], $nodes),
              $responder,
            );
          },
        ),
      )
        |> Vec\flatten($$)
        |> self::fromFlatMapImpl($$),
    );

    $by_first = Dict\group_by($regexps, $entry ==> $entry[0]);
    $regexps = dict[];
    foreach ($by_first as $first => $entries) {
      if (C\count($entries) === 1) {
        list($_, $nodes, $responder) = C\onlyx($entries);
        $rest = Str\join(Vec\map($nodes, $n ==> $n->asRegexp('#')), '');
        $regexps[$first.$rest] = new PrefixMapOrResponder(null, $responder);
        continue;
      }
      $regexps[$first] = new PrefixMapOrResponder(
        self::fromFlatMapImpl(Vec\map($entries, $e ==> tuple($e[1], $e[2]))),
        null,
      );
    }

    return new self($literals, $prefixes, $regexps, $prefix_length);
  }