omarchy-ui 0.0.2-x86_64-linux → 0.0.3-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8c832cd4301f1b237ef13b46fea6eed08cafdae66a1411eae88a887a59a5cf0
-  data.tar.gz: 60b933f9795e67a7b6c1ce2d8e90cb15716dbc9821250bbd8e85a4c7e840d1f1
+  metadata.gz: 4f53f63774323d862684e519c9884aed320d675b9391d228354def2b7768f0e4
+  data.tar.gz: 0ed0b927c051f03f6418f737769b51bc16c80114a70e362254daf23832f72196
 SHA512:
-  metadata.gz: 415009fe051699cef4821e70e394dec94b883aa86dfd325a8c2e8afd38a7a3076c9ec21df6efea747ae791b715c5a5de92ef837ccef84f458683f49d805e295e
-  data.tar.gz: 3a017f0872adcec2dff15d35f03e7ac40a2d463dcee56a978e2e514aee187c804ecfce9e8573e3cf1b4312fad5364ec0686af3e7e9e6f7f9eab9ea09a45a1eab
+  metadata.gz: 20c6694b5a1641f360402835d44b2eabefd164a373e28f94b878d0e41e1351cb3c40a67db4a19e2d7ff0df5298d1a6ff0ed8316ea7aa89ffe2073ffef2f7dfd0
+  data.tar.gz: 00457faae9811da4e493d35d77b7c0ed514200c16acd51174841e5e3a172f9687a891d44f18c5dca60ad1be1ea47398a4b7128160d66dfd8c37c1ad796dde9df

data/README.md

@@ -25,29 +25,28 @@ end
 
 ## Install
 
-On Omarchy x86-64, install the gem and start building:
+On Omarchy x86-64, install the gem:
 
 ```bash
 gem install omarchy-ui
-omarchy_ui new "My App"
 ```
 
-The gem contains everything required to create, launch, and bundle an application. Developers do
+The gem contains everything required to launch and bundle an application. Developers do
 not need to install a separate runtime or copy framework files. Bundled applications require only
 an Omarchy computer to run.
 
-## Create and run an application
+## Start an application
 
 ```bash
-omarchy_ui new "My App"
-cd my-app
+omarchy_ui new MyApp
+cd myapp
 omarchy_ui launch main.rb
 ```
 
-The standalone generator creates no plugin manifest or copied runtime files:
+A new standalone project contains only application-owned files:
 
 ```text
-my-app/
+myapp/
 ├── Components/
 │   └── Welcome.qml
 ├── README.md
@@ -63,10 +62,10 @@ From an application directory:
 
 ```bash
 omarchy_ui bundle
-./dist/my-app/run
+./dist/myapp/run
 ```
 
-`bundle` creates a self-contained application under `dist/<project-name>/`. The generated `run`
+`bundle` creates a self-contained application under `dist/<project-name>/`. Its `run`
 launcher works on another Omarchy computer without Ruby or the `omarchy-ui` gem.
 
 An Omarchy Shell plugin is a separate packaging mode. It requires `manifest.json` so the shell
@@ -306,15 +305,6 @@ Component names, files, properties, events, IDs, effects, values, message sizes,
 limits are validated. Commands use argv arrays without a shell. Applications and plugins run with
 the current user's permissions, so review third-party code before installing it.
 
-## Omarchy Phone example
-
-`examples/omarchy-phone` demonstrates reactive controls, background discovery, safe commands,
-ADB pairing and connection, scrcpy launching, iPhone discovery, and UxPlay AirPlay mirroring.
-
-```bash
-omarchy_ui launch examples/omarchy-phone/main.rb
-```
-
 ## Development and verification
 
 ```bash
