wisp_inertia

-module(internal@template).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/internal/template.gleam").
-export([exist_template/0, has_manifest/0, has_ssr_manifest/0, read_file_lines/1, read_template/1, parse_template/3, parse_ssr_template/2]).

-file("src/internal/template.gleam", 15).
-spec exist_template() -> {ok, boolean()} |
    {error, internal@errors:inertia_error()}.
exist_template() ->
    Pattern@1 = case globlin:new_pattern(<<"**/index.html"/utf8>>) of
        {ok, Pattern} -> Pattern;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"internal/template"/utf8>>,
                        function => <<"exist_template"/utf8>>,
                        line => 16,
                        value => _assert_fail,
                        start => 369,
                        'end' => 430,
                        pattern_start => 380,
                        pattern_end => 391})
    end,
    Files = begin
        _pipe = globlin_fs:glob(Pattern@1, regular_files),
        gleam@result:map_error(
            _pipe,
            fun(_) -> fun(Field@0) -> {file_error, Field@0} end end
        )
    end,
    case Files of
        {ok, [_]} ->
            {ok, true};

        _ ->
            {error, template_not_found}
    end.

-file("src/internal/template.gleam", 27).
-spec has_manifest() -> {ok, binary()} |
    {error, internal@errors:inertia_error()}.
has_manifest() ->
    App@1 = case begin
        _pipe = internal@context:get_orelse(<<"app"/utf8>>, <<""/utf8>>),
        gleam_erlang_ffi:priv_directory(_pipe)
    end of
        {ok, App} -> App;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"internal/template"/utf8>>,
                        function => <<"has_manifest"/utf8>>,
                        line => 28,
                        value => _assert_fail,
                        start => 714,
                        'end' => 798,
                        pattern_start => 725,
                        pattern_end => 732})
    end,
    Pattern@1 = case globlin:new_pattern(<<"**/manifest.json"/utf8>>) of
        {ok, Pattern} -> Pattern;
        _assert_fail@1 ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"internal/template"/utf8>>,
                        function => <<"has_manifest"/utf8>>,
                        line => 31,
                        value => _assert_fail@1,
                        start => 802,
                        'end' => 866,
                        pattern_start => 813,
                        pattern_end => 824})
    end,
    Files = begin
        _pipe@1 = globlin_fs:glob(Pattern@1, regular_files),
        gleam@result:map_error(
            _pipe@1,
            fun(_) -> fun(Field@0) -> {file_error, Field@0} end end
        )
    end,
    case Files of
        {ok, [F]} ->
            {ok, F};

        _ ->
            case simplifile_erl:is_file(
                <<App@1/binary, "/static/.vite/manifest.json"/utf8>>
            ) of
                {ok, true} ->
                    {ok, <<App@1/binary, "/static/.vite/manifest.json"/utf8>>};

                _ ->
                    {error, manifest_not_found}
            end
    end.

-file("src/internal/template.gleam", 46).
-spec has_ssr_manifest() -> boolean().
has_ssr_manifest() ->
    App@1 = case begin
        _pipe = internal@context:get_orelse(<<"app"/utf8>>, <<""/utf8>>),
        gleam_erlang_ffi:priv_directory(_pipe)
    end of
        {ok, App} -> App;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"internal/template"/utf8>>,
                        function => <<"has_ssr_manifest"/utf8>>,
                        line => 47,
                        value => _assert_fail,
                        start => 1272,
                        'end' => 1356,
                        pattern_start => 1283,
                        pattern_end => 1290})
    end,
    case simplifile_erl:is_file(
        <<App@1/binary, "/static/ssr-manifest.json"/utf8>>
    ) of
        {ok, true} ->
            true;

        _ ->
            false
    end.

-file("src/internal/template.gleam", 72).
-spec read_line(file_streams@file_stream:file_stream(), list(binary())) -> list(binary()).
read_line(Stream, Lines) ->
    case file_streams@file_stream:read_line(Stream) of
        {ok, Line} ->
            read_line(Stream, lists:append(Lines, [Line]));

        {error, eof} ->
            Lines;

        _ ->
            Lines
    end.

-file("src/internal/template.gleam", 67).
-spec read_file_lines(binary()) -> binary().
read_file_lines(Filename) ->
    Stream@1 = case file_streams@file_stream:open_read(Filename) of
        {ok, Stream} -> Stream;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"internal/template"/utf8>>,
                        function => <<"read_file_lines"/utf8>>,
                        line => 68,
                        value => _assert_fail,
                        start => 1815,
                        'end' => 1870,
                        pattern_start => 1826,
                        pattern_end => 1836})
    end,
    _pipe = read_line(Stream@1, []),
    gleam@string:join(_pipe, <<""/utf8>>).

-file("src/internal/template.gleam", 56).
-spec read_template(binary()) -> {ok, binary()} |
    {error, internal@errors:inertia_error()}.
