weft 0.1.0

data/lib/weft/component.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require "uri"
+require "weft/context/interception"
+
+module Weft
+  # Base class for all Weft components. Extends Arbre::Component with:
+  # - Attribute DSL for declaring wire state
+  # - Convention-based DOM ID and partial URL
+  # - Auto-registration with the global Registry
+  class Component < Arbre::Component
+    extend Weft::Registry::Eligibility
+
+    include Weft::DSL::Attributes
+    include Weft::DSL::Recoveries
+    include Weft::DSL::Triggers
+    include Weft::DSL::Inclusions
+    include Weft::DSL::Updates
+    include Weft::DSL::Actions
+    include Weft::DSL::Containers
+
+    class << self
+      # Class-level path override (string or proc). Inherited by subclasses.
+      def component_path
+        if instance_variable_defined?(:@component_path)
+          @component_path
+        elsif superclass.respond_to?(:component_path)
+          superclass.component_path
+        end
+      end
+
+      attr_writer :component_path
+
+      # Resolves the actual path string for this component class. An explicit
+      # class-level override (string or proc) wins; otherwise the configured
+      # default proc derives one from the class name (see default_component_path).
+      def resolved_component_path
+        case (path = component_path)
+        when Proc then path.call(self)
+        when String then path
+        else default_component_path
+        end
+      end
+
+      # Inferred routability from declared state, ignoring any explicit
+      # override (see Weft::Registry::Eligibility#routable?). A component is
+      # independently addressable when it declares interactive behavior —
+      # attributes, actions, refresh triggers, or push config. Pure
+      # presentational components (none of those) register but are never served.
+      # Subclasses fall back to this when they have no override of their own, so
+      # an abstract parent does not disable concrete children.
+      def inferred_routable?
+        attributes.any? || actions.any? || refresh_triggers.any? || !push_config.nil?
+      end
+
+      def inherited(subclass)
+        super
+        Weft.registry.register(subclass)
+      end
+
+      # Render this component as an HTML string, outside any Arbre DSL context.
+      # Used by the Router for partial responses, and available to users for
+      # testing, REPL exploration, or any standalone rendering need.
+      #
+      #   StatCard.render(status: "shipped")  # => "<div id=\"...\">...</div>"
+      def render(**attributes)
+        klass = self
+        Weft::Context.new({}, nil) do
+          insert_tag(klass, **attributes)
+        end.to_s
+      end
+
+      # Compute the would-be DOM ID for an instance of this class given a
+      # plain attrs hash, without instantiating. The Router uses this to
+      # populate the `:component_id` auto-injected attribute when a recovery
+      # target opts in. Single source of truth; the instance method delegates.
+      def weft_id_for(attrs = {})
+        base = name.underscore.tr("/", "-").tr("_", "-")
+        primary_value = attrs.respond_to?(:values) ? attrs.values.first : nil
+        primary_value ? "#{base}-#{primary_value}" : base
+      end
+
+      private
+
+      # Gem-default name-based path derivation, plus the well-formedness guard.
+      # Mirrors {Weft::Page.default_page_path}: a routable class whose demodulized
+      # name has no usable stem (e.g. a bare +Component+ or +Foo::Component+)
+      # can't form a sensible default route, so we raise with remediation
+      # guidance rather than emit a degenerate "/_components/". Non-routable
+      # classes never reach a route and are exempt.
+      def default_component_path
+        if routable? && name.to_s.demodulize.delete_suffix("Component").empty?
+          raise Weft::InvalidDefinition,
+                "#{name.inspect} has no resolvable default component path. " \
+                "Either rename the class with a meaningful stem (e.g. OrdersPanel), " \
+                "set self.component_path = \"/your/path\" explicitly, " \
+                "or mark the class abstract! if it isn't meant to route."
+        end
+
+        Weft.configuration.component_path.call(self)
+      end
+    end
+
+    include Weft::Context::Interception
+
+    # Gem-default recovery edges. Symbol form defers resolution until error-handling
+    # time so reassigning the matching Weft.configuration knob propagates everywhere.
+    # NotFound is declared first (more specific) so a component-context 404 renders
+    # the not-found body; StandardError stays last as the catch-all.
+    recovers from: Weft::NotFound, with: :not_found_component
+    recovers from: StandardError, with: :error_component
+
+    def build(attributes = {})
+      schema = self.class.attributes
+      @attrs = Weft::Attributes.extract_from(attributes, using: schema)
+      super(attributes.except(*schema.keys))
+      self.id = weft_id
+      apply_refresh_attrs
+      apply_push_attrs
+    end
+
+    # URL to this component's Weft route with current attrs as query params.
+    # Pass overrides to change specific attr values in the URL.
+    #
+    #   weft_url                          # => "/_components/orders_panel?status=shipped&page=1"
+    #   weft_url(page: 2)                 # => "/_components/orders_panel?status=shipped&page=2"
+    #   weft_url(status: nil, page: 1)    # => "/_components/orders_panel?page=1"
+    def weft_url(**overrides)
+      path = self.class.resolved_component_path
+      params = @attrs.to_h.merge(overrides).compact
+      params.empty? ? path : "#{path}?#{URI.encode_www_form(params)}"
+    end
+
+    # Convention-based DOM ID: dasherized class name + primary attribute value.
+    def weft_id
+      self.class.weft_id_for(@attrs ? @attrs.to_h : {})
+    end
+
+    private
+
+    # URL to this component's Weft route with current attrs (no overrides).
+    # Used internally by apply_refresh_attrs.
+    def refresh_url
+      weft_url
+    end
+
+    def apply_refresh_attrs
+      triggers = self.class.refresh_triggers
+      return if triggers.empty?
+
+      set_attribute "hx-get", refresh_url
+      set_attribute "hx-trigger", triggers.join(", ")
+      set_attribute "hx-swap", "outerHTML"
+    end
+
+    # Apply SSE connection attributes for components declaring `pushes`.
+    # Uses innerHTML swap — the wrapper element (holding the SSE connection)
+    # must persist across pushes.
+    def apply_push_attrs
+      config = self.class.push_config
+      return unless config&.key?(:every)
+
+      set_attribute "hx-ext", "sse"
+      set_attribute "sse-connect", stream_url
+      set_attribute "sse-swap", weft_id
+      set_attribute "hx-swap", "innerHTML"
+    end
+
+    # URL to this component's SSE stream endpoint with current attrs.
+    def stream_url
+      path = "#{self.class.resolved_component_path}/#{Weft.configuration.stream_suffix}"
+      params = @attrs.to_h.compact
+      params.empty? ? path : "#{path}?#{URI.encode_www_form(params)}"
+    end
+  end
+end

