funicular 0.0.1 → 0.2.0

data/sig/component.rbs

@@ -0,0 +1,149 @@
+module Funicular
+  class Component
+    class StateAccessor
+      def initialize: (Hash[Symbol, untyped] state_hash) -> void
+      def []: (Symbol key) -> untyped
+      def method_missing: (Symbol method, *untyped args) -> untyped
+      def respond_to_missing?: (Symbol method, ?bool include_private) -> bool
+      def errors: () -> Hash[Symbol, String]
+    end
+
+    HTML_TAGS: Array[String]
+
+    attr_accessor props: Hash[Symbol, untyped]
+    attr_accessor vdom: VDOM::VNode | VDOM::Text | nil
+    attr_accessor dom_element: JS::Element
+    attr_accessor mounted: bool
+    attr_reader refs: Hash[Symbol, JS::Element]
+    @event_listeners: Array[Integer]
+    @child_components: Array[Component]
+    @suspense_data: Hash[Symbol, untyped]
+    @suspense_states: Hash[Symbol, Symbol]
+    @suspense_errors: Hash[Symbol, untyped]
+    @suspense_pending_timers: Array[Integer]
+    self.@suspense_definitions: Hash[Symbol, suspense_definition]
+
+    def initialize: (?Hash[Symbol, untyped] props) -> void
+
+    # Styles DSL class methods
+    def self.styles: () { (StyleBuilder) -> void } -> void
+    def self.styles_definitions: () -> Hash[Symbol, Hash[Symbol, untyped]]
+
+    # Suspense DSL class methods
+    # Note: Using untyped for Proc types to avoid instance_exec block type mismatch warnings
+    type suspense_definition = { loader: untyped, on_resolve: untyped, min_delay: Integer? }
+    def self.use_suspense: (Symbol name, untyped loader, ?on_resolve: untyped, ?min_delay: Integer) -> void
+    def self.suspense_definitions: () -> Hash[Symbol, suspense_definition]
+
+    def state: () -> StateAccessor
+
+    # Styles DSL instance method
+    def s: () -> StyleAccessor
+
+    # Public API
+    def initialize_state: () -> Hash[Symbol, untyped]
+
+    # Suspense instance methods
+    def load_suspense_data: () -> void
+    def load_single_suspense: (Symbol name, ?suspense_definition? definition) -> void
+    def reload_suspense: (Symbol name) -> void
+    def suspense_loading?: (*Symbol names) -> bool
+    def suspense_error?: (Symbol name) -> bool
+    def suspense_error: (Symbol name) -> untyped
+    def suspense: (fallback: ^() -> void, ?error: ^(untyped) -> void) { () -> void } -> void
+
+    def patch: (Hash[Symbol, untyped] new_state) -> void
+    def mount: (JS::Element container) -> void
+    def hydrate: (JS::Element dom_element) -> void
+    def seed_state: (Hash[untyped, untyped]? state_hash) -> self
+    def unmount: () -> void
+    def render: () -> (VDOM::VNode | String | Integer | Float | Array[untyped] | nil)
+    def bind_events: (JS::Element dom_element, VDOM::VNode | VDOM::Text | nil vnode) -> void
+    def build_vdom: () -> (VDOM::VNode | VDOM::Text | nil)
+
+    # Lifecycle hooks (public, can be overridden in subclasses)
+    def component_will_mount: () -> void
+    def component_mounted: () -> void
+    def component_will_update: () -> void
+    def component_updated: () -> void
+    def component_will_unmount: () -> void
+    def component_unmounted: () -> void
+    def component_raised: (Exception e) -> void
+
+    # Child component helper
+    def component: (Class component_class, ?Hash[Symbol, untyped] props) ?{ () -> untyped } -> VDOM::Component
+
+    # Rails-style form helper
+    def form_for: (Symbol model_key, ?Hash[Symbol, untyped] options) { (FormBuilder) -> void } -> VDOM::Element
+
+    # Rails-style routing helpers
+    def link_to: (String path, ?method: Symbol, ?navigate: bool, **untyped options) { -> untyped } -> VDOM::Element
+    def method_missing: (Symbol method, *untyped args) -> untyped
+    def respond_to_missing?: (Symbol method, ?bool include_private) -> bool
+
+    # Transition helpers
+    def remove_via: (String element_id, String from, String to, ?duration: Integer) ?{ () -> void } -> void
+    def add_via: (String element_id, String from, String to, ?duration: Integer) ?{ () -> void } -> void
+
+    # Private methods
+    private def handle_link_click: (String path) -> void
+    private def handle_link_with_method: (String path, Symbol method) -> void
+    private def handle_link_response: (HTTP::Response response, String path, Symbol method) -> void
+    private def normalize_state_value: (untyped value) -> untyped
+    private def re_render: () -> void
+    private def normalize_vnode: (untyped value) -> (VDOM::Element | VDOM::Text | VDOM::Component | nil)
+    private def add_data_component_attribute: (VDOM::VNode vnode) -> void
+    private def collect_refs: (JS::Element dom_element, VDOM::VNode | VDOM::Text | nil vnode, ?Hash[Symbol, JS::Element] refs_map) -> Hash[Symbol, JS::Element]
+    private def cleanup_events: () -> void
+    private def cleanup_suspense_timers: () -> void
+    private def add_child: (untyped child) -> void
+    private def collect_child_components: (VDOM::VNode | VDOM::Text | nil vnode) -> void
+    private def collect_child_components_recursive: (VDOM::VNode | VDOM::Text | nil vnode, Array[Component] components) -> void
+
+    # Hydration helpers
+    private def hydration_match?: (untyped vnode, untyped dom_element) -> bool
+    private def warn_hydration_mismatch: (untyped vnode, untyped dom_element) -> void
+    private def full_render_fallback: (VDOM::VNode | VDOM::Text | nil new_vdom, untyped server_dom) -> JS::Element
+    private def hydrate_child_components: (untyped vnode, untyped dom_element) -> void
+
+    # HTML element methods (DSL)
+    def div: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def span: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def p: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def a: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def h1: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def h2: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def h3: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def h4: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def h5: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def h6: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def ul: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def ol: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def li: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def table: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def thead: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def tbody: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def tr: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def th: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def td: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def form: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def input: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def textarea: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def button: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def select: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def option: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def label: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def header: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def footer: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def nav: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def section: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def article: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def aside: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def img: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def video: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def audio: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def canvas: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def br: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+    def hr: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
+  end
+end

