RubyGems - shadcn_view_component - Versions diffs - 0.3.3 - Mend

shadcn_view_component 0.3.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (507) hide show

data/lib/generators/shadcn_view_component/install/install_generator.rb ADDED Viewed

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+require "rails/generators/base"
+module ShadcnViewComponent
+  module Generators
+    # `bin/rails generate shadcn_view_component:install`
+    #
+    # Wires the gem into a host app. The part worth automating is every line
+    # that names a path into this gem: they have to point inside whatever
+    # directory bundler put us in, and that differs between a system gem,
+    # `bundle config set path`, a `path:` checkout and a `git:` source.
+    #
+    # All three lines, not just `@source`. This generator used to write
+    # `@import "shadcn.css"`, which reads like an asset-pipeline path and is
+    # not one: `tailwindcss-rails` runs the CLI with `-i` and `-o` and no load
+    # path, so the CLI resolves a bare name the way Node does — beside the file,
+    # then `node_modules` — and a Rails app has neither. It stopped the build
+    # with `Can't resolve 'shadcn.css'`. The dummy never showed it because its
+    # own entrypoint reaches the engine with `../../../../..`, which is a
+    # relationship no host has.
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+      # Where a Stimulus application is in scope. `controllers/index.js` is the
+      # file importmap-rails generates, and it opens with
+      # `import { application } from "controllers/application"` — so a line
+      # appended there can register onto the app's own instance.
+      #
+      # `app/javascript/application.js` is not that file. It imports
+      # `"controllers"` for the side effect and defines no `application`
+      # binding, which is where this generator used to append: a stock Rails 8
+      # app got `ReferenceError: application is not defined`, no controllers
+      # registered, and every dialog, select and menu inert — with the CSS
+      # working, so it looked installed.
+      JAVASCRIPT_ENTRYPOINT = "app/javascript/controllers/index.js"
+      TAILWIND_ENTRYPOINTS = [
+        "app/assets/tailwind/application.css",
+        "app/assets/stylesheets/application.tailwind.css",
+        "app/assets/stylesheets/application.css"
+      ].freeze
+      def add_tailwind_imports
+        entrypoint = TAILWIND_ENTRYPOINTS.find { |path| File.exist?(Rails.root.join(path)) }
+        unless entrypoint
+          say_status :skip, "no Tailwind entrypoint found; add the block below yourself", :yellow
+          say "(paths are written for #{TAILWIND_ENTRYPOINTS.first}; adjust them if yours sits elsewhere)"
+          say tailwind_block(TAILWIND_ENTRYPOINTS.first)
+          return
+        end
+        if File.read(Rails.root.join(entrypoint)).include?("shadcn.css")
+          say_status :identical, entrypoint
+          return
+        end
+        append_to_file entrypoint, "\n#{tailwind_block(entrypoint)}"
+      end
+      def add_javascript
+        return say_status :skip, "no importmap; import \"shadcn\" yourself", :yellow unless importmap?
+        unless File.exist?(Rails.root.join(JAVASCRIPT_ENTRYPOINT))
+          say_status :skip, "#{JAVASCRIPT_ENTRYPOINT} not found; register the controllers yourself", :yellow
+          say javascript_block
+          return
+        end
+        if File.read(Rails.root.join(JAVASCRIPT_ENTRYPOINT)).include?("registerShadcnControllers")
+          return say_status :identical, JAVASCRIPT_ENTRYPOINT
+        end
+        append_to_file JAVASCRIPT_ENTRYPOINT, "\n#{javascript_block}"
+      end
+      def show_layout_hint
+        say "\nAdd the theming tags to your layout:", :green
+        say <<~ERB
+          <head>
+            <%= shadcn_theme_script_tag %>
+          </head>
+          <body class="<%= shadcn_theme_class %>">
+        ERB
+      end
+      private
+      def importmap?
+        File.exist?(Rails.root.join("config/importmap.rb"))
+      end
+      # Resolved from the loaded gem spec, so it is correct wherever bundler put
+      # us — including a `path:` or `git:` source.
+      def gem_root
+        Pathname(ShadcnViewComponent::Engine.root)
+      end
+      # Relative to the file the line is written into, whenever this gem sits
+      # inside the application — which is what `bundle config set path
+      # vendor/bundle` does, and what CI and most containers do. An absolute
+      # path is correct only on the machine that generated it, and the CSS is
+      # built on every machine.
+      #
+      # Computed against the entrypoint rather than against a fixed depth: the
+      # three conventional locations happen to be three deep today, and a
+      # generator that would break on the fourth is a generator waiting.
+      def path_to(target, entrypoint)
+        return target.to_s unless inside_application?(target)
+        target.relative_path_from(Rails.root.join(entrypoint).dirname).to_s
+      end
+      # A relative path is worth having only while it stays inside the
+      # application: between two unrelated trees — a system gem, a sibling
+      # checkout — it encodes the distance between them, which is as personal
+      # to one machine as an absolute path and harder to read.
+      def inside_application?(target)
+        !target.relative_path_from(Rails.root).to_s.start_with?("..")
+      rescue ArgumentError
+        # Different volumes: no relative path exists at all.
+        false
+      end
+      # `application` is the binding `controllers/index.js` already has. Adding
+      # an `Application.start()` here instead would start a *second* Stimulus
+      # instance beside the app's own, and two instances fight over every
+      # element they both claim.
+      def javascript_block
+        <<~JS
+          import { registerShadcnControllers } from "shadcn"
+          registerShadcnControllers(application)
+        JS
+      end
+      def tailwind_block(entrypoint)
+        stylesheets = gem_root.join("app/assets/stylesheets")
+        <<~CSS
+          /* shadcn_view_component */
+          @import "#{path_to(stylesheets.join('shadcn.css'), entrypoint)}";
+          @import "#{path_to(stylesheets.join('shadcn-themes.css'), entrypoint)}";
+          @source "#{path_to(gem_root.join('app/components'), entrypoint)}";
+        CSS
+      end
+    end
+  end
+end

