ruflet 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a46d9a04d401502b437f5f1f4bd16825d70fd83a0742f2222be7b3f44779806e
+  data.tar.gz: 6cd952e7b2cfe71fb900a9e6bfcab4459e0f5a573013ea45ef61c5fc5557374d
+SHA512:
+  metadata.gz: b2357c3392cc63a15cc83efd9cab123bccc80eba1de9a7363e969b608268fc24a1741dae5f90ea1a2a15db6452c17a7ba5d97a2e45457e82f97222e221c62892
+  data.tar.gz: cdeea6994f53e37c3a622f9b0997a9b8f5bed7c4b49af60cfd0bfe0b37e9e1ea569bc242cdc95cadbc908b81aa0315e27eb957f34cfb00ea5f18846f2f77e57f

data/README.md

@@ -0,0 +1,3 @@
+# ruflet
+
+Part of Ruflet monorepo.

data/lib/ruflet/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Ruflet
+  VERSION = "0.0.1" unless const_defined?(:VERSION)
+end

data/lib/ruflet.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "thread"
+require "ruflet_protocol"
+require "ruflet_ui"
+
+module Ruflet
+  @run_interceptors = []
+  @run_interceptors_mutex = Mutex.new
+
+  module_function
+
+  def run(entrypoint = nil, host: "0.0.0.0", port: 8550, &block)
+    begin
+      require "ruflet_server"
+    rescue LoadError => e
+      raise LoadError, "Ruflet.run requires the 'ruflet_server' gem. Add it to your Gemfile.", e.backtrace
+    end
+
+    callback = entrypoint || block
+    raise ArgumentError, "Ruflet.run requires a callable entrypoint or block" unless callback.respond_to?(:call)
+
+    interceptor = @run_interceptors_mutex.synchronize { @run_interceptors.last }
+    if interceptor
+      result = interceptor.call(entrypoint: callback, host: host, port: port)
+      return result unless result == :pass
+    end
+
+    Server.new(host: host, port: port) do |page|
+      callback.call(page)
+    end.start
+  end
+
+  def with_run_interceptor(interceptor)
+    @run_interceptors_mutex.synchronize { @run_interceptors << interceptor }
+    yield
+  ensure
+    @run_interceptors_mutex.synchronize { @run_interceptors.delete(interceptor) }
+  end
+end

data/lib/ruflet_protocol/ruflet/protocol.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Ruflet
+  module Protocol
+    ACTIONS = {
+      register_client: 1,
+      patch_control: 2,
+      control_event: 3,
+      update_control: 4,
+      invoke_control_method: 5,
+      session_crashed: 6,
+
+      # Legacy JSON protocol aliases kept for compatibility.
+      register_web_client: "registerWebClient",
+      page_event_from_web: "pageEventFromWeb",
+      update_control_props: "updateControlProps"
+    }.freeze
+
+    module_function
+
+    def pack_message(action:, payload:)
+      [action, payload]
+    end
+
+    def normalize_register_payload(payload)
+      page = payload["page"] || {}
+      {
+        "session_id" => payload["session_id"],
+        "page_name" => payload["page_name"] || "",
+        "route" => page["route"] || "/",
+        "width" => page["width"],
+        "height" => page["height"],
+        "platform" => page["platform"],
+        "platform_brightness" => page["platform_brightness"],
+        "media" => page["media"] || {}
+      }
+    end
+
+    def normalize_control_event_payload(payload)
+      {
+        "target" => payload["target"] || payload["eventTarget"],
+        "name" => payload["name"] || payload["eventName"],
+        "data" => payload["data"] || payload["eventData"]
+      }
+    end
+
+    def normalize_update_control_payload(payload)
+      {
+        "id" => payload["id"] || payload["target"] || payload["eventTarget"],
+        "props" => payload["props"].is_a?(Hash) ? payload["props"] : {}
+      }
+    end
+
+    def register_response(session_id:)
+      {
+        "session_id" => session_id,
+        "page_patch" => {},
+        "error" => nil
+      }
+    end
+  end
+end

data/lib/ruflet_protocol.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "ruflet/version"
+require_relative "ruflet_protocol/ruflet/protocol"