data/sig/debug.rbs

@@ -0,0 +1,28 @@
+$__funicular_debug__: Funicular::Debug
+
+module Funicular
+  module Debug
+    self.@error_registry: Array[Hash[Symbol, untyped]]
+
+    def self.enabled?: () -> bool
+    def self.component_registry: () -> Hash[Integer, Funicular::Component]
+    def self.register_component: (Funicular::Component) -> Integer?
+    def self.unregister_component: (Integer) -> void
+    def self.get_component: (Integer) -> Funicular::Component?
+    def self.all_components: () -> Array[Funicular::Component]
+    def self.component_tree: () -> String
+    def self.get_component_state: (Integer) -> String
+    def self.get_component_instance_variables: (Integer) -> String
+    def self.expose_to_global: () -> void
+    def self.report_error: (ErrorBoundary boundary, Exception error, ?(Hash[Symbol, Component] | nil) error_info) -> Hash[Symbol, untyped]?
+    def self.clear_errors: () -> void
+    def self.error_list: () -> String
+    def self.last_error: () -> Hash[Symbol, untyped]?
+    def self.error_count: () -> Integer
+
+    private def self.error_registry: () -> Array[Hash[Symbol, untyped]]
+    private def self.get_state_keys: (Funicular::Component) -> Array[String]
+    private def self.get_child_ids: (Funicular::Component) -> Array[Integer]
+    private def self.collect_direct_children: (Funicular::VDOM::VNode, Array[Funicular::Component]) -> void
+  end
+end

data/sig/differ.rbs

@@ -0,0 +1,18 @@
+module Funicular
+  module VDOM
+    class Differ
+      type children_t = Array[child_t]
+      def self.diff: (untyped old_node, untyped new_node) -> Array[patch_t]
+
+      private def self.diff_text: (Text old_node, Text new_node) -> Array[patch_t]
+      private def self.diff_element: (Element old_node, Element new_node) -> Array[patch_t]
+      private def self.diff_props: (Hash[Symbol, untyped] old_props, Hash[Symbol, untyped] new_props) -> Hash[Symbol, untyped]
+      private def self.diff_children: (children_t old_children, children_t new_children) -> Array[patch_t]
+      private def self.diff_children_with_keys: (children_t old_children, children_t new_children) -> Array[patch_t]
+      private def self.diff_children_by_index: (children_t old_children, children_t new_children) -> Array[patch_t]
+      private def self.diff_component: (VDOM::Component old_node, VDOM::Component new_node) -> Array[patch_t]
+
+      private def self.props_changed_excluding_procs?: (Hash[Symbol, untyped] old_props, Hash[Symbol, untyped] new_props) -> bool
+    end
+  end
+end

