gleamgen

-module(gleamgen@module@definition).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/gleamgen/module/definition.gleam").
-export([new/1, with_publicity/2, with_attributes/2, with_position/2, with_documentation_comments/2, with_text_before/2, set_predefined/2, get_name/1, get_position/1, render_attribute/1, create_base_definition/1, attribute_from_glance/1]).
-export_type([attribute/0, target/0, definition/0, position/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 attribute() :: {external, target(), binary(), binary()} |
    {deprecated, binary()} |
    internal.

-type target() :: erlang | javascript.

-opaque definition() :: {definition,
        binary(),
        boolean(),
        list(attribute()),
        position(),
        binary(),
        boolean(),
        list(binary())}.

-type position() :: bottom | top | {after_definition, binary()}.

-file("src/gleamgen/module/definition.gleam", 36).
-spec new(binary()) -> definition().
new(Name) ->
    {definition, Name, false, [], bottom, <<""/utf8>>, false, []}.

-file("src/gleamgen/module/definition.gleam", 48).
-spec with_publicity(definition(), boolean()) -> definition().
with_publicity(Definition, Is_public) ->
    {definition,
        erlang:element(2, Definition),
        Is_public,
        erlang:element(4, Definition),
        erlang:element(5, Definition),
        erlang:element(6, Definition),
        erlang:element(7, Definition),
        erlang:element(8, Definition)}.

-file("src/gleamgen/module/definition.gleam", 52).
-spec with_attributes(definition(), list(attribute())) -> definition().
with_attributes(Definition, Attributes) ->
    {definition,
        erlang:element(2, Definition),
        erlang:element(3, Definition),
        Attributes,
        erlang:element(5, Definition),
        erlang:element(6, Definition),
        erlang:element(7, Definition),
        erlang:element(8, Definition)}.

-file("src/gleamgen/module/definition.gleam", 59).
-spec with_position(definition(), position()) -> definition().
with_position(Definition, Position) ->
    {definition,
        erlang:element(2, Definition),
        erlang:element(3, Definition),
        erlang:element(4, Definition),
        Position,
        erlang:element(6, Definition),
        erlang:element(7, Definition),
        erlang:element(8, Definition)}.

-file("src/gleamgen/module/definition.gleam", 66).
-spec with_documentation_comments(definition(), list(binary())) -> definition().
with_documentation_comments(Definition, Comments) ->
    {definition,
        erlang:element(2, Definition),
        erlang:element(3, Definition),
        erlang:element(4, Definition),
        erlang:element(5, Definition),
        erlang:element(6, Definition),
        erlang:element(7, Definition),
        Comments}.

-file("src/gleamgen/module/definition.gleam", 74).
?DOC(false).
-spec with_text_before(definition(), binary()) -> definition().
with_text_before(Definition, Text_before) ->
    {definition,
        erlang:element(2, Definition),
        erlang:element(3, Definition),
        erlang:element(4, Definition),
        erlang:element(5, Definition),
        Text_before,
        erlang:element(7, Definition),
        erlang:element(8, Definition)}.

-file("src/gleamgen/module/definition.gleam", 82).
?DOC(false).
-spec set_predefined(definition(), boolean()) -> definition().
set_predefined(Definition, Predefined) ->
    {definition,
        erlang:element(2, Definition),
        erlang:element(3, Definition),
        erlang:element(4, Definition),
        erlang:element(5, Definition),
        erlang:element(6, Definition),
        Predefined,
        erlang:element(8, Definition)}.

-file("src/gleamgen/module/definition.gleam", 86).
-spec get_name(definition()) -> binary().
get_name(Definition) ->
    erlang:element(2, Definition).

-file("src/gleamgen/module/definition.gleam", 90).
-spec get_position(definition()) -> position().
get_position(Definition) ->
    erlang:element(5, Definition).

-file("src/gleamgen/module/definition.gleam", 126).
-spec render_attribute(attribute()) -> glam@doc:document().
render_attribute(Attribute) ->
    case Attribute of
        {external, Target, Module_name, Function_name} ->
            Target_str = case Target of
                erlang ->
                    <<"erlang"/utf8>>;

                javascript ->
                    <<"javascript"/utf8>>
            end,
            To_str = fun(S) ->
                glam@doc:from_string(
                    <<<<"\""/utf8, S/binary>>/binary, "\""/utf8>>
                )
            end,
            glam@doc:concat(
                [glam@doc:from_string(<<"@external("/utf8>>),
                    glam@doc:from_string(Target_str),
                    glam@doc:from_string(<<", "/utf8>>),
                    To_str(Module_name),
                    glam@doc:from_string(<<", "/utf8>>),
                    To_str(Function_name),
                    glam@doc:from_string(<<")"/utf8>>)]
            );

        {deprecated, Reason} ->
            glam@doc:concat(
                [glam@doc:from_string(<<"@deprecated(\""/utf8>>),
                    glam@doc:from_string(Reason),
                    glam@doc:from_string(<<"\")"/utf8>>)]
            );

        internal ->
            glam@doc:from_string(<<"@internal"/utf8>>)
    end.

-file("src/gleamgen/module/definition.gleam", 95).
?DOC(false).
-spec create_base_definition(definition()) -> glam@doc:document().
create_base_definition(Details) ->
    Documentation_comments = begin
        _pipe = glam@doc:join(
            gleam@list:map(
                erlang:element(8, Details),
                fun(Comment) ->
                    glam@doc:from_string(<<"/// "/utf8, Comment/binary>>)
                end
            ),
            {line, 1}
        ),
        glam@doc:append(_pipe, case erlang:element(8, Details) of
                [] ->
                    {concat, []};

                _ ->
                    {line, 1}
            end)
    end,
    Rendered_attributes = case gleam@list:is_empty(erlang:element(4, Details)) of
        true ->
            {concat, []};

        false ->
            {line, 1}
    end,
    Pub_keyword = case erlang:element(3, Details) andalso not erlang:element(
        7,
        Details
    ) of
        true ->
            glam@doc:concat(
                [glam@doc:from_string(<<"pub"/utf8>>),
                    {break, <<" "/utf8>>, <<""/utf8>>}]
            );

        false ->
            {concat, []}
    end,
    _pipe@1 = glam@doc:concat(
        [glam@doc:from_string(erlang:element(6, Details)),
            Documentation_comments,
            glam@doc:join(
                gleam@list:map(
                    erlang:element(4, Details),
                    fun render_attribute/1
                ),
                {line, 1}
            )]
    ),
    _pipe@2 = glam@doc:append(_pipe@1, Rendered_attributes),
    glam@doc:append(_pipe@2, Pub_keyword).

-file("src/gleamgen/module/definition.gleam", 155).
?DOC(false).
-spec attribute_from_glance(glance:attribute()) -> {ok, attribute()} |
    {error, nil}.
attribute_from_glance(Attribute) ->
    Glance_expr_to_string = fun(Expr) -> case Expr of
            {string, _, Value} ->
                {ok, gleamgen@internal@render:escape_string(Value)};

            {variable, _, Name} ->
                {ok, Name};

            _ ->
                {error, nil}
        end end,
    case Attribute of
        {attribute, <<"external"/utf8>>, [Target, Module, Definition]} ->
            Parsed_target = case Glance_expr_to_string(Target) of
                {ok, <<"erlang"/utf8>>} ->
                    {ok, erlang};

                {ok, <<"javascript"/utf8>>} ->
                    {ok, javascript};

                _ ->
                    {error, nil}
            end,
            gleam@result:'try'(
                Parsed_target,
                fun(Target@1) ->
                    gleam@result:'try'(
                        Glance_expr_to_string(Module),
                        fun(Module@1) ->
                            gleam@result:'try'(
                                Glance_expr_to_string(Definition),
                                fun(Definition@1) ->
                                    {ok,
                                        {external,
                                            Target@1,
                                            Module@1,
                                            Definition@1}}
                                end
                            )
                        end
                    )
                end
            );

        {attribute, <<"internal"/utf8>>, []} ->
            {ok, internal};

        {attribute, <<"deprecated"/utf8>>, [Reason]} ->
            gleam@result:map(
                Glance_expr_to_string(Reason),
                fun(Field@0) -> {deprecated, Field@0} end
            );

        _ ->
            {error, nil}
    end.