data/lib/shadcn_view_component/engine.rb ADDED Viewed

@@ -0,0 +1,73 @@
+module ShadcnViewComponent
+  # Rails engine wiring.
+  #
+  # `app/components` is picked up automatically as an autoload/eager-load root
+  # by the `app/{*,*/concerns}` glob every Rails::Engine declares, so
+  # `app/components/shadcn/card/component.rb` resolves to `Shadcn::Card::Component`
+  # with no extra configuration. Nesting everything under `shadcn/` keeps names
+  # such as `Card`, `Table` or `Field` out of the host application's top level,
+  # where they would clash with its own models.
+  class Engine < ::Rails::Engine
+    COMPONENTS_PATH = "app/components".freeze
+    # Host apps configure the gem through `config.shadcn_view_component` in
+    # their `application.rb`, e.g.
+    #
+    #     config.shadcn_view_component.cache_size = 50_000
+    config.shadcn_view_component = ActiveSupport::OrderedOptions.new
+    # Register component previews (sidecar `preview.rb` next to `component.rb`).
+    initializer "shadcn_view_component.previews" do |app|
+      options = app.config.view_component
+      options.previews.paths << root.join(COMPONENTS_PATH).to_s
+      ActiveSupport.on_load(:view_component) do
+        ViewComponent::Preview.extend ViewComponentContrib::Preview::Sidecarable
+      end
+    end
+    # Build the tailwind-merge instance at boot rather than on the first
+    # request: it costs a few milliseconds to construct, and two Puma threads
+    # racing on a lazy `||=` would each build one and discard a warm cache.
+    initializer "shadcn_view_component.merger" do |app|
+      configured = app.config.shadcn_view_component.cache_size
+      ShadcnViewComponent.cache_size = configured if configured
+      ShadcnViewComponent.build_merger
+      # Style blocks are redefined when components reload, so the memoised
+      # class strings have to go with them.
+      app.config.to_prepare { ShadcnViewComponent.class_cache.clear }
+    end
+    # Make the theming and form helpers available to the host application's
+    # views. The form builder is required here rather than at the top of the gem
+    # because it subclasses ActionView's.
+    initializer "shadcn_view_component.helpers" do
+      ActiveSupport.on_load(:action_view) do
+        require "shadcn_view_component/form_builder"
+      end
+      ActiveSupport.on_load(:action_controller_base) do
+        helper ShadcnViewComponent::ThemeHelper
+        helper ShadcnViewComponent::FormHelper
+      end
+    end
+    # Expose the bundled stylesheet and Stimulus controllers to the asset pipeline.
+    initializer "shadcn_view_component.assets" do |app|
+      next unless app.config.respond_to?(:assets)
+      app.config.assets.paths << root.join("app/assets/stylesheets")
+      app.config.assets.paths << root.join("app/javascript")
+    end
+    # Make `shadcn/*` importable when the host app uses importmap-rails.
+    initializer "shadcn_view_component.importmap", before: "importmap" do |app|
+      next unless app.config.respond_to?(:importmap)
+      app.config.importmap.paths << root.join("config/importmap.rb")
+      app.config.importmap.cache_sweepers << root.join("app/javascript")
+    end
+  end
+end

