builder

-module(builder@core).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/builder/core.gleam").
-export([run_builders/3]).
-export_type([builder/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.

-type builder() :: {single_file_builder,
        list(binary()),
        fun((builder@context:build_context(), builder@asset:build_asset()) -> nil)} |
    {multiple_files_builder,
        list(binary()),
        fun((builder@context:build_context(), list(builder@asset:build_asset())) -> nil)}.

-file("src/builder/core.gleam", 73).
-spec match_builder_patern(builder(), binary()) -> boolean().
match_builder_patern(Builder, File) ->
    case gleam@list:find(
        erlang:element(2, Builder),
        fun(Extension) -> gleam_stdlib:string_ends_with(File, Extension) end
    ) of
        {ok, _} ->
            true;

        {error, _} ->
            false
    end.

-file("src/builder/core.gleam", 22).
?DOC(false).
-spec run_builders(
    list(builder()),
    builder@context:build_context(),
    list(binary())
) -> nil.
run_builders(Builders, Build_context, File_paths) ->
    Single_builders = gleam@list:filter_map(
        Builders,
        fun(Builder) -> case Builder of
                {single_file_builder, _, _} ->
                    {ok, Builder};

                {multiple_files_builder, _, _} ->
                    {error, nil}
            end end
    ),
    Multiple_builders = gleam@list:filter_map(
        Builders,
        fun(Builder@1) -> case Builder@1 of
                {single_file_builder, _, _} ->
                    {error, nil};

                {multiple_files_builder, _, _} ->
                    {ok, Builder@1}
            end end
    ),
    gleam@list:map(Multiple_builders, fun(Builder@2) -> case Builder@2 of
                {single_file_builder, _, _} ->
                    nil;

                {multiple_files_builder, _, Build} ->
                    Build(
                        Build_context,
                        begin
                            _pipe = gleam@list:filter(
                                File_paths,
                                fun(_capture) ->
                                    match_builder_patern(Builder@2, _capture)
                                end
                            ),
                            gleam@list:map(
                                _pipe,
                                fun builder@asset:new_build_asset/1
                            )
                        end
                    )
            end end),
    gleam@list:map(
        File_paths,
        fun(File) ->
            gleam@list:map(
                Single_builders,
                fun(Builder@3) -> case match_builder_patern(Builder@3, File) of
                        true ->
                            case Builder@3 of
                                {single_file_builder, _, Build@1} ->
                                    Build@1(
                                        Build_context,
                                        builder@asset:new_build_asset(File)
                                    );

                                {multiple_files_builder, _, _} ->
                                    nil
                            end;

                        _ ->
                            nil
                    end end
            )
        end
    ),
    nil.