studio-engine 0.52.2 → 0.53.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b252a824ebae2c1a14b0efb4a89a056207f11550c6f21585d290b5469960134
-  data.tar.gz: d45781ea692d918b89770e19675af88f68fb717f8906dc525ead01aefff02836
+  metadata.gz: 5ce8edffaa3298d94b27113b1add2064ed036620a6c8372e84e947cfbeefb895
+  data.tar.gz: d72221add8e7af3e036cb616779bf59fb9428573b478ecda56ebd804300387f5
 SHA512:
-  metadata.gz: 12b68644186bbfd48b52d4ca073f305b04367538acea66b480e1313cfead58053c0abe3d2f2d49318728d0a99470df3d74f36e784fba5f09cdc926f0c68dd3cf
-  data.tar.gz: 06a8baea9fa0164bf7cff3b823148d4c90f349b89949cedc0d3a8c6d165bf3c95314dd4eb0fe1929638c9434426618d076bc9e983d80cbff4778b988a1caf6ae
+  metadata.gz: f72e5c3f5c5e6c0f03deca8238fff54a8da590b384c0987689becee01ca791c645178ff32d5597664ed5320e5a82408f91d5d6b4cb3b8219be602536f6cb2dd7
+  data.tar.gz: d28e41b0a6c6c1a2b58fbcfe66787e2be955e353e101ac567d78d628f3de865dfbf81aeb30b3cf1796809fe087cee5e5bb2ab77317510f4ff951da5bea038d64

data/CHANGELOG.md

@@ -4,6 +4,79 @@ The format is [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). This pro
 
 ## Unreleased
 
+### Added
+
+- **`Studio.after_newsletter_change`** — a seam so a host can react to a
+  subscribe or unsubscribe without the engine knowing what it does.
+
+  ```ruby
+  Studio.after_newsletter_change = lambda do |user, subscribed:, first_join:|
+    GrantWelcomeSeeds.call(user) if subscribed && first_join
+  end
+  ```
+
+  **Why it exists, concretely:** turf-monster pays a 25-seed welcome bonus
+  on-chain, gated on `first_newsletter_join?` — literally
+  `joined_email_list_at.nil?`. The engine's subscribe action set that column and
+  told nobody, so a subscribe from `/profile` granted no seeds **and** made the
+  once-ever bonus unclaimable forever. Turf had to hold the newsletter row off
+  its profile page entirely; this is what lets it come back.
+
+  **`first_join:` is computed BEFORE the write**, because the write is what sets
+  the column — asked afterwards it is always false, and no host could ever pay a
+  welcome bonus.
+
+  **A raising callback cannot undo the subscription.** The subscription is the
+  durable fact and the reaction is not: turf's grant goes over RPC to a chain
+  that is sometimes unreachable, and a failed bonus must not cost someone their
+  place on the mailing list, or roll the write back inside `rescue_and_log`. It
+  is rescued and logged.
+
+  Fires on both verbs, so a host that only cares about joins ignores the flag.
+  The default is inert.
+
+
+### Fixed
+
+- **The birthday calendar keeps the side it opened on.** `place()` runs on every
+  scroll and resize, and it also **chose** the side — so the popover snapped
+  between above and below the moment the available space crossed the threshold.
+  Measured on turf-monster at 60px scroll steps: ABOVE, ABOVE, ABOVE, ABOVE, then
+  below — a **254px jump between two steps**, mid-scroll, while the reader was
+  looking at it.
+
+  The side is now decided once, by `chooseSide()`, when the popover opens.
+  `place()` only moves it.
+
+  This is a different bug from the height fix that shipped alongside it: that one
+  corrected **where** a flipped popover lands, and never asked whether the side
+  should be re-decided at all. The flip spec added with it opens and asserts
+  once, so a side that changes **later** was invisible to it.
+
+
+### Fixed
+
+- **The birthday calendar measures itself instead of guessing, so a flipped
+  popover stays attached to its field.** `place()` used a hardcoded
+  `estimatedHeight = 340` for both the flip DECISION and the flipped COORDINATE.
+  The real popover is about 245px, so whenever the field sat near the bottom of
+  the viewport the calendar opened roughly 95px above where it belonged — visibly
+  detached, and jumping on every scroll, because scroll re-runs the same
+  arithmetic.
+
+  It now reads the popover's own `offsetHeight` through an `x-ref`, with the
+  constant surviving only as the fallback for the first call before the element
+  is shown. `toggle()` places twice: once so it never appears at 0,0 for a frame,
+  then again in `$nextTick` — the call that can actually measure, since
+  `offsetHeight` is 0 while `x-show` still has it hidden.
+
+  **No earlier spec had ever run the flip branch.** The lab's field sits near the
+  top with room below, so every placement assertion exercised the below-branch
+  only, and "it fits on screen" cannot catch this — a popover 95px too high still
+  fits. The new spec forces the flip, asserts the flip actually happened, and then
+  asserts the popover's bottom edge sits against the trigger's top edge.
+
+
 ### Changed
 
 - **The edit page's avatar is now the control; its corner badge is gone.**

