esgleam

-module(esgleam).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([new/1, entry/2, format/2, target/2, minify/2, serve/2, watch/2, raw/2, bundle/1]).
-export_type([format/0, config/0]).

-type format() :: esm | cjs | iife.

-type config() :: {config,
        binary(),
        list(binary()),
        format(),
        boolean(),
        list(binary()),
        gleam@option:option(binary()),
        boolean(),
        boolean(),
        binary()}.

-spec new(binary()) -> config().
new(Path) ->
    {config, Path, [], esm, false, [], none, false, false, <<""/utf8>>}.

-spec entry(config(), binary()) -> config().
entry(Config, Path) ->
    erlang:setelement(3, Config, [Path | erlang:element(3, Config)]).

-spec format(config(), format()) -> config().
format(Config, Format) ->
    erlang:setelement(4, Config, Format).

-spec target(config(), binary()) -> config().
target(Config, Target) ->
    erlang:setelement(6, Config, [Target | erlang:element(6, Config)]).

-spec minify(config(), boolean()) -> config().
minify(Config, Do_minify) ->
    erlang:setelement(5, Config, Do_minify).

-spec serve(config(), binary()) -> config().
serve(Config, Path) ->
    erlang:setelement(7, Config, {some, Path}).

-spec watch(config(), boolean()) -> config().
watch(Config, Do_watch) ->
    erlang:setelement(9, Config, Do_watch).

-spec raw(config(), binary()) -> config().
raw(Config, Args) ->
    erlang:setelement(10, Config, gleam@string:append(<<" "/utf8>>, Args)).

-spec format_to_string(format()) -> binary().
format_to_string(Format) ->
    case Format of
        esm ->
            <<"esm"/utf8>>;

        cjs ->
            <<"cjs"/utf8>>;

        iife ->
            <<"iife"/utf8>>
    end.

-spec if_true(gleam@string_builder:string_builder(), boolean(), binary()) -> gleam@string_builder:string_builder().
if_true(Builder, Predicate, Value) ->
    _pipe = case Predicate of
        true ->
            Value;

        false ->
            <<""/utf8>>
    end,
    gleam@string_builder:append(Builder, _pipe).

-spec if_some(
    gleam@string_builder:string_builder(),
    gleam@option:option(binary()),
    binary()
) -> gleam@string_builder:string_builder().
if_some(Builder, Opt, Flag) ->
    _pipe = case Opt of
        {some, Value} ->
            <<Flag/binary, Value/binary>>;

        none ->
            <<""/utf8>>
    end,
    gleam@string_builder:append(Builder, _pipe).