data/lib/shadcn_view_component/form_builder.rb ADDED Viewed

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+module ShadcnViewComponent
+  # Bridges the components to Rails forms.
+  #
+  # shadcn's `Field` family is the right shape for this — label, control,
+  # description, error — but on its own it knows nothing about a model. This
+  # builder wires the two together: ids and names come from Rails, the error
+  # text and `aria-invalid` come from `ActiveModel::Errors`, and `Field` gets the
+  # `data-invalid` its styles key off.
+  #
+  #   <%= shadcn_form_with model: @user do |f| %>
+  #     <%= f.shadcn_field :email, label: "Email", description: "We never share it." do %>
+  #       <%= f.shadcn_input :email, type: "email" %>
+  #     <% end %>
+  #   <% end %>
+  #
+  # Or, when the control needs no arguments of its own:
+  #
+  #   <%= f.shadcn_input_field :email, label: "Email", type: "email" %>
+  class FormBuilder < ActionView::Helpers::FormBuilder
+    # A labelled control with its description and any validation errors, wired
+    # together by id. `Field` styles itself from `data-invalid`, so that is set
+    # from the model rather than passed in.
+    #
+    # @param method [Symbol] the attribute
+    # @param label [String] omit to leave the label out entirely
+    # @param description [String] hint text below the control
+    # @param orientation [Symbol] :vertical, :horizontal or :responsive
+    def shadcn_field(method, label: nil, description: nil, orientation: :vertical, **options, &block)
+      messages = errors_for(method)
+      described[method.to_s] = description.present?
+      @template.render(Shadcn::Field::Component.new(
+        orientation:,
+        "data-invalid": (true if messages.any?),
+        **options
+      )) do |field|
+        field.with_label(id: label_id(method), for: field_id(method)) { label } if label
+        field.with_field_content { @template.capture(&block) }
+        field.with_description(id: description_id(method)) { description } if description
+        field.with_error(id: error_id(method), errors: messages) if messages.any?
+      end
+    end
+    # `shadcn_input_field`, `shadcn_textarea_field`, … — the common case where
+    # the field wraps exactly one control.
+    %i[input textarea native_select switch checkbox].each do |control|
+      define_method(:"shadcn_#{control}_field") do |method, label: nil, description: nil, orientation: nil, **options|
+        shadcn_field(
+          method,
+          label:,
+          description:,
+          orientation: orientation || (%i[switch checkbox].include?(control) ? :horizontal : :vertical)
+        ) { public_send(:"shadcn_#{control}", method, **options) }
+      end
+    end
+    def shadcn_input(method, **options)
+      @template.render(Shadcn::Input::Component.new(**control_options(method, **options)))
+    end
+    def shadcn_textarea(method, **options)
+      @template.render(Shadcn::Textarea::Component.new(**control_options(method, **options))) do
+        value_for(method).to_s
+      end
+    end
+    # A real `<select>`: browser validation, autofill and keyboard behaviour for
+    # free. Prefer it over `shadcn_select` unless you need the styled listbox.
+    def shadcn_native_select(method, choices = [], **options)
+      @template.render(Shadcn::NativeSelect::Component.new(**control_options(method, **options))) do
+        @template.safe_join(Array(choices).map { |choice| native_option(method, choice) })
+      end
+    end
+    # The Radix-style listbox. It submits through a hidden input, so it has no
+    # browser validation — `required` will not stop the form.
+    def shadcn_select(method, choices = [], placeholder: nil, **options)
+      selected = value_for(method).to_s
+      @template.render(Shadcn::Select::Component.new(
+        name: field_name(method), value: selected, placeholder:, **options
+      )) do |select|
+        select.with_trigger(**aria_labelled(method,
+                                            id: field_id(method),
+                                            placeholder: selected.blank?,
+                                            "aria-invalid": invalid(method))) do |trigger|
+          trigger.with_value(placeholder:) { label_for(choices, selected) }
+        end
+        select.with_select_content do
+          @template.safe_join(Array(choices).map { |choice|
+            label, value = option_pair(choice)
+            @template.render(Shadcn::Select::Item::Component.new(value:, selected: value == selected)) { label }
+          })
+        end
+      end
+    end
+    # A calendar bound to the model, in any of its three modes.
+    #
+    #   f.shadcn_calendar :starts_on
+    #   f.shadcn_calendar :dates, mode: :multiple
+    #   f.shadcn_calendar :starts_on, mode: :range, to: :ends_on
+    #
+    # `to:` is what makes a range Rails-shaped: two dates are usually two
+    # columns, so the two ends are named after two attributes and each comes
+    # back as itself. Without it a range submits `name[from]` and `name[to]`
+    # under one parameter, which suits a form object rather than a record.
+    #
+    # The month shown follows the value rather than today, so reopening a form
+    # lands on the date already chosen.
+    def shadcn_calendar(method, mode: :single, to: nil, **options)
+      selected = calendar_selection(method, mode:, to:)
+      @template.render(Shadcn::Calendar::Component.new(
+        mode:,
+        selected:,
+        name: to ? [ field_name(method), field_name(to) ] : field_name(method),
+        month: options.delete(:month) || Array(selected).compact.first,
+        **aria_labelled(method, options)
+      ))
+    end
+    def shadcn_checkbox(method, **options)
+      @template.render(Shadcn::Checkbox::Component.new(
+        name: field_name(method),
+        checked: !!value_for(method),
+        **aria_labelled(method, **control_options(method, **options))
+      ))
+    end
+    def shadcn_switch(method, **options)
+      @template.render(Shadcn::Switch::Component.new(
+        name: field_name(method),
+        checked: !!value_for(method),
+        **aria_labelled(method, **control_options(method, **options))
+      ))
+    end
+    # Each option is rendered as block content rather than through the `item`
+    # slot: the items have to sit inside their own label rows, and slot content
+    # is emitted before block content, which would pull them all out of place.
+    def shadcn_radio_group(method, choices = [], **options)
+      selected = value_for(method).to_s
+      @template.render(Shadcn::RadioGroup::Component.new(
+        name: field_name(method), value: selected, **options
+      )) do
+        @template.safe_join(Array(choices).map { |choice|
+          label, value = option_pair(choice)
+          id = "#{field_id(method)}_#{value.parameterize.underscore}"
+          @template.tag.div(class: "flex items-center gap-2") do
+            @template.safe_join([
+              @template.render(Shadcn::RadioGroup::Item::Component.new(
+                value:, checked: value == selected, id:
+              )),
+              @template.render(Shadcn::Label::Component.new(for: id)) { label }
+            ])
+          end
+        })
+      end
+    end
+    def shadcn_submit(text = nil, **options, &block)
+      @template.render(Shadcn::Button::Component.new(type: "submit", **options)) do
+        block ? @template.capture(&block) : (text || submit_default_value)
+      end
+    end
+    private
+    # Which attributes have actually had a description rendered. `aria-describedby`
+    # may only name elements that exist — a reference to a missing id is invalid
+    # ARIA and simply resolves to nothing, so the control ends up describing
+    # itself as having a description it does not have.
+    #
+    # Upstream has the same defect and it is not reproduced on purpose:
+    # `FormControl` sets `aria-describedby` to the description id unconditionally
+    # (form.tsx:113-119), whether or not a `FormDescription` was ever rendered.
+    # This port shipped it too, until writing features/form.md checked the claim
+    # that it did not.
+    #
+    # A control rendered outside any `shadcn_field` is the same case and gets the
+    # same answer: no description element, so nothing to point at.
+    def described
+      @described ||= {}
+    end
+    def errors_for(method)
+      return [] unless object.respond_to?(:errors)
+      object.errors[method] || []
+    end
+    def invalid(method)
+      "true" if errors_for(method).any?
+    end
+    # What is already chosen, in the shape the component takes: one date, a
+    # list of them, or the two ends of a range.
+    def calendar_selection(method, mode:, to:)
+      return [ value_for(method), value_for(to) ].compact if to
+      return Array(value_for(method)).compact if mode == :multiple
+      value_for(method)
+    end
+    def value_for(method)
+      object.respond_to?(method) ? object.public_send(method) : nil
+    end
+    # Everything a control needs to belong to the form and to announce itself.
+    def control_options(method, **options)
+      wants_description = options.delete(:described_by) != false
+      described_by = [
+        (description_id(method) if wants_description && described[method.to_s]),
+        (error_id(method) if errors_for(method).any?)
+      ].compact
+      {
+        id: field_id(method),
+        name: field_name(method),
+        value: value_for(method),
+        "aria-invalid": invalid(method),
+        "aria-describedby": described_by.presence&.join(" ")
+      }.compact.merge(options)
+    end
+    def description_id(method) = "#{field_id(method)}_description"
+    def error_id(method) = "#{field_id(method)}_error"
+    def label_id(method) = "#{field_id(method)}_label"
+    # Select, Checkbox and Switch render a `<button>` carrying an ARIA role, and
+    # a `<label for>` does not name a button — `role="combobox"` goes further and
+    # forbids taking the name from its own content. So they are named by pointing
+    # at the label instead. Without this they reach the browser unnamed, which
+    # `spec/system/accessibility_spec.rb` catches.
+    def aria_labelled(method, options)
+      return options if options.key?(:"aria-label") || options.key?(:"aria-labelledby")
+      options.merge("aria-labelledby": label_id(method))
+    end
+    # Accepts the same shapes as Rails' `options_for_select`: bare values, or
+    # `[label, value]` pairs.
+    def option_pair(choice)
+      choice.is_a?(Array) ? [ choice.first.to_s, choice.last.to_s ] : [ choice.to_s, choice.to_s ]
+    end
+    def label_for(choices, value)
+      Array(choices).map { |choice| option_pair(choice) }.find { |(_label, v)| v == value }&.first
+    end
+    def native_option(method, choice)
+      label, value = option_pair(choice)
+      @template.render(Shadcn::NativeSelect::Option::Component.new(
+        value:, selected: value == value_for(method).to_s
+      )) { label }
+    end
+  end
+end

