lilac-router 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7a6abd5e56ff36094f0bb8069844b33877b2e3dd58ef62739a247a66733e2fe7
+  data.tar.gz: af8c214eaafea581124411ebe3fbd395e52eddad3c6be657200ba8e0ad364e07
+SHA512:
+  metadata.gz: 69df2c585a1ffebd1444faa6727cd7d452b0d0d752d84ee3db16536c5e08270a41543b2b7c2b6c4fe219c0a1bed5d379e394372e8b62dc41280324beb014aac6
+  data.tar.gz: c24df74f2d0721903f9942219c88b4476a38379dfa7b412538f3dd59f69421ebf95082c056ff1a36672e5cf01660d0f883c3127491effd2ee64153328f68de8c

data/lilac-router.gemspec

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |spec|
+  spec.name = "lilac-router"
+  spec.version = "0.2.0"
+  spec.authors = ["takahashim"]
+
+  spec.summary = "Lilac package: signal-based URL routing (`Lilac::Router`)"
+  spec.description = "Provides `Lilac::Router`, a signal-backed driver for " \
+                     "SPA-style navigation against `window.location`. " \
+                     "Designed for the lilac-compiled wasm variant; " \
+                     "lilac-full already links the router gem in. Picked up " \
+                     "automatically by `lilac build` via Bundler when the " \
+                     "gem appears in the project's Gemfile."
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2.0"
+
+  # See lilac-extras.gemspec for the mrblib source distribution rationale.
+  spec.files = Dir["mrblib/**/*.rb", "*.gemspec"]
+
+  spec.metadata = {
+    "lilac_package"         => "true",
+    "source_code_uri"       => "https://github.com/takahashim/lilac",
+    "rubygems_mfa_required" => "true",
+  }
+end

data/mrblib/lilac_router.rb

