phlex-reactive 0.13.1 → 0.13.3

data/lib/phlex/reactive/component/dsl.rb

@@ -389,6 +389,13 @@ module Phlex
           #     inputs: { title: :string, qty: :number },
           #     outputs: %i[title_preview char_count]
           #
+          # A CHECKBOX contributes its checked state, never its constant .value
+          # (issue #262): 1/0 as a :number, "true"/"false" as a :string, and a
+          # real boolean as a :boolean. It wins over the hidden companion Rails
+          # renders before it. A radio group contributes its checked radio's value.
+          #
+          #   reactive_compute :total, inputs: [:price, { gift_wrap: :boolean }], outputs: %i[total]
+          #
           # An output with no matching form field writes to its reactive_text(:name)
           # node (textContent); a declared input also mirrors into its own text node
           # with no reducer. The array form's wire stays byte-identical.

data/lib/phlex/reactive/component/helpers.rb

@@ -449,7 +449,7 @@ module Phlex
         # the baseline is the DOM's own `defaultValue`/`defaultChecked`/
         # `defaultSelected` from the last server render (dirty = current ≠ default).
         # The descriptor deep-merges via mix, so a caller's own data-action is
-        # token-joined, not clobbered (CLAUDE.md Never-Do #8).
+        # token-joined, not clobbered (AGENTS.md Never-Do #8).
         def reactive_field(param, **attrs)
           # Issue #184: the removed dirty: kwarg lands in **attrs — catch it and
           # print the reactive_dirty rewrite.
@@ -1232,8 +1232,9 @@ module Phlex
         # The inputs param wire (issue #104). Untyped (array form) → a JSON ARRAY of
         # names, byte-identical to the shipped wire so the client keeps its numeric
         # coercion. Typed (hash form) → a JSON OBJECT of name→type
-        # ({"title":"string","qty":"number"}) so the client reads a :string raw and
-        # coerces a :number through Number.
+        # ({"title":"string","qty":"number"}) so the client reads a :string raw,
+        # coerces a :number through Number and reads a :boolean as a checkbox's
+        # checked state (issue #262).
         def compute_inputs_param(definition)
           types = definition.input_types
           return definition.inputs.map(&:to_s).to_json if types.nil?

data/lib/phlex/reactive/component.rb

@@ -102,7 +102,8 @@ module Phlex
       # `input_types` (issue #104) is nil for the ARRAY input form (untyped ⇒ the
       # client coerces every input through Number, the shipped behavior) and a
       # { name => type } hash for the typed HASH form (:string reads the field
-      # value raw, :number coerces). `inputs` stays the ordered name list either
+      # value raw, :number coerces, :boolean reads a checkbox's checked state —
+      # issue #262). `inputs` stays the ordered name list either
       # way, so iteration order is preserved and the array-form wire is unchanged.
       #
       # `mirror` (issue #159) is nil when undeclared, else a { name => [id

data/lib/phlex/reactive/param_schema.rb

@@ -174,6 +174,22 @@ module Phlex
         coerced.equal?(DROP) ? {} : coerced
       end
 
+      # The key this DECLARATION holds for `name` if it declares it as an ARRAY
+      # param, else nil. Reads the declaration, never the incoming params, so the
+      # endpoint's empty-group announcement (issue #258) can only ever fill
+      # something the action asked for.
+      #
+      # A key that is neither a String nor a Symbol stays unresolved on purpose:
+      # `compile` accepts `{ 0 => [:string] }`, but `coerce_hash` raises on
+      # `0.to_sym` the moment that key is PRESENT, and the announcement is what
+      # would make it present. Resolving it would turn a request that answers 200
+      # and fills nothing into a 500.
+      def array_param(name)
+        name = name.to_s
+        key, type = @schema.find { |k, _| (k.is_a?(String) || k.is_a?(Symbol)) && k.to_s == name }
+        key if type.is_a?(Array)
+      end
+
       private
 
       # Coerce a value against a declared type. Arrays accept both a real JSON

data/lib/phlex/reactive/settles.rb

@@ -27,15 +27,19 @@ module Phlex
     # ## The handle rides ActiveJob metadata
     #
     # `reply.pending` installs a Pending::Handle in a thread-local and runs the
-    # caller's enqueue inside it; #serialize below copies it into the job's
-    # metadata, #deserialize restores it. So `perform`'s ARITY IS UNTOUCHED and
-    # every OTHER caller of the same job — a nightly sweep, a webhook — enqueues
-    # it with no handle, in which case `reactive_settle` is a NO-OP that returns
-    # nil. That is load-bearing: these jobs almost always have non-UI callers.
+    # caller's enqueue inside it; #initialize below captures it onto the job
+    # instance, #serialize copies it into the job's metadata, #deserialize
+    # restores it. So `perform`'s ARITY IS UNTOUCHED and every OTHER caller of
+    # the same job — a nightly sweep, a webhook — builds it with no handle, in
+    # which case `reactive_settle` is a NO-OP that returns nil. That is
+    # load-bearing: these jobs almost always have non-UI callers.
     #