data/lib/ruflet_ui/ruflet/app.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Ruflet
+  class App
+    def initialize(host: "0.0.0.0", port: 8550)
+      @host = host
+      @port = port
+    end
+
+    def run
+      Ruflet.run(host: @host, port: @port) do |page|
+        view(page)
+      end
+    end
+
+    def view(_page)
+      raise NotImplementedError, "#{self.class} must implement #view(page)"
+    end
+  end
+end

data/lib/ruflet_ui/ruflet/colors.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Ruflet
+  module Colors
+    module_function
+
+    SEMANTIC_COLORS = {
+      PRIMARY: "primary",
+      ON_PRIMARY: "onprimary",
+      PRIMARY_CONTAINER: "primarycontainer",
+      ON_PRIMARY_CONTAINER: "onprimarycontainer",
+      PRIMARY_FIXED: "primaryfixed",
+      PRIMARY_FIXED_DIM: "primaryfixeddim",
+      ON_PRIMARY_FIXED: "onprimaryfixed",
+      ON_PRIMARY_FIXED_VARIANT: "onprimaryfixedvariant",
+      SECONDARY: "secondary",
+      ON_SECONDARY: "onsecondary",
+      SECONDARY_CONTAINER: "secondarycontainer",
+      ON_SECONDARY_CONTAINER: "onsecondarycontainer",
+      SECONDARY_FIXED: "secondaryfixed",
+      SECONDARY_FIXED_DIM: "secondaryfixeddim",
+      ON_SECONDARY_FIXED: "onsecondaryfixed",
+      ON_SECONDARY_FIXED_VARIANT: "onsecondaryfixedvariant",
+      TERTIARY: "tertiary",
+      ON_TERTIARY: "ontertiary",
+      TERTIARY_CONTAINER: "tertiarycontainer",
+      ON_TERTIARY_CONTAINER: "ontertiarycontainer",
+      TERTIARY_FIXED: "tertiaryfixed",
+      TERTIARY_FIXED_DIM: "tertiaryfixeddim",
+      ON_TERTIARY_FIXED: "ontertiaryfixed",
+      ON_TERTIARY_FIXED_VARIANT: "ontertiaryfixedvariant",
+      ERROR: "error",
+      ON_ERROR: "onerror",
+      ERROR_CONTAINER: "errorcontainer",
+      ON_ERROR_CONTAINER: "onerrorcontainer",
+      SURFACE: "surface",
+      ON_SURFACE: "onsurface",
+      ON_SURFACE_VARIANT: "onsurfacevariant",
+      SURFACE_TINT: "surfacetint",
+      SURFACE_DIM: "surfacedim",
+      SURFACE_BRIGHT: "surfacebright",
+      SURFACE_CONTAINER: "surfacecontainer",
+      SURFACE_CONTAINER_LOW: "surfacecontainerlow",
+      SURFACE_CONTAINER_LOWEST: "surfacecontainerlowest",
+      SURFACE_CONTAINER_HIGH: "surfacecontainerhigh",
+      SURFACE_CONTAINER_HIGHEST: "surfacecontainerhighest",
+      OUTLINE: "outline",
+      OUTLINE_VARIANT: "outlinevariant",
+      SHADOW: "shadow",
+      SCRIM: "scrim",
+      INVERSE_SURFACE: "inversesurface",
+      ON_INVERSE_SURFACE: "oninversesurface",
+      INVERSE_PRIMARY: "inverseprimary"
+    }.freeze
+
+    BASE_PRIMARY = %w[
+      amber blue bluegrey brown cyan deeporange deeppurple green grey indigo lightblue
+      lightgreen lime orange pink purple red teal yellow
+    ].freeze
+    BASE_ACCENT = %w[
+      amber blue cyan deeporange deeppurple green indigo lightblue lightgreen lime
+      orange pink purple red teal yellow
+    ].freeze
+    PRIMARY_SHADES = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900].freeze
+    ACCENT_SHADES = [100, 200, 400, 700].freeze
+
+    FIXED_COLORS = {
+      BLACK: "black",
+      BLACK_12: "black12",
+      BLACK_26: "black26",
+      BLACK_38: "black38",
+      BLACK_45: "black45",
+      BLACK_54: "black54",
+      BLACK_87: "black87",
+      WHITE: "white",
+      WHITE_10: "white10",
+      WHITE_12: "white12",
+      WHITE_24: "white24",
+      WHITE_30: "white30",
+      WHITE_38: "white38",
+      WHITE_54: "white54",
+      WHITE_60: "white60",
+      WHITE_70: "white70",
+      TRANSPARENT: "transparent"
+    }.freeze
+
+    DEPRECATED_ALIASES = {
+      BLACK12: :BLACK_12,
+      BLACK26: :BLACK_26,
+      BLACK38: :BLACK_38,
+      BLACK45: :BLACK_45,
+      BLACK54: :BLACK_54,
+      BLACK87: :BLACK_87,
+      WHITE10: :WHITE_10,
+      WHITE12: :WHITE_12,
+      WHITE24: :WHITE_24,
+      WHITE30: :WHITE_30,
+      WHITE38: :WHITE_38,
+      WHITE54: :WHITE_54,
+      WHITE60: :WHITE_60,
+      WHITE70: :WHITE_70
+    }.freeze
+
+    def with_opacity(opacity, color)
+      value = Float(opacity)
+      raise ArgumentError, "opacity must be between 0.0 and 1.0 inclusive, got #{opacity}" unless value.between?(0.0, 1.0)
+
+      "#{normalize_color(color)},#{value}"
+    end
+
+    def random(exclude: nil, weights: nil)
+      choices = all_values.dup
+      excluded = Array(exclude).map { |c| normalize_color(c) }
+      choices.reject! { |c| excluded.include?(c) }
+      return nil if choices.empty?
+
+      if weights && !weights.empty?
+        expanded = choices.flat_map do |color|
+          weight = weights.fetch(color, weights.fetch(color.to_sym, 1)).to_i rescue 1
+          weight = 1 if weight <= 0
+          [color] * weight
+        end
+        return expanded.sample
+      end
+
+      choices.sample
+    end
+
+    def all_values
+      @all_values ||= constants(false)
+                      .map { |c| const_get(c) }
+                      .select { |v| v.is_a?(String) }
+                      .uniq
+                      .freeze
+    end
+
+    def normalize_color(color)
+      return color.to_s if color.is_a?(Symbol)
+      return color if color.is_a?(String)
+      return color.to_s unless color.respond_to?(:to_s)
+
+      color.to_s
+    end
+
+    BASE_PREFIX = {
+      "amber" => "AMBER",
+      "blue" => "BLUE",
+      "bluegrey" => "BLUE_GREY",
+      "brown" => "BROWN",
+      "cyan" => "CYAN",
+      "deeporange" => "DEEP_ORANGE",
+      "deeppurple" => "DEEP_PURPLE",
+      "green" => "GREEN",
+      "grey" => "GREY",
+      "indigo" => "INDIGO",
+      "lightblue" => "LIGHT_BLUE",
+      "lightgreen" => "LIGHT_GREEN",
+      "lime" => "LIME",
+      "orange" => "ORANGE",
+      "pink" => "PINK",
+      "purple" => "PURPLE",
+      "red" => "RED",
+      "teal" => "TEAL",
+      "yellow" => "YELLOW"
+    }.freeze
+
+    def constant_prefix_for(base_name)
+      BASE_PREFIX.fetch(base_name) { base_name.upcase }
+    end
+
+    SEMANTIC_COLORS.each { |k, v| const_set(k, v) }
+    FIXED_COLORS.each { |k, v| const_set(k, v) }
+
+    BASE_PRIMARY.each do |base|
+      prefix = constant_prefix_for(base)
+      const_set(prefix, base)
+      PRIMARY_SHADES.each do |shade|
+        const_set("#{prefix}_#{shade}", "#{base}#{shade}")
+      end
+    end
+
+    BASE_ACCENT.each do |base|
+      prefix = "#{constant_prefix_for(base)}_ACCENT"
+      const_set(prefix, "#{base}accent")
+      ACCENT_SHADES.each do |shade|
+        const_set("#{prefix}_#{shade}", "#{base}accent#{shade}")
+      end
+    end
+
+    DEPRECATED_ALIASES.each do |alias_name, target|
+      const_set(alias_name, const_get(target))
+    end
+
+    constants(false).each do |name|
+      next if respond_to?(name)
+
+      define_singleton_method(name) { const_get(name) }
+    end
+  end
+end