@@ -0,0 +1,683 @@
+# Lilac Router — signal-based URL routing for `mruby-lilac`.
+#
+# 2-layer API:
+#
+#   * Low-level: `router.location` (Signal), `path`/`query`/`hash` (sugar),
+#     `match(pattern)` (Computed), `navigate(path, replace:)`,
+#     `intercept_link(event)`. SPA-style URL state as a reactive signal.
+#
+#   * High-level DSL: `router.draw outlet:` block + `page :name, "/path",
+#     template:` declarations. Generates `*_path` /  `*_match` helpers via
+#     `define_singleton_method`, plus `params` / `current` computeds. Active
+#     route's `<template id="...">` is cloned into the outlet on every
+#     location change (lazy mount via existing
+#     MutationObserver-driven component lifecycle).
+#
+# This gem is opt-in: `mruby-lilac` core does not depend on it. MPA
+# constructions (each route is its own HTML file) should not load this
+# gem at all — Router is for SPA navigation only.
+module Lilac
+  module Router
+    # Bookkeeper for `*_path` / `*_match` singleton methods generated by
+    # the `page` DSL. Encapsulates the lifecycle (define, remember,
+    # remove) so Router proper can stay focused on URL state.
+    class GeneratedRouteMethods
+      def initialize(target)
+        @target = target
+        @names = []
+      end
+
+      def define_path(name, compiled)
+        required = compiled[:params]
+        segs = compiled[:segs]
+        method_name = "#{name}_path"
+        @target.define_singleton_method(method_name) do |**params|
+          missing = required - params.keys
+          raise ArgumentError, "missing keys: #{missing.inspect}" unless missing.empty?
+          extra = params.keys - required
+          raise ArgumentError, "unknown keys: #{extra.inspect}" unless extra.empty?
+          segs.map { |seg|
+            seg.start_with?(":") ? encode(params[seg[1..].to_sym]) : seg
+          }.join("/")
+        end
+        remember(method_name)
+      end
+
+      def define_match(name, compiled)
+        sym = name.to_sym
+        method_name = "#{name}_match"
+        @target.define_singleton_method(method_name) do
+          ensure_signal!
+          @named_match_computeds[sym] ||= begin
+            loc = @location_signal
+            Lilac::Computed.new { match_path(compiled, loc.value[:path]) }
+          end
+        end
+        remember(method_name)
+      end
+
+      # Remove every helper this bookkeeper has installed. Idempotent.
+      def clear_all
+        eigen = (class << @target; self; end)
+        @names.each do |meth|
+          begin
+            eigen.__send__(:remove_method, meth)
+          rescue NameError
+            # Already absent; tolerated for re-entrant draw / reset.
+          end
+        end
+        @names.clear
+      end
+
+      private
+
+      def remember(method_name)
+        sym = method_name.to_sym
+        @names << sym unless @names.include?(sym)
+      end
+    end
+
+    # Stateful router object. `Lilac::Router` exposes the default context as
+    # a compatibility facade, while components receive a context-shaped `router`
+    # object that can later be replaced through provider injection.
+    class Context
+      def initialize
+        @started = false
+        @routes = []
+        @fallback_template = nil
+        @outlet_selector = nil
+        @mode = :hash
+        @base = "/"
+        @location_signal = nil
+        @match_computed_cache = {}
+        @named_match_computeds = {}
+        @params_computed = nil
+        @current_computed = nil
+        @route_methods = GeneratedRouteMethods.new(self)
+        @hashchange_cb = nil
+        @popstate_cb = nil
+        @render_effect = nil
+        @rendering = false
+      end
+
+      # ---------- Bootstrap ----------
+
+      # Install listeners and seed the location signal. Idempotent: a
+      # second call after the first start is a no-op. Safe to call
+      # *after* components that already accessed `path` / `match` / etc.
+      # — those triggered `ensure_signal!` lazily, and we reuse the same
+      # signal here so their subscriptions stay connected.
+      def start(mode: nil, base: nil)
+        return if @started
+        @mode = mode if mode
+        @base = base if base
+        ensure_signal!
+        # Force-refresh the signal so subscribers (computeds that read
+        # `current` / `params` before draw) re-evaluate now that the
+        # route table is populated. Hash-valued signals always notify
+        # via `value=` (no equal_for_skip? short-circuit on Hash), so
+        # this is unconditional.
+        @location_signal.value = read_location
+        install_listeners
+        # Lazy-mount render effect, only if a draw with outlet has been
+        # configured. Subscribes to @location_signal and re-clones the
+        # active template on change.
+        @render_effect = Lilac::Effect.new(label: "router-render") { render_active_route } if @outlet_selector
+        @started = true
+        nil
+      end
+
+      # ---------- DSL ----------
+
+      # Declare routes. Required for lazy-mount usage; not needed for
+      # low-level only (just call `start`). `outlet:` is a CSS selector
+      # passed to `document.querySelector` for the single mount target.
+      def draw(outlet:, &block)
+        raise ArgumentError, "block required" unless block
+        @outlet_selector = outlet
+        @route_methods.clear_all
+        @routes.clear
+        @fallback_template = nil
+        @named_match_computeds.clear
+        instance_eval(&block)
+        # If start has already run (test re-init flow), set up the render
+        # effect now that we have an outlet.
+        if @started && @render_effect.nil?
+          @render_effect = Lilac::Effect.new(label: "router-render") { render_active_route }
+        elsif @started
+          render_active_route
+        end
+        nil
+      end
+
+      # Declare a named route. `template:` defaults to "page-#{name}"
+      # (convention). Auto-generates `Lilac::Router.{name}_path` and
+      # `Lilac::Router.{name}_match` via `define_singleton_method`
+      # (requires mruby-metaprog in the build config). Method lifecycle
+      # is owned by `@route_methods` (see `GeneratedRouteMethods`).
+      def page(name, pattern, template: nil)
+        compiled = compile(pattern)
+        template_id = template || "page-#{name}"
+        @routes << { name: name.to_sym, pattern: pattern, compiled: compiled, template: template_id }
+        @route_methods.define_path(name, compiled)
+        @route_methods.define_match(name, compiled)
+      end
+
+      # Last-resort route shown when no `page` matches. Takes only a
+      # template (no path, no helpers).
+      def fallback(template:)
+        @fallback_template = template
+      end
+
+      # ---------- Reactive accessors ----------
+
+      def location
+        ensure_signal!
+        @location_signal
+      end
+
+      def path
+        ensure_signal!
+        @location_signal.value[:path]
+      end
+
+      def query
+        ensure_signal!
+        @location_signal.value[:query]
+      end
+
+      def hash
+        ensure_signal!
+        @location_signal.value[:hash]
+      end
+
+      # Match computed for an arbitrary pattern. Cached per pattern string so
+      # two components matching the same pattern share one computed (avoids
+      # graph blowup on hot paths).
+      def match(pattern)
+        ensure_signal!
+        @match_computed_cache[pattern] ||= begin
+          compiled = compile(pattern)
+          loc = @location_signal
+          Lilac::Computed.new { match_path(compiled, loc.value[:path]) }
+        end
+      end
+
+      # Hash of params for the currently-active named route, or `{}` if
+      # no route matches. Only meaningful with the DSL.
+      #
+      # Accessing `params` inside a reactive scope (computed / effect / bind)
+      # registers a dependency on the location signal automatically (via
+      # the internal `@location_signal.value` read), so `params[:id]`
+      # in a `computed { ... }` will re-evaluate on URL change.
+      def params
+        ensure_signal!
+        current_route_params
+      end
+
+      # Active route name (`:home` / `:user` / `:fallback` / nil). Only
+      # meaningful with the DSL. Auto-tracks location like `params`.
+      def current
+        ensure_signal!
+        current_route_name
+      end
+
+      # ---------- Link helpers ----------
+
+      # Convert an app-route path into an actual href suitable for `<a>`.
+      # In hash mode this returns "#/path"; in history mode it includes
+      # `base:` as a pathname prefix.
+      def href(path)
+        raw = path.to_s
+        return raw if external_url?(raw)
+
+        build_navigate_url(resolve(raw))
+      end
+
+      # Resolve a relative path against the current route path.
+      # Uses the browser URL implementation instead of hand-rolling URL
+      # dot-segment / query / fragment behavior.
+      def resolve(path, from: nil)
+        ensure_signal!
+        raw = path.to_s
+        return raw if external_url?(raw)
+
+        origin = JS.global[:location][:origin].to_s
+        base_path = from || @location_signal.value[:path]
+        base_url = "#{origin}#{base_path}"
+        url = JS.global[:URL].new(raw, base_url)
+        "#{url[:pathname]}#{url[:search]}#{url[:hash]}"
+      rescue StandardError
+        raw.start_with?("/") ? raw : "/#{raw}"
+      end
+
+      # True when the current route matches `target`.
+      #
+      # `target` may be:
+      # - Symbol route name (`:home`)
+      # - Array of route names (`[:users, :user]`)
+      # - Path string (`"/users"`), with descendant matching by default
+      def active?(target, exact: false)
+        ensure_signal!
+        case target
+        when Array
+          target.include?(current_route_name)
+        when Symbol
+          current_route_name == target
+        else
+          target_path = route_path_only(resolve(target))
+          current_path = route_path_only(@location_signal.value[:path])
+          return current_path == target_path if exact || target_path == "/"
+
+          prefix = target_path.end_with?("/") ? target_path : "#{target_path}/"
+          current_path == target_path || current_path.start_with?(prefix)
+        end
+      end
+
+      # Bind one anchor as a router-aware link: writes `href` and toggles
+      # an active CSS class reactively.
+      #
+      # Args:
+      #   el                — RefElement (preferred) or raw JS element
+      #   href:             — String / Symbol / Signal / Computed / Proc → route path
+      #   match:            — what makes the link "active" (Symbol route name,
+      #                       Array of names, or path string with prefix matching).
+      #                       When omitted, falls back to `href`'s path
+      #                       (descendant matches highlight too — `/users` is
+      #                       active at `/users/42`).
+      #   active_class:     — CSS class to toggle on match (default `"active"`)
+      #   inactive_class:   — CSS class to toggle on miss (default nil)
+      #   exact:            — disable prefix matching for path-string `match`
+      #   owner_component:     — Component that owns the lifetime of the binding.
+      #                       Internal: the ComponentMixin passes itself so the
+      #                       effect is auto-disposed on unmount. When nil,
+      #                       a free-standing Effect lives until VM teardown.
+      #
+      # Returns nil. Effect lifecycle:
+      # - `component.bind_link(...)` (mixin form) → tracked on component, auto-cleanup
+      # - `router.bind_link(raw_el, ...)` → leaks until VM exits
+      def bind_link(el, href:, match: nil, active_class: "active", inactive_class: nil, exact: false, owner_component: nil)
+        runner = proc do
+          route = source_value(href)
+          set_anchor_href(el, self.href(route))
+          active_target = match.nil? ? route : source_value(match)
+          is_active = active?(active_target, exact: exact)
+          toggle_anchor_class(el, active_class, is_active) if active_class
+          toggle_anchor_class(el, inactive_class, !is_active) if inactive_class
+        end
+
+        if owner_component
+          owner_component.effect(label: "router-link") { runner.call }
+        else
+          Lilac::Effect.new(label: "router-link") { runner.call }
+        end
+        nil
+      end
+
+      # ---------- Mutation ----------
+
+      def navigate(path, replace: false)
+        ensure_signal!
+        new_url = build_navigate_url(path)
+        history = JS.global[:history]
+        method = replace ? :replaceState : :pushState
+        # 1st arg: state; 2nd: title (deprecated, "" is conventional);
+        # 3rd: URL. We pass the existing state through to keep popstate
+        # restoration consistent.
+        history.call(method, history[:state], "", new_url)
+        # pushState/replaceState don't fire popstate, so refresh the
+        # location signal manually.
+        update_location
+        nil
+      end
+
+      # `<a>` click → SPA navigate. Skips modifier-key clicks, middle/right
+      # mouse, target=_blank, and external origins so the user retains
+      # browser-default behaviour for those cases.
+      def intercept_link(event)
+        return if event[:metaKey].js_bool || event[:ctrlKey].js_bool ||
+                  event[:shiftKey].js_bool || event[:altKey].js_bool
+        return if event[:button].to_i != 0
+
+        target = event[:target].call(:closest, "a[href]")
+        return if target.js_null?
+
+        target_attr = target.call(:getAttribute, "target")
+        return if !target_attr.js_null? && target_attr.to_s == "_blank"
+
+        href = target[:href].to_s
+        route_path = route_path_from_href(href)
+        return unless route_path
+
+        event.call(:preventDefault)
+        navigate(route_path)
+      end
+
+      # ---------- Internal: testing / lifecycle ----------
+
+      # For tests: forget every piece of router state and reinstall. Not
+      # part of the public API.
+      def __reset_for_tests__
+        @started = false
+        @routes = []
+        @fallback_template = nil
+        @outlet_selector = nil
+        @match_computed_cache.clear
+        @named_match_computeds.clear
+        @params_computed = nil
+        @current_computed = nil
+        @route_methods.clear_all
+        @mode = :hash
+        @base = "/"
+        @location_signal = nil
+        @render_effect&.dispose
+        @render_effect = nil
+        # Listeners stay registered (one per VM lifetime); they no-op
+        # against a nil signal. Re-installing is conditional in
+        # install_listeners.
+        nil
+      end
+
+      private
+
+      # ---------- Path compilation ----------
+
+      def compile(pattern)
+        segs = pattern.split("/", -1)
+        params = []
+        segs.each_with_index do |seg, i|
+          params << seg[1..].to_sym if seg.start_with?(":")
+        end
+        { pattern: pattern, segs: segs, params: params }
+      end
+
+      def match_path(compiled, path)
+        segs = path.split("/", -1)
+        return nil unless segs.length == compiled[:segs].length
+        out = {}
+        compiled[:segs].each_with_index do |seg, i|
+          if seg.start_with?(":")
+            out[seg[1..].to_sym] = decode(segs[i])
+          elsif seg != segs[i]
+            return nil
+          end
+        end
+        out
+      end
+
+      # ---------- Listeners ----------
+
+      def install_listeners
+        win = JS.global[:window]
+        if @hashchange_cb.nil?
+          @hashchange_cb = JS.callback { |_e| update_location }
+          win.call(:addEventListener, "hashchange", @hashchange_cb)
+        end
+        if @popstate_cb.nil?
+          @popstate_cb = JS.callback { |_e| update_location }
+          win.call(:addEventListener, "popstate", @popstate_cb)
+        end
+      end
+
+      def update_location
+        return if @location_signal.nil?
+        @location_signal.value = read_location
+      end
+
+      # ---------- URL parsing ----------
+
+      def read_location
+        loc = JS.global[:location]
+        if @mode == :hash
+          hash_str = loc[:hash].to_s
+          # hash starts with "#" (or empty); the part after "#" is our path+query
+          raw = hash_str.start_with?("#") ? hash_str[1..] : hash_str
+          raw = strip_base(raw)
+          raw = "/" if raw.empty?
+          path_part, query_str = split_query(raw)
+          { path: path_part, query: parse_query(query_str), hash: "" }
+        else
+          path_part = loc[:pathname].to_s
+          path_part = strip_base(path_part)
+          path_part = "/" if path_part.empty?
+          search = loc[:search].to_s
+          search = search[1..] if search.start_with?("?")
+          h = loc[:hash].to_s
+          h = h[1..] if h.start_with?("#")
+          { path: path_part, query: parse_query(search), hash: h.to_s }
+        end
+      end
+
+      def strip_base(path)
+        return path if @base == "/" || @base.empty?
+        prefix = @base.chomp("/")
+        if path == prefix
+          return "/"
+        elsif path.start_with?("#{prefix}/")
+          rest = path[prefix.length..]
+          return "/" if rest.nil? || rest.empty?
+          return rest
+        end
+        path
+      end
+
+      def split_query(s)
+        if s.include?("?")
+          s.split("?", 2)
+        else
+          [s, ""]
+        end
+      end
+
+      def parse_query(s)
+        return {} if s.nil? || s.empty?
+        out = {}
+        s.split("&").each do |pair|
+          next if pair.empty?
+          k, v = pair.split("=", 2)
+          out[decode(k)] = decode(v || "")
+        end
+        out
+      end
+
+      def decode(s)
+        JS.decode_uri_component(s)
+      rescue StandardError
+        s.to_s
+      end
+
+      def encode(s)
+        JS.encode_uri_component(s)
+      rescue StandardError
+        s.to_s
+      end
+
+      def build_navigate_url(path)
+        prefix = @base == "/" ? "" : @base.chomp("/")
+        if @mode == :hash
+          "##{prefix}#{path}"
+        else
+          "#{prefix}#{path}"
+        end
+      end
+
+      def external_url?(s)
+        s.include?("://") || s.start_with?("//")
+      end
+
+      def route_path_only(s)
+        path_part, _query = split_query(s.to_s)
+        if path_part.include?("#")
+          path_part.split("#", 2)[0]
+        else
+          path_part
+        end
+      end
+
+      def source_value(source)
+        if source.is_a?(Lilac::Signal) || source.is_a?(Lilac::Computed)
+          source.value
+        elsif source.is_a?(Proc)
+          source.call
+        else
+          source
+        end
+      end
+
+      def set_anchor_href(el, value)
+        if ref_element?(el)
+          el.attr("href", value)
+        else
+          el.call(:setAttribute, "href", value.to_s)
+        end
+      end
+
+      def toggle_anchor_class(el, class_name, enabled)
+        if ref_element?(el)
+          el.toggle_class(class_name, enabled)
+        else
+          el[:classList].call(:toggle, class_name.to_s, !!enabled)
+        end
+      end
+
+      def ref_element?(el)
+        el.class == Lilac::RefElement
+      rescue StandardError
+        false
+      end
+
+      def route_path_from_href(href)
+        origin = JS.global[:location][:origin].to_s
+        url = JS.global[:URL].new(href.to_s, origin)
+        return nil unless url[:origin].to_s == origin
+
+        if @mode == :hash
+          hash_str = url[:hash].to_s
+          return nil if !hash_str.empty? && !hash_str.start_with?("#/")
+
+          if hash_str.start_with?("#/")
+            raw = strip_base(hash_str[1..])
+            raw = "/" if raw.empty?
+            return raw
+          end
+        end
+
+        path_part = strip_base(url[:pathname].to_s)
+        path_part = "/" if path_part.empty?
+        "#{path_part}#{url[:search]}#{url[:hash]}"
+      rescue StandardError
+        nil
+      end
+
+      # ---------- Active route resolution ----------
+
+      def find_active_route
+        return nil if @location_signal.nil?
+        path = @location_signal.value[:path]
+        @routes.find { |r| match_path(r[:compiled], path) }
+      end
+
+      def current_route_name
+        active = find_active_route
+        return active[:name] if active
+        return :fallback if @fallback_template
+        nil
+      end
+
+      def current_route_params
+        active = find_active_route
+        return {} unless active
+        match_path(active[:compiled], @location_signal.value[:path]) || {}
+      end
+
+      # ---------- Render (lazy mount) ----------
+
+      def render_active_route
+        return unless @outlet_selector
+        return if @rendering # guard against re-entry during template clone
+        outlet = JS.global[:document].call(:querySelector, @outlet_selector)
+        return if outlet.js_null?
+
+        active = find_active_route
+        template_id = active ? active[:template] : @fallback_template
+
+        @rendering = true
+        begin
+          # Always clear: this triggers our MutationObserver to unmount
+          # any components mounted in the previous route, regardless of
+          # whether a new template will replace them.
+          outlet[:innerHTML] = ""
+          if template_id
+            mount_template_into_outlet(template_id, outlet)
+          end
+        ensure
+          @rendering = false
+        end
+      end
+
+      def mount_template_into_outlet(template_id, outlet)
+        template_el = JS.global[:document].call(:getElementById, template_id)
+        if template_el.js_null?
+          Lilac.logger.warn("router: template '#{template_id}' not found")
+          return
+        end
+        cloned = template_el[:content].call(:cloneNode, true)
+        outlet.call(:appendChild, cloned)
+      end
+
+      def ensure_signal!
+        return unless @location_signal.nil?
+        # Allow signal-only access before `start` is called by initialising
+        # with current URL. Listeners get registered on the first `start`.
+        @location_signal = Lilac::Signal.new(read_location)
+      end
+    end
+
+    class << self
+      def default_context
+        @default_context ||= Context.new
+      end
+
+      def new_context
+        Context.new
+      end
+
+      # Lifecycle shortcuts on the default context. Limited to the two
+      # "called once at boot" operations: `draw` declares the route
+      # table, `start` installs listeners + first render. Per-call
+      # operations (`path`, `navigate`, `params`, ...) are intentionally
+      # NOT exposed here — those should be reached via Component#router
+      # (auto-tracked through `lookup(:router)`) or
+      # `Lilac::Router.default_context` directly, so sub-contexts
+      # remain a clean override path.
+      def draw(outlet:, &block)
+        default_context.draw(outlet: outlet, &block)
+      end
+
+      def start(mode: nil, base: nil)
+        default_context.start(mode: mode, base: base)
+      end
+    end
+
+    # Mixed into `Lilac::Component` so users can write `bind_link refs.x,
+    # href: ..., match: ...` directly inside `setup`, alongside the other
+    # binding helpers (`bind`, `bind_list`, `bind_input`). Same pattern as the
+    # Form Builder's `Lilac::FormBuilder` mixin — keeps the Router gem
+    # opt-in: Component gains `bind_link` only when this gem is required.
+    module ComponentMixin
+      def router
+        lookup(:router) { Lilac::Router.default_context }
+      end
+
+      def bind_link(el, href:, match: nil, active_class: "active", inactive_class: nil, exact: false)
+        router.bind_link(
+          el,
+          href: href, match: match,
+          active_class: active_class, inactive_class: inactive_class,
+          exact: exact, owner_component: self)
+      end
+    end
+  end
+end
+
+Lilac::Component.include(Lilac::Router::ComponentMixin)

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: lilac-router
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- takahashim
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Provides `Lilac::Router`, a signal-backed driver for SPA-style navigation
+  against `window.location`. Designed for the lilac-compiled wasm variant; lilac-full
+  already links the router gem in. Picked up automatically by `lilac build` via Bundler
+  when the gem appears in the project's Gemfile.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lilac-router.gemspec
+- mrblib/lilac_router.rb
+licenses:
+- MIT
+metadata:
+  lilac_package: 'true'
+  source_code_uri: https://github.com/takahashim/lilac
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: 'Lilac package: signal-based URL routing (`Lilac::Router`)'
+test_files: []