read_template(Pdir) ->
    case internal@context:get_orelse(<<"root_template"/utf8>>, <<""/utf8>>) of
        <<""/utf8>> ->
            Tmpl = read_file_lines(<<Pdir/binary, "/index.html"/utf8>>),
            internal@context:add_entry(<<"root_template"/utf8>>, Tmpl),
            {ok, Tmpl};

        Content ->
            {ok, Content}
    end.

-file("src/internal/template.gleam", 155).
-spec generate_css_tag(binary()) -> binary().
generate_css_tag(File) ->
    <<<<"<link rel=\"stylesheet\" href=\"/static/"/utf8, File/binary>>/binary,
        "\" />"/utf8>>.

-file("src/internal/template.gleam", 159).
-spec generate_preload_tag(binary()) -> binary().
generate_preload_tag(File) ->
    <<<<"<link rel=\"modulepreload\" as=\"script\" href=\"/static/"/utf8,
            File/binary>>/binary,
        "\" />"/utf8>>.

-file("src/internal/template.gleam", 137).
-spec generate_head_entries(list(internal@manifest:entry())) -> binary().
generate_head_entries(Entries) ->
    _pipe = Entries,
    _pipe@2 = gleam@list:map(_pipe, fun(E) -> case erlang:element(6, E) of
                true ->
                    generate_preload_tag(erlang:element(3, E));

                false ->
                    case erlang:element(4, E) of
                        [] ->
                            <<""/utf8>>;

                        [Css] ->
                            generate_css_tag(Css);

                        _ ->
                            _pipe@1 = gleam@list:map(
                                erlang:element(4, E),
                                fun generate_css_tag/1
                            ),
                            gleam@string:join(_pipe@1, <<"\n"/utf8>>)
                    end
            end end),
    gleam@string:join(_pipe@2, <<"\n"/utf8>>).

-file("src/internal/template.gleam", 126).
-spec head_tags(list(internal@manifest:entry())) -> binary().
head_tags(Entries) ->
    case Entries of
        [] ->
            _pipe = [<<"<script type=\"module\" src='//localhost:5173/@vite/client'></script>"/utf8>>],
            gleam@string:join(_pipe, <<"\n"/utf8>>);

        _ ->
            generate_head_entries(Entries)
    end.

-file("src/internal/template.gleam", 163).
-spec generate_app_entry(list(internal@manifest:entry())) -> binary().
generate_app_entry(Entries) ->
    _pipe = Entries,
    _pipe@1 = gleam@list:filter(_pipe, fun(E) -> erlang:element(5, E) end),
    _pipe@2 = gleam@list:map(
        _pipe@1,
        fun(E@1) ->
            <<<<"<script type=\"module\" src=\"/static/"/utf8,
                    (erlang:element(3, E@1))/binary>>/binary,
                "\"></script>"/utf8>>
        end
    ),
    gleam@string:join(_pipe@2, <<"\n"/utf8>>).

-file("src/internal/template.gleam", 85).
-spec parse_template(binary(), binary(), list(internal@manifest:entry())) -> binary().
parse_template(Tmpl, State, Entries) ->
    Body_content = begin
        _pipe = case Entries of
            [] ->
                [<<"<script data-page=\"app\" type=\"application/json\">"/utf8>>,
                    State,
                    <<"</script>"/utf8>>,
                    <<"<div id='app'></div>"/utf8>>,
                    <<"<script type=\"module\" src=\"//localhost:5173/priv/app/app.ts\"></script>"/utf8>>];

            _ ->
                [<<"<script data-page=\"app\" type=\"application/json\">"/utf8>>,
                    State,
                    <<"</script>"/utf8>>,
                    <<"<div id=\"app\"></div>"/utf8>>,
                    generate_app_entry(Entries)]
        end,
        gleam@string:join(_pipe, <<"\n"/utf8>>)
    end,
    gleam@string:replace(
        gleam@string:replace(
            Tmpl,
            <<"<!-- @inertiaHead -->"/utf8>>,
            head_tags(Entries)
        ),
        <<"<!-- @inertia -->"/utf8>>,
        Body_content
    ).

-file("src/internal/template.gleam", 116).
-spec parse_ssr_template(binary(), internal@ssr:s_s_r_render_response()) -> binary().
parse_ssr_template(Tmpl, Ssr_resp) ->
    Ssr_head = begin
        _pipe = erlang:element(2, Ssr_resp),
        _pipe@1 = gleam@list:map(_pipe, fun(Str) -> Str end),
        gleam@string:join(_pipe@1, <<"\n"/utf8>>)
    end,
    gleam@string:replace(
        gleam@string:replace(Tmpl, <<"<!-- @inertiaHead -->"/utf8>>, Ssr_head),
        <<"<!-- @inertia -->"/utf8>>,
        erlang:element(3, Ssr_resp)
    ).