igniter 0.5.1 → 0.5.2

data/packages/igniter-frontend/lib/igniter/frontend/arbre/components/tabs.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require_relative "../component"
-
-module Igniter
-  module Frontend
-    module Arbre
-      module Components
-        class Tabs < Arbre::Component
-          builder_method :tabs
-
-          def build(*args, &block)
-            options = extract_options!(args)
-            title = options.delete(:title)
-            subtitle = options.delete(:subtitle)
-            span = options.delete(:span)
-            class_name = options.delete(:class_name)
-            tabs_id = options.delete(:id) || "tabs-#{object_id.abs}"
-            span_class = span ? "span-#{span}" : nil
-
-            @tabs_id = tabs_id
-            @tabs = []
-
-            super(
-              options.merge(
-                id: @tabs_id,
-                class: merge_classes("panel tabs-panel", span_class, class_name),
-                "data-ig-controller": "tabs"
-              )
-            )
-
-            build_heading(title, subtitle)
-            render_build_block(block)
-            render_tabs(title || "Tabs")
-          end
-
-          def add_child(child)
-            super
-          end
-
-          def meta(value = nil, &block)
-            container = ensure_header_container!
-            value.nil? ? container.div(class: "meta", &block) : container.div(value, class: "meta", &block)
-          end
-
-          def actions(class_name: nil, &block)
-            ensure_header_container!.action_group(class_name: class_name, &block)
-          end
-
-          def tab(title, active: nil, id: nil, &block)
-            active = @tabs.empty? if active.nil?
-            fragment = id || fragmentize(title)
-            pane_id = "#{@tabs_id}-#{fragment}"
-            button_id = "#{pane_id}-tab"
-            @tabs << {
-              title: title,
-              active: active,
-              pane_id: pane_id,
-              button_id: button_id,
-              block: block
-            }
-          end
-
-          def json_tab(title, payload:, panel_id: nil, panel_attributes: nil, active: nil, id: nil)
-            tab(title, active: active, id: id) do |pane|
-              attributes = (panel_attributes || {}).merge(id: panel_id)
-              pane.pre(attributes) { |code| code.text_node(JSON.pretty_generate(payload)) }
-            end
-          end
-
-          private
-
-          def render_tabs(label)
-            div(class: "tabs-nav", role: "tablist", "aria-label": label) do |nav|
-              @tabs.each do |entry|
-                nav.button(
-                  entry.fetch(:title),
-                  type: "button",
-                  id: entry.fetch(:button_id),
-                  class: merge_classes("tab-button", entry.fetch(:active) ? "active" : nil),
-                  role: "tab",
-                  "aria-controls": entry.fetch(:pane_id),
-                  "aria-selected": entry.fetch(:active).to_s,
-                  tabindex: entry.fetch(:active) ? "0" : "-1",
-                  "data-ig-tabs-target": "button",
-                  "data-ig-tabs-pane-id": entry.fetch(:pane_id)
-                )
-              end
-            end
-
-            div(class: "panel-body tabs-body") do |body|
-              body.div(class: "tabs-panes") do |panes|
-                @tabs.each do |entry|
-                  panes.div(
-                    id: entry.fetch(:pane_id),
-                    class: merge_classes("tab-pane", entry.fetch(:active) ? "active" : nil),
-                    role: "tabpanel",
-                    "aria-labelledby": entry.fetch(:button_id),
-                    "data-ig-tabs-target": "pane"
-                  ) do |pane|
-                    render_tab_content(pane, entry[:block])
-                  end
-                end
-              end
-            end
-          end
-
-          def render_tab_content(pane, block)
-            return unless block
-
-            if block.arity.zero?
-              pane.instance_exec(&block)
-            else
-              block.call(pane)
-            end
-          end
-
-          def build_heading(title, subtitle)
-            return if title.nil? && subtitle.nil?
-
-            ensure_heading_container!
-            @heading.h2(title) if title
-            @heading.div(subtitle, class: "caption") if subtitle
-          end
-
-          def ensure_header_container!
-            @header ||= div(class: "panel-header")
-          end
-
-          def ensure_heading_container!
-            ensure_header_container!
-            @heading ||= @header.div(class: "panel-heading")
-          end
-
-          def fragmentize(value)
-            value.to_s.downcase.gsub(/[^a-z0-9]+/, "-").gsub(/\A-+|-+\z/, "")
-          end
-
-          def tag_name
-            "article"
-          end
-        end
-      end
-    end
-  end
-end