data/app/controllers/studio/profiles_controller.rb

@@ -166,11 +166,17 @@ module Studio
         current_user.email = value
       end
 
+      # BEFORE THE WRITE, because the write is what sets the column — asking
+      # afterwards always answers false, and "is this their first ever join" is
+      # exactly the question a once-ever welcome bonus asks.
+      first_join = !Studio::Newsletter.ever_joined?(current_user)
+
       rescue_and_log(target: current_user) do
         # left_email_list_at is CLEARED rather than left in place. `subscribed?`
         # compares the two dates, so a stale leave date in the future of the join
         # would read as unsubscribed the moment the clock disagreed.
         current_user.update!(joined_email_list_at: Time.current, left_email_list_at: nil)
+        notify_newsletter_change(subscribed: true, first_join: first_join)
         redirect_to profile_path, notice: "You're on the list."
       end
     end
@@ -191,12 +197,34 @@ module Studio
 
       rescue_and_log(target: current_user) do
         current_user.update!(left_email_list_at: Time.current)
+        notify_newsletter_change(subscribed: false, first_join: false)
         redirect_to profile_path, notice: "You've been unsubscribed."
       end
     end
 
     private
 
+    # Tell the host, and NEVER let it break the subscription.
+    #
+    # The subscription is the durable fact; the reaction is not. turf-monster's
+    # callback grants seeds ON-CHAIN over RPC to a node that is sometimes
+    # unreachable, and a failed bonus must not cost someone their place on the
+    # mailing list — or, worse, roll the write back inside rescue_and_log and
+    # leave them looking unsubscribed.
+    #
+    # Rescued and logged rather than re-raised for that reason. The host's own
+    # controller already treats its grant as deferred and backfillable; this
+    # keeps that true when the same grant is reached from here.
+    def notify_newsletter_change(subscribed:, first_join:)
+      callback = Studio.after_newsletter_change
+      return unless callback.respond_to?(:call)
+
+      callback.call(current_user, subscribed: subscribed, first_join: first_join)
+    rescue StandardError => e
+      Rails.logger.warn("[studio][newsletter] after_newsletter_change raised for " \
+                        "user=#{current_user&.id}: #{e.class}: #{e.message.to_s[0, 200]}")
+    end
+
     # Would the page render this row for this viewer?
     #
     # A HIDDEN ROW IS NOT A GUARD. Studio::ProfileSections drops a row this host

data/app/views/studio/profiles/_birthday_fields.html.erb

@@ -66,6 +66,7 @@
       </button>
 
       <div x-show="open" x-cloak
+           x-ref="popover"
            @click.outside="open = false"
            @keydown.escape.window="open = false"
            @scroll.window="place()" @resize.window="place()"

data/app/views/studio/profiles/_birthday_picker_script.html.erb

