omarchy-ui 0.0.1-x86_64-linux

data/lib/omarchy_ui/application.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require "json" unless Object.const_defined?(:JSON)
+require "thread" unless Object.const_defined?(:Mutex)
+
+module OmarchyUI
+  class Application
+    ANIMATION_DEFAULTS = { "opacity" => 1.0, "scale" => 1.0, "rotation" => 0.0, "z" => 0.0 }.freeze
+    attr_reader :state, :surfaces, :surface_options, :components
+
+    def initialize(components: DEFAULT_COMPONENTS, &definition)
+      @surfaces = {}
+      @surface_options = {}
+      @nodes = {}
+      @bindings = []
+      @structures = []
+      @handlers = {}
+      @sequence = 0
+      @output = nil
+      @error = $stderr
+      @running = false
+      @write_lock = Mutex.new
+      @state_change_lock = Mutex.new
+      @components = components.dup
+      @builder = Builder.new(self)
+      @state = StateStore.new(method(:state_changed))
+      @scheduler = Scheduler.new(evaluator: method(:evaluate), on_error: method(:report_internal_error))
+      @builder.instance_eval(&definition) if definition
+      raise ArgumentError, "plugin defines no surfaces" if @surfaces.empty?
+    end
+
+    def define_state(name, initial) = @state.define(name, initial)
+
+    def build_node(type, explicit_id: nil, props: {})
+      definition = @components.fetch(type)
+      @sequence += 1
+      id = explicit_id ? explicit_id.to_s : "#{type}.#{@sequence}"
+      validate_id!(id)
+      raise ArgumentError, "duplicate control id: #{id}" if @nodes.key?(id)
+
+      normalized_props = normalize_props(props)
+      unknown = normalized_props.keys - definition.properties.map(&:to_s)
+      raise ArgumentError, "unsupported properties for #{type}: #{unknown.join(', ')}" unless unknown.empty?
+      Node.new(type:, id:, props: normalized_props).tap { |node| @nodes[id] = node }
+    end
+
+    def add_surface(name, node, options: {})
+      key = name.to_s
+      validate_id!(key)
+      raise ArgumentError, "duplicate surface: #{key}" if @surfaces.key?(key)
+      @surfaces[key] = node
+      @surface_options[key] = options.transform_keys(&:to_s).transform_values { |value| normalize_value(value) }
+    end
+
+    def register_binding(node, property, reader, animation: nil)
+      property = property.to_s
+      unless @components.fetch(node.type).properties.map(&:to_s).include?(property)
+        raise ArgumentError, "unsupported bound property for #{node.type}: #{property}"
+      end
+      value = normalize_value(evaluate(reader), property)
+      node.props[property] = value
+      @bindings << Binding.new(node:, property:, reader:, last_value: value, animation:)
+    end
+
+    def register_structure(node, renderer)
+      @structures << StructuralBinding.new(node:, renderer:, last_children: node.children.map(&:to_h))
+    end
+
+    def register_handler(control_id, event, handler)
+      raise ArgumentError, "handler requires a block" unless handler
+      node = @nodes.fetch(control_id.to_s) { raise ArgumentError, "unknown event control: #{control_id}" }
+      event_name = event.to_s
+      declared = @components.fetch(node.type).events.map(&:to_s)
+      unless declared.include?(event_name) || %w[mount unmount].include?(event_name)
+        raise ArgumentError, "#{node.type} does not declare event: #{event_name}"
+      end
+      node.subscribe(event_name)
+      key = [control_id.to_s, event_name]
+      raise ArgumentError, "duplicate handler for #{key.join('/')}" if @handlers.key?(key)
+      @handlers[key] = handler
+    end
+
+    def emit_effect(name, payload = {})
+      emit("v" => PROTOCOL_VERSION, "type" => "effect", "name" => name.to_s, "payload" => payload)
+    end
+
+    def animate(node, properties, animation)
+      emit_animation(node, animation_tracks(node, properties, animation))
+    end
+
+    def animation_tracks(node, properties, animation)
+      definition = @components.fetch(node.type)
+      properties.map do |property, value|
+        property_name = property.to_s
+        unless definition.properties.map(&:to_s).include?(property_name)
+          raise ArgumentError, "unsupported animated property for #{node.type}: #{property_name}"
+        end
+        normalized = normalize_value(value, property_name)
+        track = {
+          "property" => property_name,
+          "from" => node.props.fetch(property_name, ANIMATION_DEFAULTS[property_name]),
+          "to" => normalized
+        }.merge(animation.to_h)
+        node.props[property_name] = normalized
+        track
+      end
+    end
+
+    def emit_animation(node, tracks)
+      raise ArgumentError, "animation requires at least one property" if tracks.empty?
+      emit("v" => PROTOCOL_VERSION, "type" => "patch", "op" => "animate", "id" => node.id, "tracks" => tracks)
+      node
+    end
+
+    def tree = @surfaces.transform_values(&:to_h)
+    def normalize_value(value, property = nil) = Value.normalize(value, property:)
+
+    def start(output: $stdout, error: $stderr)
+      @output = output
+      @error = error
+      @output.sync = true if @output.respond_to?(:sync=)
+      @error.sync = true if @error.respond_to?(:sync=)
+      @running = true
+      pid = Object.const_defined?(:Process) && Process.respond_to?(:pid) ? Process.pid : 0
+      emit("v" => PROTOCOL_VERSION, "type" => "ready", "pid" => pid, "surfaces" => @surfaces.keys)
+      emit("v" => PROTOCOL_VERSION, "type" => "render", "components" => @components.protocol_schema,
+           "surfaces" => tree, "surface_options" => @surface_options)
+      @scheduler.start
+      self
+    end
+
+    def run(input: $stdin, output: $stdout, error: $stderr)
+      start(output:, error:)
+      input.each_line do |line|
+        receive(line)
+      rescue StandardError => exception
+        report_internal_error(exception)
+      end
+    ensure
+      stop
+    end
+
+    def stop
+      @running = false
+      @scheduler.stop
+      self
+    end
+
+    def schedule(kind, interval: 0, immediate: false, &block)
+      @scheduler.schedule(kind, interval:, immediate:, &block)
+    end
+
+    def receive(raw_line)
+      raise ProtocolError, "message exceeds #{MAX_MESSAGE_BYTES} bytes" if raw_line.bytesize > MAX_MESSAGE_BYTES
+      message = JSON.parse(raw_line)
+      if message.is_a?(Hash) && message["v"] == PROTOCOL_VERSION && message["type"] == "tick"
+        @scheduler.tick
+        return
+      end
+      validate_message!(message)
+      dispatch_event(message)
+    rescue JSON::ParserError => exception
+      emit_protocol_error("invalid_json", exception.message)
+    rescue ProtocolError => exception
+      emit_protocol_error("invalid_message", exception.message)
+    end
+
+    private
+
+    def state_changed(_name, _previous, _value)
+      @state_change_lock.synchronize do
+        @structures.dup.each do |structure|
+          reconcile_structure(structure) if @structures.include?(structure)
+        end
+        @bindings.dup.each { |binding| update_binding(binding) }
+      end
+    end
+
+    def update_binding(binding)
+      value = normalize_value(evaluate(binding.reader), binding.property)
+      return if value == binding.last_value
+      binding.last_value = value
+      binding.node.props[binding.property] = value
+      patch = {
+        "v" => PROTOCOL_VERSION, "type" => "patch", "op" => "set",
+        "id" => binding.node.id, "property" => binding.property, "value" => value
+      }
+      patch["animation"] = binding.animation.to_h if binding.animation
+      emit(patch)
+    end
+
+    def reconcile_structure(structure)
+      structure.node.children.dup.each { |child| unregister_subtree(child) }
+      structure.node.children.clear
+      @builder.rebuild(structure.node, &structure.renderer)
+      children = structure.node.children.map(&:to_h)
+      return if children == structure.last_children
+      structure.last_children = children
+      emit("v" => PROTOCOL_VERSION, "type" => "patch", "op" => "replace_children",
+           "id" => structure.node.id, "children" => children)
+    end
+
+    def unregister_subtree(node)
+      node.children.each { |child| unregister_subtree(child) }
+      @nodes.delete(node.id)
+      @bindings.delete_if { |binding| binding.node.equal?(node) }
+      @structures.delete_if { |structure| structure.node.equal?(node) }
+      @handlers.delete_if { |(control_id, _event), _handler| control_id == node.id }
+    end
+
+    def dispatch_event(message)
+      key = [message.fetch("id"), message.fetch("event")]
+      handler = @handlers[key]
+      raise ProtocolError, "unknown event target: #{key.join('/')}" unless handler
+      @builder.instance_exec(message["payload"] || {}, &handler)
+      acknowledgement = {
+        "v" => PROTOCOL_VERSION, "type" => "ack", "seq" => message["seq"],
+        "id" => message.fetch("id"), "event" => message.fetch("event")
+      }
+      acknowledgement["rss_kib"] = process_rss_kib if message.dig("payload", "diagnostics") == true
+      emit(acknowledgement)
+    rescue StandardError => exception
+      emit("v" => PROTOCOL_VERSION, "type" => "handler_error", "seq" => message["seq"],
+           "id" => message["id"], "message" => exception.message.to_s[0, 500])
+      @error.puts("omarchy-ui handler error: #{exception.class}: #{exception.message}")
+    end
+
+    def validate_message!(message)
+      raise ProtocolError, "message must be an object" unless message.is_a?(Hash)
+      raise ProtocolError, "unsupported protocol version" unless message["v"] == PROTOCOL_VERSION
+      raise ProtocolError, "unsupported message type" unless message["type"] == "event"
+      raise ProtocolError, "invalid surface" unless VALID_ID.match?(message["surface"].to_s)
+      raise ProtocolError, "unknown surface" unless @surfaces.key?(message["surface"])
+      raise ProtocolError, "invalid control id" unless VALID_ID.match?(message["id"].to_s)
+      unless surface_contains?(@surfaces.fetch(message["surface"]), message["id"])
+        raise ProtocolError, "control does not belong to surface"
+      end
+      raise ProtocolError, "invalid event" unless VALID_EVENT.match?(message["event"].to_s)
+      unless message["payload"].nil? || message["payload"].is_a?(Hash)
+        raise ProtocolError, "payload must be an object"
+      end
+      raise ProtocolError, "seq must be an integer" unless message["seq"].nil? || message["seq"].is_a?(Integer)
+    end
+
+    def surface_contains?(node, control_id)
+      node.id == control_id || node.children.any? { |child| surface_contains?(child, control_id) }
+    end
+
+    def evaluate(callable) = @builder.instance_exec(&callable)
+
+    def normalize_props(props)
+      props.each_with_object({}) { |(key, value), result| result[key.to_s] = normalize_value(value, key) }
+    end
+
+    def validate_id!(id)
+      raise ArgumentError, "invalid id: #{id.inspect}" unless VALID_ID.match?(id)
+    end
+
+    def emit(message)
+      return unless @running && @output
+      encoded = JSON.generate(message)
+      @write_lock.synchronize { @output.puts(encoded) }
+    end
+
+    def emit_protocol_error(code, message)
+      emit("v" => PROTOCOL_VERSION, "type" => "protocol_error", "code" => code,
+           "message" => message.to_s[0, 500])
+    end
+
+    def report_internal_error(exception)
+      @error.puts("omarchy-ui runtime error: #{exception.class}: #{exception.message}")
+      emit("v" => PROTOCOL_VERSION, "type" => "runtime_error", "message" => exception.message.to_s[0, 500])
+    end
+
+    def process_rss_kib
+      line = File.read("/proc/self/status").each_line.find { |entry| entry.start_with?("VmRSS:") }
+      line ? line.split[1].to_i : 0
+    rescue SystemCallError
+      0
+    end
+  end
+end

