phlex-reactive 0.11.5 → 0.11.6

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

@@ -793,8 +793,34 @@ module Phlex
         # The container cloned rows land in — one per association, inside the
         # root. Server-rendered rows (an edit form's persisted children) render
         # inside it too.
-        def reactive_nested_list(association)
-          { data: { reactive_nested_list: nested_identifier!(:reactive_nested_list, :association, association) } }
+        #
+        # `as: :json` (issue #208) switches the SUBMIT wire from Rails'
+        # accepts_nested_attributes_for names to ONE hidden JSON field — for an
+        # app whose controller already parses a serialized JSON param
+        # (`JSON.parse(params[:order][:todos])`) instead of nested attributes.
+        # The container keeps its plain marker (nestedAdd/Remove still key on
+        # it), and gains data-reactive-nested-json plus a scope-aware selector
+        # naming the hidden field the client mirrors the rows into on every
+        # add/remove/input. The default (:attributes) is unchanged — the plain
+        # accepts_nested_attributes_for wire.
+        def reactive_nested_list(association, as: :attributes)
+          name = nested_identifier!(:reactive_nested_list, :association, association)
+          data = { reactive_nested_list: name }
+          return { data: } if as == :attributes
+
+          unless as == :json
+            raise ArgumentError,
+              "reactive_nested_list(as:) takes :attributes (the default, Rails nested-attribute names) " \
+              "or :json (serialize the rows into one hidden JSON field), got #{as.inspect}"
+          end
+
+          # JSON mode: mark the container and name the hidden field the client
+          # keeps in sync — a scope-aware [name="…"] selector, the same
+          # convention reactive_tags/reactive_filter use so the field resolves
+          # under reactive_scope too.
+          data[:reactive_nested_json] = name
+          data[:reactive_nested_json_field] = %([name="#{scoped_field_name(association)}"])
+          { data: }
         end
 
         # The <template> holding ONE row's markup (server-owned, inert until
@@ -864,6 +890,22 @@ module Phlex
         #
         #   reactive_show_targets(mode: { "#advanced-tab" => "advanced" },
         #                         kind: { "#premium-note" => %w[gold platinum] })
+        #
+        # MULTI-FIELD targets (issue #209): a "#id" KEY takes a full
+        # if:/if_any:/unless: conditions Hash — the SAME language reactive_show
+        # speaks, so a cross-root target can finally read a COMBINATION of
+        # owned fields (the last case forcing a bespoke JS listener):
+        #
+        #   reactive_show_targets("#trade-warning" => {
+        #     if: { type: "trade", price: ..0 }   # type == "trade" AND price <= 0
+        #   })
+        #
+        # Target-keyed and field-keyed entries mix in the ONE call (a "#" key is
+        # unambiguous — a field name may never start with "#"). The client folds
+        # the target's DNF payload with the same per-term field reads as an
+        # in-root reactive_show: every referenced field must be OWNED by this
+        # root (a missing owned field reads as blank, fail-closed); a target
+        # whose fields are ALL unowned is left alone, like the single-field skip.
         def reactive_show_targets(field, targets = nil)
           field_maps = targets.nil? ? field : { field => targets }
           unless field_maps.is_a?(Hash) && field_maps.any?
@@ -873,16 +915,12 @@ module Phlex
           end
 
           normalized = field_maps.to_h do |name, map|
-            # Catch the forgotten-field-name misuse — reactive_show_targets(
-            # "#id" => {…}) — before the per-target validation turns it into a
-            # baffling "predicate" error.
             if name.to_s.start_with?("#")
-              raise ArgumentError,
-                "reactive_show_targets: #{name.inspect} looks like a target selector, not a field " \
-                "name — call reactive_show_targets(:field, #{name.inspect} => { ... })"
+              # Target-keyed conditions (issue #209): "#id" => { if:/if_any:/unless: }.
+              [name.to_s, normalize_show_target_conditions(name.to_s, map)]
+            else
+              [name.to_s, normalize_show_target_map(name, map)]
             end
-
-            [name.to_s, normalize_show_target_map(name, map)]
           end
 
           { data: { reactive_show_targets: normalized.to_json } }
@@ -1122,6 +1160,40 @@ module Phlex
           end
         end
 
+        # Normalize + validate ONE target-keyed entry (issue #209): the "#id"
+        # key is a single id selector (the same declare-time guard as
+        # field-keyed targets), the value a full if:/if_any:/unless: conditions
+        # Hash compiled by ShowConditions into the SAME { "any" => groups } DNF
+        # payload reactive_show emits. Anything else — a bare value, unknown
+        # keys, empty conditions — raises a guided error at render (a dead
+        # binding must never reach the browser).
+        def normalize_show_target_conditions(selector, conditions)
+          unless selector.match?(DSL::MIRROR_ID_SELECTOR)
+            raise ArgumentError,
+              "reactive_show_targets target #{selector.inspect} must be a single " \
+              "ID selector (\"#id\") — cross-root visibility is id-allowlisted, like mirror: (#159)"
+          end
+          unless conditions.is_a?(Hash) && conditions.any?
+            raise ArgumentError,
+              "reactive_show_targets: a target key takes a conditions Hash — " \
+              "reactive_show_targets(#{selector.inspect} => { if: { field: value, ... } }); " \
+              "to key by field instead: reactive_show_targets(:field, #{selector.inspect} => value). " \
+              "Got #{selector.inspect} => #{conditions.inspect}"
+          end
+          # Unknown keys are reported BEFORE the presence check so { bogus: 1 }
+          # names its offender instead of the generic shape message (specific
+          # beats generic). A non-empty hash surviving this subtraction holds
+          # only condition keys, so no separate presence check remains.
+          if (unknown = conditions.keys - SHOW_CONDITION_KEYS).any?
+            raise ArgumentError,
+              "reactive_show_targets #{selector.inspect}: unknown conditions key(s) " \
+              "#{unknown.map(&:inspect).join(", ")} — a target's conditions Hash takes only " \
+              "if:/if_any:/unless: (the reactive_show language)"
+          end
+
+          { "any" => Phlex::Reactive::ShowConditions.normalize(**conditions) }
+        end
+
         # Reject the removed 0.9.5 reactive_show surface (issue #180 clean break)
         # with a GUIDED error printing the if:/if_any:/unless: rewrite. A
         # positional field, a predicate kwarg (equals:/not:/in:/gte:/…), or a

data/lib/phlex/reactive/version.rb

@@ -2,6 +2,6 @@
 
 module Phlex
   module Reactive
-    VERSION = "0.11.5"
+    VERSION = "0.11.6"
   end
 end

metadata

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