data/lib/weft/configuration.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module Weft
+  class Configuration
+    DEFAULT_COMPONENT_PATH = ->(klass) { "/_components/#{klass.name.to_s.delete_suffix('Component').underscore}" }
+    VALID_HTMX_ERRORS = %i[fragment redirect].freeze
+    VALID_INCLUDE_SSE_EXT = [:auto, true, false].freeze
+    LOG_LEVELS = {
+      debug: Logger::DEBUG, info: Logger::INFO, warn: Logger::WARN,
+      error: Logger::ERROR, fatal: Logger::FATAL, unknown: Logger::UNKNOWN
+    }.freeze
+    private_constant :DEFAULT_COMPONENT_PATH, :VALID_HTMX_ERRORS, :VALID_INCLUDE_SSE_EXT, :LOG_LEVELS
+
+    attr_reader :component_path, :htmx_errors, :include_sse_ext, :log_level, :stream_suffix
+    attr_accessor :include_htmx, :auto_reload, :reload_paths, :verbose_error_pages, :router_logging
+    attr_writer :error_component, :error_page, :not_found_page, :not_found_component
+
+    # @api private
+    # Instantiated internally by {Weft.configuration}. Configure Weft via
+    # +Weft.configure { |c| ... }+ rather than constructing this directly.
+    def initialize
+      @component_path = DEFAULT_COMPONENT_PATH
+      @include_htmx = true
+      @include_sse_ext = :auto
+      @auto_reload = false
+      @reload_paths = []
+      @router_logging = false
+      @verbose_error_pages = true
+      @htmx_errors = :fragment
+      @log_level = :info
+      @stream_suffix = "_stream"
+      @static_assets = {}
+    end
+
+    def component_path=(value)
+      raise ArgumentError, "component_path must be a Proc, got #{value.class}" unless value.is_a?(Proc)
+
+      @component_path = value
+    end
+
+    def htmx_errors=(value)
+      unless VALID_HTMX_ERRORS.include?(value)
+        raise ArgumentError, "htmx_errors must be :fragment or :redirect, got #{value.inspect}"
+      end
+
+      @htmx_errors = value
+    end
+
+    # Controls when Weft::Page emits the htmx-ext-sse script tag.
+    # - :auto (default) -- include only if any registered component declares
+    #   `pushes`. Driven by Weft.registry.any_sse_components?.
+    # - true            -- always include (escape hatch for lazy autoload or
+    #   custom Registry population timing where :auto would miss components).
+    # - false           -- never include.
+    def include_sse_ext=(value)
+      unless VALID_INCLUDE_SSE_EXT.include?(value)
+        raise ArgumentError, "include_sse_ext must be :auto, true, or false, got #{value.inspect}"
+      end
+
+      @include_sse_ext = value
+    end
+
+    def log_level=(value)
+      unless LOG_LEVELS.key?(value)
+        raise ArgumentError, "log_level must be one of #{LOG_LEVELS.keys.inspect}, got #{value.inspect}"
+      end
+
+      @log_level = value
+    end
+
+    # The path segment that marks a component's SSE stream endpoint. The leading
+    # slash is supplied by Weft, so set the bare segment (e.g. "stream", "sse").
+    # It's appended as "<component_path>/<stream_suffix>" on both sides: the
+    # client-facing sse-connect URL (Weft::Component#stream_url) and the Router's
+    # stream-request routing. Must be a non-empty segment with no slashes.
+    def stream_suffix=(value)
+      unless value.is_a?(String) && !value.empty? && !value.include?("/")
+        raise ArgumentError,
+              "stream_suffix must be a non-empty path segment with no slashes — " \
+              "Weft adds the leading slash itself (e.g. \"stream\"), got #{value.inspect}"
+      end
+
+      @stream_suffix = value
+    end
+
+    # Resolves the configured log_level symbol to its Logger severity constant
+    # (e.g. :warn -> Logger::WARN). Used by Weft.configure to set logger.level.
+    def resolved_log_level
+      LOG_LEVELS.fetch(@log_level)
+    end
+
+    # Register a directory to serve as static assets at a URL prefix, under
+    # a logical bundle name. The bundle name is the stable reference used at
+    # call sites (`register_stylesheet "css/app.css", assets: :app`); the
+    # root/from pair can be reconfigured (e.g. from env vars in production)
+    # without touching call sites.
+    #
+    # Multi-call: each call adds a {name => {root:, from:}} entry. Raises
+    # ArgumentError on duplicate name or duplicate root.
+    #
+    #   c.static_assets root: "/static", from: File.join(APP_ROOT, "public")
+    #   # name: defaults to :default — call sites without an `assets:` kwarg
+    #   # implicitly resolve against this bundle.
+    #
+    #   c.static_assets name: :vendor, root: "/vendor",
+    #                   from: File.join(APP_ROOT, "vendor", "assets")
+    #
+    # Called with no arguments, returns a copy of the registered bundles as a
+    # hash (name => {root:, from:}). Used by the apply step and the page-side
+    # resolve_asset_url logic.
+    def static_assets(name: nil, root: nil, from: nil)
+      return @static_assets.transform_values(&:dup) if name.nil? && root.nil? && from.nil?
+
+      register_static_assets_bundle(name: name, root: root, from: from)
+    end
+
+    # Lazy defaults — resolved on first read so Weft::Defaults classes load before
+    # the Configuration class is required. Assignment sticks.
+    def error_component
+      @error_component ||= Weft::Defaults::ErrorComponent
+    end
+
+    def error_page
+      @error_page ||= Weft::Defaults::ErrorPage
+    end
+
+    def not_found_page
+      @not_found_page ||= Weft::Defaults::NotFoundPage
+    end
+
+    def not_found_component
+      @not_found_component ||= Weft::Defaults::NotFoundComponent
+    end
+
+    private
+
+    def register_static_assets_bundle(name:, root:, from:)
+      if root.nil? || from.nil?
+        raise ArgumentError,
+              "static_assets requires both root: and from: " \
+              "(e.g., static_assets root: '/static', from: File.join(APP_ROOT, 'public'))"
+      end
+      unless root.start_with?("/")
+        raise Weft::InvalidConfiguration, "static_assets root must start with '/', got #{root.inspect}"
+      end
+
+      bundle_name = (name || :default).to_sym
+      normalized_root = normalize_static_assets_root(root)
+      check_static_assets_uniqueness!(bundle_name, normalized_root)
+
+      @static_assets[bundle_name] = { root: normalized_root, from: from }
+    end
+
+    # Strip a trailing slash so URL building can always `"#{root}/#{path}"`
+    # without producing double slashes. "/" is left alone to allow root-mount
+    # (though apps typically use a prefix).
+    def normalize_static_assets_root(root)
+      root == "/" ? root : root.chomp("/")
+    end
+
+    def check_static_assets_uniqueness!(name, root)
+      if (existing = @static_assets[name])
+        raise Weft::InvalidConfiguration,
+              "static_assets bundle #{name.inspect} is already registered " \
+              "(at root #{existing[:root].inspect}, from #{existing[:from].inspect}); refusing to overwrite"
+      end
+
+      conflict = @static_assets.find { |_n, b| b[:root] == root }
+      return unless conflict
+
+      raise Weft::InvalidConfiguration,
+            "static_assets root #{root.inspect} is already registered (by bundle #{conflict[0].inspect})"
+    end
+  end
+end