data/sig/environment_iquirer.rbs

@@ -0,0 +1,10 @@
+module Funicular
+  class EnvironmentInquirer
+    def initialize: (EnvironmentInquirer | String env) -> void
+    def to_s: () -> String
+    def inspect: () -> String
+    def ==: (String other) -> bool
+    def development?: () -> bool
+  end
+end
+

data/sig/error_boundary.rbs

@@ -0,0 +1,14 @@
+module Funicular
+  class ErrorBoundary < Component
+    attr_accessor error_caught_during_render: bool?
+
+    def initialize_state: () -> Hash[Symbol, untyped]
+    def catch_error: (Exception error, ?Hash[Symbol, untyped]? error_info) -> bool
+    def reset: () -> void
+    def render: () -> (VDOM::VNode | String | Integer | Float | Array[untyped] | nil)
+
+    private def render_fallback: () -> (VDOM::VNode | String)
+    private def default_fallback: () -> VDOM::VNode
+    private def render_children: () -> VDOM::VNode
+  end
+end

data/sig/file_upload.rbs

@@ -0,0 +1,18 @@
+module Funicular
+  module FileUpload
+    self.@callback_counters: Array[Integer]
+
+    JS_HELPER_CODE: String
+
+    def self.mount: () -> void
+    def self.select_file_with_preview: (String input_id) { (JS::Object? file, String? preview_url) -> void } -> void
+    def self.upload_with_formdata: (
+      String url,
+      ?fields: Hash[untyped, untyped],
+      ?file_field: String?,
+      ?file: JS::Object?
+    ) { (Hash[untyped, untyped] result) -> void } -> void
+    def self.store_file: (String input_id, ?String storage_key) -> JS::Object?
+    def self.retrieve_file: (?String storage_key) -> JS::Object?
+  end
+end

data/sig/form_builder.rbs

@@ -0,0 +1,29 @@
+module Funicular
+  class FormBuilder
+    attr_reader component: Component
+    attr_reader model_key: Symbol
+    attr_reader options: Hash[Symbol, untyped]
+
+    def initialize: (Component component, Symbol model_key, ?Hash[Symbol, untyped] options) -> void
+
+    # Field builder methods
+    def text_field: (Symbol field_name, ?Hash[Symbol, untyped] options) -> VDOM::Element
+    def password_field: (Symbol field_name, ?Hash[Symbol, untyped] options) -> VDOM::Element
+    def email_field: (Symbol field_name, ?Hash[Symbol, untyped] options) -> VDOM::Element
+    def number_field: (Symbol field_name, ?Hash[Symbol, untyped] options) -> VDOM::Element
+    def textarea: (Symbol field_name, ?Hash[Symbol, untyped] options) -> VDOM::Element
+    def checkbox: (Symbol field_name, ?Hash[Symbol, untyped] options) -> VDOM::Element
+    def select: (Symbol field_name, Array[untyped] choices, ?Hash[Symbol, untyped] options) -> VDOM::Element
+    def file_field: (Symbol field_name, ?Hash[Symbol, untyped] options) -> VDOM::Element
+    def submit: (?String label, ?Hash[Symbol, untyped] options) -> VDOM::Element
+    def label: (Symbol field_name, ?String? text, ?Hash[Symbol, untyped] options) -> VDOM::Element
+
+    # Generic field builder
+    private def build_field: (Symbol field_name, String field_type, Hash[Symbol, untyped] field_options) -> VDOM::Element
+
+    # Helper methods for nested state access
+    private def get_nested_value: (Component::StateAccessor state, String key_path) -> untyped
+    private def set_nested_value: (Symbol model_key, String field_key, untyped new_value) -> void
+    private def deep_merge_value: (Hash[Symbol, untyped] hash, Array[String] keys, untyped value) -> Hash[Symbol, untyped]
+  end
+end

