lively 0.21.0 → 0.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8430df315a92af764a65128e479adf71cd0971e27edfc259ba9ec5c7bbc21cbc
-  data.tar.gz: c48c124558fd175a016cd60a38e5f9773821d0c9fe260ed5a60218ee21e4f08d
+  metadata.gz: 02c1d603877c33f60d054f04e6d9ef68d5385b23d3f165b23520e2ea47eefa80
+  data.tar.gz: 6a48a1a8753f2a35adb4da6abb5527a7f95c2462903499f4a4b2ae968f0e0ebb
 SHA512:
-  metadata.gz: 529d3090d929d951da18f7f58df1cb6df958f1489b54bdcbf370003b24a103dcee9ec72071be2b50c0ca327c66486cb44ed3954064cd38180774166c50e319b8
-  data.tar.gz: 23a4576c7fd367afbe32c761f6e039c74b5bef211d35f1be48690a30c68c2546d4c2530101fbe7798a526b497b864ec98e52d6b6cea29bb30fa3c6bcbb433b43
+  metadata.gz: 63c191f0001969c89b0b8b7f0fcf6de08757b202a7d53423d6d2ddd91aa05eea34f8b66f4e2e7c9363546b6c1064afa35878904722bd19f9d82436c58f6f5c62
+  data.tar.gz: efd50bf88258523e7a95dbec278ec95a448ded6849ab77209cf6fc1158805dc0b0f06ed3228b0b616806ff8af2bc27124171eb56ff10d6f277d4143c78b8989a

data/context/getting-started.md

@@ -82,7 +82,7 @@ class GameState
 end
 
 class GameView < Live::View
-	def initialize(id = self.class.unique_id, data = {}, game_state: nil)
+	def initialize(id, data, game_state: nil)
 		super(id, data)
 		@game_state = game_state
 	end
@@ -117,22 +117,24 @@ class Application < Lively::Application
 	end
 	
 	def configure_routes(router)
-		router.get("/") do |request|
-			render_view(request, DisplayView)
+		router.get("/") do
+			body = resolver.root(DisplayView)
+			Lively::Pages::Index.new(title: title, body: body).call
 		end
 		
-		router.get("/control") do |request, parameters|
-			render_view(request, ControlView, mode: parameters["mode"])
+		router.get("/control") do
+			body = resolver.root(ControlView)
+			Lively::Pages::Index.new(title: title, body: body).call
 		end
 	end
 end
 ```
 
-`allowed_views` defines the view classes the live resolver may construct. Routes select which view to display at each path, including `/`. `make_view` constructs a view with shared state, `make_page` wraps it in the default page, and `render_view` composes both operations. A custom route can construct any {ruby Lively::Page} around `make_view` and call it with the request. Lively installs its `/live` WebSocket route independently, so overriding `configure_routes` does not remove it.
+`allowed_views` defines the view classes the shared resolver may construct. Each matched route constructs its root view using the shared resolver, wraps that concrete body in a page, and invokes `Page#call` to produce the response. This keeps view construction lazy without making the page body itself callable. Lively installs its `/live` WebSocket route independently, so overriding `configure_routes` does not remove it.
 
-Routes match exact paths and may accept one or more HTTP methods. Query parameters are decoded using `protocol-url` and passed to the handler as its second argument. Routes without an explicit method accept every method.
+Routes match exact paths and may accept one or more HTTP methods. Handlers receive the original request and can parse query parameters when needed. Routes without an explicit method accept every method.
 
-Requests which do not match a route are passed to the application's delegate. An application using client-side history routing can instead override `#handle` to render an application page for unmatched paths.
+Requests which do not match a route are passed to the application's delegate. Applications that need custom fallback behavior can supply an appropriate delegate when they are constructed.
 
 ## Live Reloading
 

data/lib/lively/application.rb

@@ -23,7 +23,7 @@ module Lively
 	#
 	# Use {.[]} to create a simple application class for a single view, optionally
 	# with shared state. For more complex applications, subclass and override
-	# {#allowed_views}, {#state}, and {#configure_routes}.
+	# {#allowed_views}, {#state}, and {#configure_routes} to route requests to pages.
 	class Application < Protocol::HTTP::Middleware
 		VIEWS = [HelloWorld].freeze
 		STATE = {}.freeze
@@ -43,15 +43,6 @@ module Lively
 			return klass
 		end
 		
