Packages
moon
2.90.5
2.90.5
retired
2.90.4
2.90.3
2.90.2
2.90.1
2.90.0
2.89.4
2.89.1
2.89.0
2.88.0
2.87.11
2.87.10
2.87.9
2.87.8
2.87.7
2.87.6
2.87.5
2.87.4
2.87.3
2.87.2
2.87.1
2.87.0
2.86.1
2.86.0
2.85.1
2.85.0
2.84.0
2.83.0
2.82.0
2.81.4
2.81.3
2.81.2
2.81.1
2.81.0
2.80.2
2.80.1
2.80.0
2.79.13
2.79.12
2.79.11
2.79.10
2.79.9
2.79.8
2.79.7
2.79.6
2.79.5
2.79.4
2.79.3
2.79.2
2.79.1
2.79.0
2.78.4
2.78.3
2.78.2
2.78.1
2.78.0
2.77.0
2.76.5
2.76.4
2.76.3
2.76.2
2.76.1
2.76.0
2.75.0
2.74.1
2.74.0
2.73.8
2.73.7
2.73.6
2.73.5
2.73.4
2.73.3
2.73.2
2.73.1
2.73.0
2.72.5
2.72.4
2.72.3
2.72.2
2.72.1
2.72.0
2.71.1
2.71.0
2.70.0
2.69.2
2.69.1
2.69.0
2.68.11
2.68.10
Components-based design system written in elixir
Retired package: Deprecated - Package no longer supported. Use moon_live_view package instead
Current section
Files
Jump to
Current section
Files
lib/moon/convert/module.ex
defmodule Moon.Convert.Module do
@moduledoc "Functions for converting AST surface -> live_view"
require Logger
def translate_render(%{component_type: Surface.LiveComponent}, ast), do: ast
def translate_render(
%{component_type: Surface.Component, short: short},
{:def, m1, [{:render, m2, attrs} | children]}
) do
{:def, m1, [{:"#{Macro.underscore(short)}", m2, attrs} | children]}
end
def translate_prop(_, {:prop, meta, [{name, _, nil}, :event]}, doc),
do: {:attr, meta, [name, Event, translate_prop_options([], doc)]}
# translate {:prop, [line: 21], [{:step, [line: 21], nil}, :integer, [default: 1]]}
# to {:attr, [line: 38], [:id, :string, [required: true]]}
def translate_prop(_, {macro_name, meta, [{name, _, nil}, type]}, doc)
when macro_name in [:prop, :data],
do: {:attr, meta, [name, translate_prop_type(type), translate_prop_options([], doc)]}
def translate_prop(_, {macro_name, meta, [{name, _, nil}, type, options]}, doc)
when macro_name in [:prop, :data],
do:
{:attr, meta,
[
name,
translate_prop_type(type),
translate_prop_options(options, doc)
]}
def translate_prop_type(type)
when type in [:boolean, :integer, :float, :string, :atom, :list, :map, :global],
do: type
def translate_prop_type(_), do: :any
def translate_prop_options(options, doc) do
(options
|> Enum.map(fn
{:values!, v} ->
{:values, v}
{:from_context, _v} ->
Logger.warning("Attribute is taken from_context")
dbg(options)
nil
{k, v} when k in [:required, :default, :values, :examples] ->
{k, v}
end)
|> Enum.filter(&(!!&1))) ++
((doc && [doc: doc]) || []) ++
(((Keyword.has_key?(options, :default) || Keyword.has_key?(options, :required)) && []) ||
[default: nil])
end
def translate_slot(_, {:slot, meta, [{:default, _, nil}]}, doc),
do: {:slot, meta, [:inner_block, (doc && [doc: doc]) || []]}
def translate_slot(_, {:slot, meta, [{name, _, nil}]}, doc),
do: {:slot, meta, [name, (doc && [doc: doc]) || []]}
def translate_slot(_, {:slot, meta, [{:default, _, nil}, options]}, doc),
do: {:slot, meta, [:inner_block, options ++ ((doc && [doc: doc]) || [])]}
def translate_slot(_, {:slot, meta, [{name, _, nil}, options]}, doc),
do: {:slot, meta, [name, options ++ ((doc && [doc: doc]) || [])]}
def translate_doc(_, _res = {:@, _, [{:doc, _, [text]}]}) do
text
end
def translate_moduledoc(%{component_type: Surface.LiveComponent}, res), do: res
def translate_moduledoc(
%{component_type: Surface.Component},
{:@, m1, [{:moduledoc, m2, [text]}]}
),
do: (text && {:@, m1, [{:doc, m2, [text]}]}) || :skip
def translate_use_defmodule(
%{component_type: Surface.Component},
{:use, _, _}
) do
:skip
end
def translate_use_defmodule(
%{config: config},
{type, m1, [{:__aliases__, m2, alias} | other]}
)
when type in [:use, :defmodule] do
{type, m1, [{:__aliases__, m2, config[:"#{type}_translates"].(alias)} | other]}
end
end