data/sig/funicular.rbs

@@ -1,4 +1,27 @@
 module Funicular
   VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+
+  self.@server: bool
+  self.@form_builder_config: Hash[Symbol, String]?
+
+  def self.version: () -> String
+  def self.env: () -> EnvironmentInquirer
+  def self.env=: (EnvironmentInquirer | String environment) -> EnvironmentInquirer?
+  def self.router: () -> Router?
+
+  # SSR / hydration support
+  def self.server?: () -> bool
+  def self.server=: (untyped value) -> bool
+  def self.window_state: () -> Hash[String, untyped]
+  def self.has_ssr_state?: () -> bool
+  def self.first_element_child: (JS::Element container_element) -> JS::Element?
+
+  def self.load_schemas: (Hash[singleton(Model), String] models) ?{ () -> void } -> void
+  def self.start: (?singleton(Component)? component_class, ?container: String | JS::Element, ?props: Hash[Symbol, untyped], ?hydrate: bool) ?{ (Router router) -> void } -> (Component | Router | nil)
+  def self.configure_forms: () ?{ (Hash[Symbol, String]) -> void } -> void
+  def self.form_builder_config: () -> Hash[Symbol, String]?
+  def self.form_builder_config=: (Hash[Symbol, String] config) -> Hash[Symbol, String]
+  def self.configure_debug: () ?{ (self) -> void } -> void
+  def self.export_debug_config: () -> void
+
 end

data/sig/html_serializer.rbs

@@ -0,0 +1,20 @@
+module Funicular
+  module VDOM
+    class HTMLSerializer
+      VOID_ELEMENTS: Array[String]
+      SKIP_PROPS: Array[Symbol]
+
+      def self.serialize: (VNode? vnode) -> String
+      def render: (VNode? vnode) -> String
+
+      private
+      def render_element: (Element element) -> String
+      def render_children: (Array[child_t] children) -> String
+      def render_text: (Text text) -> String
+      def render_component: (Component component_vnode) -> String
+      def serialize_props: (Hash[Symbol, untyped] props) -> String
+      def escape_html: (untyped str) -> String
+      def escape_attr: (untyped str) -> String
+    end
+  end
+end

data/sig/http.rbs

@@ -0,0 +1,37 @@
+module Funicular
+  module HTTP
+    CACHE_DB_NAME: String
+    CACHE_STORE: String
+
+    self.@cache: IndexedDB::KVS?
+
+    class Response
+      attr_reader data: untyped
+      attr_reader status: Integer
+      attr_reader ok: bool
+
+      def initialize: (Integer status, untyped data) -> void
+      def error?: () -> bool
+      def error_message: () -> String?
+    end
+
+    def self.cache_init!: () -> IndexedDB::KVS
+    def self.cache_purge: (String url) -> nil
+    def self.cache_clear: () -> nil
+    def self.cache_lookup: (String url) -> untyped
+    def self.cache_write: (String url, Hash[String, untyped] entry) -> nil
+
+    def self.get: (String url, ?cache: Integer?) { (Response) -> void } -> void
+    def self.post: (String url, ?Hash[untyped, untyped]? body, ?cache: Integer?) { (Response) -> void } -> void
+    def self.patch: (String url, ?Hash[untyped, untyped]? body, ?cache: Integer?) { (Response) -> void } -> void
+    def self.delete: (String url, ?cache: Integer?) { (Response) -> void } -> void
+    def self.put: (String url, ?Hash[untyped, untyped]? body, ?cache: Integer?) { (Response) -> void } -> void
+    def self.csrf_token: () -> String?
+
+    private def self.warn_unsupported_cache: (String verb) -> void
+    private def self.now_seconds: () -> Integer
+    private def self.cache_hit?: (untyped entry, Integer ttl) -> bool
+    private def self.serve_from_cache: (Hash[String, untyped] entry) { (Response) -> void } -> void
+    private def self.request: (String method, String url, Hash[untyped, untyped]? body, ?cache: Integer?) { (Response) -> void } -> void
+  end
+end

data/sig/model.rbs