data/lib/weft/context/interception.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Weft
+  class Context < Arbre::Context
+    # Mixin for Arbre elements that need to forward Weft kwargs
+    # (action:, navigate:, trigger:, etc.) to the Context for expansion.
+    #
+    # Included by Weft::Context, Weft::Component, and Weft::Page — all three
+    # share this one #insert_tag. It forwards any Weft kwargs to the root
+    # Weft::Context (via +arbre_context+), which is the expansion engine
+    # (#weft_kwarg? / #expand_weft_attrs).
+    module Interception
+      def insert_tag(klass, *args, &)
+        h = args.last
+        if h.is_a?(Hash) && arbre_context.is_a?(Weft::Context) && arbre_context.weft_kwarg?(h)
+          args[-1] = arbre_context.expand_weft_attrs(h, for_class: klass)
+        end
+        super
+      end
+    end
+  end
+end

data/lib/weft/context.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "weft/context/interception"
+
+module Weft
+  # Arbre::Context subclass that intercepts element creation to expand
+  # Weft kwargs into htmx attributes.
+  #
+  # Works at every nesting depth because Arbre instance_evals the top-level
+  # block, making the Context the receiver for all insert_tag calls throughout
+  # the element tree.
+  #
+  # Supported kwargs:
+  # - `action: :name` — expands into htmx attrs for a declared performs/transfers action
+  # - `navigate: { key: val }` — expands into htmx GET to self with overridden attrs
+  # - `trigger: "event"` — sets hx-trigger (standalone or alongside action:/navigate:)
+  class Context < Arbre::Context
+    include Interception
+
+    # @api private
+    # Expands Weft kwargs into htmx attributes. Invoked by the Interception
+    # mixin's #insert_tag on the root Weft::Context (via +arbre_context+).
+    def expand_weft_attrs(attrs, for_class: nil)
+      attrs = attrs.dup
+      custom_trigger = attrs.delete(:trigger)
+      push_url = attrs.delete(:push_url)
+      attrs = expand_action(attrs, for_class: for_class) || expand_navigate(attrs) || expand_loads(attrs) ||
+              expand_shorthand(attrs) || attrs
+      attrs["hx-trigger"] = resolve_trigger(custom_trigger) if custom_trigger
+      attrs["hx-push-url"] = push_url.to_s if push_url
+      attrs
+    end
+
+    # @api private
+    # Guard check for whether an attrs hash carries any Weft kwarg. Invoked by
+    # the Interception mixin's #insert_tag on the root Weft::Context (via
+    # +arbre_context+).
+    def weft_kwarg?(hash)
+      hash[:action].is_a?(Symbol) || hash.key?(:trigger) || hash[:navigate].is_a?(Hash) ||
+        hash[:loads].is_a?(Class) || hash.key?(:push_url) || find_shorthand_kwarg(hash)
+    end
+
+    private
+
+    def expand_action(attrs, for_class: nil)
+      action_name = attrs[:action]
+      return unless action_name.is_a?(Symbol)
+
+      component = find_action_context(action_name)
+      return unless component
+
+      action = component.class.action_for(action_name)
+      htmx = action.to_htmx_attrs(component)
+      expanded = attrs.except(:action).merge(htmx)
+      return augment_for_form(expanded, action, htmx) if for_class && for_class <= Arbre::HTML::Form
+
+      expanded
+    end
+
+    # On <form> elements, also emit the HTML action and method attributes so
+    # non-JS submission works (browser POSTs to the same URL htmx would).
+    # Drop hx-vals because the form fields are the submission payload —
+    # hx-vals would duplicate or shadow them.
+    def augment_for_form(expanded, action, htmx)
+      url = htmx["hx-#{action.method}"]
+      expanded.except("hx-vals").merge("action" => url, "method" => action.method.to_s)
+    end
+
+    def expand_navigate(attrs)
+      overrides = attrs[:navigate]
+      return unless overrides.is_a?(Hash)
+
+      component = find_nearest_component
+      return unless component
+
+      attrs.except(:navigate).merge(navigate_attrs(component, overrides))
+    end
+
+    def expand_loads(attrs)
+      target_class = attrs[:loads]
+      return unless target_class.is_a?(Class)
+
+      validate_loads_kwargs!(attrs)
+      remaining = attrs.except(:loads, :swap, :target, :with)
+      remaining.merge(loads_attrs(target_class, resolve_with(attrs), attrs[:swap], attrs[:target]))
+    end
+
+    def expand_shorthand(attrs)
+      shorthand_key, target_class = find_shorthand_kwarg(attrs)
+      return unless shorthand_key
+
+      build_shorthand_attrs(attrs, shorthand_key, target_class, Weft.shorthand(shorthand_key))
+    end
+
+    # A shorthand value is either a target Class (derive the URL from it) or a
+    # ready-made URL String (retry-style — the caller already has the URL).
+    def find_shorthand_kwarg(attrs)
+      attrs.find { |k, v| (v.is_a?(Class) || v.is_a?(String)) && Weft.shorthand(k) }
+    end
+
+    def build_shorthand_attrs(attrs, shorthand_key, target_or_url, preset)
+      target = attrs[:target] || preset[:target]
+      raise ArgumentError, "#{shorthand_key}: requires target: (e.g., target: :self)" unless target
+
+      swap = attrs[:swap] || preset[:swap]
+      htmx = if target_or_url.is_a?(String)
+               htmx_get_attrs(target_or_url, swap, target)
+             else
+               loads_attrs(target_or_url, resolve_with(attrs), swap, target)
+             end
+      htmx["hx-trigger"] = resolve_trigger(preset[:trigger]) if preset[:trigger]
+      attrs.except(shorthand_key, :swap, :target, :with).merge(htmx)
+    end
+
+    def resolve_with(attrs)
+      attrs[:with] || find_nearest_component&.attrs&.to_h || {}
+    end
+
+    def validate_loads_kwargs!(attrs)
+      raise ArgumentError, "loads: requires swap: (e.g., swap: :fill)" unless attrs[:swap]
+      raise ArgumentError, "loads: requires target: (e.g., target: :self)" unless attrs[:target]
+    end
+
+    def find_action_context(action_name)
+      el = current_arbre_element
+      while el
+        return el if el.is_a?(Weft::Component) && el.class.action_for(action_name)
+
+        el = el.parent
+      end
+      nil
+    end
+
+    def find_nearest_component
+      el = current_arbre_element
+      while el
+        return el if el.is_a?(Weft::Component)
+
+        el = el.parent
+      end
+      nil
+    end
+
+    def navigate_attrs(component, overrides)
+      {
+        "hx-get" => component.weft_url(**overrides),
+        "hx-target" => "##{component.weft_id}",
+        "hx-swap" => "outerHTML"
+      }
+    end
+
+    def loads_attrs(target_class, with_attrs, swap, target)
+      htmx_get_attrs(component_url(target_class, with_attrs), swap, target)
+    end
+
+    def component_url(target_class, with_attrs)
+      path = target_class.resolved_component_path
+      params = with_attrs.compact
+      params.empty? ? path : "#{path}?#{URI.encode_www_form(params)}"
+    end
+
+    def htmx_get_attrs(url, swap, target)
+      {
+        "hx-get" => url,
+        "hx-swap" => Action.resolve_swap(swap),
+        "hx-target" => resolve_target(target)
+      }
+    end
+
+    def resolve_target(target)
+      case target
+      when :self then "this"
+      when String then target
+      else
+        # Arbre element reference — extract #id
+        target.respond_to?(:id) ? "##{target.id}" : target.to_s
+      end
+    end
+
+    def resolve_trigger(value)
+      Action.resolve_trigger(value)
+    end
+  end
+end

