refactor: remove code duplication using helper modules

lib/mv_web/live/member_field_live/index_component.ex

@@ -11,8 +11,10 @@ defmodule MvWeb.MemberFieldLive.IndexComponent do
   """
   use MvWeb, :live_component
 
+  alias Ash.Resource.Info
   alias Mv.Membership
-  alias MvWeb.Translations.FieldTypes
+  alias Mv.Membership.Helpers.VisibilityConfig
+  alias MvWeb.Helpers.FieldTypeFormatter
   alias MvWeb.Translations.MemberFields
 
   @impl true
@@ -180,11 +182,11 @@ defmodule MvWeb.MemberFieldLive.IndexComponent do
     visibility_config = settings.member_field_visibility || %{}
 
     # Normalize visibility config keys to atoms
-    normalized_config = normalize_visibility_config(visibility_config)
+    normalized_config = VisibilityConfig.normalize(visibility_config)
 
     Enum.map(member_fields, fn field ->
       show_in_overview = Map.get(normalized_config, field, true)
-      attribute = Ash.Resource.Info.attribute(Mv.Membership.Member, field)
+      attribute = Info.attribute(Mv.Membership.Member, field)
 
       %{
         field: field,
@@ -199,68 +201,15 @@ defmodule MvWeb.MemberFieldLive.IndexComponent do
   end
 
   defp format_value_type(field) when is_atom(field) do
-    case Ash.Resource.Info.attribute(Mv.Membership.Member, field) do
-      nil -> FieldTypes.label(:string)
-      attribute -> format_value_type(attribute.type)
+    case Info.attribute(Mv.Membership.Member, field) do
+      nil -> FieldTypeFormatter.format(:string)
+      attribute -> FieldTypeFormatter.format(attribute.type)
     end
   end
 
-  defp format_value_type(type) when is_atom(type) do
-    type_string = to_string(type)
-
-    # Check if it's an Ash type module (e.g., Ash.Type.String or Elixir.Ash.Type.String)
-    if String.contains?(type_string, "Ash.Type.") do
-      # Extract the base type name from Ash type modules
-      # e.g., "Elixir.Ash.Type.String" -> "String" -> :string
-      type_name =
-        type_string
-        |> String.split(".")
-        |> List.last()
-        |> String.downcase()
-
-      try do
-        type_atom = String.to_existing_atom(type_name)
-        FieldTypes.label(type_atom)
-      rescue
-        ArgumentError ->
-          # Fallback if atom doesn't exist
-          FieldTypes.label(:string)
-      end
-    else
-      # It's already an atom like :string, :boolean, :date
-      FieldTypes.label(type)
-    end
-  end
-
-  defp format_value_type(type) do
-    # Fallback for unknown types
-    to_string(type)
-  end
-
-  defp normalize_visibility_config(config) when is_map(config) do
-    Enum.reduce(config, %{}, fn
-      {key, value}, acc when is_atom(key) ->
-        Map.put(acc, key, value)
-
-      {key, value}, acc when is_binary(key) ->
-        try do
-          atom_key = String.to_existing_atom(key)
-          Map.put(acc, atom_key, value)
-        rescue
-          ArgumentError ->
-            acc
-        end
-
-      _, acc ->
-        acc
-    end)
-  end
-
-  defp normalize_visibility_config(_), do: %{}
-
   # Check if a field is required by checking the actual attribute definition
   defp required?(field) when is_atom(field) do
-    case Ash.Resource.Info.attribute(Mv.Membership.Member, field) do
+    case Info.attribute(Mv.Membership.Member, field) do
       nil -> false
       attribute -> not attribute.allow_nil?
     end