craft-native 0.0.235 → 0.0.236

package/dist/android/templates/MainActivityNative.kt.template

@@ -866,8 +866,146 @@ private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMap
     private fun color(value: String): Int = runCatching { craftNativeColor(value) }.getOrDefault(Color.BLUE)
 }
 
+/** A finite celebration owned by a View, never by the JavaScript frame loop. */
+internal class CraftNativeCelebration(private val view: View) {
+    private var request: Pair<Double, Boolean>? = null
+    private var pending = false
+    private var animator: ValueAnimator? = null
+    private var decoration: Drawable? = null
+    private var root: View? = null
+    private var radius = 0f
+    var starts = 0
+        private set
+    val isRunning: Boolean get() = animator != null
+
+    fun configure(raw: JSONObject?, radius: Float) {
+        val replay = craftNativeNumber(raw?.opt("replay"))?.takeIf { it >= 0 }
+        val next = replay?.let { it to (raw?.opt("enabled") != false) }
+        this.radius = radius
+        if (next == request) return
+        stop()
+        request = next
+        pending = next?.second == true
+        view.requestLayout()
+    }
+
+    fun stop() {
+        pending = false
+        animator?.removeAllUpdateListeners()
+        animator?.removeAllListeners()
+        animator?.cancel()
+        animator = null
+        decoration?.let { root?.overlay?.remove(it) }
+        decoration = null
+        root = null
+        view.clearAnimation()
+    }
+
+    fun layout(animationsEnabled: Boolean = ValueAnimator.areAnimatorsEnabled()) {
+        if (!pending || !view.isAttachedToWindow || !view.isShown || view.width <= 0 || view.height <= 0) return
+        pending = false
+        if (!animationsEnabled) return
+        starts += 1
+        val root = view.rootView
+        this.root = root
+        val at = IntArray(2)
+        val origin = IntArray(2)
+        view.getLocationInWindow(at)
+        root.getLocationInWindow(origin)
+        val frame = RectF((at[0] - origin[0]).toFloat(), (at[1] - origin[1]).toFloat(), (at[0] - origin[0] + view.width).toFloat(), (at[1] - origin[1] + view.height).toFloat())
+        val density = view.resources.displayMetrics.density
+        var progress = 0f
+        val paint = Paint(Paint.ANTI_ALIAS_FLAG)
+        val colors = intArrayOf(Color.rgb(59, 130, 246), Color.rgb(153, 246, 228), Color.rgb(230, 196, 140), Color.WHITE)
+        val decoration = object : Drawable() {
+            override fun draw(canvas: Canvas) {
+                for (index in 0 until 52) {
+                    val side = if (index % 2 == 0) -1f else 1f
+                    val spread = (index * 37 % 101) / 100f
+                    val t = ((progress * 3f - (index % 7) * .018f) / (2.2f + spread * .45f)).coerceIn(0f, 1f)
+                    if (t <= 0 || t >= 1) continue
+                    val startX = frame.centerX() + side * frame.width() * .42f
+                    val startY = frame.top + 28 * density
+                    val endX = frame.centerX() + side * (35 * density + spread * root.width * .7f)
+                    val endY = root.height + 30 * density
+                    val x = startX + (endX - startX) * t
+                    val y = startY + (endY - startY) * t * t - (70 + spread * 100) * density * 4 * t * (1 - t)
+                    val saved = canvas.save()
+                    canvas.translate(x, y)
+                    canvas.rotate(side * (index * 30f + t * (400 + spread * 600)))
+                    paint.shader = null
+                    paint.color = colors[index % colors.size]
+                    paint.alpha = (255 * min(1f, min(t / .04f, (1 - t) / .3f))).roundToInt()
+                    canvas.drawRoundRect(RectF(-3 * density, -5 * density, (if (index % 3 == 0) 1 else 4) * density, 6 * density), density, density, paint)
+                    canvas.restoreToCount(saved)
+                }
+                val light = (progress * 3f - .55f) / 1.15f
+                if (light > 0 && light < 1) {
+                    val saved = canvas.save()
+                    val mask = Path().apply { addRoundRect(frame, radius, radius, Path.Direction.CW) }
+                    canvas.clipPath(mask)
+                    val x = frame.left - frame.width() + light * frame.width() * 3
+                    paint.alpha = 255
+                    paint.shader = LinearGradient(x - frame.width() * .25f, frame.top, x + frame.width() * .25f, frame.bottom, intArrayOf(Color.TRANSPARENT, 0x33ffffff, Color.TRANSPARENT), null, Shader.TileMode.CLAMP)
+                    canvas.drawRect(frame, paint)
+                    paint.shader = null
+                    canvas.restoreToCount(saved)
+                }
+            }
+            override fun setAlpha(alpha: Int) {}
+            override fun setColorFilter(colorFilter: ColorFilter?) {}
+            @Deprecated("Deprecated in Java")
+            override fun getOpacity(): Int = PixelFormat.TRANSLUCENT
+        }
+        decoration.setBounds(0, 0, root.width, root.height)
+        this.decoration = decoration
+        root.overlay.add(decoration)
+        // Classic view animations leave authored transform properties intact.
+        val entrance = android.view.animation.AnimationSet(true).apply {
+            addAnimation(android.view.animation.ScaleAnimation(.86f, 1f, .86f, 1f, android.view.animation.Animation.RELATIVE_TO_SELF, .5f, android.view.animation.Animation.RELATIVE_TO_SELF, .5f))
+            addAnimation(android.view.animation.TranslateAnimation(0f, 0f, 34 * density, 0f))
+            addAnimation(android.view.animation.RotateAnimation(-2.6f, 0f, android.view.animation.Animation.RELATIVE_TO_SELF, .5f, android.view.animation.Animation.RELATIVE_TO_SELF, .5f))
+            duration = 950
+            interpolator = android.view.animation.OvershootInterpolator(.65f)
+        }
+        view.startAnimation(entrance)
+        val clock = ValueAnimator.ofFloat(0f, 1f)
+        animator = clock
+        clock.apply {
+            duration = 3000
+            interpolator = LinearInterpolator()
+            addUpdateListener {
+                if (!ValueAnimator.areAnimatorsEnabled()) { stop(); return@addUpdateListener }
+                progress = it.animatedValue as Float
+                decoration.invalidateSelf()
+            }
+            addListener(object : android.animation.AnimatorListenerAdapter() {
+                override fun onAnimationEnd(animation: android.animation.Animator) { stop() }
+            })
+            start()
+        }
+    }
+}
+
 /** A deterministic flex-shaped container shared by normal views and scroll content. */
 private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