@@ -0,0 +1,28 @@
+module Funicular
+  class Model
+    include Funicular::Model::Validations
+    extend Funicular::Model::Validations::ClassMethods
+
+    attr_reader id: untyped
+    @changed_attributes: Hash[String, untyped]
+
+    def self.schema: () -> Hash[String, Hash[String, untyped]]
+    def self.schema=: (Hash[String, Hash[String, untyped]] schema) -> Hash[String, Hash[String, untyped]]
+    def self.endpoints: () -> Hash[String, Hash[String, String]]
+    def self.endpoints=: (Hash[String, Hash[String, String]] endpoints) -> Hash[String, Hash[String, String]]
+
+    def initialize: (?Hash[untyped, untyped] attributes) -> void
+    def self.load_schema: (Hash[String, untyped] schema_data) -> void
+    def self.register_schema_validations: (untyped validations) -> void
+    def self.normalize_validation_options: (Symbol | String kind, untyped opts) -> untyped
+
+    def self.all: (?Hash[untyped, untyped] params) ?{ (Array[Model]? instances, String? error) -> void } -> void
+    def self.find: (?untyped id, ?endpoint_name: String, ?model_class: singleton(Model)) ?{ (Model? instance, String? error) -> void } -> void
+    def self.create: (Hash[untyped, untyped] attrs, ?model_class: singleton(Model)) ?{ (Model? instance, untyped error) -> void } -> void
+    def self.destroy: (?untyped id) ?{ (bool success, untyped result) -> void } -> void
+
+    def update: (?Hash[untyped, untyped]? attrs) ?{ (bool success, untyped result) -> void } -> void
+    def destroy: () ?{ (bool success, untyped result) -> void } -> void
+    def reload: () ?{ (Model? instance, String? error) -> void } -> void
+  end
+end

data/sig/patcher.rbs

@@ -0,0 +1,18 @@
+module Funicular
+  module VDOM
+    BOOLEAN_ATTRIBUTES: Array[String]
+
+    class Patcher
+      def initialize: (?JS::Element? doc) -> void
+      # `apply` accepts any DOM node so text-node patches (e.g. :replace)
+      # can recurse into it; Element-only operations are narrowed inside.
+      def apply: (JS::Object element, Array[patch_t] patches) -> JS::Object
+
+      # Accepts JS::Object since callers narrow via is_a?(JS::Element) at runtime
+      private def update_props: (JS::Object element, Hash[Symbol, String?] props_patch) -> void
+      private def create_element: (untyped vnode) -> JS::Object
+      private def unmount_component: (VDOM::VNode vnode) -> void
+    end
+
+  end
+end

data/sig/router.rbs

@@ -0,0 +1,44 @@
+module Funicular
+  type route_constraints_t = Hash[Symbol, Regexp]
+  type route_definition_t = { method: Symbol, path: String, component: singleton(Component), name: String?, pattern_segments: Array[String], constraints: route_constraints_t }
+
+  # URL helper methods are dynamically generated based on route definitions
+  # Example: router.get('/users/:id', to: UserComponent, as: 'user')
+  # generates: user_path(id) -> String
+  module RouteHelpers
+    # Dynamic methods are generated at runtime by Router#generate_url_helper
+    # Method signatures depend on route parameters:
+    # - No parameters: def helper_name_path: () -> String
+    # - With parameters: def helper_name_path: (Integer | String | untyped) -> String
+    def method_missing: (Symbol method, *untyped args) -> String
+    def respond_to_missing?: (Symbol method, ?bool include_private) -> bool
+  end
+
+  class Router
+    attr_reader routes: Array[route_definition_t]
+    attr_reader current_component: Component?
+    attr_reader current_path: String?
+
+    def initialize: (JS::Element? container) -> void
+    def get: (String path, to: singleton(Component), ?as: String?, ?constraints: route_constraints_t?) -> void
+    def post: (String path, to: singleton(Component), ?as: String?, ?constraints: route_constraints_t?) -> void
+    def put: (String path, to: singleton(Component), ?as: String?, ?constraints: route_constraints_t?) -> void
+    def patch: (String path, to: singleton(Component), ?as: String?, ?constraints: route_constraints_t?) -> void
+    def delete: (String path, to: singleton(Component), ?as: String?, ?constraints: route_constraints_t?) -> void
+    def add_route: (String path, singleton(Component) component_class, ?as: String?, ?constraints: route_constraints_t?) -> void
+    def set_default: (String path) -> void
+    def match: (String path) -> [singleton(Component)?, Hash[Symbol, untyped]]
+    def start: (?hydrate: bool) -> void
+    def stop: () -> void
+    def navigate: (String path) -> void
+    def current_hash_path: () -> String
+    def current_location_path: () -> String
+
+    private def add_route_with_method: (Symbol method, String path, singleton(Component) component_class, String? name, ?route_constraints_t? constraints) -> void
+    private def generate_url_helper: (String name, String path_pattern) -> void
+    private def extract_param_names: (String path_pattern) -> Array[Symbol]
+    private def handle_route_change: () -> void
+    private def unmount_current_component: () -> void
+    private def find_route: (String path) -> [singleton(Component) | nil, Hash[Symbol, untyped]]
+  end
+end