data/lib/weft/defaults/error_component.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Weft
+  module Defaults
+    # Gem-default component rendered when an action or partial-render fails
+    # and no user-declared recovers entry matches. Verbose mode shows the
+    # exception class and message; non-verbose shows a generic message.
+    # Users override by setting Weft.configuration.error_component or by
+    # declaring their own `recovers` chain.
+    class ErrorComponent < Weft::Component
+      abstract!
+
+      # Auto-injected attributes (opt-in, schema-gated by the Router). The
+      # Router populates these at error-handling time on any recovers target
+      # that declares them.
+      # :component_id preserves the failing component's DOM identity so the
+      # recovered fragment lands at the original element's id — preventing
+      # duplicate IDs when several siblings fail in the same window.
+      # :retry_url is the failing component's GET URL with current attrs.
+      attribute :component_id
+      attribute :exception
+      attribute :request_path
+      attribute :status_code
+      attribute :retry_url
+
+      STYLE = "padding:1rem; border:1px solid #fca5a5; border-radius:6px; " \
+              "background:#fef2f2; color:#991b1b; font-size:0.875rem"
+      MONO_STYLE = "margin-bottom:0.5rem; font-family:monospace; font-size:0.8rem"
+      BUTTON_STYLE = "padding:0.25rem 0.75rem; border:1px solid #b91c1c; border-radius:4px; " \
+                     "background:#fff; color:#b91c1c; font-size:0.75rem; cursor:pointer"
+
+      def build(attributes = {})
+        super
+        add_class "weft-error"
+        set_attribute "style", STYLE
+
+        div(style: "font-weight:600; margin-bottom:0.5rem") { text_node "Something went wrong" }
+        render_verbose if Weft.configuration.verbose_error_pages && @attrs.exception
+        render_retry_button if @attrs.retry_url
+      end
+
+      # Preserve the failing component's DOM identity when the Router injected
+      # :component_id. Otherwise fall back to the class-derived default.
+      def weft_id
+        @attrs.component_id || super
+      end
+
+      private
+
+      def render_verbose
+        exc = @attrs.exception
+        div(style: MONO_STYLE) { text_node "#{exc.class}: #{exc.message}" }
+      end
+
+      # Retry by re-issuing a GET to refresh the failing component. The :retry
+      # shorthand supplies the htmx wiring (outerHTML-swap the closest
+      # .weft-error box), so it works whether or not :component_id was carved out.
+      def render_retry_button
+        button "Retry", retry: @attrs.retry_url, style: BUTTON_STYLE
+      end
+    end
+  end
+end

