defmodule ChesstrainerWeb.CoreComponents do @moduledoc """ Provides core UI components. At first glance, this module may seem daunting, but its goal is to provide core building blocks for your application, such as tables, forms, and inputs. The components consist mostly of markup and are well-documented with doc strings and declarative assigns. You may customize and style them in any way you want, based on your application growth and needs. The foundation for styling is Tailwind CSS, a utility-first CSS framework. Semantic colors such as `base-100`, `base-content` and `primary` are defined in `assets/css/app.css` and switch with the `data-theme` attribute. Here are useful references: * [Tailwind CSS](https://tailwindcss.com) - the foundational framework we build on. You will use it for layout, sizing, flexbox, grid, and spacing. * [Heroicons](https://heroicons.com) - see `icon/1` for usage. * [Phoenix.Component](https://phoenix-live-view.hexdocs.pm/Phoenix.Component.html) - the component system used by Phoenix. Some components, such as `<.link>` and `<.form>`, are defined there. """ use Phoenix.Component use Gettext, backend: ChesstrainerWeb.Gettext alias Phoenix.LiveView.JS @input_class "w-full rounded-md border border-base-300 bg-base-100 px-3 py-2 text-sm text-base-content placeholder:text-base-content/50 focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/30" @input_error_class "border-error focus:border-error focus:ring-error/30" @label_class "mb-1 block text-sm font-medium text-base-content" @checkbox_class "size-4 rounded border-base-300 accent-primary" defp input_class, do: @input_class defp input_error_class, do: @input_error_class defp label_class, do: @label_class defp checkbox_class, do: @checkbox_class @table_class "w-full border-collapse text-left text-sm [&_th]:border-b [&_th]:border-base-200 [&_th]:px-4 [&_th]:py-3 [&_th]:font-semibold [&_td]:border-b [&_td]:border-base-200 [&_td]:px-4 [&_td]:py-3 [&_tbody_tr:nth-child(odd)]:bg-base-200/50" @doc """ Returns the shared data-table classes, for tables that render their own ``/`` markup. """ def table_class, do: @table_class @doc """ Renders flash notices. ## Examples <.flash kind={:info} flash={@flash} /> <.flash id="welcome-back" kind={:info} phx-mounted={show("#welcome-back") |> JS.remove_attribute("hidden")} hidden > Welcome Back! """ attr :id, :string, doc: "the optional id of flash container" attr :flash, :map, default: %{}, doc: "the map of flash messages to display" attr :title, :string, default: nil attr :kind, :atom, values: [:info, :error], doc: "used for styling and flash lookup" attr :rest, :global, doc: "the arbitrary HTML attributes to add to the flash container" slot :inner_block, doc: "the optional inner block that renders the flash message" def flash(assigns) do assigns = assign_new(assigns, :id, fn -> "flash-#{assigns.kind}" end) ~H"""
hide("##{@id}")} role="alert" class="fixed right-4 top-4 z-50 flex flex-col gap-2" {@rest} >
<.icon :if={@kind == :info} name="hero-information-circle" class="size-5 shrink-0" /> <.icon :if={@kind == :error} name="hero-exclamation-circle" class="size-5 shrink-0" />

{@title}

{msg}

""" end @doc """ Renders a button with navigation support. ## Examples <.button>Send! <.button phx-click="go" variant="primary">Send! <.button navigate={~p"/"}>Home """ attr :rest, :global, include: ~w(href navigate patch method download name value disabled) attr :class, :any attr :variant, :string, values: ~w(primary secondary ghost danger) slot :inner_block, required: true def button(%{rest: rest} = assigns) do variants = %{ "primary" => "bg-primary text-primary-content hover:bg-primary/90", "secondary" => "border border-base-300 bg-base-100 text-base-content hover:bg-base-200", "ghost" => "text-base-content hover:bg-base-200", "danger" => "bg-error text-error-content hover:bg-error/90", nil => "bg-primary/15 text-primary hover:bg-primary/25" } assigns = assign(assigns, :class, [ "inline-flex items-center justify-center gap-2 rounded-md px-4 py-2 text-sm font-semibold transition-colors focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-primary disabled:cursor-not-allowed disabled:opacity-60", Map.fetch!(variants, assigns[:variant]), assigns[:class] ]) if rest[:href] || rest[:navigate] || rest[:patch] do ~H""" <.link class={@class} {@rest}> {render_slot(@inner_block)} """ else ~H""" """ end end @doc """ Renders an input with label and error messages. A `Phoenix.HTML.FormField` may be passed as argument, which is used to retrieve the input name, id, and values. Otherwise all attributes may be passed explicitly. ## Types This function accepts all HTML input types, considering that: * You may also set `type="select"` to render a ` """ end def input(%{type: "checkbox"} = assigns) do assigns = assign_new(assigns, :checked, fn -> Phoenix.HTML.Form.normalize_value("checkbox", assigns[:value]) end) ~H"""
<.error :for={msg <- @errors}>{msg}
""" end def input(%{type: "select"} = assigns) do ~H"""
<.error :for={msg <- @errors}>{msg}
""" end def input(%{type: "textarea"} = assigns) do ~H"""
<.error :for={msg <- @errors}>{msg}
""" end # All other inputs text, datetime-local, url, password, etc. are handled here... def input(assigns) do ~H"""
<.error :for={msg <- @errors}>{msg}
""" end # Helper used by inputs to generate form errors defp error(assigns) do ~H"""