data/packages/igniter-frontend/lib/igniter/frontend/arbre/components/viz.rb

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../component"
-
-module Igniter
-  module Frontend
-    module Arbre
-      module Components
-        class Viz < Arbre::Component
-          builder_method :viz
-
-          DEFAULT_MAX_ITEMS = 20
-
-          def build(value, *args)
-            options = extract_options!(args)
-            title = options.delete(:title)
-            name = options.delete(:name)
-            open = options.key?(:open) ? options.delete(:open) : true
-            compact = options.delete(:compact)
-            max_items = options.delete(:max_items) || DEFAULT_MAX_ITEMS
-            class_name = options.delete(:class_name)
-
-            @theme = ui_theme(:companion)
-            @compact = compact
-            @max_items = max_items
-
-            super(options.merge(class: merge_classes("viz-panel grid gap-3", class_name)))
-            render_header(title)
-            render_value(self, normalize(value), label: name, open: open, depth: 0, root: true)
-          end
-
-          private
-
-          def render_header(title)
-            return unless title
-
-            h3(title, class: @theme.section_heading_class(extra: "mt-0"))
-          end
-
-          def render_value(view, value, label:, open:, depth:, root: false)
-            case value
-            when Hash
-              render_hash(view, value, label: label, open: open, depth: depth, root: root)
-            when Array
-              render_array(view, value, label: label, open: open, depth: depth, root: root)
-            else
-              render_leaf(view, value, label: label)
-            end
-          end
-
-          def render_hash(view, hash, label:, open:, depth:, root:)
-            entries = hash.to_a.first(@max_items)
-
-            if root
-              container = view.div(class: block_class(depth))
-              entries.each do |key, value|
-                render_value(container, normalize(value), label: key.to_s, open: false, depth: depth + 1)
-              end
-              render_omitted_notice(container, hash.size - entries.size)
-              return
-            end
-
-            view.details(open: open ? true : nil, class: block_class(depth)) do |details|
-              details.summary(class: summary_class) do |summary|
-                summary.strong(label.to_s, class: "font-semibold text-stone-100") if label
-                summary.span("Hash · #{hash.size} entr#{hash.size == 1 ? "y" : "ies"}", class: "caption")
-              end
-
-              details.div(class: merge_classes("mt-3 grid gap-3", nested_class(depth))) do |body|
-                if entries.empty?
-                  body.div("Empty Hash", class: empty_class)
-                else
-                  entries.each do |key, value|
-                    render_value(body, normalize(value), label: key.to_s, open: false, depth: depth + 1)
-                  end
-                  render_omitted_notice(body, hash.size - entries.size)
-                end
-              end
-            end
-          end
-
-          def render_array(view, array, label:, open:, depth:, root: false)
-            items = array.first(@max_items)
-
-            if root
-              container = view.div(class: block_class(depth))
-              items.each_with_index do |item, index|
-                render_value(container, normalize(item), label: "[#{index}]", open: false, depth: depth + 1)
-              end
-              render_omitted_notice(container, array.size - items.size)
-              return
-            end
-
-            view.details(open: open ? true : nil, class: block_class(depth)) do |details|
-              details.summary(class: summary_class) do |summary|
-                summary.strong(label.to_s, class: "font-semibold text-stone-100") if label
-                summary.span("Array · #{array.size} item#{array.size == 1 ? "" : "s"}", class: "caption")
-              end
-
-              details.div(class: merge_classes("mt-3 grid gap-3", nested_class(depth))) do |body|
-                if items.empty?
-                  body.div("Empty Array", class: empty_class)
-                else
-                  items.each_with_index do |item, index|
-                    render_value(body, normalize(item), label: "[#{index}]", open: false, depth: depth + 1)
-                  end
-                  render_omitted_notice(body, array.size - items.size)
-                end
-              end
-            end
-          end
-
-          def render_leaf(view, value, label:)
-            view.div(class: row_class) do |row|
-              row.div(label.to_s, class: @theme.field_label_class) if label
-
-              case value
-              when true, false
-                row.badge(value, size: :sm)
-              when nil
-                row.div("nil", class: empty_class)
-              else
-                row.code(display_text(value), class: @theme.code_class)
-              end
-            end
-          end
-
-          def render_omitted_notice(view, omitted_count)
-            return unless omitted_count.positive?
-
-            view.div("… #{omitted_count} more item#{omitted_count == 1 ? "" : "s"}", class: empty_class)
-          end
-
-          def normalize(value)
-            return value if value.is_a?(Hash) || value.is_a?(Array)
-            return value unless value.respond_to?(:to_h)
-
-            value.to_h
-          rescue StandardError
-            value
-          end
-
-          def display_text(value)
-            case value
-            when Symbol
-              humanize_label(value)
-            else
-              value.to_s
-            end
-          end
-
-          def block_class(depth)
-            merge_classes(
-              "rounded-2xl border border-white/10 bg-white/[0.03] p-4",
-              depth.zero? && @compact ? "p-3" : nil
-            )
-          end
-
-          def nested_class(depth)
-            depth.positive? ? "pl-3 border-l border-white/5" : nil
-          end
-
-          def row_class
-            merge_classes(
-              "grid gap-2",
-              @compact ? "grid-cols-[minmax(110px,160px)_1fr]" : "grid-cols-[minmax(140px,190px)_1fr]"
-            )
-          end
-
-          def summary_class
-            "flex flex-wrap items-center gap-3 cursor-pointer"
-          end
-
-          def empty_class
-            "text-sm italic text-stone-400"
-          end
-
-          def tag_name
-            "div"
-          end
-        end
-      end
-    end
-  end
-end