data/sig/store.rbs

@@ -0,0 +1,89 @@
+module Funicular
+  class Store
+    EVENT_REGISTRY: Hash[Symbol, Array[singleton(Funicular::Store)]]
+    KVS_POOL: Hash[Array[String], IndexedDB::KVS]
+
+    class SubscribesTo < Data
+      attr_reader channel_name: String
+      attr_reader params_proc: ^(Funicular::Store::Scope) -> Hash[Symbol, untyped]
+      attr_reader handler_block: Proc
+
+      def self.new: (String channel_name, ^(Funicular::Store::Scope) -> Hash[Symbol, untyped] params_proc, Proc handler_block) -> instance
+    end
+
+    class Subscription
+      attr_reader cable_sub: Funicular::Cable::Subscription
+
+      def initialize: (Funicular::Cable::Subscription cable_sub) -> void
+      def unsubscribe: () -> nil
+    end
+
+    class Scope
+      attr_reader store_class: singleton(Funicular::Store)
+      attr_reader scope_kwargs: Hash[Symbol, untyped]
+
+      @on_change: Hash[Integer, Proc]
+      @next_cb_id: Integer
+      @subscription: Funicular::Store::Subscription?
+
+      def initialize: (singleton(Funicular::Store) store_class, Hash[Symbol, untyped] scope_kwargs) -> void
+      def method_missing: (Symbol name, *untyped args) -> untyped
+      def respond_to_missing?: (Symbol name, ?bool include_private) -> bool
+      def on_change: () { (untyped) -> void } -> Integer
+      def off_change: (Integer id) -> nil
+      def subscribed?: () -> bool
+      def subscription: () -> Funicular::Store::Subscription?
+      def subscribe!: () -> Funicular::Store::Subscription
+      def unsubscribe!: () -> nil
+
+      private def storage_key: () -> String
+      private def kvs: () -> IndexedDB::KVS
+      private def now_seconds: () -> Integer
+      private def expired_record?: (untyped rec) -> bool
+      private def fire_change: (untyped snapshot) -> void
+    end
+
+    self.@__database: String?
+    self.@__kvs_store_name: String?
+    self.@__scope_keys: Array[Symbol]?
+    self.@__expires_in: Integer?
+    self.@__source: untyped
+    self.@__belongs_to: Symbol?
+    self.@__cable_url: String?
+    self.@__cable_binding: SubscribesTo?
+    self.@__cleared_handlers: Hash[Symbol, Proc?]?
+    self.@__scope_pool: Hash[Hash[Symbol, untyped], Funicular::Store::Scope]?
+    self.@__consumer: Funicular::Cable::Consumer?
+
+    def self.database: (String name) -> String
+    def self.kvs_store: (String name) -> String
+    def self.scope: (*Symbol keys) -> Array[Symbol]
+    def self.expires_in: (Integer seconds) -> Integer
+    def self.source: (untyped model_class) -> untyped
+    def self.belongs_to: (Symbol name) -> Symbol
+    def self.cable_url: (String url) -> String
+    def self.subscribes_to: (String channel_name, params: ^(Funicular::Store::Scope) -> Hash[Symbol, untyped]) { (untyped, Funicular::Store::Scope) -> void } -> SubscribesTo
+    def self.cleared_on: (*Symbol event_names) ?{ (untyped) -> void } -> void
+
+    def self.where: (**untyped scope_kwargs) -> Funicular::Store::Scope
+    def self.scope_class: () -> singleton(Funicular::Store::Scope)
+
+    def self.__database: () -> String?
+    def self.__kvs_store_name: () -> String?
+    def self.__scope_keys: () -> Array[Symbol]?
+    def self.__expires_in: () -> Integer?
+    def self.__source: () -> untyped
+    def self.__belongs_to: () -> Symbol?
+    def self.__cable_url: () -> String?
+    def self.__cable_binding: () -> SubscribesTo?
+    def self.__cleared_handlers: () -> Hash[Symbol, Proc?]?
+    def self.__kvs: () -> IndexedDB::KVS
+    def self.__consumer: () -> Funicular::Cable::Consumer
+    def self.__handle_dispatch: (Symbol event, untyped payload) -> void
+    def self.__clear_all!: () -> nil
+
+    private def self.validate_scope_kwargs!: (Hash[Symbol, untyped] scope_kwargs) -> void
+
+    def self.dispatch: (Symbol | String event, ?untyped payload) -> nil
+  end
+end