data/lib/shadcn_view_component/icon_registry.rb ADDED Viewed

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+module ShadcnViewComponent
+  # Backs `Shadcn::Icon.register` / `.registered`. Deliberately outside
+  # `app/components`, which Rails reloads in development: a hash living on
+  # the `Shadcn::Icon` module object would be discarded with it on the next
+  # code reload, silently un-registering every icon a host added at boot.
+  # `lib/` is not reloaded, so this survives.
+  module IconRegistry
+    # lucide-react's own aliases, kept so call sites read like the TSX imports
+    # — `Icon::Component.new("more-horizontal")` is what `pagination.tsx`
+    # writes. They live here rather than beside the drawings because *this* is
+    # the file that has to know about them: a host registering
+    # `"more-horizontal"` and the gem rendering `"ellipsis"` are the same icon,
+    # and until they were resolved in one place the registration was stored
+    # under a key nothing ever looked up.
+    ALIASES = {
+      "loader-2" => "loader-circle",
+      "more-horizontal" => "ellipsis"
+    }.freeze
+    def self.registered
+      @registered ||= {}
+    end
+    # Stored under the canonical name, so registering under either spelling
+    # reaches every call site that uses either — one icon, one entry.
+    def self.register(name, path)
+      registered[canonical(name)] = path
+    end
+    def self.canonical(name)
+      ALIASES.fetch(name.to_s, name.to_s)
+    end
+    # Register every `*.svg` in a directory, under its own basename. This is
+    # how a host adds icons the gem does not bundle: download the SVGs it wants
+    # — lucide publishes them as files, and so does everyone else — drop them
+    # in a directory and point here from an initializer.
+    #
+    #   ShadcnViewComponent::IconRegistry.load_directory(
+    #     Rails.root.join("app/assets/icons")
+    #   )
+    #
+    # It reads files, so it is the caller who decides when: an initializer
+    # pays once at boot. Nothing in the gem calls it — the bundled icons are
+    # generated into `Icons::PATHS` at build time, so a host that adds none
+    # reads no files at all.
+    def self.load_directory(path)
+      Dir.glob(File.join(path, "*.svg")).sort.each do |file|
+        register(File.basename(file, ".svg"), drawing(File.read(file)))
+      end
+    end
+    # What a `<svg>` element contains, with the whitespace its author used to
+    # lay it out taken back out. The outer element is deliberately dropped:
+    # `Icon::Component` renders that itself, with lucide's own attributes and
+    # `lucide lucide-<name>` classes, so a file's own `<svg …>` would arrive as
+    # a second opinion about the thing the component already owns.
+    def self.drawing(source)
+      inside = source[%r{<svg\b[^>]*>(.*)</svg>}m, 1].to_s
+      inside.gsub(/>\s+</, "><").gsub(%r{\s+/>}, "/>").strip
+    end
+  end
+end