data/packages/igniter-frontend/lib/igniter/frontend/arbre/page.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../tailwind"
-require_relative "component"
-
-require_relative "components/action_group"
-require_relative "components/badge"
-require_relative "components/boolean"
-require_relative "components/breadcrumbs"
-require_relative "components/card"
-require_relative "components/conversation_panel"
-require_relative "components/datetime"
-require_relative "components/empty_state"
-require_relative "components/event_list"
-require_relative "components/filters"
-require_relative "components/indicator"
-require_relative "components/json_panel"
-require_relative "components/key_value_list"
-require_relative "components/loading_state"
-require_relative "components/metric_grid"
-require_relative "components/number"
-require_relative "components/page_header"
-require_relative "components/panel"
-require_relative "components/pagination"
-require_relative "components/percentage"
-require_relative "components/resource_list"
-require_relative "components/scenario_card"
-require_relative "components/shell_columns"
-require_relative "components/sidebar_shell"
-require_relative "components/table_with"
-require_relative "components/tabs"
-require_relative "components/viz"
-
-module Igniter
-  module Frontend
-    module Arbre
-      class Page
-        class << self
-          def render_fragment(assigns: {}, helpers: nil, &block)
-            Arbre.ensure_available!
-            context_class.new(assigns, helpers, &block).to_s
-          end
-
-          def render_page(title:, lang: "en", theme: :companion,
-                          body_class: Igniter::Frontend::Tailwind::DEFAULT_BODY_CLASS,
-                          main_class: Igniter::Frontend::Tailwind::DEFAULT_MAIN_CLASS,
-                          include_play_cdn: true, tailwind_config: nil, head_content: nil,
-                          assigns: {}, helpers: nil, &block)
-            fragment = render_fragment(assigns: assigns, helpers: helpers, &block)
-
-            Igniter::Frontend::Tailwind.render_page(
-              title: title,
-              lang: lang,
-              theme: theme,
-              body_class: body_class,
-              main_class: main_class,
-              include_play_cdn: include_play_cdn,
-              tailwind_config: tailwind_config,
-              head_content: head_content
-            ) do |main|
-              main.raw(fragment)
-            end
-          end
-
-          private
-
-          def context_class
-            Arbre.context_class
-          end
-        end
-      end
-    end
-  end
-end