data/sig/store_collection.rbs

@@ -0,0 +1,43 @@
+module Funicular
+  class Store
+    class Collection < Funicular::Store
+      DEFAULT_KEY_PROC: ^(untyped) -> untyped
+
+      self.@__limit: Integer?
+      self.@__order: Symbol?
+      self.@__key_proc: ^(untyped) -> untyped | nil
+
+      def self.limit: (Integer n) -> Integer
+      def self.order: (Symbol direction) -> Symbol
+      def self.key: (^(untyped) -> untyped proc) -> (^(untyped) -> untyped)
+      def self.scope_class: () -> singleton(Funicular::Store::Collection::Scope)
+
+      def self.__limit: () -> Integer?
+      def self.__order: () -> Symbol?
+      def self.__key_proc: () -> (^(untyped) -> untyped | nil)
+
+      class Scope < Funicular::Store::Scope
+        attr_reader store_class: singleton(Funicular::Store::Collection)
+        @store_class: singleton(Funicular::Store::Collection)
+
+        def all: () -> Array[untyped]
+        def replace: (untyped arr) -> Array[untyped]
+        def append: (untyped item) -> Array[untyped]
+        def remove: (untyped id) -> Array[untyped]
+        def last: () -> untyped
+        def last_id: () -> untyped
+        def size: () -> Integer
+        def clear: () -> nil
+        def expired?: () -> bool
+        def same_tail?: (untyped other) -> bool
+
+        private def key_proc: () -> ^(untyped) -> untyped
+        private def cap: (Array[untyped] arr) -> Array[untyped]
+        private def append_to: (Array[untyped] arr, untyped item) -> Array[untyped]
+        private def read: () -> untyped
+        private def write: (Array[untyped] items) -> Hash[String, untyped]
+        private def erase: () -> nil
+      end
+    end
+  end
+end

data/sig/store_singleton.rbs

@@ -0,0 +1,19 @@
+module Funicular
+  class Store
+    class Singleton < Funicular::Store
+      def self.scope_class: () -> singleton(Funicular::Store::Singleton::Scope)
+
+      class Scope < Funicular::Store::Scope
+        def value: () -> untyped
+        def value=: (untyped v) -> untyped
+        def delete: () -> nil
+        def present?: () -> bool
+        def expired?: () -> bool
+
+        private def read: () -> untyped
+        private def write: (untyped v) -> Hash[String, untyped]
+        private def erase: () -> nil
+      end
+    end
+  end
+end

data/sig/styles.rbs

@@ -0,0 +1,25 @@
+module Funicular
+  # StyleValue represents a CSS class string that can be combined with other styles
+  class StyleValue
+    attr_reader value: String
+    def initialize: (String | untyped value) -> void
+    def |: (StyleValue | String | nil other) -> StyleValue
+    def to_s: () -> String
+  end
+
+  # StyleAccessor provides access to defined styles via method calls
+  class StyleAccessor
+    def initialize: (Hash[Symbol, Hash[Symbol, untyped]] definitions) -> void
+    private def method_missing: (Symbol name, *untyped args) -> StyleValue
+    private def respond_to_missing?: (Symbol name, ?bool include_private) -> bool
+  end
+
+  # StyleBuilder is used to define styles within the styles {} block
+  class StyleBuilder
+    @definitions: Hash[Symbol, Hash[Symbol, untyped]]
+
+    def initialize: () -> void
+    def to_definitions: () -> Hash[Symbol, Hash[Symbol, untyped]]
+    private def method_missing: (Symbol name, *untyped args) -> void
+  end
+end