phlex-reactive 0.15.2 → 0.15.4

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Phlex
+  module Reactive
+    module Component
+      # The reactive_show keywords beyond the condition itself.
+      #
+      # after: (issue #396) — keep the section hidden until the named field has
+      # fired `blur` once since connect. `after: :blur` names the condition's
+      # one field; a condition over several fields names it: `after: :code`.
+      # The client keeps the touched flag on the root's controller, so a morph
+      # keeps it and a full navigation (a new controller) drops it. The server
+      # cannot have seen a blur, so first paint is hidden.
+      #
+      # clear:, focus:, scroll: (issue #394) — work the client does when the
+      # section CHANGES visibility, never on first paint. Going hidden, each
+      # clear: field (owned, scope-aware) is emptied with js.set_value's write
+      # (a checkbox or radio is unchecked; a file input is rejected at render) and a bubbling
+      # `input` is dispatched per field that changed. Going visible, the first
+      # element inside the root matching focus: is focused, and scroll: true
+      # scrolls the section into view. clear: names are checked at render: an
+      # unknown one, or a file input, raises.
+      module ShowOptions
+        private
+
+        # The wire data for a reactive_show's options, merged into its data:.
+        def show_option_data(groups, after:, clear:, focus:, scroll:)
+          data = {}
+          data[:reactive_show_after] = show_after_field!(groups, after) unless after.nil?
+          data[:reactive_show_clear] = show_clear_fields!(clear).to_json unless clear.nil?
+          data[:reactive_show_focus] = show_focus!(focus) unless focus.nil?
+          data[:reactive_show_scroll] = "true" if show_scroll!(scroll)
+          data
+        end
+
+        def show_clear_fields!(clear)
+          names = Array(clear).map do
+            name = it.to_s if it.is_a?(Symbol) || it.is_a?(String)
+            next name unless name.nil? || name.strip.empty?
+
+            raise ArgumentError,
+              "reactive_show clear: takes a field name or an Array of them, got #{clear.inspect}"
+          end
+          raise ArgumentError, "reactive_show clear: needs at least one field name, got #{clear.inspect}" if names.empty?
+
+          reference_fields!(:reactive_show, :clear, names.uniq, no_file: true)
+          names.uniq
+        end
+
+        def show_focus!(focus)
+          return focus if focus.is_a?(String) && !focus.strip.empty?
+
+          raise ArgumentError,
+            "reactive_show focus: takes a non-empty CSS selector inside the root (e.g. \"#notes\"), got #{focus.inspect}"
+        end
+
+        def show_scroll!(scroll)
+          return scroll if [nil, true, false].include?(scroll)
+
+          raise ArgumentError, "reactive_show scroll: takes true or false, got #{scroll.inspect}"
+        end
+
+        def show_after_field!(groups, after)
+          fields = Phlex::Reactive::ShowConditions.fields(groups)
+          unless after.is_a?(Symbol) || after.is_a?(String)
+            raise ArgumentError,
+              "reactive_show after: takes :blur or the name of the condition's field to wait for, got #{after.inspect}"
+          end
+
+          name = after == :blur ? show_after_single!(fields) : after.to_s
+          unless fields.include?(name)
+            raise ArgumentError,
+              "reactive_show after: #{after.inspect} is not a field of this condition " \
+              "(it names #{fields.map(&:to_sym).inspect})"
+          end
+
+          reference_fields!(:reactive_show, :after, [name])
+          name
+        end
+
+        def show_after_single!(fields)
+          return fields.first if fields.size == 1
+
+          raise ArgumentError,
+            "reactive_show after: :blur needs a condition over one field — this one names " \
+            "#{fields.map(&:to_sym).inspect}; pass the field to wait for (after: #{fields.first.to_sym.inspect})"
+        end
+      end
+    end
+  end
+end

data/lib/phlex/reactive/doctor.rb

@@ -248,7 +248,15 @@ module Phlex
       # authorization / mark_authorized! call. It is :unknown, NEVER a hard fail:
       # a helper may authorize indirectly, so this is a hint, not a verdict.
       def authorization_check(components)