-		# Initialize a new Lively application.
-		# @parameter delegate [Protocol::HTTP::Middleware] The next middleware in the chain.
-		def initialize(delegate)
-			super(delegate)
-		end
-		
-		# @attribute [Protocol::HTTP::Middleware] The delegate middleware for request handling.
-		attr :delegate
-		
 		# The shared state for this application, passed to all views via the resolver.
 		# Override this in subclasses to provide custom state.
 		# @returns [Hash] Key-value pairs passed as keyword arguments to view constructors.
@@ -87,52 +78,22 @@ module Lively
 			self.class.name
 		end
 		
-		# Construct a view with shared application state.
-		# @parameter view_class [Class] The view class to construct.
-		# @parameter arguments [Hash] Additional keyword arguments for the view.
-		# @returns [Live::View] A new view instance.
-		def make_view(view_class, **arguments)
-			view_class.new(**self.state, **arguments)
-		end
-		
-		# Construct the default page for a view.
-		# Override this to customize the document surrounding live views.
-		# @parameter view [Live::View] The root view for the page.
-		# @returns [Page] A new page instance.
-		def make_page(view)
-			Pages::Index.new(title: self.title, body: view)
-		end
-		
-		# Construct a view and its default page, then render an HTTP response.
-		# @parameter request [Protocol::HTTP::Request] The incoming request.
-		# @parameter view_class [Class] The view class to render.
-		# @parameter arguments [Hash] Additional keyword arguments for the view.
-		# @returns [Protocol::HTTP::Response] A successful HTML response.
-		def render_view(request, view_class, **arguments)
-			make_page(make_view(view_class, **arguments)).call(request)
-		end
-		
-		# Handle a standard HTTP request which did not match a configured route.
-		# @parameter request [Protocol::HTTP::Request] The incoming HTTP request.
-		# @returns [Protocol::HTTP::Response] The delegate response.
-		def handle(request)
-			return delegate.call(request)
-		end
-		
 		# Add application routes to the given router.
 		# Override this method to map paths to views or other handlers.
-		# @parameter router [Router] The router to configure.
+		# @parameter router [Router::Builder] The router to configure.
 		def configure_routes(router)
-			router.get("/") do |request|
-				self.render_view(request, self.allowed_views.first)
+			router.get("/") do
+				view_class = self.allowed_views.first
+				body = self.resolver.root(view_class) if view_class
+				Pages::Index.new(title: self.title, body: body).call
 			end
 		end
 		
-		# The router for this application. Unmatched requests are handled separately
-		# by {#handle}.
+		# The router for this application. Unmatched requests are passed to the
+		# application delegate.
 		# @returns [Router] The configured router.
 		def router
-			@router ||= Router.new.tap do |router|
+			@router ||= Router.build(delegate) do |router|
 				configure_system_routes(router)
 				configure_routes(router)
 			end
@@ -142,13 +103,13 @@ module Lively
 		# @parameter request [Protocol::HTTP::Request] The incoming HTTP request.
 		# @returns [Protocol::HTTP::Response] The appropriate response for the request.
 		def call(request)
-			return router.call(request) || handle(request)
+			return router.call(request)
 		end
 		
 		private
 		
 		# Add framework-owned routes to the given router.
-		# @parameter router [Router] The router to configure.
+		# @parameter router [Router::Builder] The router to configure.
 		def configure_system_routes(router)
 			router.route("/live") do |request|
 				Async::WebSocket::Adapters::HTTP.open(request, &self.method(:live)) || Protocol::HTTP::Response[400]

data/lib/lively/hello_world.rb

@@ -64,11 +64,7 @@ module Lively
 				builder.text(<<~TEXT)
 					#!/usr/bin/env lively
 					
-					class Application < Lively::Application
-						def body
-							Lively::HelloWorld.new
-						end
-					end
+					Application = Lively::Application[Lively::HelloWorld]
 				TEXT
 			end
 			

data/lib/lively/page.rb

@@ -12,15 +12,15 @@ require "xrb/template"
 module Lively
 	# Represents a complete HTML document.
 	#
-	# A page combines application content with the stylesheets, import map,
-	# JavaScript modules, and body attributes required to present it. Applications
-	# can use this class directly or subclass it to provide shared defaults.
+	# A page combines a renderable body with the stylesheets, import map,
+	# JavaScript modules, and body attributes required to present it.
+	# Pages render complete HTTP responses after a route has selected their content.
 	class Page
 		TEMPLATE = XRB::Template.load_file(File.expand_path("page.xrb", __dir__))
 		
 		# Initialize a new page.
 		# @parameter title [String] The document title.