-spec do_bundle(config()) -> nil.
do_bundle(Config) ->
    _assert_subject@3 = begin
        _pipe = simplifile:read(<<"./gleam.toml"/utf8>>),
        gleam@result:map(
            _pipe,
            fun(File) ->
                _assert_subject = gleam@regex:from_string(
                    <<"name *= *\"(\\w[\\w_]*)\""/utf8>>
                ),
                {ok, Re} = case _assert_subject of
                    {ok, _} -> _assert_subject;
                    _assert_fail ->
                        erlang:error(#{gleam_error => let_assert,
                                    message => <<"Assertion pattern match failed"/utf8>>,
                                    value => _assert_fail,
                                    module => <<"esgleam"/utf8>>,
                                    function => <<"do_bundle"/utf8>>,
                                    line => 124})
                end,
                _assert_subject@1 = begin
                    _pipe@1 = gleam@regex:scan(Re, File),
                    gleam@list:first(_pipe@1)
                end,
                {ok, Match} = case _assert_subject@1 of
                    {ok, _} -> _assert_subject@1;
                    _assert_fail@1 ->
                        erlang:error(#{gleam_error => let_assert,
                                    message => <<"Assertion pattern match failed"/utf8>>,
                                    value => _assert_fail@1,
                                    module => <<"esgleam"/utf8>>,
                                    function => <<"do_bundle"/utf8>>,
                                    line => 125})
                end,
                _assert_subject@2 = gleam@list:first(erlang:element(3, Match)),
                {ok, First_maybe} = case _assert_subject@2 of
                    {ok, _} -> _assert_subject@2;
                    _assert_fail@2 ->
                        erlang:error(#{gleam_error => let_assert,
                                    message => <<"Assertion pattern match failed"/utf8>>,
                                    value => _assert_fail@2,
                                    module => <<"esgleam"/utf8>>,
                                    function => <<"do_bundle"/utf8>>,
                                    line => 129})
                end,
                {some, Name} = case First_maybe of
                    {some, _} -> First_maybe;
                    _assert_fail@3 ->
                        erlang:error(#{gleam_error => let_assert,
                                    message => <<"Assertion pattern match failed"/utf8>>,
                                    value => _assert_fail@3,
                                    module => <<"esgleam"/utf8>>,
                                    function => <<"do_bundle"/utf8>>,
                                    line => 130})
                end,
                Name
            end
        )
    end,
    {ok, Project_name} = case _assert_subject@3 of
        {ok, _} -> _assert_subject@3;
        _assert_fail@4 ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail@4,
                        module => <<"esgleam"/utf8>>,
                        function => <<"do_bundle"/utf8>>,
                        line => 121})
    end,
    Entries = begin
        _pipe@2 = gleam@list:map(
            erlang:element(3, Config),
            fun(Entry) ->
                <<<<<<"./build/dev/javascript/"/utf8, Project_name/binary>>/binary,
                        "/"/utf8>>/binary,
                    (gleam@string:replace(
                        Entry,
                        <<".gleam"/utf8>>,
                        <<".mjs"/utf8>>
                    ))/binary>>
            end
        ),
        gleam@string:join(_pipe@2, <<" "/utf8>>)
    end,
    Cmd = begin
        _pipe@3 = gleam@string_builder:from_string(
            <<"./build/dev/bin/esbuild "/utf8>>
        ),
        _pipe@4 = gleam@string_builder:append(_pipe@3, Entries),
        _pipe@5 = gleam@string_builder:append(_pipe@4, <<" --bundle"/utf8>>),
        _pipe@6 = gleam@string_builder:append(_pipe@5, <<" --outdir="/utf8>>),
        _pipe@7 = gleam@string_builder:append(
            _pipe@6,
            erlang:element(2, Config)
        ),
        _pipe@8 = if_true(
            _pipe@7,
            erlang:element(5, Config),
            <<" --minify"/utf8>>
        ),
        _pipe@9 = if_true(
            _pipe@8,
            erlang:element(9, Config),
            <<" --watch"/utf8>>
        ),
        _pipe@10 = gleam@string_builder:append(_pipe@9, <<" --format="/utf8>>),
        _pipe@11 = gleam@string_builder:append(
            _pipe@10,
            format_to_string(erlang:element(4, Config))
        ),
        _pipe@12 = if_true(
            _pipe@11,
            not gleam@list:is_empty(erlang:element(6, Config)),
            <<" --target="/utf8>>
        ),
        _pipe@13 = gleam@string_builder:append(
            _pipe@12,
            gleam@string:join(erlang:element(6, Config), <<","/utf8>>)
        ),
        _pipe@14 = if_some(
            _pipe@13,
            erlang:element(7, Config),
            <<" --servedir="/utf8>>
        ),
        _pipe@15 = gleam@string_builder:append(
            _pipe@14,
            erlang:element(10, Config)
        ),
        gleam@string_builder:to_string(_pipe@15)
    end,
    gleam@io:println(<<"$ "/utf8, Cmd/binary>>),
    esgleam@internal:exec_shell(Cmd, <<"."/utf8>>).

-spec bundle(config()) -> {ok, nil} | {error, simplifile:file_error()}.
bundle(Config) ->
    _pipe = simplifile:create_directory_all(erlang:element(2, Config)),
    gleam@result:map(_pipe, fun(_) -> do_bundle(Config) end).