+    private var celebration: CraftNativeCelebration? = null
+    fun configureCelebration(raw: JSONObject?, radius: Float) {
+        if (raw != null && celebration == null) celebration = CraftNativeCelebration(this)
+        celebration?.configure(raw, radius)
+    }
+    override fun onDetachedFromWindow() {
+        celebration?.stop()
+        super.onDetachedFromWindow()
+    }
+    override fun onVisibilityChanged(changedView: View, visibility: Int) {
+        super.onVisibilityChanged(changedView, visibility)
+        if (visibility != View.VISIBLE) celebration?.stop()
+    }
+    override fun onWindowVisibilityChanged(visibility: Int) {
+        super.onWindowVisibilityChanged(visibility)
+        if (visibility != View.VISIBLE) celebration?.stop()
+    }
     var onLayoutChanged: (() -> Unit)? = null
     private val styles = mutableMapOf<View, CraftNativeLayoutStyle>()
     private var wrap = false
@@ -1770,6 +1908,7 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
     }
 
     override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+        celebration?.layout()
         widthDefinite = true
         if (grid) {
             val layout = gridLayout(width, height)
@@ -5749,6 +5888,7 @@ class MainActivity : AppCompatActivity() {
             }
         }
         if (control is CraftNativeFlexLayout) {
+            control.configureCelebration(props.optJSONObject("celebration"), ((craftNativeNumber(style.opt("borderRadius")) ?: 0.0) * resources.displayMetrics.density).toFloat())
             control.onLayoutChanged = { if (screen.active) emitLayoutEvents(screen) }
         } else if (control is CraftNativeKeyboardAvoidingView) {
             control.content.onLayoutChanged = { if (screen.active) emitLayoutEvents(screen) }

package/dist/cli.js

@@ -3424,7 +3424,7 @@ function pinCraftNativeDependency(packagePath, craftVersion) {
 `);
 }
 // package.json
-var version = "0.0.235";
+var version = "0.0.236";
 
 // bin/cli.ts
 var spawnedFrom = process6.env[CRAFT_CLI_SPAWN_MARKER];

package/dist/index.cjs

@@ -309,7 +309,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.235";
+var version = "0.0.236";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/index.js

@@ -57,7 +57,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.235";
+var version = "0.0.236";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/ios/templates/CraftNativeScreen.swift

@@ -1834,7 +1834,172 @@ extension UIView {
     }
 }
 
+/// A finite, opt-in native celebration. Reconciliation with the same replay
+/// value never restarts it; Reduce Motion always leaves the complete card still.
+struct CraftNativeCelebrationSpec: Equatable {
+    let replay: Double
+    let enabled: Bool
+
+    init?(_ raw: Any?) {
+        guard let value = raw as? [String: Any],
+              let replay = value["replay"] as? NSNumber,
+              CFGetTypeID(replay) != CFBooleanGetTypeID(),
+              replay.doubleValue.isFinite, replay.doubleValue >= 0 else { return nil }
+        self.replay = replay.doubleValue
+        enabled = value["enabled"] as? Bool != false
+    }
+}
+
+final class CraftNativeCelebration {
+    private weak var view: UIView?
+    private var request: CraftNativeCelebrationSpec?
+    private var pending = false
+    private var overlay: CALayer?
+    private var sheen: CALayer?
+    private var cleanup: DispatchWorkItem?
+    private var observers: [NSObjectProtocol] = []
+    private(set) var starts = 0
+    var isRunning: Bool { overlay != nil }
+
+    init(view: UIView) {
+        self.view = view
+        for name in [UIApplication.didEnterBackgroundNotification, UIAccessibility.reduceMotionStatusDidChangeNotification] {
+            observers.append(NotificationCenter.default.addObserver(forName: name, object: nil, queue: .main) { [weak self] _ in self?.stop() })
+        }
+    }
+
+    deinit {
+        cleanup?.cancel()
+        overlay?.removeFromSuperlayer()
+        sheen?.removeFromSuperlayer()
+        observers.forEach(NotificationCenter.default.removeObserver)
+    }
+
+    func configure(_ raw: Any?) {
+        let next = CraftNativeCelebrationSpec(raw)
+        guard next != request else { return }
+        stop()
+        request = next
+        pending = next?.enabled == true
+        view?.setNeedsLayout()
+    }
+
+    func stop() {
+        pending = false
+        cleanup?.cancel()
+        cleanup = nil
+        view?.layer.removeAnimation(forKey: "craft.celebration.entrance")
+        overlay?.removeFromSuperlayer()
+        overlay = nil
+        sheen?.removeFromSuperlayer()
+        sheen = nil
+    }
+
+    func layout(reduceMotion: Bool = UIAccessibility.isReduceMotionEnabled) {
+        guard pending, let view, let window = view.window,
+              view.bounds.width > 0, view.bounds.height > 0, !view.isHidden else { return }
+        var ancestor: UIView? = view.superview
+        while let parent = ancestor {
+            if parent.isHidden { return }
+            ancestor = parent.superview
+        }
+        pending = false
+        guard !reduceMotion else { return }
+        starts += 1
+        let frame = view.convert(view.bounds, to: window)
+        let overlay = CALayer()
+        overlay.name = "craft.celebration.confetti"
+        overlay.frame = window.bounds
+        window.layer.addSublayer(overlay)
+        self.overlay = overlay
+
+        // Core Animation owns every frame. No script timers, per-frame bridge
+        // messages, bitmap assets or touch-intercepting overlay views.
+        let colors: [UIColor] = [.init(red: 0.23, green: 0.51, blue: 0.96, alpha: 1), .init(red: 0.6, green: 0.96, blue: 0.89, alpha: 1), .init(red: 0.9, green: 0.77, blue: 0.55, alpha: 1), .white]
+        let now = CACurrentMediaTime()
+        for index in 0..<52 {
+            let side: CGFloat = index % 2 == 0 ? -1 : 1
+            let spread = CGFloat((index * 37) % 101) / 100
+            let start = CGPoint(x: frame.midX + side * frame.width * 0.42, y: frame.minY + 28)
+            let end = CGPoint(x: frame.midX + side * (35 + spread * window.bounds.width * 0.7), y: window.bounds.height + 30)
+            let piece = CALayer()
+            piece.bounds = CGRect(x: 0, y: 0, width: index % 3 == 0 ? 4 : 7, height: 11)
+            piece.cornerRadius = 1
+            piece.backgroundColor = colors[index % colors.count].cgColor
+            piece.position = end
+            piece.opacity = 0
+            overlay.addSublayer(piece)
+            let path = CAKeyframeAnimation(keyPath: "position")
+            path.values = [NSValue(cgPoint: start), NSValue(cgPoint: CGPoint(x: start.x + side * (45 + spread * 65), y: max(0, start.y - 70 - spread * 100))), NSValue(cgPoint: end)]
+            path.keyTimes = [0, 0.28, 1]
+            path.calculationMode = .cubic
+            let tumble = CABasicAnimation(keyPath: "transform.rotation")
+            tumble.fromValue = side * Double(index)
+            tumble.toValue = side * (Double(index) + 7 + Double(spread) * 10)
+            let fade = CAKeyframeAnimation(keyPath: "opacity")
+            fade.values = [0, 1, 1, 0]
+            fade.keyTimes = [0, 0.04, 0.7, 1]
+            let group = CAAnimationGroup()
+            group.animations = [path, tumble, fade]
+            group.duration = 2.2 + Double(spread) * 0.45
+            group.beginTime = now + Double(index % 7) * 0.018
+            group.fillMode = .backwards
+            piece.add(group, forKey: "craft.celebration.particle")
+        }
+
+        let entrance = CASpringAnimation(keyPath: "transform")
+        var from = CATransform3DMakeTranslation(0, 34, 0)
+        from = CATransform3DRotate(from, -0.045, 0, 0, 1)
+        from = CATransform3DScale(from, 0.86, 0.86, 1)
+        entrance.fromValue = NSValue(caTransform3D: CATransform3DConcat(view.layer.transform, from))
+        entrance.toValue = NSValue(caTransform3D: view.layer.transform)
+        entrance.damping = 19
+        entrance.stiffness = 160
+        entrance.mass = 1
+        entrance.duration = 0.95
+        view.layer.add(entrance, forKey: "craft.celebration.entrance")
+
+        let sheen = CAGradientLayer()
+        sheen.name = "craft.celebration.sheen"
+        sheen.frame = view.bounds
+        sheen.colors = [UIColor.clear.cgColor, UIColor.white.withAlphaComponent(0.2).cgColor, UIColor.clear.cgColor]
+        sheen.locations = [0.25, 0.5, 0.75]
+        sheen.startPoint = CGPoint(x: 0, y: 0.3)
+        sheen.endPoint = CGPoint(x: 1, y: 0.7)
+        sheen.opacity = 0
+        let mask = CAShapeLayer()
+        mask.path = UIBezierPath(roundedRect: view.bounds, cornerRadius: view.layer.cornerRadius).cgPath
+        sheen.mask = mask
+        view.layer.addSublayer(sheen)
+        self.sheen = sheen
+        let sweep = CABasicAnimation(keyPath: "transform.translation.x")
+        sweep.fromValue = -view.bounds.width
+        sweep.toValue = view.bounds.width
+        let light = CAKeyframeAnimation(keyPath: "opacity")
+        light.values = [0, 1, 1, 0]
+        light.keyTimes = [0, 0.15, 0.8, 1]
+        let shine = CAAnimationGroup()
+        shine.animations = [sweep, light]
+        shine.duration = 1.15
+        shine.beginTime = now + 0.55
+        sheen.add(shine, forKey: "craft.celebration.sweep")
+        let cleanup = DispatchWorkItem { [weak self] in self?.stop() }
+        self.cleanup = cleanup
+        DispatchQueue.main.asyncAfter(deadline: .now() + 3, execute: cleanup)
+    }
+}
+
 private class CraftNativeFlowView: UIStackView {
+    var celebration: CraftNativeCelebration?
+    func configureCelebration(_ raw: Any?) {
+        if raw != nil && celebration == nil { celebration = CraftNativeCelebration(view: self) }
+        celebration?.configure(raw)
+    }
+    override func didMoveToWindow() {
+        super.didMoveToWindow()
+        if window == nil { celebration?.stop() }
+        else { setNeedsLayout() }
+    }
     var pressActiveOpacity: CGFloat?
     var pressBaseOpacity: CGFloat = 1
     var pressUnderlayColor: UIColor?
@@ -2051,6 +2216,7 @@ private class CraftNativeFlowView: UIStackView {
     override func layoutSubviews() {
         super.layoutSubviews()
         craftApplyCornerRadius()
+        celebration?.layout()
         let scale = window?.screen.scale ?? traitCollection.displayScale
         let result = layout(width: bounds.width, height: bounds.height, maxWidth: bounds.width, maxHeight: bounds.height, place: true)
         var moved = false
@@ -4134,6 +4300,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
 
     override func viewWillDisappear(_ animated: Bool) {
         super.viewWillDisappear(animated)
+        stopCelebrations(in: view)
         // The accessory belongs to the visible native screen. Clear the
         // shared shell state before a hybrid/web route appears, otherwise a
         // destination from the outgoing screen remains tappable on top of it.
@@ -4188,6 +4355,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// `SCREEN_FOCUS { focused: true }`, and going away is `focused: false`.
     func screenVisibilityChanged(_ visible: Bool) {
         guard !runtimeDisposed else { return }
+        if !visible, isViewLoaded { stopCelebrations(in: view) }
         // Hidden tab stacks receive no UIKit appearance callback. A cancelled
         // preview also restores a screen that never lost focus, so restore its
         // chrome even when no new SCREEN_FOCUS event is needed.
@@ -6217,9 +6385,15 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             if disabled { result.isUserInteractionEnabled = false }
         }
         applyAccessibility(props, type: type, to: result)
+        (result as? CraftNativeFlowView)?.configureCelebration(props["celebration"])
         return current
     }
 
+    private func stopCelebrations(in root: UIView) {
+        (root as? CraftNativeFlowView)?.celebration?.stop()
+        root.subviews.forEach { stopCelebrations(in: $0) }
+    }
+
     private func makeView(_ type: String, props: [String: Any]) -> UIView {
         switch type {
         case "Text":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "craft-native",
-  "version": "0.0.235",
+  "version": "0.0.236",
   "type": "module",
   "description": "Build desktop apps with web languages - TypeScript SDK for Craft",
   "author": "Chris Breuer <chris@stacksjs.org>",