@@ -324,7 +314,7 @@ ruby script/benchmark.rb
 ```
 
 The suite covers state, bindings, repeated structures, event persistence, component schemas,
-animation tracks and sequences, tasks, command safety, standalone project generation, packaging,
+animation tracks and sequences, tasks, command safety, standalone projects, packaging,
 manifests, component contracts, linting, and the phone backend.
 
 ## License

data/lib/omarchy_ui/application.rb

@@ -190,16 +190,50 @@ module OmarchyUI
     end
 
     def reconcile_structure(structure)
+      previous_children = structure.last_children
       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
+      if patchable_trees?(previous_children, children)
+        emit_property_patches(previous_children, children)
+        structure.last_children = children
+        return
+      end
       structure.last_children = children
       emit("v" => PROTOCOL_VERSION, "type" => "patch", "op" => "replace_children",
            "id" => structure.node.id, "children" => children)
     end
 
+    def patchable_trees?(previous, current)
+      return false unless previous.length == current.length
+      previous.zip(current).all? do |before, after|
+        before["id"] == after["id"] && before["type"] == after["type"] &&
+          before.fetch("events", []) == after.fetch("events", []) &&
+          before.fetch("props", {}).keys.sort == after.fetch("props", {}).keys.sort &&
+          patchable_trees?(before.fetch("children", []), after.fetch("children", []))
+      end
+    end
+
+    def emit_property_patches(previous, current)
+      previous.zip(current).each do |before, after|
+        before.fetch("props", {}).each do |property, old_value|
+          value = after.fetch("props", {}).fetch(property)
+          next if value == old_value
+          next if echoed_input_patch?(after.fetch("id"), property, value)
+          emit("v" => PROTOCOL_VERSION, "type" => "patch", "op" => "set",
+               "id" => after.fetch("id"), "property" => property, "value" => value)
+        end
+        emit_property_patches(before.fetch("children", []), after.fetch("children", []))
+      end
+    end
+
+    def echoed_input_patch?(control_id, property, value)
+      @active_event && @active_event["event"] == "input" && @active_event["id"] == control_id &&
+        %w[text value].include?(property) && @active_event.dig("payload", "value") == value
+    end
+
     def unregister_subtree(node)
       node.children.each { |child| unregister_subtree(child) }
       @nodes.delete(node.id)
@@ -212,7 +246,12 @@ module OmarchyUI
       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)
+      begin
+        @active_event = message
+        @builder.instance_exec(message["payload"] || {}, &handler)
+      ensure
+        @active_event = nil
+      end
       acknowledgement = {
         "v" => PROTOCOL_VERSION, "type" => "ack", "seq" => message["seq"],
         "id" => message.fetch("id"), "event" => message.fetch("event")

data/lib/omarchy_ui/builder.rb

@@ -16,11 +16,12 @@ module OmarchyUI
     def initialize(application)
       @application = application
       @stack = []
+      @dynamic_scopes = []
     end
 
     def component(type, id: nil, **props, &block)
       definition = @application.components.fetch(type)
-      node = @application.build_node(type, explicit_id: id, props:)
+      node = @application.build_node(type, explicit_id: id || scoped_id(type), props:)
       append(node)
       if block
         raise ArgumentError, "#{type} is not a container" unless definition.container
@@ -64,7 +65,8 @@ module OmarchyUI
       definition = @application.components.fetch(type)
       raise ArgumentError, "dynamic component must be a container: #{type}" unless definition.container
 
-      node = component(type, id:, **props, &renderer)
+      node = component(type, id:, **props)
+      within_dynamic(node, &renderer)
       @application.register_structure(node, renderer)
       node
     end
@@ -166,7 +168,7 @@ module OmarchyUI
     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 rebuild(node, &renderer) = within_dynamic(node, &renderer)
     def open_panel(name) = @application.emit_effect("open_panel", "surface" => name.to_s)
 
     def close_panel(name = nil)
@@ -175,6 +177,20 @@ module OmarchyUI
 
     private
 
+    def scoped_id(type)
+      return nil if @dynamic_scopes.empty?
+      scope = @dynamic_scopes.last
+      scope[:sequence] += 1
+      "#{scope.fetch(:id)}.#{type}.#{scope.fetch(:sequence)}"
+    end
+
+    def within_dynamic(node, &block)
+      @dynamic_scopes.push({ id: node.id, sequence: 0 })
+      within(node, &block)
+    ensure
+      @dynamic_scopes.pop
+    end
+
     def surface(name, id:, options: {}, &block)
       raise ArgumentError, "surface requires a block" unless block
       node = @application.build_node(:container, explicit_id: id)
@@ -192,7 +208,8 @@ module OmarchyUI
     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
+      event = type == :text_field ? :input : :change
+      @application.register_handler(node.id, event, handler) if handler
       node
     end
 

data/lib/omarchy_ui/cli.rb

@@ -103,12 +103,15 @@ module OmarchyUI
       destination = File.join(source, "dist", File.basename(source))
       raise ArgumentError, "bundle destination already exists: #{destination}" if File.exist?(destination)
       FileUtils.mkdir_p(destination)
-      entries = Dir.children(source).reject { |entry| %w[.git dist].include?(entry) }
+      entries = application_entries(source)
       FileUtils.cp_r(entries.map { |entry| File.join(source, entry) }, destination)
       Project.install_runtime(destination)
-      runtime = File.join(destination, "omarchy-ui-runtime")
-      FileUtils.cp(Runtime::BUNDLED, runtime)
-      FileUtils.chmod(0o755, runtime)
+      if File.file?(File.join(destination, "manifest.json"))
+        raise ArgumentError, "bundled plugin validation failed" unless system("omarchy", "plugin", "validate", destination)
+        @out.puts("Bundled plugin in #{destination}")
+        return 0
+      end
+
       %w[Commons Ui].each do |module_name|
         FileUtils.ln_s(File.join("/usr/share/omarchy/shell", module_name), File.join(destination, module_name))
       end
@@ -135,11 +138,15 @@ module OmarchyUI
       [ENV["QT_LOGGING_RULES"], "qt.qpa.services.warning=false"].compact.reject(&:empty?).join(";")
     end
 
+    def application_entries(source)
+      generated = Project::RUNTIME_FILES + %w[omarchy-ui-runtime run Commons Ui]
+      Dir.children(source).reject { |entry| %w[.git dist].include?(entry) || generated.include?(entry) }
+    end
+
     def push(arguments)
       enable = !arguments.delete("--no-enable")
       restart = !arguments.delete("--no-restart")
       source = File.expand_path(arguments.shift || Dir.pwd)
-      Runtime.install_shared
       manifest_path = File.join(source, "manifest.json")
       manifest = JSON.parse(File.read(manifest_path))
       plugin_id = manifest.fetch("id")
@@ -185,7 +192,7 @@ module OmarchyUI
     def stage_project(source, parent: nil, prefix: ".omarchy-ui-staging-")
       raise ArgumentError, "project directory not found: #{source}" unless File.directory?(source)
       staging = parent ? Dir.mktmpdir(prefix, parent) : Dir.mktmpdir(prefix)
-      entries = Dir.children(source).reject { |entry| entry == ".git" }
+      entries = application_entries(source)
       FileUtils.cp_r(entries.map { |entry| File.join(source, entry) }, staging) unless entries.empty?
       Project.install_runtime(staging) if File.file?(File.join(staging, "main.rb"))
       staging

data/lib/omarchy_ui/project.rb

@@ -28,7 +28,7 @@ module OmarchyUI
     def self.install_runtime(path, framework_root: FRAMEWORK_ROOT)
       RUNTIME_FILES.each do |file|
         destination = File.join(path, file)
-        FileUtils.cp(File.join(framework_root, file), destination) unless File.exist?(destination)
+        FileUtils.cp(File.join(framework_root, file), destination)
       end
       bundled_runtime = File.join(framework_root, "vendor", "runtime", "x86_64-linux", "omarchy-ui-runtime")
       if File.file?(bundled_runtime)

data/lib/omarchy_ui.rb

@@ -15,7 +15,7 @@ require_relative "omarchy_ui/project"
 require_relative "omarchy_ui/runtime"
 
 module OmarchyUI
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
   FRAMEWORK_ROOT = File.expand_path("..", __dir__)
 
   def self.plugin(&definition)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omarchy-ui
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: x86_64-linux
 authors:
 - Adam Moussa Ali