wisp_inertia

-module(internal@props).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/internal/props.gleam").
-export([dict_to_prop/1, page_object_to_json/2]).
-export_type([page_prop/0, render_context/0, page_object/0]).

-type page_prop() :: {error_prop, binary(), gleam@json:json()} |
    {base_prop, binary(), gleam@json:json()} |
    {once_prop, binary(), fun(() -> gleam@json:json())} |
    {merge_prop, binary(), fun(() -> gleam@json:json())} |
    {shared_prop, binary(), gleam@json:json()} |
    {defer_prop,
        binary(),
        fun(() -> {ok, gleam@json:json()} | {error, nil}),
        gleam@option:option(binary())}.

-type render_context() :: {render_context,
        binary(),
        binary(),
        boolean(),
        list(binary()),
        list(binary()),
        list(binary())}.

-type page_object() :: {page_object,
        binary(),
        binary(),
        list(page_prop()),
        list(page_prop()),
        list(page_prop()),
        list(page_prop()),
        binary(),
        gleam@option:option(boolean())}.

-file("src/internal/props.gleam", 44).
-spec dict_to_prop(gleam@dict:dict(binary(), binary())) -> list(page_prop()).
dict_to_prop(D) ->
    _pipe = maps:keys(D),
    gleam@list:map(
        _pipe,
        fun(Key) ->
            Val@1 = case gleam_stdlib:map_get(D, Key) of
                {ok, Val} -> Val;
                _assert_fail ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"internal/props"/utf8>>,
                                function => <<"dict_to_prop"/utf8>>,
                                line => 47,
                                value => _assert_fail,
                                start => 1036,
                                'end' => 1073,
                                pattern_start => 1047,
                                pattern_end => 1054})
            end,
            {base_prop, Key, gleam@json:string(Val@1)}
        end
    ).

-file("src/internal/props.gleam", 187).
-spec resolve_shared(list(page_prop())) -> gleam@option:option({binary(),
    gleam@json:json()}).
resolve_shared(List) ->
    case List of
        [] ->
            none;

        _ ->
            Prop_names = begin
                _pipe = List,
                gleam@list:map(_pipe, fun(P) -> erlang:element(2, P) end)
            end,
            {some,
                {<<"sharedProps"/utf8>>,
                    gleam@json:array(Prop_names, fun gleam@json:string/1)}}
    end.

-file("src/internal/props.gleam", 199).
-spec should_resolve_merge(render_context(), page_prop()) -> boolean().
should_resolve_merge(Ctx, Mp) ->
    Is_reset = gleam@list:contains(
        erlang:element(5, Ctx),
        erlang:element(2, Mp)
    ),
    Is_partial = gleam@list:contains(
        erlang:element(6, Ctx),
        erlang:element(2, Mp)
    ),
    case {Is_partial, Is_reset} of
        {true, false} ->
            true;

        {false, true} ->
            false;

        {_, _} ->
            false
    end.

-file("src/internal/props.gleam", 210).
-spec resolve_merge_prop(render_context(), list(page_prop())) -> gleam@option:option({binary(),
    gleam@json:json()}).
resolve_merge_prop(Ctx, Props) ->
    Mergable = begin
        _pipe = Props,
        _pipe@1 = gleam@list:filter(_pipe, fun(P) -> case P of
                    {merge_prop, _, _} ->
                        should_resolve_merge(Ctx, P);

                    _ ->
                        false
                end end),
        gleam@list:map(_pipe@1, fun(P@1) -> erlang:element(2, P@1) end)
    end,
    case Mergable of
        [] ->
            none;

        _ ->
            {some,
                {<<"mergeProps"/utf8>>,
                    gleam@json:array(Mergable, fun gleam@json:string/1)}}
    end.

-file("src/internal/props.gleam", 158).
-spec resolve_defer_prop(list(page_prop())) -> gleam@option:option({binary(),
    gleam@json:json()}).
resolve_defer_prop(Props) ->
    Groups = begin
        _pipe = Props,
        gleam@list:group(_pipe, fun(P) -> case P of
                    {defer_prop, _, _, G} ->
                        gleam@option:unwrap(G, <<"default"/utf8>>);

                    _ ->
                        <<""/utf8>>
                end end)
    end,
    Items = begin
        _pipe@1 = maps:keys(Groups),
        _pipe@2 = gleam@list:filter(_pipe@1, fun(Key) -> Key /= <<""/utf8>> end),
        gleam@list:map(
            _pipe@2,
            fun(K) ->
                Values = begin
                    _pipe@3 = gleam_stdlib:map_get(Groups, K),
                    _pipe@4 = gleam@result:unwrap(_pipe@3, []),
                    gleam@list:map(
                        _pipe@4,
                        fun(P@1) -> erlang:element(2, P@1) end
                    )
                end,
                {K, gleam@json:array(Values, fun gleam@json:string/1)}
            end
        )
    end,
    case Items of
        [] ->
            none;

        _ ->
            {some, {<<"deferredProps"/utf8>>, gleam@json:object(Items)}}
    end.

-file("src/internal/props.gleam", 132).
-spec resolve_once_props(list(page_prop())) -> gleam@option:option({binary(),
    gleam@json:json()}).