data/lib/ruflet_ui/ruflet/control.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require_relative "ui/control_registry"
+require_relative "icon_data"
+require_relative "icons/material_icon_lookup"
+require_relative "icons/cupertino_icon_lookup"
+
+module Ruflet
+  class Control
+    TYPE_MAP = UI::ControlRegistry::TYPE_MAP
+    EVENT_PROPS = UI::ControlRegistry::EVENT_PROPS
+    HOST_EXPANDED_TYPES = %w[view row column].freeze
+
+    attr_reader :type, :id, :props, :children
+    attr_accessor :wire_id, :runtime_page
+
+    def initialize(type:, id: nil, **props)
+      @type = type.to_s.downcase
+      @id = (id || props.delete(:id) || "ctrl_#{SecureRandom.hex(4)}").to_s
+      @children = []
+      @handlers = {}
+      @wire_id = nil
+      @props = normalize_props(extract_handlers(preprocess_props(props)))
+    end
+
+    def on(event_name, &block)
+      name = normalized_event_name(event_name)
+      @handlers[name] = block
+      @props["on_#{name}"] = true
+      runtime_page&.update(self, "on_#{name}": true) if wire_id
+      self
+    end
+
+    def emit(event_name, event)
+      handler = @handlers[normalized_event_name(event_name)]
+      return false unless handler
+
+      handler.call(event)
+      true
+    end
+
+    def has_handler?(event_name)
+      @handlers.key?(normalized_event_name(event_name))
+    end
+
+    def to_patch
+      patch = {
+        "_c" => TYPE_MAP.fetch(type, type.split("_").map(&:capitalize).join),
+        "_i" => wire_id
+      }
+
+      internals = {}
+      internals["host_positioned"] = true if type == "stack"
+      internals["host_expanded"] = true if HOST_EXPANDED_TYPES.include?(type)
+      patch["_internals"] = internals unless internals.empty?
+
+      props.each { |k, v| patch[k] = serialize_value(v) }
+      patch["controls"] = children.map(&:to_patch) unless children.empty?
+      patch
+    end
+
+    private
+
+    def serialize_value(value)
+      case value
+      when Control
+        value.to_patch
+      when Ruflet::IconData
+        value.value
+      when Array
+        value.map { |v| serialize_value(v) }
+      when Hash
+        value.transform_values { |v| serialize_value(v) }
+      else
+        value
+      end
+    end
+
+    def extract_handlers(input)
+      output = input.dup
+
+      EVENT_PROPS.each do |prop, event_name|
+        string_prop = prop.to_s
+        next unless output.key?(prop) || output.key?(string_prop)
+
+        handler = output.key?(prop) ? output.delete(prop) : output.delete(string_prop)
+        @handlers[event_name] = handler if handler.respond_to?(:call)
+        output["on_#{event_name}"] = true
+      end
+
+      output
+    end
+
+    def normalize_props(hash)
+      hash.each_with_object({}) do |(k, v), result|
+        key = k.to_s
+        mapped_key = key
+        value =
+          if v.is_a?(Symbol)
+            v.to_s
+          elsif v.is_a?(Ruflet::IconData)
+            v.value
+          else
+            v
+          end
+        value = normalize_icon_prop(mapped_key, value)
+        value = normalize_color_prop(mapped_key, value)
+
+        result[mapped_key] = value
+      end
+    end
+
+    def preprocess_props(props)
+      props
+    end
+
+    def normalize_color_prop(key, value)
+      return value unless value.is_a?(String)
+      return value.downcase if color_prop_key?(key)
+
+      value
+    end
+
+    def color_prop_key?(key)
+      key == "color" || key == "bgcolor" || key.end_with?("_color")
+    end
+
+    def normalize_icon_prop(key, value)
+      return value unless icon_prop_key?(key)
+      codepoint = resolve_icon_codepoint(value)
+      codepoint.nil? ? value : codepoint
+    end
+
+    def icon_prop_key?(key)
+      key == "icon" || key.end_with?("_icon")
+    end
+
+    def resolve_icon_codepoint(value)
+      return nil unless value.is_a?(Integer) || value.is_a?(Symbol) || value.is_a?(String)
+
+      codepoint = Ruflet::MaterialIconLookup.codepoint_for(value)
+      if codepoint.nil? || (value.is_a?(Integer) && codepoint == value)
+        cupertino = Ruflet::CupertinoIconLookup.codepoint_for(value)
+        codepoint = cupertino unless cupertino.nil?
+      end
+      codepoint
+    end
+
+    def normalized_event_name(event_name)
+      event_name.to_s.sub(/\Aon_/, "")
+    end
+  end
+end