<.icon name="hero-exclamation-circle" class="size-5" /> {render_slot(@inner_block)}

""" end @doc """ Renders a header with title. """ slot :inner_block, required: true slot :subtitle slot :actions def header(assigns) do ~H"""

{render_slot(@inner_block)}

{render_slot(@subtitle)}

{render_slot(@actions)}
""" end @doc """ Renders a table with generic styling. ## Examples <.table id="users" rows={@users}> <:col :let={user} label="id">{user.id} <:col :let={user} label="username">{user.username} """ attr :id, :string, required: true attr :rows, :list, required: true attr :row_id, :any, default: nil, doc: "the function for generating the row id" attr :row_click, :any, default: nil, doc: "the function for handling phx-click on each row" attr :row_item, :any, default: &Function.identity/1, doc: "the function for mapping each row before calling the :col and :action slots" slot :col, required: true do attr :label, :string end slot :action, doc: "the slot for showing user actions in the last table column" def table(assigns) do assigns = with %{rows: %Phoenix.LiveView.LiveStream{}} <- assigns do assign(assigns, row_id: assigns.row_id || fn {id, _item} -> id end) end ~H"""
{col[:label]} {gettext("Actions")}
{render_slot(col, @row_item.(row))}
<%= for action <- @action do %> {render_slot(action, @row_item.(row))} <% end %>
""" end @doc """ Renders a data list. ## Examples <.list> <:item title="Title">{@post.title} <:item title="Views">{@post.views} """ slot :item, required: true do attr :title, :string, required: true end def list(assigns) do ~H""" """ end @doc """ Renders a small pill label. ## Examples <.badge>Lucena <.badge color="primary" size="sm">KR v K """ attr :color, :string, default: "neutral", values: ~w(neutral primary warning) attr :size, :string, default: "md", values: ~w(sm md) attr :class, :any, default: nil attr :rest, :global slot :inner_block, required: true def badge(assigns) do ~H""" {render_slot(@inner_block)} """ end @doc """ Renders a [Heroicon](https://heroicons.com). Heroicons come in three styles – outline, solid, and mini. By default, the outline style is used, but solid and mini may be applied by using the `-solid` and `-mini` suffix. You can customize the size and colors of the icons by setting width, height, and background color classes. Icons are extracted from the `deps/heroicons` directory and bundled within your compiled app.css by the plugin in `assets/vendor/heroicons.js`. ## Examples <.icon name="hero-x-mark" /> <.icon name="hero-arrow-path" class="ml-1 size-3 motion-safe:animate-spin" /> """ attr :name, :string, required: true attr :class, :any, default: "size-4" def icon(%{name: "hero-" <> _} = assigns) do ~H""" """ end ## JS Commands def show(js \\ %JS{}, selector) do JS.show(js, to: selector, time: 300, transition: {"transition-all ease-out duration-300", "opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95", "opacity-100 translate-y-0 sm:scale-100"} ) end def hide(js \\ %JS{}, selector) do JS.hide(js, to: selector, time: 200, transition: {"transition-all ease-in duration-200", "opacity-100 translate-y-0 sm:scale-100", "opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95"} ) end @doc """ Translates an error message using gettext. """ def translate_error({msg, opts}) do # When using gettext, we typically pass the strings we want # to translate as a static argument: # # # Translate the number of files with plural rules # dngettext("errors", "1 file", "%{count} files", count) # # However the error messages in our forms and APIs are generated # dynamically, so we need to translate them by calling Gettext # with our gettext backend as first argument. Translations are # available in the errors.po file (as we use the "errors" domain). if count = opts[:count] do Gettext.dngettext(ChesstrainerWeb.Gettext, "errors", msg, msg, count, opts) else Gettext.dgettext(ChesstrainerWeb.Gettext, "errors", msg, opts) end end @doc """ Translates the errors for a field from a keyword list of errors. """ def translate_errors(errors, field) when is_list(errors) do for {^field, {msg, opts}} <- errors, do: translate_error({msg, opts}) end end