-module(lightspeed@form_compat).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/lightspeed/form_compat.gleam").
-export([new/1, change/4, blur/3, tick/2, submit/3, dispatch_label/1, has_pending/2, mode/2]).
-export_type([change_mode/0, input_config/0, dispatch/0, input_state/0, runtime/0]).
-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(" LiveView-style form change/submit compatibility semantics.\n").
-type change_mode() :: immediate |
{debounce, integer()} |
debounce_blur |
{throttle, integer()}.
-type input_config() :: {input_config, binary(), change_mode()}.
-type dispatch() :: {dispatch_change, binary(), lightspeed@form:form_data()} |
{dispatch_submit, lightspeed@form:form_data()} |
{queued, binary()} |
{suppressed, binary(), binary()} |
no_dispatch.
-type input_state() :: {input_state,
binary(),
change_mode(),
gleam@option:option(integer()),
gleam@option:option(lightspeed@form:form_data()),
gleam@option:option(integer())}.
-opaque runtime() :: {runtime, list(input_state())}.
-file("src/lightspeed/form_compat.gleam", 126).
-spec from_configs(list(input_config()), list(input_state())) -> list(input_state()).
from_configs(Configs, States_rev) ->
case Configs of
[] ->
lists:reverse(States_rev);
[{input_config, Name, Mode} | Rest] ->
from_configs(
Rest,
[{input_state, Name, Mode, none, none, none} | States_rev]
)
end.
-file("src/lightspeed/form_compat.gleam", 45).
?DOC(" Build a runtime from known inputs.\n").
-spec new(list(input_config())) -> runtime().
new(Configs) ->
{runtime, from_configs(Configs, [])}.
-file("src/lightspeed/form_compat.gleam", 400).
-spec reverse_into(list(input_state()), list(input_state())) -> list(input_state()).
reverse_into(Left, Right) ->
case Left of
[] ->
Right;
[Entry | Rest] ->
reverse_into(Rest, [Entry | Right])
end.
-file("src/lightspeed/form_compat.gleam", 392).
-spec rebuild(list(input_state()), input_state(), list(input_state())) -> list(input_state()).
rebuild(States_rev, Updated, Rest) ->
reverse_into([Updated | States_rev], Rest).
-file("src/lightspeed/form_compat.gleam", 365).
-spec should_dispatch_throttle(
gleam@option:option(integer()),
integer(),
integer()
) -> boolean().
should_dispatch_throttle(Last_dispatch, Now_ms, Window_ms) ->
case Window_ms =< 0 of
true ->
true;
false ->
case Last_dispatch of
none ->
true;
{some, Last} ->
(Now_ms - Last) >= Window_ms
end
end.
-file("src/lightspeed/form_compat.gleam", 147).
-spec apply_change(
list(input_state()),
binary(),
lightspeed@form:form_data(),
integer(),
list(input_state())
) -> {list(input_state()), dispatch()}.
apply_change(States, Input, Payload, At_ms, States_rev) ->
case States of
[] ->
{lists:reverse(States_rev),
{suppressed, Input, <<"unknown_input"/utf8>>}};
[State | Rest] ->
case erlang:element(2, State) =:= Input of
false ->
apply_change(
Rest,
Input,
Payload,
At_ms,
[State | States_rev]
);
true ->
case erlang:element(3, State) of
immediate ->
Next = {input_state,
erlang:element(2, State),
erlang:element(3, State),
{some, At_ms},
none,
none},
{rebuild(States_rev, Next, Rest),
{dispatch_change, Input, Payload}};
{debounce, Wait_ms} ->
case Wait_ms =< 0 of
true ->
Next@1 = {input_state,
erlang:element(2, State),
erlang:element(3, State),
{some, At_ms},
none,
none},
{rebuild(States_rev, Next@1, Rest),
{dispatch_change, Input, Payload}};
false ->
Next@2 = {input_state,
erlang:element(2, State),
erlang:element(3, State),
erlang:element(4, State),
{some, Payload},
{some, At_ms}},
{rebuild(States_rev, Next@2, Rest),
{queued, Input}}
end;
debounce_blur ->
Next@3 = {input_state,
erlang:element(2, State),
erlang:element(3, State),
erlang:element(4, State),
{some, Payload},
{some, At_ms}},
{rebuild(States_rev, Next@3, Rest), {queued, Input}};
{throttle, Window_ms} ->
case should_dispatch_throttle(
erlang:element(4, State),
At_ms,
Window_ms
) of
true ->
Next@4 = {input_state,
erlang:element(2, State),
erlang:element(3, State),
{some, At_ms},
none,
none},
{rebuild(States_rev, Next@4, Rest),
{dispatch_change, Input, Payload}};
false ->
{rebuild(States_rev, State, Rest),
{suppressed,
Input,
<<"throttled"/utf8>>}}
end
end
end
end.
-file("src/lightspeed/form_compat.gleam", 356).
-spec clear_timers(input_state()) -> input_state().
clear_timers(State) ->
{input_state,
erlang:element(2, State),
erlang:element(3, State),
none,
none,
none}.
-file("src/lightspeed/form_compat.gleam", 325).
-spec reset_other_timers(list(input_state()), binary(), list(input_state())) -> list(input_state()).
reset_other_timers(States, Selected_input, States_rev) ->
case States of
[] ->
lists:reverse(States_rev);
[State | Rest] ->
case erlang:element(2, State) =:= Selected_input of
true ->
reset_other_timers(
Rest,
Selected_input,
[State | States_rev]
);
false ->
reset_other_timers(
Rest,
Selected_input,
[clear_timers(State) | States_rev]
)
end
end.
-file("src/lightspeed/form_compat.gleam", 56).
?DOC(
" Handle one `phx-change`-style event.\n"
"\n"
" Semantics:\n"
" - debounce stores pending payload\n"
" - debounce blur stores pending payload until blur\n"
" - throttle emits immediately then suppresses inside window\n"
" - change for one input resets timers for all other inputs\n"
).
-spec change(runtime(), binary(), binary(), integer()) -> {runtime(),
dispatch()}.
change(Runtime, Input, Payload, At_ms) ->
Parsed = lightspeed@form:parse_payload(Payload),
Inputs = reset_other_timers(erlang:element(2, Runtime), Input, []),
{Inputs@1, Dispatch} = apply_change(Inputs, Input, Parsed, At_ms, []),
{{runtime, Inputs@1}, Dispatch}.
-file("src/lightspeed/form_compat.gleam", 250).
-spec apply_blur(list(input_state()), binary(), integer(), list(input_state())) -> {list(input_state()),
dispatch()}.
apply_blur(States, Input, At_ms, States_rev) ->
case States of
[] ->
{lists:reverse(States_rev),
{suppressed, Input, <<"unknown_input"/utf8>>}};
[State | Rest] ->
case erlang:element(2, State) =:= Input of
false ->
apply_blur(Rest, Input, At_ms, [State | States_rev]);
true ->
case {erlang:element(3, State), erlang:element(5, State)} of
{debounce_blur, {some, Payload}} ->
Next = {input_state,
erlang:element(2, State),
erlang:element(3, State),
{some, At_ms},
none,
none},
{rebuild(States_rev, Next, Rest),
{dispatch_change, Input, Payload}};
{_, _} ->
{rebuild(States_rev, State, Rest), no_dispatch}
end
end
end.
-file("src/lightspeed/form_compat.gleam", 69).
?DOC(" Handle one blur event used by `phx-debounce=\"blur\"`.\n").
-spec blur(runtime(), binary(), integer()) -> {runtime(), dispatch()}.
blur(Runtime, Input, At_ms) ->
{Inputs, Dispatch} = apply_blur(
erlang:element(2, Runtime),
Input,
At_ms,
[]
),
{{runtime, Inputs}, Dispatch}.
-file("src/lightspeed/form_compat.gleam", 288).
-spec flush_debounce(
list(input_state()),
integer(),
list(input_state()),
list(dispatch())
) -> {list(input_state()), list(dispatch())}.
flush_debounce(States, At_ms, States_rev, Dispatches_rev) ->
case States of
[] ->
{lists:reverse(States_rev), Dispatches_rev};
[State | Rest] ->
case {erlang:element(3, State),
erlang:element(5, State),
erlang:element(6, State)} of
{{debounce, Wait_ms}, {some, Payload}, {some, Pending_since}} ->
case (At_ms - Pending_since) >= Wait_ms of
true ->
Next = {input_state,
erlang:element(2, State),
erlang:element(3, State),
{some, At_ms},
none,
none},
flush_debounce(
Rest,
At_ms,
[Next | States_rev],
[{dispatch_change,
erlang:element(2, State),
Payload} |
Dispatches_rev]
);
false ->
flush_debounce(
Rest,
At_ms,
[State | States_rev],
Dispatches_rev
)
end;
{_, _, _} ->
flush_debounce(
Rest,
At_ms,
[State | States_rev],
Dispatches_rev
)
end
end.
-file("src/lightspeed/form_compat.gleam", 79).
?DOC(" Flush due debounce timers.\n").
-spec tick(runtime(), integer()) -> {runtime(), list(dispatch())}.
tick(Runtime, At_ms) ->
{Inputs, Dispatches_rev} = flush_debounce(
erlang:element(2, Runtime),
At_ms,
[],
[]
),
{{runtime, Inputs}, lists:reverse(Dispatches_rev)}.
-file("src/lightspeed/form_compat.gleam", 345).
-spec clear_all_timers(list(input_state()), list(input_state())) -> list(input_state()).
clear_all_timers(States, States_rev) ->
case States of
[] ->
lists:reverse(States_rev);
[State | Rest] ->
clear_all_timers(Rest, [clear_timers(State) | States_rev])
end.
-file("src/lightspeed/form_compat.gleam", 87).
?DOC(
" Handle one `phx-submit`-style event.\n"
"\n"
" Submit resets existing change timers.\n"
).
-spec submit(runtime(), binary(), integer()) -> {runtime(), dispatch()}.
submit(Runtime, Payload, _) ->
Inputs = clear_all_timers(erlang:element(2, Runtime), []),
{{runtime, Inputs},
{dispatch_submit, lightspeed@form:parse_payload(Payload)}}.
-file("src/lightspeed/form_compat.gleam", 100).
?DOC(" Stable dispatch label for tests and logs.\n").
-spec dispatch_label(dispatch()) -> binary().
dispatch_label(Dispatch) ->
case Dispatch of
{dispatch_change, _, _} ->
<<"change"/utf8>>;
{dispatch_submit, _} ->
<<"submit"/utf8>>;
{queued, _} ->
<<"queued"/utf8>>;
{suppressed, _, Reason} ->
<<"suppressed:"/utf8, Reason/binary>>;
no_dispatch ->
<<"none"/utf8>>
end.
-file("src/lightspeed/form_compat.gleam", 381).
-spec find_input(list(input_state()), binary()) -> gleam@option:option(input_state()).
find_input(States, Name) ->
case States of
[] ->
none;
[State | Rest] ->
case erlang:element(2, State) =:= Name of
true ->
{some, State};
false ->
find_input(Rest, Name)
end
end.
-file("src/lightspeed/form_compat.gleam", 111).
?DOC(" Return pending status for one input.\n").
-spec has_pending(runtime(), binary()) -> boolean().
has_pending(Runtime, Input) ->
case find_input(erlang:element(2, Runtime), Input) of
{some, {input_state, _, _, _, {some, _}, _}} ->
true;
_ ->
false
end.
-file("src/lightspeed/form_compat.gleam", 119).
?DOC(" Return the current mode for one input.\n").
-spec mode(runtime(), binary()) -> gleam@option:option(change_mode()).
mode(Runtime, Input) ->
case find_input(erlang:element(2, Runtime), Input) of
{some, {input_state, _, Mode, _, _, _}} ->
{some, Mode};
none ->
none
end.