data/lib/ruflet_ui/ruflet/dsl.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require_relative "ui/control_methods"
+require_relative "ui/control_factory"
+
+module Ruflet
+  module DSL
+    module_function
+
+    def _pending_app
+      @_pending_app ||= App.new(host: "0.0.0.0", port: 8550)
+    end
+
+    def _reset_pending_app!
+      @_pending_app = App.new(host: "0.0.0.0", port: 8550)
+    end
+
+    def app(host: "0.0.0.0", port: 8550, &block)
+      return App.new(host: host, port: port).tap { |a| a.instance_eval(&block) } if block
+
+      pending = _pending_app
+      pending.set_endpoint!(host: host, port: port)
+      _reset_pending_app!
+      pending
+    end
+
+    def page(**props, &block) = _pending_app.page(**props, &block)
+    def control(type, **props, &block) = _pending_app.control(type, **props, &block)
+    def widget(type, **props, &block) = _pending_app.widget(type, **props, &block)
+    def column(**props, &block) = _pending_app.column(**props, &block)
+    def center(**props, &block) = _pending_app.center(**props, &block)
+    def row(**props, &block) = _pending_app.row(**props, &block)
+    def stack(**props, &block) = _pending_app.stack(**props, &block)
+    def container(**props, &block) = _pending_app.container(**props, &block)
+    def gesture_detector(**props, &block) = _pending_app.gesture_detector(**props, &block)
+    def gesturedetector(**props, &block) = _pending_app.gesturedetector(**props, &block)
+    def draggable(**props, &block) = _pending_app.draggable(**props, &block)
+    def drag_target(**props, &block) = _pending_app.drag_target(**props, &block)
+    def dragtarget(**props, &block) = _pending_app.dragtarget(**props, &block)
+    def text(value = nil, **props) = _pending_app.text(value, **props)
+    def button(**props) = _pending_app.button(**props)
+    def elevated_button(**props) = _pending_app.elevated_button(**props)
+    def elevatedbutton(**props) = _pending_app.elevatedbutton(**props)
+    def text_field(**props) = _pending_app.text_field(**props)
+    def textfield(**props) = _pending_app.textfield(**props)
+    def icon(**props) = _pending_app.icon(**props)
+    def image(src = nil, **props) = _pending_app.image(src, **props)
+    def icon_button(**props) = _pending_app.icon_button(**props)
+    def iconbutton(**props) = _pending_app.iconbutton(**props)
+    def app_bar(**props) = _pending_app.app_bar(**props)
+    def appbar(**props) = _pending_app.appbar(**props)
+    def text_button(**props) = _pending_app.text_button(**props)
+    def textbutton(**props) = _pending_app.textbutton(**props)
+    def filled_button(**props) = _pending_app.filled_button(**props)
+    def filledbutton(**props) = _pending_app.filledbutton(**props)
+    def checkbox(**props) = _pending_app.checkbox(**props)
+    def radio(**props) = _pending_app.radio(**props)
+    def radio_group(**props) = _pending_app.radio_group(**props)
+    def radiogroup(**props) = _pending_app.radiogroup(**props)
+    def alert_dialog(**props) = _pending_app.alert_dialog(**props)
+    def alertdialog(**props) = _pending_app.alertdialog(**props)
+    def snack_bar(**props) = _pending_app.snack_bar(**props)
+    def snackbar(**props) = _pending_app.snackbar(**props)
+    def bottom_sheet(**props) = _pending_app.bottom_sheet(**props)
+    def bottomsheet(**props) = _pending_app.bottomsheet(**props)
+    def markdown(value = nil, **props) = _pending_app.markdown(value, **props)
+    def floating_action_button(**props) = _pending_app.floating_action_button(**props)
+    def floatingactionbutton(**props) = _pending_app.floatingactionbutton(**props)
+    def tabs(**props, &block) = _pending_app.tabs(**props, &block)
+    def tab(**props, &block) = _pending_app.tab(**props, &block)
+    def tab_bar(**props, &block) = _pending_app.tab_bar(**props, &block)
+    def tabbar(**props, &block) = _pending_app.tabbar(**props, &block)
+    def tab_bar_view(**props, &block) = _pending_app.tab_bar_view(**props, &block)
+    def tabbarview(**props, &block) = _pending_app.tabbarview(**props, &block)
+    def navigation_bar(**props, &block) = _pending_app.navigation_bar(**props, &block)
+    def navigationbar(**props, &block) = _pending_app.navigationbar(**props, &block)
+    def navigation_bar_destination(**props, &block) = _pending_app.navigation_bar_destination(**props, &block)
+    def navigationbardestination(**props, &block) = _pending_app.navigationbardestination(**props, &block)
+    def fab(content = nil, **props) = _pending_app.fab(content, **props)
+    def cupertino_button(**props) = _pending_app.cupertino_button(**props)
+    def cupertinobutton(**props) = _pending_app.cupertinobutton(**props)
+    def cupertino_filled_button(**props) = _pending_app.cupertino_filled_button(**props)
+    def cupertinofilledbutton(**props) = _pending_app.cupertinofilledbutton(**props)
+    def cupertino_text_field(**props) = _pending_app.cupertino_text_field(**props)
+    def cupertinotextfield(**props) = _pending_app.cupertinotextfield(**props)
+    def cupertino_switch(**props) = _pending_app.cupertino_switch(**props)
+    def cupertinoswitch(**props) = _pending_app.cupertinoswitch(**props)
+    def cupertino_slider(**props) = _pending_app.cupertino_slider(**props)
+    def cupertinoslider(**props) = _pending_app.cupertinoslider(**props)
+    def cupertino_alert_dialog(**props) = _pending_app.cupertino_alert_dialog(**props)
+    def cupertinoalertdialog(**props) = _pending_app.cupertinoalertdialog(**props)
+    def cupertino_action_sheet(**props) = _pending_app.cupertino_action_sheet(**props)
+    def cupertinoactionsheet(**props) = _pending_app.cupertinoactionsheet(**props)
+    def cupertino_dialog_action(**props) = _pending_app.cupertino_dialog_action(**props)
+    def cupertinodialogaction(**props) = _pending_app.cupertinodialogaction(**props)
+    def cupertino_navigation_bar(**props) = _pending_app.cupertino_navigation_bar(**props)
+    def cupertinonavigationbar(**props) = _pending_app.cupertinonavigationbar(**props)
+
+    class App
+      include UI::ControlMethods
+
+      attr_reader :page_props, :host, :port
+
+      def initialize(host:, port:)
+        @host = host
+        @port = port
+        @roots = []
+        @stack = []
+        @page_props = { "route" => "/" }
+        @seq = 0
+      end
+
+      def set_endpoint!(host:, port:)
+        @host = host
+        @port = port
+      end
+
+      def page(**props, &block)
+        @page_props.merge!(normalize_props(props))
+        instance_eval(&block) if block
+        self
+      end
+
+      def widget(type, **props, &block)
+        control(type.to_s, **props, &block)
+      end
+
+      def control(type, **props, &block)
+        mapped_props = props.dup
+        prop_children = mapped_props.delete(:controls) || mapped_props.delete("controls")
+
+        id = mapped_props.delete(:id)&.to_s || next_id(type)
+        c = Ruflet::UI::ControlFactory.build(type.to_s, id: id, **normalize_props(mapped_props))
+        attach(c)
+
+        if block
+          @stack.push(c)
+          instance_eval(&block)
+          @stack.pop
+        end
+
+        if prop_children
+          Array(prop_children).each { |child| c.children << child if child.is_a?(Ruflet::Control) }
+        end
+
+        c
+      end
+
+      def run
+        app_roots = @roots
+        page_props = @page_props.dup
+
+        Ruflet::Server.new(host: host, port: port) do |runtime_page|
+          runtime_page.set_view_props(page_props)
+          runtime_page.add(*app_roots)
+        end.start
+      end
+
+      private
+
+      def build_widget(type, **props, &block) = control(type.to_s, **props, &block)
+
+      def attach(control)
+        if @stack.empty?
+          @roots << control
+        else
+          @stack.last.children << control
+        end
+      end
+
+      def normalize_props(hash)
+        hash.transform_keys(&:to_s).transform_values { |v| v.is_a?(Symbol) ? v.to_s : v }
+      end
+
+      def next_id(type)
+        @seq += 1
+        "#{type}_#{@seq}"
+      end
+
+    end
+  end
+end