-        suspects = components.flat_map { unauthorized_action_labels(it) }
+        infos = nil
+        suspects = components.flat_map do
+          next [] if component_defines_authorization_method?(it)
+
+          # Read once, and only when needed: Inspector.components Prism-scans
+          # every component's actions.
+          infos ||= inspector_infos
+          unauthorized_action_labels(it, infos)
+        end
         return Check.new(:ok, "every mutating action appears to authorize", name: :authorization) if suspects.empty?
 
         Check.new(:unknown, "actions with no detected authorization call: #{suspects.join(", ")}",
@@ -394,13 +402,11 @@ module Phlex
       end
 
       # "Klass#action" for every declared action on `klass` that (advisory)
-      # appears unauthorized: the component defines no authorization method in its
-      # ancestry, the action isn't skipped, and the Prism scan (via the shared
-      # Inspector) finds no authorization / mark_authorized! call in its body.
-      def unauthorized_action_labels(klass)
-        return [] if component_defines_authorization_method?(klass)
-
-        info = Phlex::Reactive::Inspector.components.find { it.klass == klass }
+      # appears unauthorized (the caller has already ruled out an authorization
+      # method in its ancestry): the action isn't skipped, and the Prism scan (via
+      # the shared Inspector) finds no authorization / mark_authorized! call in its body.
+      def unauthorized_action_labels(klass, infos)
+        info = infos[klass]
         return [] unless info
 
         info.actions
@@ -417,6 +423,12 @@ module Phlex
       # Phlex::Reactive.authorization_methods and NOT the Inspector's set, which
       # folds in mark_authorized! — every component inherits that instance helper,
       # so including it would silence the check for everything.
+      def inspector_infos
+        Phlex::Reactive::Inspector.components.to_h { [it.klass, it] }
+      rescue StandardError
+        {}
+      end
+
       def component_defines_authorization_method?(klass)
         Phlex::Reactive.authorization_methods.any? do
           klass.method_defined?(it) || klass.private_method_defined?(it)

data/lib/phlex/reactive/engine.rb

@@ -20,10 +20,10 @@ module Phlex
       # build script (scripts/build_client.js), the core's own table and the
       # default entry name the same features —
       # spec/phlex/engine_client_pin_spec.rb fails when they disagree.
-      CLIENT_FEATURES = %w[persist defer form bindings compute sortable presence effects hints devtools].freeze
+      CLIENT_FEATURES = %w[persist defer form bindings compute sortable presence countdown effects hints devtools].freeze
       # (Gzipped, bun zlib level 9, KB = 1,024 B: the default file 30.9 KB; the core 14.3 KB;
       # persist 3.1, defer 2.9, form 1.1, bindings 6.5, compute 2.0, sortable
-      # 3.1, presence 1.3, effects 1.7, hints 0.9, devtools 1.5 KB. spec/javascript/bundle_budget.test.js
+      # 3.1, presence 1.3, countdown 0.9, effects 1.7, hints 0.9, devtools 1.5 KB. spec/javascript/bundle_budget.test.js
       # is the source of truth and holds a ratchet on each.)
 
       # Mount POST /reactive/actions -> Phlex::Reactive::ActionsController#create

data/lib/phlex/reactive/js.rb

@@ -193,6 +193,9 @@ module Phlex
       # focus(to)        — focus the FIRST match of the selector.
       # focus_first(to)  — focus the first FOCUSABLE DESCENDANT of the match
       #                    (e.g. focus the first menuitem inside an opened menu).
+      # blur(to)         — blur the focused element when it IS the match or sits
+      #                    inside it (issue #399): Escape ends a menu's
+      #                    :focus-within. Focus elsewhere is left alone.
 
       def focus(to, global: false)
         append("focus", target_args(to, global:))
@@ -202,6 +205,10 @@ module Phlex
         append("focus_first", target_args(to, global:))
       end
 
+      def blur(to, global: false)
+        append("blur", target_args(to, global:))
+      end
+
       # --- Modal dialogs (issue #365) ---
       #
       # show_modal(to)   — HTMLDialogElement#showModal(): the top layer, a
@@ -297,8 +304,33 @@ module Phlex
       # that read every subscriber's file input would be hostile.
       #   input(type: "file", id: "photo-file", accept: "image/*",
       #     **on_client(:change, js.preview_file("#photo-file", into: "#photo", name: "#photo-name")))
-
-      def preview_file(to, into:, name: nil, global: false)
+      #
+      # Upload validation (issue #382): `valid: true` treats an input whose
+      # validity is false (setCustomValidity, required) as empty, so a rejected
+      # file never gets a preview. An app that clears the input without a
+      # change event dispatches `reactive:file-changed` on it; bind the same op
+      # to that event too and the preview clears:
+      #   op = js.preview_file("#photo-file", into: "#photo", valid: true)
+      #   input(type: "file", id: "photo-file",
+      #     **mix(on_client(:change, op), on_client("reactive:file-changed", op)))
+      #
+      # The box and the refusals (issue #391): `wrap:` is a CSS selector the
+      # client shows when it paints an image and hides when the preview clears
+      # (it shows again only a wrapper it hid itself, never one the author
+      # hid, and never writes its text). `max_bytes:` (a positive Integer)
+      # refuses a larger file before any object URL exists. `accept: true`
+      # reads the input's own accept attribute (extensions, MIME types,
+      # type/*); a String is that list for this op; omitted keeps the image/*
+      # rule. Only an image is painted: a listed non-image (a PDF) clears the
+      # preview and hides `wrap:`, unrefused. A refused file clears the img,
+      # hides `wrap:` and dispatches
+      # `reactive:file-rejected` on the input (detail.reason "type" | "size").
+      # The op never clears input.files nor sets a custom validity message.
+      #   input(type: "file", id: "photo-file", accept: "image/png,image/jpeg",
+      #     **on_client(:change, js.preview_file("#photo-file", into: "#photo",
+      #       wrap: "#photo-frame", max_bytes: 2_000_000, accept: true)))
+
+      def preview_file(to, into:, name: nil, global: false, valid: false, wrap: nil, max_bytes: nil, accept: nil)
         if [:root, ROOT_SENTINEL].include?(to)
           raise ArgumentError,
             "#{self.class}: preview_file reads a file input, not the component root — " \
@@ -308,6 +340,10 @@ module Phlex
         args = { "to" => normalize_target(to), "into" => preview_selector(:into, into) }
         args["name"] = preview_selector(:name, name) unless name.nil?
         args["global"] = true if global
+        args["valid"] = true if valid
+        args["wrap"] = preview_selector(:wrap, wrap) unless wrap.nil?
+        args["max_bytes"] = preview_max_bytes(max_bytes) unless max_bytes.nil?
+        args["accept"] = preview_accept(accept) unless accept.nil? || accept == false
         append("preview_file", args.freeze)
       end
 
@@ -331,9 +367,10 @@ module Phlex
       # onto the `to` <img>. Both are ELEMENTS (:root or a CSS selector,
       # resolved with the op's own scoping, global: included): the URL is read
       # off the live source element in the browser and is never an argument,
-      # so the set_attr refusal of src (issue #96) stays. A missing source, a
-      # non-<img> source or one without src clears the target's src, srcset
-      # and alt; a target that is not an <img> is skipped. The same URL twice
+      # so the set_attr refusal of src (issue #96) stays. A missing or
+      # non-<img> source clears the target's src, srcset and alt; an <img>
+      # source without src removes the target's src and srcset and copies its
+      # alt (issue #381); a target that is not an <img> is skipped. The same URL twice
       # is not written again (no reload). Broadcast-safe: it only reads
       # elements already in the subscriber's document.
       #   button(**on_client(:click, js.copy_media("#logo", from: "#logo-007"))) { "North" }
@@ -516,6 +553,22 @@ module Phlex
           "#{self.class}: preview_file #{key}: must be a CSS selector string, got #{selector.inspect}"
       end
 
+      def preview_max_bytes(bytes)
+        return bytes if bytes.is_a?(Integer) && bytes.positive?
+
+        raise ArgumentError,
+          "#{self.class}: preview_file max_bytes: must be a positive Integer, got #{bytes.inspect}"
+      end
+
+      # true reads the input's accept attribute; a String is the list itself.
+      def preview_accept(accept)
+        return accept if accept == true || (accept.is_a?(String) && !accept.strip.empty?)
+
+        raise ArgumentError,
+          "#{self.class}: preview_file accept: must be true or an accept list " \
+          "(e.g. \"image/png,.jpg\"), got #{accept.inspect}"
+      end
+
       # The [on, off] pair of a two-value toggle_attr, stringified. Loud on a
       # half-specified pair or one that could never change anything.
       def toggle_values(name, values)

data/lib/phlex/reactive/show_conditions/compare_terms.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Phlex
+  module Reactive
+    module ShowConditions
+      # The Hash-valued terms that are not a count: `same:` (issue #395) — a
+      # field equal to ANOTHER owned field — and `digits:` (issue #396) — a
+      # closed format: ASCII digits only, an exact count or an Integer Range,
+      # and an optional digit prefix (`starts_with:`). Compiled and evaluated
+      # here; the client mirrors both in features/bindings.js, and the shared
+      # fixture (spec/fixtures/show_predicate_vectors.json) holds them to
+      # agreement.
+      #
+      # A negated term (under unless:) keeps its shape and carries
+      # "negate" => true, the way unless: turns equals into not.
+      module CompareTerms
+        # The digit-count wire keys: the count suffixes length: uses.
+        DIGITS_KEYS = %w[digits_eq digits_gte digits_lt digits_lte].freeze
+        DIGIT_STRING = /\A[0-9]*\z/
+        PREFIX = /\A[0-9]+\z/
+
+        # { digits: 10, starts_with: "9" } -> ONE term (a Range's bounds sit in
+        # the same term, so unless: can negate the whole format at once).
+        def digits_term(name, hash, negate:)
+          options = option_keys(hash)
+          if (extra = options.keys - %i[digits starts_with]).any?
+            raise ArgumentError, "reactive_show: #{name.inspect} digits: takes only starts_with: (got #{extra.inspect})"
+          end
+          unless options.key?(:digits)
+            raise ArgumentError, "reactive_show: #{name.inspect} starts_with: needs digits: (e.g. digits: 10)"
+          end
+
+          term = { "field" => name }.merge(digits_bounds(name, options[:digits]))
+          term["prefix"] = digits_prefix!(name, options[:starts_with]) if options.key?(:starts_with)
+          term["negate"] = true if negate
+          term
+        end
+
+        # digits: — every character is 0-9, the count fits every bound, and the
+        # value starts with the prefix; negate flips it. A malformed literal
+        # (a hand-built term) is false either way, like the client's skip.
+        def digits_matches?(term, value)
+          keys = DIGITS_KEYS.select { term.key?(it) }
+          return false unless keys.all? { term[it].is_a?(Integer) } && (term["prefix"].nil? || term["prefix"].is_a?(String))
+
+          text = value.to_s
+          ok = text.match?(DIGIT_STRING) &&
+               keys.all? { count_matches?(it, term[it], text.length) } &&
+               (term["prefix"].nil? || text.start_with?(term["prefix"]))
+          ok != (term["negate"] == true)
+        end
+
+        # Symbol/String keys as Symbols; any other key stays as it is, so the
+        # unknown-key check names it in an ArgumentError.
+        def option_keys(hash)
+          hash.transform_keys { it.is_a?(String) || it.is_a?(Symbol) ? it.to_sym : it }
+        end
+
+        # { same: :other, case: :fold } -> one term comparing this field's
+        # value with another owned field's, both read as strings. The other
+        # name is a bare field like any show field (the client applies
+        # reactive_scope).
+        def same_term(name, hash, negate:)
+          options = option_keys(hash)
+          if (extra = options.keys - %i[same case]).any?
+            raise ArgumentError, "reactive_show: #{name.inspect} same: takes only case: (got #{extra.inspect})"
+          end
+
+          term = { "field" => name, "same" => same_field!(name, options[:same]) }
+          term["fold"] = true if same_case!(name, options[:case])
+          term["negate"] = true if negate
+          term
+        end
+
+        # same: — this field's value against the other field's (an absent
+        # field is ""), folded when the term says so; negate flips it.
+        def same_matches?(term, value, values)
+          left = value.to_s
+          right = values.fetch(term["same"], "").to_s
+          if term["fold"] == true
+            left = ascii_fold(left)
+            right = ascii_fold(right)
+          end
+          (left == right) != (term["negate"] == true)
+        end
+
+        # The ASCII-only fold both evaluators apply: A-Z to a-z and nothing
+        # else (never downcase, which folds letters the client would not).
+        def ascii_fold(value)
+          value.tr("A-Z", "a-z")
+        end
+
+        private
+
+        def digits_bounds(name, digits)
+          case digits
+          when Integer
+            return { "digits_eq" => digits } if digits >= 0
+          when Range
+            first = digits.begin
+            last = digits.end
+            if [first, last].compact.any? && [first, last].compact.all? { it.is_a?(Integer) && it >= 0 }
+              bounds = {}
+              bounds["digits_gte"] = first unless first.nil?
+              bounds[digits.exclude_end? ? "digits_lt" : "digits_lte"] = last unless last.nil?
+              return bounds
+            end
+          end
+
+          raise ArgumentError,
+            "reactive_show: #{name.inspect} digits: takes a non-negative Integer or an Integer Range " \
+            "(a digit count), got #{digits.inspect}"
+        end
+
+        def digits_prefix!(name, prefix)
+          return prefix if prefix.is_a?(String) && prefix.match?(PREFIX)
+
+          raise ArgumentError,
+            "reactive_show: #{name.inspect} starts_with: takes a String of digits (0-9), got #{prefix.inspect}"
+        end
+
+        def same_field!(name, other)
+          field = other.to_s if other.is_a?(Symbol) || other.is_a?(String)
+          return field unless field.nil? || field.strip.empty?
+
+          raise ArgumentError,
+            "reactive_show: #{name.inspect} same: needs the other field's name (e.g. same: :email), " \
+            "got #{other.inspect}"
+        end
+
+        # case: is absent (an exact compare) or :fold. Anything else raises:
+        # there is no locale-aware fold to ask for.
+        def same_case!(name, value)
+          return false if value.nil?
+          return true if (value.is_a?(Symbol) || value.is_a?(String)) && value.to_s == "fold"
+
+          raise ArgumentError, "reactive_show: #{name.inspect} case: takes only :fold, got #{value.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/phlex/reactive/show_conditions.rb

@@ -23,6 +23,9 @@ module Phlex
     #   { checked: 1.. } / { checked: 0 } -> checked_* (issue #319 — how many
     #                                   owned boxes of a checkbox GROUP are
     #                                   ticked; same Integer/Range shapes)
+    #   { same: :email }             -> same "email" (issue #395 — equal to
+    #   { same: :email, case: :fold }   ANOTHER owned field; fold lowercases
+    #                                   ASCII A-Z only, on both sides)
     # Under unless: each term is NEGATED (De Morgan):
     #   scalar -> not; Array -> ∉ (AND of nots); Range -> the complement
     #   predicate (¬gte→lt, ¬lte→gt, ¬lt→gte), and a BOUNDED range complements
@@ -49,6 +52,8 @@ module Phlex
       # A Hash value's one key -> its wire-key prefix.
       COUNT_PREFIXES = { "length" => "len", "checked" => "checked" }.freeze
 
+      extend CompareTerms
+
       module_function
 
       # Compile if:/if_any:/unless: into DNF groups. Loud validation at render
@@ -83,7 +88,7 @@ module Phlex
       # Every field named across all groups/terms — drives reactive_values
       # coverage (server first paint only fires when every field is provided).
       def fields(groups)
-        groups.flat_map { |group| group.map { |term| term.fetch("field") } }.uniq
+        groups.flat_map { |group| group.flat_map { |term| [term.fetch("field"), term["same"]].compact } }.uniq
       end
       # rubocop:enable Style/ItBlockParameter
 
@@ -147,7 +152,7 @@ module Phlex
         case value
         when Range then range_terms(name, value)
         when Array then [membership_term(name, value)]
-        when Hash then count_terms(name, value)
+        when Hash then hash_terms(name, value)
         else [{ "field" => name, "equals" => equals_literal(value) }]
         end
       end
@@ -191,6 +196,32 @@ module Phlex
         end
       end
 
+      # --- Hash values: same: (#395, in CompareTerms) or a count -------------
+
+      def hash_terms(name, hash)
+        case hash_kind(hash)
+        when :same then [same_term(name, hash, negate: false)]
+        when :digits then [digits_term(name, hash, negate: false)]
+        else count_terms(name, hash)
+        end
+      end
+
+      # The complement under unless: — a list of alternative term-lists.
+      def hash_complement(name, hash)
+        case hash_kind(hash)
+        when :same then [[same_term(name, hash, negate: true)]]
+        when :digits then [[digits_term(name, hash, negate: true)]]
+        else count_complement(name, hash)
+        end
+      end
+
+      def hash_kind(hash)
+        keys = hash.keys.map(&:to_s)
+        if keys.include?("same") then :same
+        elsif keys.include?("digits") || keys.include?("starts_with") then :digits
+        end
+      end
+
       # --- the count predicates: length: (#226) and checked: (#319) ---------
 
       # A Hash value names a STRUCTURAL predicate over a COUNT — length: (the
@@ -262,7 +293,7 @@ module Phlex
         kind = hash.keys.first.to_s if hash.size == 1
         unless COUNT_PREFIXES.key?(kind)
           raise ArgumentError,
-            "reactive_show: #{name.inspect} Hash value supports only length: or checked: " \
+            "reactive_show: #{name.inspect} Hash value supports only same:, digits:, or one of length: or checked: " \
             "(got #{hash.keys.inspect})"
         end
 
@@ -294,7 +325,7 @@ module Phlex
         name = field.to_s
         case value
         when Range then range_complement(name, value)
-        when Hash then count_complement(name, value)
+        when Hash then hash_complement(name, value)
         when Array
           list = value.map(&:to_s)
           raise ArgumentError, "reactive_show: #{name.inspect} Array needs at least one value" if list.empty?
@@ -333,7 +364,9 @@ module Phlex
         field = term.fetch("field")
         value = values.fetch(field, "")
 
-        if term.key?("equals") then value == term["equals"]
+        if term.key?("same") then same_matches?(term, value, values)
+        elsif CompareTerms::DIGITS_KEYS.any? { term.key?(it) } then digits_matches?(term, value)
+        elsif term.key?("equals") then value == term["equals"]
         elsif term.key?("not") then value != term["not"]
         elsif term.key?("in") then term["in"].include?(value)
         elsif (key = LENGTH_KEYS.find { term.key?(it) }) then count_matches?(key, term[key], value.to_s.length)
@@ -350,7 +383,7 @@ module Phlex
       def count_matches?(key, literal, count)
         return false unless literal.is_a?(Integer)
 
-        case key.delete_prefix("len_").delete_prefix("checked_")
+        case key.split("_", 2).last
         when "eq" then count == literal
         when "gte" then count >= literal
         when "gt" then count > literal

data/lib/phlex/reactive/streamable.rb

@@ -34,7 +34,9 @@ module Phlex
       ThreadViewContext = Struct.new(:view_context, :builder, :renderer, :generation)
 
       # Actor-only ops: a js broadcast rejects a broadcast that carries one.
-      # Focus ops steal focus in every subscriber's tab (issue #96); submit
+      # Focus ops steal focus in every subscriber's tab (issue #96); blur (issue
+      # #399) would drop focus in every subscriber whose focused element sits
+      # inside the target; submit
       # (issue #226) would force-submit every subscriber's form; paste_into
       # (issue #228) would read every subscriber's clipboard; check_group
       # (issue #342) would tick or clear every subscriber's selection; presence
@@ -46,7 +48,7 @@ module Phlex
       # belong to the actor's own reply (reply.js) or gesture (on_client / a
       # reducer's $ops), never a broadcast. Names mirror Phlex::Reactive::JS's verbs.
       BROADCAST_REFUSED_OPS = %w[
-        focus focus_first submit paste_into persist_state persist_clear check_group presence
+        focus focus_first blur submit paste_into persist_state persist_clear check_group presence
         show_modal close_dialog
         preview_file
         set_value
@@ -205,7 +207,8 @@ module Phlex
           unless refused.empty?
             raise ArgumentError,
               "broadcast_to(js:) refuses actor-only op(s) #{refused.join(", ")} — broadcasting focus " \
-              "steals it in every subscriber's tab; broadcasting submit force-submits every " \
+              "steals it in every subscriber's tab; broadcasting blur drops focus in every subscriber " \
+              "whose focused element is inside the target; broadcasting submit force-submits every " \
               "subscriber's form; broadcasting paste_into reads every subscriber's clipboard; " \
               "broadcasting check_group ticks or clears every subscriber's selection; " \
               "broadcasting presence writes every subscriber's presence state; " \

data/lib/phlex/reactive/version.rb

@@ -2,6 +2,6 @@
 
 module Phlex
   module Reactive
-    VERSION = "0.15.2"
+    VERSION = "0.15.4"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: phlex-reactive
 version: !ruby/object:Gem::Version
-  version: 0.15.2
+  version: 0.15.4
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -140,6 +140,9 @@ files:
 - app/javascript/phlex/reactive/features/compute.js
 - app/javascript/phlex/reactive/features/compute.min.js
 - app/javascript/phlex/reactive/features/compute.min.js.map
+- app/javascript/phlex/reactive/features/countdown.js
+- app/javascript/phlex/reactive/features/countdown.min.js
+- app/javascript/phlex/reactive/features/countdown.min.js.map
 - app/javascript/phlex/reactive/features/defer.js
 - app/javascript/phlex/reactive/features/defer.min.js
 - app/javascript/phlex/reactive/features/defer.min.js.map
@@ -193,15 +196,20 @@ files:
 - lib/phlex/reactive/client_bindings.rb
 - lib/phlex/reactive/collections.rb
 - lib/phlex/reactive/component.rb
+- lib/phlex/reactive/component/countdown_binding.rb
 - lib/phlex/reactive/component/dsl.rb
 - lib/phlex/reactive/component/editable.rb
+- lib/phlex/reactive/component/field_references.rb
 - lib/phlex/reactive/component/helpers.rb
 - lib/phlex/reactive/component/identity.rb
+- lib/phlex/reactive/component/image_fallback_binding.rb
 - lib/phlex/reactive/component/lazy.rb
 - lib/phlex/reactive/component/media_binding.rb
+- lib/phlex/reactive/component/media_pattern.rb
 - lib/phlex/reactive/component/presence_declaration.rb
 - lib/phlex/reactive/component/registry.rb
 - lib/phlex/reactive/component/selection.rb
+- lib/phlex/reactive/component/show_options.rb
 - lib/phlex/reactive/component/sortable.rb
 - lib/phlex/reactive/defer.rb
 - lib/phlex/reactive/deferred_render_job.rb
@@ -239,6 +247,7 @@ files:
 - lib/phlex/reactive/settles.rb
 - lib/phlex/reactive/shortcut.rb
 - lib/phlex/reactive/show_conditions.rb
+- lib/phlex/reactive/show_conditions/compare_terms.rb
 - lib/phlex/reactive/stream.rb
 - lib/phlex/reactive/streamable.rb
 - lib/phlex/reactive/test_helpers.rb