-		# @parameter body [Object | Nil] The document body. The result of `to_html` is interpolated into the template.
+		# @parameter body [Object | Nil] The renderable document body.
 		# @parameter icon [String | Nil] The favicon URL.
 		# @parameter stylesheets [Array(String | Hash)] Stylesheets in document order. Hash entries specify link attributes.
 		# @parameter imports [Hash] JavaScript import map entries.
@@ -40,7 +40,7 @@ module Lively
 		# @attribute [String] The document title.
 		attr :title
 		
-		# @attribute [Object | Nil] The document body.
+		# @attribute [Object | Nil] The renderable document body.
 		attr :body
 		
 		# @attribute [String | Nil] The favicon URL.
@@ -80,12 +80,6 @@ module Lively
 			XRB::Tag.closed("link", {rel: "stylesheet", type: "text/css"}.merge(attributes))
 		end
 		
-		# The rendered body content.
-		# @returns [Object]
-		def body_content
-			@body&.to_html || "No body specified!"
-		end
-		
 		# The serialized JavaScript import map.
 		# @returns [XRB::MarkupString]
 		def import_map
@@ -102,9 +96,8 @@ module Lively
 		end
 		
 		# Render this page as an HTTP response.
-		# @parameter request [Protocol::HTTP::Request] The incoming request.
 		# @returns [Protocol::HTTP::Response] A successful HTML response.
-		def call(request)
+		def call
 			Protocol::HTTP::Response[200, {"content-type" => "text/html; charset=utf-8"}, [to_html]]
 		end
 	end

data/lib/lively/page.xrb

@@ -25,6 +25,6 @@
 	</head>
 	
 	#{self.body_tag}
-		#{self.body_content}
+		#{self.body&.to_html}
 	</body>
 </html>

data/lib/lively/pages/index.rb

@@ -29,7 +29,7 @@ module Lively
 			
 			# Initialize a new index page.
 			# @parameter title [String] The title of the page.
-			# @parameter body [Object] The body content of the page.
+			# @parameter body [Object | Nil] The renderable document body.
 			def initialize(title: "Lively", body: nil)
 				super(
 					title: title,
@@ -37,7 +37,7 @@ module Lively
 					icon: ICON,
 					stylesheets: STYLESHEETS,
 					imports: IMPORTS,
-					modules: MODULES,
+					modules: MODULES
 				)
 			end
 		end

data/lib/lively/resolver.rb

@@ -21,14 +21,11 @@ module Lively
 		# @attribute [Hash] The shared state passed to view constructors.
 		attr :state
 		
-		# Resolve a client-side element to a server-side instance with shared state.
-		# @parameter id [String] The unique element identifier.
-		# @parameter data [Hash] The element data attributes.
-		# @returns [Live::Element | Nil] The resolved element, or `nil`.
-		def call(id, data)
-			if klass = @allowed[data[:class]]
-				return klass.new(id, data, **@state)
-			end
+		private
+		
+		# Construct a view with shared application state.
+		def make(view_class, id, data, **options)
+			super(view_class, id, data, **@state, **options)
 		end
 	end
 end

data/lib/lively/router.rb

@@ -3,136 +3,155 @@
 # Released under the MIT License.
 # Copyright, 2026, by Samuel Williams.
 
-require "protocol/http"
+require "protocol/http/middleware"
 require "protocol/url"
 
 module Lively
 	# Dispatches HTTP requests to handlers using exact path and method matches.
 	#
 	# Request targets are parsed with {Protocol::URL::Reference}. Handlers receive
-	# the original request and the decoded query parameters.
-	class Router
-		EMPTY_PARAMETERS = {}.freeze
+	# the original request.
+	class Router < Protocol::HTTP::Middleware
 		ANY_METHOD = nil
-		private_constant :EMPTY_PARAMETERS, :ANY_METHOD
+		private_constant :ANY_METHOD
 		
-		# Initialize a router.
-		# @yields {|router| ...} The router to configure.
-		def initialize
-			@routes = {}
+		# Builds an immutable route table.
+		class Builder
+			# Initialize a route builder.
+			def initialize
+				@routes = {}
+			end
 			