data/lib/omarchy_ui/builder.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module OmarchyUI
+  class Builder
+    UNSET = Object.new.freeze
+    CONTAINERS = %i[row column container grid stack scroll rectangle].freeze
+    VALUE_INPUTS = {
+      text_field: :text,
+      number_field: :value,
+      slider: :value,
+      dropdown: :value,
+      multi_select: :values,
+      button_group: :value
+    }.freeze
+
+    def initialize(application)
+      @application = application
+      @stack = []
+    end
+
+    def component(type, id: nil, **props, &block)
+      definition = @application.components.fetch(type)
+      node = @application.build_node(type, explicit_id: id, props:)
+      append(node)
+      if block
+        raise ArgumentError, "#{type} is not a container" unless definition.container
+        within(node, &block)
+      end
+      node
+    end
+    alias widget component
+    alias qml_component component
+
+    CONTAINERS.each do |type|
+      define_method(type) { |id: nil, **props, &block| component(type, id:, **props, &block) }
+    end
+
+    def register_component(name, qml:, properties: [], events: [], property_map: {}, event_map: {}, container: false, auto_bind: true)
+      unless @stack.empty? && @application.surfaces.empty?
+        raise ArgumentError, "components must be registered before a surface"
+      end
+      @application.components.register(name, qml:, properties:, events:, property_map:, event_map:, container:, auto_bind:)
+    end
+
+    def state(name = nil, initial = UNSET)
+      return @application.state if name.nil?
+      raise ArgumentError, "state requires an initial value" if initial.equal?(UNSET)
+      @application.define_state(name, initial)
+    end
+
+    APP_OPTIONS = %i[title width height min_width min_height max_width max_height color visible maximized fullscreen].freeze
+
+    def bar_widget(&block) = surface("bar", id: "bar", &block)
+    def panel(name, &block) = surface(name.to_s, id: "panel.#{name}", &block)
+
+    def app(name = :main, **options, &block)
+      unknown = options.keys - APP_OPTIONS
+      raise ArgumentError, "unsupported app options: #{unknown.join(', ')}" unless unknown.empty?
+      surface(name.to_s, id: "app.#{name}", options:, &block)
+    end
+
+    def dynamic(type: :column, id: nil, **props, &renderer)
+      raise ArgumentError, "dynamic requires a block" unless renderer
+      definition = @application.components.fetch(type)
+      raise ArgumentError, "dynamic component must be a container: #{type}" unless definition.container
+
+      node = component(type, id:, **props, &renderer)
+      @application.register_structure(node, renderer)
+      node
+    end
+
+    def text(value = UNSET, id: nil, **props, &reader)
+      node = component(:text, id:, **props)
+      bind_or_set(node, "text", value, reader)
+      node
+    end
+
+    def icon(name, id: nil, **props) = component(:icon, id:, name: name.to_s, **props)
+    def image(source, id: nil, **props) = component(:image, id:, source: source.to_s, **props)
+    def spacer(id: nil, **props) = component(:spacer, id:, **props)
+    def separator(id: nil, **props) = component(:separator, id:, **props)
+    def section_header(value, id: nil, **props) = component(:section_header, id:, text: value.to_s, **props)
+
+    def button(label, id: nil, **props, &handler)
+      action_component(:button, :text, label, id:, props:, handler:)
+    end
+
+    def action_button(icon, id: nil, **props, &handler)
+      action_component(:action_button, :icon, icon, id:, props:, handler:)
+    end
+
+    def toggle(label = "", id: nil, checked: UNSET, **props, &handler)
+      input_component(:toggle, :checked, checked, id:, props: props.merge(label: label.to_s), handler:)
+    end
+
+    def toggle_switch(id: nil, checked: UNSET, **props, &handler)
+      input_component(:toggle_switch, :checked, checked, id:, props:, handler:)
+    end
+
+    VALUE_INPUTS.each do |type, property|
+      define_method(type) do |value = UNSET, id: nil, **props, &handler|
+        input_component(type, property, value, id:, props:, handler:)
+      end
+    end
+
+    def progress(value = UNSET, id: nil, **props)
+      input_component(:progress, :value, value, id:, props:)
+    end
+
+    def on_click(&handler)
+      raise ArgumentError, "on_click must be inside a surface or control" if @stack.empty?
+      on(@stack.last, :click, &handler)
+    end
+
+    def on(target_or_event, event = nil, &handler)
+      raise ArgumentError, "on requires a block" unless handler
+      if target_or_event.is_a?(Node)
+        raise ArgumentError, "on(node, event) requires an event" unless event
+        node, event_name = target_or_event, event
+      else
+        raise ArgumentError, "on must be inside a surface or control" if @stack.empty?
+        node, event_name = @stack.last, target_or_event
+      end
+      @application.register_handler(node.id, event_name, handler)
+    end
+
+    def property(name, value = UNSET, &reader)
+      raise ArgumentError, "property must be inside a control" if @stack.empty?
+      bind_or_set(@stack.last, name.to_s, value, reader)
+    end
+
+    def bind(node, property, animation: nil, &reader)
+      raise ArgumentError, "bind requires a node returned by a component method" unless node.is_a?(Node)
+      raise ArgumentError, "bind requires a block" unless reader
+      transition = normalize_animation(animation)
+      @application.register_binding(node, property.to_s, reader, animation: transition)
+      node
+    end
+
+    def animation(**options) = Animation.new(**options)
+
+    def animate(node, properties, duration: 200, easing: :in_out_quad, delay: 0)
+      transition = Animation.new(duration:, easing:, delay:)
+      @application.animate(node, properties, transition)
+      node
+    end
+
+    def animate_sequence(node, steps)
+      elapsed = 0
+      tracks = steps.flat_map do |step|
+        options = step.transform_keys(&:to_sym)
+        properties = options.fetch(:to)
+        transition = Animation.new(
+          duration: options.fetch(:duration, 200),
+          easing: options.fetch(:easing, :in_out_quad),
+          delay: elapsed + options.fetch(:delay, 0)
+        )
+        elapsed = transition.delay + transition.duration + options.fetch(:pause, 0)
+        @application.animation_tracks(node, properties, transition)
+      end
+      @application.emit_animation(node, tracks)
+      node
+    end
+    def transaction(&block) = @application.state.transaction { instance_eval(&block) }
+    def after(seconds, &block) = @application.schedule(:after, interval: seconds, &block)
+    def every(seconds, immediate: false, &block) = @application.schedule(:every, interval: seconds, immediate:, &block)
+    def async(&block) = @application.schedule(:async, &block)
+    def run_command(argv, **options) = Command.run(argv, **options)
+    def rebuild(node, &renderer) = within(node, &renderer)
+    def open_panel(name) = @application.emit_effect("open_panel", "surface" => name.to_s)
+
+    def close_panel(name = nil)
+      @application.emit_effect("close_panel", name.nil? ? {} : { "surface" => name.to_s })
+    end
+
+    private
+
+    def surface(name, id:, options: {}, &block)
+      raise ArgumentError, "surface requires a block" unless block
+      node = @application.build_node(:container, explicit_id: id)
+      @application.add_surface(name, node, options:)
+      within(node, &block)
+      node
+    end
+
+    def action_component(type, property, value, id:, props:, handler:)
+      node = component(type, id:, **props.merge(property => value.to_s))
+      @application.register_handler(node.id, :click, handler) if handler
+      node
+    end
+
+    def input_component(type, property, value, id:, props:, handler: nil)
+      props = props.merge(property => value) unless value.equal?(UNSET)
+      node = component(type, id:, **props)
+      @application.register_handler(node.id, :change, handler) if handler
+      node
+    end
+
+    def within(node, &block)
+      @stack.push(node)
+      instance_eval(&block)
+    ensure
+      @stack.pop
+    end
+
+    def append(node)
+      raise ArgumentError, "#{node.type} must be inside a surface or container" if @stack.empty?
+      @stack.last.children << node
+    end
+
+    def bind_or_set(node, property, value, reader)
+      if reader
+        raise ArgumentError, "pass a value or a reactive block, not both" unless value.equal?(UNSET)
+        @application.register_binding(node, property, reader)
+      else
+        raise ArgumentError, "#{property} requires a value or block" if value.equal?(UNSET)
+        node.props[property] = @application.normalize_value(value, property)
+      end
+    end
+
+    def normalize_animation(animation)
+      case animation
+      when nil then nil
+      when Animation then animation
+      when Hash then Animation.new(**animation)
+      else raise ArgumentError, "animation must be an OmarchyUI::Animation or options hash"
+      end
+    end
+  end
+end