-    # (`perform_now` does not round-trip through serialize/deserialize, so it
-    # carries no handle either — which is the correct reading: a synchronous
-    # call has no pending UI waiting on it.)
+    # (A `perform_now` INSIDE the enqueue block does carry the handle, since the
+    # instance is built there — so it settles synchronously. That is the right
+    # reading: `reply.pending` already marked the targets, and something has to
+    # resolve the shimmer. The settle's durable message is replayed from
+    # since-id 0 when the client opens the subscription, so arriving before it
+    # exists is safe.)
     #
     # ## A rolled-back action
     #
@@ -57,12 +61,45 @@ module Phlex
       # shared namespace with every other gem in the app.
       SETTLE_METADATA_KEY = "phlex_reactive_settle"
 
-      # Capture the in-flight settle handle at ENQUEUE time. This is the same
-      # seam pgbus's own ActiveJob::CurrentAttributes integration uses, and it
-      # is adapter-agnostic: it works under :async, :test and :inline as well as
-      # a real backend, which is what app specs need.
+      # Capture the in-flight settle handle at INSTANTIATION (issue #254).
+      #
+      # `serialize` is the seam pgbus's own ActiveJob::CurrentAttributes
+      # integration uses, and it looked like the enqueue-time hook — but under
+      # Rails' `enqueue_after_transaction_commit = true` (the 7.2+ recommended
+      # setting) `job.enqueue` is deferred to
+      # ActiveRecord.after_all_transactions_commit, and the endpoint runs every
+      # action inside a transaction. So the deferral — and with it `serialize` —
+      # always fires AFTER reply.pending's `with_handle` block has exited, with
+      # an empty thread-local: no metadata key, a no-op `reactive_settle`, and a
+      # row left shimmering until someone reloads.
+      #
+      # `new` is the one moment guaranteed to be inside the block:
+      # `perform_later` → `job_or_instantiate` → `new` is synchronous, deferral
+      # or not. Pending#each_with_narrowed_handle narrows the thread-local per
+      # record BEFORE `perform_later`, so the `job:`/`args:` attribution
+      # contract is preserved.
+      def initialize(...)
+        super
+        @reactive_settle_handle ||= Phlex::Reactive::Pending.current_handle
+      end
+
+      # The same capture at ENQUEUE, for an instance built BEFORE the block and
+      # enqueued inside it (`job = MyJob.new(...)` … `reply.pending { job.enqueue }`).
+      # `enqueue` runs synchronously inside the block — it is the deferral it
+      # REGISTERS that runs later — so this is the last moment the thread-local
+      # is visible. `||=` never overwrites: a retry's `retry_job` re-enqueues a
+      # DESERIALIZED instance, which must keep the handle it came back with.
+      def enqueue(...)
+        @reactive_settle_handle ||= Phlex::Reactive::Pending.current_handle
+        super
+      end
+
+      # Prefer the captured handle; the thread-local fallback covers an instance
+      # serialized inside the block without going through either hook. A retry
+      # re-enqueue re-serializes the SAME instance, which keeps its handle — the
+      # right reading: the pending UI is still waiting on this work.
       def serialize
-        handle = Phlex::Reactive::Pending.current_handle
+        handle = @reactive_settle_handle || Phlex::Reactive::Pending.current_handle
         return super unless handle
 
         super.merge(SETTLE_METADATA_KEY => handle.to_h_wire)

data/lib/phlex/reactive/test_helpers.rb

@@ -64,10 +64,17 @@ module Phlex
       # `:file` param is present, issue #34): token + act flat, params bracketed.
       # No JSON Content-Type — Rails' test `post` builds the multipart body from
       # the nested Hash (files ride as UploadedFile values).
-      def post_reactive_multipart(component_or_class, act, params: {}, payload: {})
+      #
+      # `empty_groups:` names the `[]` groups the client cleared (issue #258). A
+      # form body cannot carry an empty array, so the client leaves those keys
+      # out and announces them in a field of its own; passing the names here is
+      # how a spec reproduces that request. Omit it and the body is exactly what
+      # it was before the field existed.
+      def post_reactive_multipart(component_or_class, act, params: {}, payload: {}, empty_groups: [])
         token = reactive_action_token(component_or_class, payload)
-        post Phlex::Reactive.action_path,
-          params: { token:, act:, params: },
+        body = { token:, act:, params: }
+        body[:empty_groups] = empty_groups if empty_groups.present?
+        post Phlex::Reactive.action_path, params: body,
           headers: { "Accept" => "text/vnd.turbo-stream.html" }
       end
 

data/lib/phlex/reactive/version.rb

@@ -2,6 +2,6 @@
 
 module Phlex
   module Reactive
-    VERSION = "0.13.1"
+    VERSION = "0.13.3"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: phlex-reactive
 version: !ruby/object:Gem::Version
-  version: 0.13.1
+  version: 0.13.3
 platform: ruby
 authors:
 - Mikael Henriksson