@@ -23,6 +23,9 @@
   window.studioBirthdayPicker = function (initial) {
     return {
       open: false,
+      // Which side this open chose. Set by chooseSide() when the popover opens and
+      // then left alone — see place() for why re-deciding it is the bug.
+      flipped: false,
       value: initial || "",
       viewYear: 0,
       viewMonth: 0,
@@ -117,27 +120,75 @@
 
       toggle() {
         this.open = !this.open;
-        if (this.open) {
-          this.syncViewFromValue();
+        if (!this.open) return;
+
+        this.syncViewFromValue();
+
+        // Placed twice, deliberately. The first call stops the popover appearing
+        // at 0,0 for a frame; the second is the one that can MEASURE, because
+        // offsetHeight is 0 while x-show still has the element hidden — and it is
+        // also the only place the SIDE is chosen, for the life of this open.
+        this.place();
+        this.$nextTick(function () {
+          this.chooseSide();
           this.place();
-        }
+        }.bind(this));
       },
 
       // Placed from the trigger's rect because the popover is fixed. Flips above
       // the trigger when there is not room below, so it never opens off-screen on
       // a short viewport.
+      //
+      // THE HEIGHT IS MEASURED, NOT GUESSED, and that distinction is the bug the
+      // operator reported. This used a hardcoded `estimatedHeight = 340` for both
+      // the decision AND the flipped coordinate. The real popover is about 245px,
+      // so a flip landed ~95px too high and the calendar floated visibly detached
+      // from its field — and since scroll re-runs this, it kept jumping. The
+      // arithmetic was legible in the screenshot: trigger at 640, popover at 300,
+      // and 640 - 340 - 4 = 316.
+      //
+      // The element is rendered under x-show (display is toggled, it stays in the
+      // DOM), so offsetHeight is readable as soon as it is shown. The constant
+      // survives only as the fallback for the first call, before the ref exists.
       place() {
         var el = this.$refs.trigger;
         if (!el) return;
+
         var r = el.getBoundingClientRect();
-        var estimatedHeight = 340;
-        var below = window.innerHeight - r.bottom;
+        var popover = this.$refs.popover;
+        var height = (popover && popover.offsetHeight) || 340;
+        var GAP = 4;
 
         this.left = r.left;
         this.width = r.width;
-        this.top = below < estimatedHeight && r.top > estimatedHeight
-          ? r.top - estimatedHeight - 4
-          : r.bottom + 4;
+
+        // THE SIDE IS NOT RE-DECIDED HERE. place() runs on every scroll and
+        // resize event, and choosing the side each time makes the popover SNAP
+        // between above and below the moment the available space crosses the
+        // threshold. Measured on turf-monster at 60px scroll steps: ABOVE, ABOVE,
+        // ABOVE, ABOVE, then below — a 254px jump between two steps, mid-scroll,
+        // while the reader was looking at it. That is what "the date picker
+        // freaks out on scroll" was.
+        //
+        // chooseSide() runs ONCE per open; this only moves the popover.
+        this.top = this.flipped ? r.top - height - GAP : r.bottom + GAP;
+      },
+
+      // Which side to open on, decided once and then left alone. Flips above only
+      // when there is not room below AND there is room above — with neither, it
+      // stays below, attached to its field rather than pinned to the top of the
+      // viewport.
+      chooseSide() {
+        var el = this.$refs.trigger;
+        if (!el) return;
+
+        var r = el.getBoundingClientRect();
+        var popover = this.$refs.popover;
+        var height = (popover && popover.offsetHeight) || 340;
+        var GAP = 4;
+        var below = window.innerHeight - r.bottom;
+
+        this.flipped = below < height + GAP && r.top > height + GAP;
       }
     };
   };

data/lib/studio/version.rb

@@ -1,3 +1,3 @@
 module Studio
-  VERSION = "0.52.2"
+  VERSION = "0.53.0"
 end

data/lib/studio.rb

@@ -29,6 +29,29 @@ module Studio
   mattr_accessor :registration_params, default: [:name, :email, :password, :password_confirmation]
   mattr_accessor :configure_new_user,  default: ->(user) {}
   mattr_accessor :configure_sso_user,  default: ->(user) {}
+
+  # Called after a newsletter subscribe or unsubscribe on /profile, so a host can
+  # react without the engine knowing anything about what it does.
+  #
+  # THE REASON THIS EXISTS, stated concretely: turf-monster pays a 25-seed welcome
+  # bonus on-chain, gated on `first_newsletter_join?` — literally
+  # `joined_email_list_at.nil?`. The engine's subscribe action sets that column
+  # and told nobody, so a subscribe from /profile granted no seeds AND made the
+  # once-ever bonus unclaimable forever. Turf had to hold the row off its profile
+  # page entirely. This is what lets it come back.
+  #
+  #   Studio.after_newsletter_change = lambda do |user, subscribed:, first_join:|
+  #     GrantWelcomeSeeds.call(user) if subscribed && first_join
+  #   end
+  #
+  # `first_join:` is computed BEFORE the write, because the write is what sets the
+  # column — asking afterwards always answers false.
+  #
+  # A raising callback CANNOT undo the subscription: the subscription is the
+  # durable fact and the reaction is not. Turf's grant goes over RPC to a chain
+  # that is sometimes unreachable, and a failed bonus must not cost someone their
+  # place on the mailing list.
+  mattr_accessor :after_newsletter_change, default: ->(_user, subscribed:, first_join:) {}
   mattr_accessor :sso_logo,            default: nil
   mattr_accessor :wallet_address_method, default: nil
   mattr_accessor :theme_logos,         default: []

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: studio-engine
 version: !ruby/object:Gem::Version
-  version: 0.52.2
+  version: 0.53.0
 platform: ruby
 authors:
 - Alex McRitchie