data/lib/weft/defaults/error_page.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Weft
+  module Defaults
+    # Gem-default full-document page rendered for traditional (non-htmx)
+    # responses when an error falls through to the Page recovers chain
+    # and no user override matches. Thin wrapper around ErrorComponent.
+    class ErrorPage < Weft::Page
+      self.page_path = "/_weft/error"
+
+      attribute :exception
+      attribute :request_path
+      attribute :status_code
+
+      def build(attributes = {})
+        attributes[:title] ||= "Error"
+        super
+        insert_tag(
+          Weft::Defaults::ErrorComponent,
+          exception: @attrs.exception,
+          request_path: @attrs.request_path,
+          status_code: @attrs.status_code
+        )
+      end
+    end
+  end
+end

data/lib/weft/defaults/not_found_component.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Weft
+  module Defaults
+    # Gem-default component rendered when a routing miss falls through to
+    # the Weft::Page chain (C4) or when an action raises Weft::NotFound and
+    # no user recovers entry matches.
+    class NotFoundComponent < Weft::Component
+      abstract!
+
+      # Opt into the :component_id auto-injected attribute for parity with
+      # ErrorComponent — preserves DOM identity when a component-context
+      # NotFound recovers through this.
+      attribute :component_id
+      attribute :request_path
+      attribute :status_code
+
+      STYLE = "padding:1rem; border:1px solid #cbd5e1; border-radius:6px; " \
+              "background:#f8fafc; color:#0f172a; font-size:0.875rem"
+      MONO_STYLE = "margin-top:0.5rem; font-family:monospace; font-size:0.8rem; color:#475569"
+
+      def build(attributes = {})
+        super
+        add_class "weft-not-found"
+        set_attribute "style", STYLE
+
+        div(style: "font-weight:600") { text_node "Not found" }
+        render_verbose if Weft.configuration.verbose_error_pages && @attrs.request_path
+      end
+
+      # Preserve the failing component's DOM identity when the Router injected
+      # :component_id. Otherwise fall back to the class-derived default.
+      def weft_id
+        @attrs.component_id || super
+      end
+
+      private
+
+      def render_verbose
+        div(style: MONO_STYLE) { text_node @attrs.request_path.to_s }
+      end
+    end
+  end
+end