resolve_once_props(Props) ->
    Once = begin
        _pipe = Props,
        _pipe@1 = gleam@list:filter(_pipe, fun(P) -> case P of
                    {once_prop, _, _} ->
                        true;

                    _ ->
                        false
                end end),
        gleam@list:map(
            _pipe@1,
            fun(P@1) ->
                Value = gleam@json:object(
                    [{<<"prop"/utf8>>,
                            gleam@json:string(erlang:element(2, P@1))},
                        {<<"expiresAt"/utf8>>, gleam@json:null()}]
                ),
                {erlang:element(2, P@1), Value}
            end
        )
    end,
    case Once of
        [] ->
            none;

        _ ->
            {some, {<<"onceProps"/utf8>>, gleam@json:object(Once)}}
    end.

-file("src/internal/props.gleam", 230).
-spec resolve_map_prop(page_prop()) -> {binary(), gleam@json:json()}.
resolve_map_prop(P) ->
    case P of
        {once_prop, Name, Fun} ->
            {Name, Fun()};

        {merge_prop, Name, Fun} ->
            {Name, Fun()};

        {base_prop, Name@1, Value} ->
            {Name@1, Value};

        {shared_prop, Name@1, Value} ->
            {Name@1, Value};

        {defer_prop, Name@2, Fun@1, _} ->
            case Fun@1() of
                {ok, Val} ->
                    {Name@2, Val};

                _ ->
                    {Name@2, gleam@json:null()}
            end;

        {error_prop, Name@3, Value@1} ->
            {<<"errors"/utf8>>, gleam@json:object([{Name@3, Value@1}])}
    end.

-file("src/internal/props.gleam", 104).
-spec should_resolve(render_context(), page_prop()) -> boolean().
should_resolve(Ctx, P) ->
    Include = gleam@list:contains(erlang:element(6, Ctx), erlang:element(2, P)),
    Exclude = gleam@list:contains(erlang:element(7, Ctx), erlang:element(2, P)),
    case {gleam@list:is_empty(erlang:element(6, Ctx)), Include} of
        {false, true} ->
            true;

        {true, _} ->
            case {gleam@list:is_empty(erlang:element(7, Ctx)), Exclude} of
                {false, true} ->
                    false;

                {true, _} ->
                    true;

                {_, _} ->
                    false
            end;

        {_, _} ->
            false
    end.

-file("src/internal/props.gleam", 119).
-spec resolve_props(render_context(), list(page_prop())) -> list({binary(),
    gleam@json:json()}).
resolve_props(Ctx, Props) ->
    _pipe = gleam@list:filter(Props, fun(P) -> case erlang:element(4, Ctx) of
                true ->
                    true;

                _ ->
                    should_resolve(Ctx, P)
            end end),
    gleam@list:map(_pipe, fun resolve_map_prop/1).

-file("src/internal/props.gleam", 52).
-spec page_object_to_json(page_object(), render_context()) -> gleam@json:json().
page_object_to_json(Po, Ctx) ->
    Default_props = begin
        _pipe = resolve_props(Ctx, erlang:element(4, Po)),
        lists:append(
            _pipe,
            [{<<"errors"/utf8>>,
                    gleam@json:object(resolve_props(Ctx, erlang:element(5, Po)))}]
        )
    end,
    View_props = case erlang:element(4, Ctx) of
        true ->
            _pipe@1 = Default_props,
            _pipe@2 = lists:append(
                _pipe@1,
                resolve_props(Ctx, erlang:element(7, Po))
            ),
            gleam@json:object(_pipe@2);

        false ->
            _pipe@3 = Default_props,
            _pipe@4 = lists:append(
                _pipe@3,
                resolve_props(Ctx, erlang:element(6, Po))
            ),
            _pipe@5 = lists:append(
                _pipe@4,
                resolve_props(Ctx, erlang:element(7, Po))
            ),
            gleam@json:object(_pipe@5)
    end,
    Base_items = [{<<"component"/utf8>>,
            gleam@json:string(erlang:element(2, Po))},
        {<<"url"/utf8>>, gleam@json:string(erlang:element(3, Po))},
        {<<"props"/utf8>>, View_props},
        {<<"version"/utf8>>, gleam@json:string(erlang:element(8, Po))},
        {<<"clearHistory"/utf8>>, gleam@json:bool(false)}],
    Once_resolved = case resolve_once_props(erlang:element(4, Po)) of
        none ->
            Base_items;

        {some, Once} ->
            lists:append(Base_items, [Once])
    end,
    Defer_resolved = case erlang:element(4, Ctx) of
        false ->
            Once_resolved;

        true ->
            case resolve_defer_prop(erlang:element(6, Po)) of
                none ->
                    Once_resolved;

                {some, Defers} ->
                    lists:append(Once_resolved, [Defers])
            end
    end,
    Merge_resolved = case resolve_merge_prop(Ctx, erlang:element(4, Po)) of
        none ->
            Defer_resolved;

        {some, Merge} ->
            lists:append(Defer_resolved, [Merge])
    end,
    Shared_resolved = case resolve_shared(erlang:element(7, Po)) of
        none ->
            Merge_resolved;

        {some, Shared} ->
            lists:append(Merge_resolved, [Shared])
    end,
    gleam@json:object(Shared_resolved).