-			yield self if block_given?
-		end
-		
-		# Add a route.
-		#
-		# When `methods` is omitted, the handler accepts every HTTP method. Otherwise,
-		# it may be a single method or an array of methods.
-		#
-		# @parameter path [String] The absolute path to match.
-		# @parameter methods [String | Symbol | Array(String | Symbol) | Nil] The accepted HTTP methods.
-		# @yields {|request, parameters| ...} The route handler.
-		# 	@parameter request [Protocol::HTTP::Request] The original request.
-		# 	@parameter parameters [Hash] The decoded query parameters.
-		# @returns [Router] The router.
-		def route(path, methods: nil, &handler)
-			raise ArgumentError, "A route handler is required!" unless handler
+			# A frozen snapshot of the configured routes.
+			# @returns [Hash] The route table.
+			def routes
+				@routes.transform_values do |handlers|
+					handlers.dup.freeze
+				end.freeze
+			end
+			
+			# Add a route.
+			#
+			# When `methods` is omitted, the handler accepts every HTTP method. Otherwise,
+			# it may be a single method or an array of methods.
+			#
+			# @parameter path [String] The absolute path to match.
+			# @parameter handler [Interface(:call) | Nil] A callable route handler.
+			# @parameter methods [String | Symbol | Array(String | Symbol) | Nil] The accepted HTTP methods.
+			# @yields {|request| ...} The route handler.
+			# 	@parameter request [Protocol::HTTP::Request] The original request.
+			# @returns [Builder] The builder.
+			def route(path, handler = nil, methods: nil, &block)
+				raise ArgumentError, "Provide a route handler or block, not both!" if handler && block
+				handler ||= block
+				raise ArgumentError, "A route handler is required!" unless handler
+				
+				path = route_path(path)
+				methods = route_methods(methods)
+				handlers = (@routes[path] ||= {})
+				
+				methods.each do |method|
+					if handlers.key?(method)
+						raise ArgumentError, "Route already defined for #{method || "any method"} #{path}!"
+					end
+					
+					handlers[method] = handler
+				end
+				
+				return self
+			end
 			
-			path = route_path(path)
-			methods = route_methods(methods)
-			handlers = (@routes[path] ||= {})
+			Protocol::HTTP::Methods.each do |name, method|
+				# Add a route for this HTTP method.
+				# @parameter path [String] The absolute path to match.
+				# @yields {|request| ...} The route handler.
+				# @returns [Builder] The builder.
+				define_method(name) do |path, handler = nil, &block|
+					route(path, handler, methods: method, &block)
+				end
+			end
+			
+			private
 			
-			methods.each do |method|
-				if handlers.key?(method)
-					raise ArgumentError, "Route already defined for #{method || "any method"} #{path}!"
+			def route_path(path)
+				url = Protocol::URL[path]
+				
+				unless url && !url.is_a?(Protocol::URL::Absolute)
+					raise ArgumentError, "Route must be an absolute path: #{path.inspect}!"
+				end
+				
+				reference = Protocol::URL::Reference[url]
+				
+				unless reference.path.absolute?
+					raise ArgumentError, "Route must be an absolute path: #{path.inspect}!"
+				end
+				
+				if reference.query? || reference.fragment?
+					raise ArgumentError, "Route path cannot include a query or fragment: #{path.inspect}!"
 				end
 				
-				handlers[method] = handler
+				return reference.path.freeze
 			end
 			
-			return self
+			def route_methods(methods)
+				return [ANY_METHOD] unless methods
+				
+				methods = Array(methods)
+				raise ArgumentError, "At least one HTTP method is required!" if methods.empty?
+				
+				return methods.map do |method|
+					raise ArgumentError, "HTTP method cannot be nil!" unless method
+					
+					method.to_s.upcase
+				end.uniq
+			end
 		end
 		
