-module(lightspeed@router).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/lightspeed/router.gleam").
-export([new/1, add/4, resolve/2, mount_instructions/2, decode/2, view_id/1, params/1, match_label/1]).
-export_type([route_param/0, route/1, router/1, route_match/1, matched_route/1]).
-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.
?MODULEDOC(" Router integration helpers for mount/render flows.\n").
-type route_param() :: {route_param, binary(), binary()}.
-type route(LKJ) :: {route,
binary(),
binary(),
fun((lightspeed@event:inbound_event(), list(route_param())) -> {ok, LKJ} |
{error, lightspeed@event:decode_error()})}.
-type router(LKK) :: {router, binary(), list(route(LKK))}.
-type route_match(LKL) :: {found, matched_route(LKL)} |
{not_found, binary(), binary()}.
-type matched_route(LKM) :: {matched_route,
binary(),
binary(),
binary(),
list(route_param()),
fun((lightspeed@event:inbound_event(), list(route_param())) -> {ok, LKM} |
{error, lightspeed@event:decode_error()})}.
-file("src/lightspeed/router.gleam", 48).
?DOC(" Create a new router with a fallback not-found view.\n").
-spec new(binary()) -> router(any()).
new(Not_found_view) ->
{router, Not_found_view, []}.
-file("src/lightspeed/router.gleam", 53).
?DOC(" Register a route pattern.\n").
-spec add(
router(LKP),
binary(),
binary(),
fun((lightspeed@event:inbound_event(), list(route_param())) -> {ok, LKP} |
{error, lightspeed@event:decode_error()})
) -> router(LKP).
add(Router, Pattern, View_id, Decode_event) ->
{router,
erlang:element(2, Router),
[{route, Pattern, View_id, Decode_event} | erlang:element(3, Router)]}.
-file("src/lightspeed/router.gleam", 229).
-spec join_graphemes(list(binary())) -> binary().
join_graphemes(Graphemes) ->
case Graphemes of
[] ->
<<""/utf8>>;
[Grapheme | Rest] ->
<<Grapheme/binary, (join_graphemes(Rest))/binary>>
end.
-file("src/lightspeed/router.gleam", 217).
-spec param_name(binary()) -> gleam@option:option(binary()).
param_name(Segment) ->
case gleam@string:to_graphemes(Segment) of
[<<":"/utf8>> | Rest] ->
case Rest of
[] ->
none;
_ ->
{some, join_graphemes(Rest)}
end;
_ ->
none
end.
-file("src/lightspeed/router.gleam", 173).
-spec match_segments(list(binary()), list(binary()), list(route_param())) -> gleam@option:option(list(route_param())).
match_segments(Pattern_segments, Path_segments, Captures_rev) ->
case {Pattern_segments, Path_segments} of
{[], []} ->
{some, lists:reverse(Captures_rev)};
{[], _} ->
none;
{_, []} ->
none;
{[Pattern_segment | Pattern_rest], [Path_segment | Path_rest]} ->
case param_name(Pattern_segment) of
{some, Name} ->
match_segments(
Pattern_rest,
Path_rest,
[{route_param, Name, Path_segment} | Captures_rev]
);
none ->
case Pattern_segment =:= Path_segment of
true ->
match_segments(
Pattern_rest,
Path_rest,
Captures_rev
);
false ->
none
end
end
end.
-file("src/lightspeed/router.gleam", 206).
-spec filter_empty(list(binary()), list(binary())) -> list(binary()).
filter_empty(Values, Kept_rev) ->
case Values of
[] ->
lists:reverse(Kept_rev);
[Value | Rest] ->
case Value =:= <<""/utf8>> of
true ->
filter_empty(Rest, Kept_rev);
false ->
filter_empty(Rest, [Value | Kept_rev])
end
end.
-file("src/lightspeed/router.gleam", 200).
-spec segments(binary()) -> list(binary()).
segments(Path) ->
_pipe = Path,
_pipe@1 = gleam@string:split(_pipe, <<"/"/utf8>>),
filter_empty(_pipe@1, []).
-file("src/lightspeed/router.gleam", 167).
-spec match_pattern(binary(), binary()) -> gleam@option:option(list(route_param())).
match_pattern(Pattern, Path) ->
Pattern_segments = segments(Pattern),
Path_segments = segments(Path),
match_segments(Pattern_segments, Path_segments, []).
-file("src/lightspeed/router.gleam", 119).
-spec find_match(list(route(LLM)), binary()) -> gleam@option:option(matched_route(LLM)).
find_match(Routes, Normalized_path) ->
case Routes of
[] ->
none;
[Route | Rest] ->
case match_pattern(erlang:element(2, Route), Normalized_path) of
{some, Captures} ->
{some,
{matched_route,
Normalized_path,
erlang:element(2, Route),
erlang:element(3, Route),
Captures,
erlang:element(4, Route)}};
none ->
find_match(Rest, Normalized_path)
end
end.
-file("src/lightspeed/router.gleam", 243).
-spec drop_last(binary()) -> binary().
drop_last(Path) ->
case lists:reverse(gleam@string:to_graphemes(Path)) of
[] ->
<<""/utf8>>;
[_ | Rest] ->
_pipe = Rest,
_pipe@1 = lists:reverse(_pipe),
join_graphemes(_pipe@1)
end.
-file("src/lightspeed/router.gleam", 236).
-spec ends_with_slash(binary()) -> boolean().
ends_with_slash(Path) ->
case lists:reverse(gleam@string:to_graphemes(Path)) of
[<<"/"/utf8>> | _] ->
true;
_ ->
false
end.
-file("src/lightspeed/router.gleam", 156).
-spec trim_trailing_slashes(binary()) -> binary().
trim_trailing_slashes(Path) ->
case Path of
<<"/"/utf8>> ->
<<"/"/utf8>>;
_ ->
case ends_with_slash(Path) of
true ->
trim_trailing_slashes(drop_last(Path));
false ->
Path
end
end.
-file("src/lightspeed/router.gleam", 142).
-spec normalize_path(binary()) -> binary().
normalize_path(Path) ->
No_query = case gleam@string:split(Path, <<"?"/utf8>>) of
[First | _] ->
First;
[] ->
Path
end,
Trimmed = trim_trailing_slashes(No_query),
case Trimmed of
<<""/utf8>> ->
<<"/"/utf8>>;
_ ->
Trimmed
end.
-file("src/lightspeed/router.gleam", 67).
?DOC(" Resolve one path into a route match.\n").
-spec resolve(router(LKV), binary()) -> route_match(LKV).
resolve(Router, Path) ->
Normalized = normalize_path(Path),
case find_match(lists:reverse(erlang:element(3, Router)), Normalized) of
{some, Matched} ->
{found, Matched};
none ->
{not_found, Normalized, erlang:element(2, Router)}
end.
-file("src/lightspeed/router.gleam", 77).
?DOC(" Build a mount/render ISA sequence for a resolved route.\n").
-spec mount_instructions(route_match(any()), binary()) -> list(lightspeed@agent@isa:instruction()).
mount_instructions(Route_match, Csrf_token) ->
case Route_match of
{found, Matched} ->
[{mount, erlang:element(2, Matched), Csrf_token},
{render, erlang:element(4, Matched)}];
{not_found, Path, View_id} ->
[{mount, Path, Csrf_token}, {render, View_id}]
end.
-file("src/lightspeed/router.gleam", 94).
?DOC(" Decode one inbound event against a matched route decoder.\n").
-spec decode(matched_route(LLB), lightspeed@event:inbound_event()) -> {ok, LLB} |
{error, lightspeed@event:decode_error()}.
decode(Matched, Inbound) ->
(erlang:element(6, Matched))(Inbound, erlang:element(5, Matched)).
-file("src/lightspeed/router.gleam", 102).
?DOC(" Matched route view id.\n").
-spec view_id(matched_route(any())) -> binary().
view_id(Matched) ->
erlang:element(4, Matched).
-file("src/lightspeed/router.gleam", 107).
?DOC(" Matched route captured params.\n").
-spec params(matched_route(any())) -> list(route_param()).
params(Matched) ->
erlang:element(5, Matched).
-file("src/lightspeed/router.gleam", 112).
?DOC(" Render stable route match labels for logs.\n").
-spec match_label(route_match(any())) -> binary().
match_label(Route_match) ->
case Route_match of
{found, Matched} ->
<<"found:"/utf8, (erlang:element(3, Matched))/binary>>;
{not_found, _, View_id} ->
<<"not_found:"/utf8, View_id/binary>>
end.