data/packages/igniter-frontend/lib/igniter/frontend/arbre/raw_text_node.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Frontend
-    module Arbre
-      FallbackElement = Class.new do
-        def self.builder_method(*)
-          nil
-        end
-      end
-
-      raw_text_base_class = if Arbre.available?
-                              dependency = Arbre.dependency
-                              if dependency.const_defined?(:Element)
-                                dependency.const_get(:Element)
-                              else
-                                component_class.superclass
-                              end
-                            else
-                              FallbackElement
-                            end
-
-      class RawTextNode < raw_text_base_class
-        builder_method :raw_text
-
-        def build(content)
-          @content = content.to_s
-        end
-
-        def to_s
-          @content
-        end
-
-        def tag_name
-          nil
-        end
-      end
-    end
-  end
-end

data/packages/igniter-frontend/lib/igniter/frontend/arbre/template_page.rb

@@ -1,243 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require_relative "component"
-
-require_relative "components/action_group"
-require_relative "components/badge"
-require_relative "components/breadcrumbs"
-require_relative "components/card"
-require_relative "components/conversation_panel"
-require_relative "components/event_list"
-require_relative "components/json_panel"
-require_relative "components/key_value_list"
-require_relative "components/metric_grid"
-require_relative "components/page_header"
-require_relative "components/panel"
-require_relative "components/resource_list"
-require_relative "components/scenario_card"
-require_relative "components/tabs"
-
-module Igniter
-  module Frontend
-    module Arbre
-      class TemplatePage
-        UNSET = Object.new
-
-        class << self
-          def inherited(subclass)
-            super
-            subclass.template_root(template_root)
-            subclass.template(template)
-            subclass.layout(layout)
-          end
-
-          def render(**kwargs)
-            new(**kwargs).render
-          end
-
-          def template_root(path = UNSET)
-            return @template_root if path.equal?(UNSET)
-
-            @template_root = path.nil? ? nil : File.expand_path(path)
-          end
-
-          def template(name = UNSET)
-            return @template_name if name.equal?(UNSET)
-
-            @template_name = name
-          end
-
-          def layout(name = UNSET)
-            return @layout_name if name.equal?(UNSET)
-
-            @layout_name = name
-          end
-        end
-
-        def render(template: self.class.template, layout: self.class.layout, locals: nil)
-          rendered_template = build_context(resolve_template_path(template), assigns: merged_template_locals(locals))
-          return rendered_template.to_s if layout.nil?
-
-          @template_context = rendered_template
-          build_context(resolve_template_path(layout), assigns: merged_layout_locals(locals)).to_s
-        ensure
-          @template_context = nil
-        end
-
-        def render_template_content
-          raise ArgumentError, "#{self.class} has no template content to render" unless @template_context
-
-          target = current_arbre_context&.current_arbre_element
-          raise ArgumentError, "#{self.class} has no active Arbre context" unless target
-
-          @template_context.children.to_a.each do |child|
-            if target.respond_to?(:add_child)
-              target.add_child(child)
-            else
-              target << child
-            end
-          end
-
-          nil
-        end
-
-        def template_locals
-          {}
-        end
-
-        def layout_locals
-          template_locals
-        end
-
-        def controller_target(controller, name, **attributes)
-          attributes.merge(:"data-ig-#{dashize(controller)}-target" => dashize(name))
-        end
-
-        def controller_scope(*controllers, **attributes)
-          names = [attributes.delete(:"data-ig-controller"), controllers]
-                  .flatten
-                  .compact
-                  .flat_map { |value| value.to_s.split(/\s+/) }
-                  .map { |value| dashize(value) }
-                  .reject(&:empty?)
-                  .uniq
-
-          attributes.merge(:"data-ig-controller" => names.join(" "))
-        end
-
-        def stream_scope(**attributes)
-          controller_scope(:stream, **attributes)
-        end
-
-        def stream_target(name, **attributes)
-          controller_target(:stream, name, **attributes)
-        end
-
-        def controller_value(controller, name, value, **attributes)
-          serialized = serialize_controller_value(value)
-          return attributes if serialized.nil?
-
-          attributes.merge(:"data-ig-#{dashize(controller)}-#{dashize(name)}-value" => serialized)
-        end
-
-        def stream_value(name, value, **attributes)
-          controller_value(:stream, name, value, **attributes)
-        end
-
-        def frontend_runtime_path(mount: Assets::DEFAULT_MOUNT_PATH)
-          frontend_route_for(Assets.runtime_path(mount_path: mount))
-        end
-
-        def frontend_javascript_path(logical_path, mount: Assets::DEFAULT_MOUNT_PATH)
-          frontend_route_for(Assets.javascript_path(logical_path, mount_path: mount))
-        end
-
-        def render_frontend_javascript(*entrypoints, runtime: true, mount: Assets::DEFAULT_MOUNT_PATH, defer: true)
-          target = current_arbre_context&.current_arbre_element
-          raise ArgumentError, "#{self.class} has no active Arbre context" unless target
-
-          target.script(src: frontend_runtime_path(mount: mount), defer: defer) if runtime
-
-          Array(entrypoints).flatten.compact.each do |entrypoint|
-            target.script(src: frontend_javascript_path(entrypoint, mount: mount), defer: defer)
-          end
-
-          nil
-        end
-
-        private
-
-        def current_arbre_context
-          @current_arbre_context
-        end
-
-        def merged_template_locals(overrides)
-          merge_locals(template_locals, overrides)
-        end
-
-        def merged_layout_locals(overrides)
-          merge_locals(layout_locals, overrides)
-        end
-
-        def merge_locals(base, overrides)
-          base.merge(overrides || {})
-        end
-
-        def build_context(path, assigns:)
-          Arbre.ensure_available!
-          Arbre::RawTextNode
-
-          context = Arbre.context_class.new(assigns, self)
-          previous_context = @current_arbre_context
-          @current_arbre_context = context
-          context.instance_eval(File.read(path), path, 1)
-          context
-        ensure
-          @current_arbre_context = previous_context
-        end
-
-        def resolve_template_path(name)
-          candidate = name.to_s.strip
-          raise ArgumentError, "#{self.class} must define a template name" if candidate.empty?
-
-          path = if absolute_template_path?(candidate)
-                   candidate
-                 else
-                   root = self.class.template_root
-                   raise ArgumentError, "#{self.class} must define template_root for relative templates" if root.nil?
-
-                   File.expand_path(candidate, root)
-                 end
-
-          path = "#{path}.arb" if File.extname(path).empty?
-          raise ArgumentError, "missing Arbre template: #{path}" unless File.file?(path)
-
-          path
-        end
-
-        def absolute_template_path?(value)
-          value.start_with?("/", "./", "../")
-        end
-
-        def frontend_route_for(suffix)
-          routeable_context = if respond_to?(:context, true)
-                              send(:context)
-                            elsif instance_variable_defined?(:@context)
-                              instance_variable_get(:@context)
-                            end
-
-          return suffix unless routeable_context&.respond_to?(:route)
-
-          routeable_context.route(suffix)
-        end
-
-        def dashize(value)
-          value.to_s
-               .gsub(/([a-z0-9])([A-Z])/, '\1-\2')
-               .tr("_", "-")
-               .downcase
-        end
-
-        def serialize_controller_value(value)
-          case value
-          when nil
-            nil
-          when String
-            value
-          when Symbol, Numeric
-            value.to_s
-          when true
-            "true"
-          when false
-            "false"
-          when Array, Hash
-            JSON.generate(value)
-          else
-            value.to_s
-          end
-        end
-      end
-    end
-  end
-end