-		Protocol::HTTP::Methods.each do |name, method|
-			# Add a route for this HTTP method.
-			# @parameter path [String] The absolute path to match.
-			# @yields {|request, parameters| ...} The route handler.
-			# @returns [Router] The router.
-			define_method(name) do |path, &handler|
-				route(path, methods: method, &handler)
-			end
+		# Build and configure a frozen router.
+		# @parameter delegate [Protocol::HTTP::Middleware] The middleware for unmatched requests.
+		# @yields {|builder| ...} Configures the routes.
+		# 	@parameter builder [Builder] The route builder.
+		# @returns [Router] The configured router.
+		def self.build(delegate = Protocol::HTTP::Middleware::NotFound)
+			builder = Builder.new
+			yield builder
+			
+			return new(delegate, builder.routes).freeze
+		end
+		
+		# Initialize a router.
+		# @parameter delegate [Protocol::HTTP::Middleware] The middleware for unmatched requests.
+		# @parameter routes [Hash] The frozen route table.
+		def initialize(delegate, routes)
+			super(delegate)
+			@routes = routes
 		end
 		
 		# Dispatch a request to a matching route.
 		# @parameter request [Protocol::HTTP::Request] The request to dispatch.
-		# @returns [Protocol::HTTP::Response | Nil] The handler or error response, or `nil` when no path matches.
+		# @returns [Protocol::HTTP::Response] The handler, error, or delegate response.
 		def call(request)
 			reference = parse_reference(request.path)
 			return Protocol::HTTP::Response[400] unless reference
 			
-			unless handlers = @routes[reference.path]
-				return nil
-			end
+			return super unless handlers = @routes[reference.path]
 			
 			unless handler = handlers[request.method] || handlers[ANY_METHOD]
 				allowed_methods = handlers.keys.compact.sort.join(", ")
 				return Protocol::HTTP::Response[405, [["allow", allowed_methods]]]
 			end
 			
-			parameters = parse_query(reference)
-			return Protocol::HTTP::Response[400] unless parameters
-			
-			return handler.call(request, parameters)
+			return handler.call(request)
 		end
 		
 		private
 		
-		def route_path(path)
-			url = Protocol::URL[path]
-			
-			unless url && !url.is_a?(Protocol::URL::Absolute)
-				raise ArgumentError, "Route must be an absolute path: #{path.inspect}!"
-			end
-			
-			reference = Protocol::URL::Reference[url]
-			
-			unless reference.path.absolute?
-				raise ArgumentError, "Route must be an absolute path: #{path.inspect}!"
-			end
-			
-			if reference.query? || reference.fragment?
-				raise ArgumentError, "Route path cannot include a query or fragment: #{path.inspect}!"
-			end
-			
-			return reference.path.freeze
-		end
-		
-		def route_methods(methods)
-			return [ANY_METHOD] unless methods
-			
-			methods = Array(methods)
-			raise ArgumentError, "At least one HTTP method is required!" if methods.empty?
-			
-			return methods.map do |method|
-				raise ArgumentError, "HTTP method cannot be nil!" unless method
-				
-				method.to_s.upcase
-			end.uniq
-		end
-		
 		def parse_reference(path)
 			reference = Protocol::URL::Reference[path]
 			return if reference&.fragment?
 			
 			return reference
-		rescue ArgumentError
-			nil
 		end
 		
-		def parse_query(reference)
-			reference.parse_query! || EMPTY_PARAMETERS
-		rescue ArgumentError
-			nil
-		end
 	end
 end

data/lib/lively/version.rb

@@ -5,5 +5,5 @@
 
 # @namespace
 module Lively
-	VERSION = "0.21.0"
+	VERSION = "0.23.0"
 end

data/public/_components/@socketry/live/Live.js

@@ -297,8 +297,10 @@ export class Live {
 	forwardFormEvent(id, event, detail, preventDefault = true) {
 		if (preventDefault) event.preventDefault();
 		
-		let form = event.form;
-		let formData = new FormData(form);
+		let form = event.target;
+		let formData = event.submitter ?
+			new this.#window.FormData(form, event.submitter) :
+			new this.#window.FormData(form);
 		
 		this.forward(id, {type: event.type, detail: detail, formData: [...formData]});
 	}

data/public/_components/@socketry/live/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@socketry/live",
   "type": "module",
-  "version": "0.16.2",
+  "version": "0.17.0",
   "description": "Live HTML tags for Ruby.",
   "main": "Live.js",
   "exports": {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lively
 version: !ruby/object:Gem::Version
-  version: 0.21.0
+  version: 0.23.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -114,28 +114,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.18'
+        version: '0.19'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.18'
+        version: '0.19'
 - !ruby/object:Gem::Dependency
   name: protocol-url
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.18'
+        version: '0.19'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.18'
+        version: '0.19'
 - !ruby/object:Gem::Dependency
   name: xrb
   requirement: !ruby/object:Gem::Requirement