data/lib/shadcn_view_component/icons.rb ADDED Viewed

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+# Generated from the vendored lucide SVGs (`vendor/lucide/icons`, taken from
+# lucide-static at the version in `vendor/lucide/REVISION`) — do not edit by
+# hand, run `rake icons:build`.
+module ShadcnViewComponent
+  module Icons
+    PATHS = {
+      "arrow-left" => %(<path d="m12 19-7-7 7-7"/><path d="M19 12H5"/>),
+      "arrow-right" => %(<path d="M5 12h14"/><path d="m12 5 7 7-7 7"/>),
+      "check" => %(<path d="M20 6 9 17l-5-5"/>),
+      "chevron-down" => %(<path d="m6 9 6 6 6-6"/>),
+      "chevron-left" => %(<path d="m15 18-6-6 6-6"/>),
+      "chevron-right" => %(<path d="m9 18 6-6-6-6"/>),
+      "chevron-up" => %(<path d="m18 15-6-6-6 6"/>),
+      "circle-check" => %(<circle cx="12" cy="12" r="10"/><path d="m9 12 2 2 4-4"/>),
+      "circle" => %(<circle cx="12" cy="12" r="10"/>),
+      "ellipsis" => %(<circle cx="12" cy="12" r="1"/><circle cx="19" cy="12" r="1"/><circle cx="5" cy="12" r="1"/>),
+      "grip-vertical" => %(<circle cx="9" cy="12" r="1"/><circle cx="9" cy="5" r="1"/><circle cx="9" cy="19" r="1"/><circle cx="15" cy="12" r="1"/><circle cx="15" cy="5" r="1"/><circle cx="15" cy="19" r="1"/>),
+      "info" => %(<circle cx="12" cy="12" r="10"/><path d="M12 16v-4"/><path d="M12 8h.01"/>),
+      "loader-circle" => %(<path d="M21 12a9 9 0 1 1-6.219-8.56"/>),
+      "minus" => %(<path d="M5 12h14"/>),
+      "moon" => %(<path d="M20.985 12.486a9 9 0 1 1-9.473-9.472c.405-.022.617.46.402.803a6 6 0 0 0 8.268 8.268c.344-.215.825-.004.803.401"/>),
+      "octagon-x" => %(<path d="m15 9-6 6"/><path d="M2.586 16.726A2 2 0 0 1 2 15.312V8.688a2 2 0 0 1 .586-1.414l4.688-4.688A2 2 0 0 1 8.688 2h6.624a2 2 0 0 1 1.414.586l4.688 4.688A2 2 0 0 1 22 8.688v6.624a2 2 0 0 1-.586 1.414l-4.688 4.688a2 2 0 0 1-1.414.586H8.688a2 2 0 0 1-1.414-.586z"/><path d="m9 9 6 6"/>),
+      "panel-left" => %(<rect width="18" height="18" x="3" y="3" rx="2"/><path d="M9 3v18"/>),
+      "search" => %(<path d="m21 21-4.34-4.34"/><circle cx="11" cy="11" r="8"/>),
+      "sun" => %(<circle cx="12" cy="12" r="4"/><path d="M12 2v2"/><path d="M12 20v2"/><path d="m4.93 4.93 1.41 1.41"/><path d="m17.66 17.66 1.41 1.41"/><path d="M2 12h2"/><path d="M20 12h2"/><path d="m6.34 17.66-1.41 1.41"/><path d="m19.07 4.93-1.41 1.41"/>),
+      "triangle-alert" => %(<path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3"/><path d="M12 9v4"/><path d="M12 17h.01"/>),
+      "x" => %(<path d="M18 6 6 18"/><path d="m6 6 12 12"/>)
+    }.freeze
+  end
+end