craft-native 0.0.133 → 0.0.135

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

@@ -418,6 +418,7 @@ class CraftBridge(
                     appReview: true,
                     flashlight: {{ENABLE_CAMERA}} && ${hasFlashlight()},
                     speech: true,
+                    brightness: true,
                     openURL: true,
                     vibrationPattern: true,
                     appState: true,
@@ -687,6 +688,18 @@ class CraftBridge(
                     return CraftAndroid.setKeepAwake(enabled);
                 },
 
+                // Screen brightness, 0 to 1. resetBrightness hands the screen
+                // back to the system setting (auto-brightness included).
+                getBrightness: function() {
+                    return Promise.resolve().then(function() { return CraftAndroid.getBrightness(); });
+                },
+                setBrightness: function(level) {
+                    return Promise.resolve().then(function() { return CraftAndroid.setBrightness(Number(level)); });
+                },
+                resetBrightness: function() {
+                    return Promise.resolve().then(function() { return CraftAndroid.resetBrightness(); });
+                },
+
                 // Orientation Lock
                 lockOrientation: function(orientation) {
                     return CraftAndroid.lockOrientation(orientation);
@@ -3628,6 +3641,49 @@ class CraftBridge(
         )
     }
 
+    // ==================== Screen Brightness ====================
+    //
+    // The window's own brightness override (WindowManager.LayoutParams
+    // .screenBrightness): no permission, and it lasts only while this window
+    // is in front, so leaving the app hands the screen back by itself.
+    // resetBrightness releases it, which also gives auto-brightness back -
+    // setting the old system level instead would freeze it there.
+    @Volatile private var brightnessOverride: Float? = null
+
+    @JavascriptInterface
+    fun getBrightness(): Double {
+        brightnessOverride?.let { return it.toDouble() }
+        return try {
+            Settings.System.getInt(activity.contentResolver, Settings.System.SCREEN_BRIGHTNESS) / 255.0
+        } catch (e: Exception) {
+            0.5
+        }
+    }
+
+    @JavascriptInterface
+    fun setBrightness(level: Double): Double {
+        if (!level.isFinite()) return getBrightness()
+        val clamped = level.coerceIn(0.0, 1.0).toFloat()
+        brightnessOverride = clamped
+        activity.runOnUiThread {
+            val params = activity.window.attributes
+            params.screenBrightness = clamped
+            activity.window.attributes = params
+        }
+        return clamped.toDouble()
+    }
+
+    @JavascriptInterface
+    fun resetBrightness(): Double {
+        brightnessOverride = null
+        activity.runOnUiThread {
+            val params = activity.window.attributes
+            params.screenBrightness = WindowManager.LayoutParams.BRIGHTNESS_OVERRIDE_NONE
+            activity.window.attributes = params
+        }
+        return getBrightness()
+    }
+
     // ==================== Keep Awake ====================
 
     @JavascriptInterface

package/dist/api/mobile.d.ts

@@ -738,15 +738,19 @@ export interface SpeechOptions {
     /** Stop whatever is being said first. Defaults to true; false queues behind it. */
     interrupt?: boolean;
 }
-/**
- * Short spoken cues: "Rest, 15 seconds. Up next: Dead Bug".
- *
- * Inside a Craft app this is native text-to-speech, which ducks the person's
- * music rather than stopping it and, on iOS, plays with the silent switch on.
- * In a browser it falls back to the Web Speech API, which does neither, and
- * where there is no speech at all it answers `false` rather than throwing, so
- * a cue never breaks the flow around it.
- */
+export declare const brightness: {
+    isAvailable(): boolean;
+    /** The screen's brightness, 0 to 1, or null where there is none to read. */
+    get(): Promise<number | null>;
+    /**
+     * Set the brightness, 0 to 1 (clamped). The first call since the last
+     * `restore()` remembers the person's own level to go back to. Resolves with
+     * the level the screen reports, or null off a phone.
+     */
+    set(level: number): Promise<number | null>;
+    /** Put the person's own brightness back. Safe to call when nothing was set. */
+    restore(): Promise<void>;
+};
 export declare const speech: {
     isAvailable(): boolean;
     /**
@@ -1184,6 +1188,7 @@ declare const mobile: {
     lifecycle: typeof lifecycle;
     notifications: typeof notifications;
     keepAwake: typeof keepAwake;
+    brightness: typeof brightness;
     speech: typeof speech;
     deepLinks: typeof deepLinks;
     network: typeof network;

package/dist/cli.js

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

package/dist/index.cjs

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

package/dist/index.js

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

package/dist/ios/templates/CraftApp.swift

@@ -473,6 +473,10 @@ struct CraftApp: App {
                         CraftTabBarView()
                         CraftSplashView(background: appState.config.resolvedBackgroundColor)
                     }
+                    // The keyboard covers the tab bar, as it does UIKit's: the
+                    // stack kept out of the keyboard's way and carried the bar
+                    // up above it, over the field being typed in.
+                    .ignoresSafeArea(.keyboard, edges: .bottom)
                 } else {
                     // The page's own chrome, drawn natively over it: the tab
                     // bar the page asks for, and the splash until it is ready.
@@ -483,6 +487,7 @@ struct CraftApp: App {
                         CraftTabBarView()
                         CraftSplashView(background: appState.config.resolvedBackgroundColor)
                     }
+                    .ignoresSafeArea(.keyboard, edges: .bottom)
                 }
             }
                 .preferredColorScheme(appState.config.colorScheme)
@@ -2135,6 +2140,15 @@ struct CraftWebView: UIViewRepresentable {
                 } else {
                     rejectCallback(callbackId, error: "Keep awake is disabled", code: "CAPABILITY_DISABLED")
                 }
+            // MARK: - Screen Brightness
+            case "getBrightness":
+                getBrightness(callbackId: callbackId)
+            case "setBrightness":
+                if let level = (body["level"] as? NSNumber)?.doubleValue, level.isFinite {
+                    setBrightness(level, callbackId: callbackId)
+                } else {
+                    rejectCallback(callbackId, error: "setBrightness was called without the values it needs", code: "INVALID_ARGUMENT")
+                }
             // MARK: - Orientation Lock
             case "lockOrientation":
                 if config.enableOrientationLock {
@@ -3097,6 +3111,7 @@ struct CraftWebView: UIViewRepresentable {
                     orientationLock: \(config.enableOrientationLock),
                     deepLinks: \(config.enableDeepLinks),
                     flashlight: true,
+                    brightness: true,
                     speech: true,
                     network: true,
                     deviceInfo: true,
@@ -4036,6 +4051,25 @@ struct CraftWebView: UIViewRepresentable {
                     });
                 },
 
+                // Screen brightness, 0 to 1. Each resolves with the level the
+                // screen then reports.
+                getBrightness: function() {
+                    var self = this;
+                    var id = 'cb_' + (++this._callbackId);
+                    window.webkit.messageHandlers.craft.postMessage({action: 'getBrightness', callbackId: id});
+                    return new Promise(function(resolve, reject) {
+                        self._callbacks[id] = {resolve: resolve, reject: reject};
+                    });
+                },
+                setBrightness: function(level) {
+                    var self = this;
+                    var id = 'cb_' + (++this._callbackId);
+                    window.webkit.messageHandlers.craft.postMessage({action: 'setBrightness', level: level, callbackId: id});
+                    return new Promise(function(resolve, reject) {
+                        self._callbacks[id] = {resolve: resolve, reject: reject};
+                    });
+                },
+
                 // Speech synthesis. speak() settles when the utterance ends:
                 // true when it was spoken, false when something stopped it.
                 // No timeout, because a long sentence at a slow rate can
@@ -6231,6 +6265,25 @@ struct CraftWebView: UIViewRepresentable {
             }
         }
 
+        // MARK: - Screen Brightness
+        //
+        // The device's backlight, 0 to 1. It is system-wide, not the app's:
+        // a page that dims it reads it first and puts it back - when it is
+        // done, and when the app leaves the foreground (@stacksjs/mobile's
+        // screen API does both off the page's visibility).
+        private func getBrightness(callbackId: String?) {
+            DispatchQueue.main.async {
+                self.resolveCallback(callbackId, result: Double(UIScreen.main.brightness))
+            }
+        }
+
+        private func setBrightness(_ level: Double, callbackId: String?) {
+            DispatchQueue.main.async {
+                UIScreen.main.brightness = CGFloat(min(max(level, 0), 1))
+                self.resolveCallback(callbackId, result: Double(UIScreen.main.brightness))
+            }
+        }
+
         // MARK: - Speech Synthesis
         //
         // Native rather than the page's own `speechSynthesis`, which in a

package/dist/ios/templates/CraftNativeScreen.swift

@@ -1793,18 +1793,27 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         button.accessibilityLabel = spec["accessibilityLabel"] as? String
         if let value = spec["badge"] as? NSNumber, value.intValue > 0 {
             let dot = spec["badgeStyle"] as? String == "dot"
-            let badge = UILabel()
-            badge.text = dot ? nil : value.intValue > 99 ? "99+" : String(value.intValue)
-            badge.font = .systemFont(ofSize: 10, weight: .bold)
-            badge.textColor = .white
-            badge.textAlignment = .center
-            badge.backgroundColor = dot ? .systemRed : .systemBlue
-            badge.clipsToBounds = true
             let size: CGFloat = dot ? 9 : 18
-            badge.layer.cornerRadius = size / 2
-            badge.frame = CGRect(x: 44 - size, y: 0, width: size, height: size)
-            badge.isAccessibilityElement = false
-            button.addSubview(badge)
+            // The fill is a tinted symbol, not a background colour: on iOS 26
+            // a bar item's custom view keeps its tint but drew a plain
+            // backgroundColor white, so the red unread dot came out white
+            // (invisible in light mode) and the count lost its blue.
+            let fill = UIImageView(image: UIImage(systemName: "circle.fill"))
+            fill.tintColor = dot ? .systemRed : .systemBlue
+            fill.contentMode = .scaleToFill
+            fill.frame = CGRect(x: 44 - size, y: 0, width: size, height: size)
+            fill.isAccessibilityElement = false
+            button.addSubview(fill)
+            if !dot {
+                let count = UILabel(frame: fill.frame)
+                count.text = value.intValue > 99 ? "99+" : String(value.intValue)
+                count.font = .systemFont(ofSize: 10, weight: .bold)
+                count.textColor = .white
+                count.textAlignment = .center
+                count.adjustsFontSizeToFitWidth = true
+                count.isAccessibilityElement = false
+                button.addSubview(count)
+            }
             button.accessibilityValue = "\(value.intValue) unread"
         }
         if let source = spec["image"] as? String, let url = URL(string: source), url.scheme == "https" {

package/dist/mobile.js

@@ -610,6 +610,64 @@ var speakingOnTheWeb = new Set;
 function speechRate(rate) {
   return typeof rate === "number" && Number.isFinite(rate) ? Math.min(Math.max(rate, 0.5), 2) : 1;
 }
+var brightnessState = { original: null, wanted: null, unwatch: null };
+function brightnessLevel(level) {
+  const value = Number(level);
+  return Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : null;
+}
+async function putBrightnessBack(craft) {
+  if (typeof craft?.resetBrightness === "function")
+    await craft.resetBrightness();
+  else if (brightnessState.original !== null)
+    await craft.setBrightness(brightnessState.original);
+}
+function watchBrightnessVisibility() {
+  if (brightnessState.unwatch || typeof document === "undefined")
+    return;
+  const onVisibility = () => {
+    const craft = getCraftRoot();
+    if (!craft?.setBrightness || brightnessState.wanted === null)
+      return;
+    if (document.visibilityState === "hidden")
+      putBrightnessBack(craft).catch(() => {});
+    else
+      craft.setBrightness(brightnessState.wanted).catch(() => {});
+  };
+  document.addEventListener("visibilitychange", onVisibility);
+  brightnessState.unwatch = () => document.removeEventListener("visibilitychange", onVisibility);
+}
+var brightness = {
+  isAvailable() {
+    return typeof getCraftRoot()?.setBrightness === "function";
+  },
+  async get() {
+    const craft = getCraftRoot();
+    if (typeof craft?.getBrightness !== "function")
+      return null;
+    return brightnessLevel(await craft.getBrightness());
+  },
+  async set(level) {
+    const craft = getCraftRoot();
+    const wanted = brightnessLevel(level);
+    if (typeof craft?.setBrightness !== "function" || wanted === null)
+      return null;
+    if (brightnessState.wanted === null && typeof craft.getBrightness === "function")
+      brightnessState.original = brightnessLevel(await craft.getBrightness());
+    brightnessState.wanted = wanted;
+    watchBrightnessVisibility();
+    return brightnessLevel(await craft.setBrightness(wanted));
+  },
+  async restore() {
+    const craft = getCraftRoot();
+    const held = brightnessState.wanted !== null;
+    brightnessState.wanted = null;
+    brightnessState.unwatch?.();
+    brightnessState.unwatch = null;
+    if (held && typeof craft?.setBrightness === "function")
+      await putBrightnessBack(craft);
+    brightnessState.original = null;
+  }
+};
 var speech = {
   isAvailable() {
     return Boolean(getCraftRoot()?.speech?.speak) || getWebSpeech() !== undefined;
@@ -1147,6 +1205,7 @@ export {
   chrome,
   camera,
   browser,
+  brightness,
   bridgeNotification,
   biometrics,
   background,

package/package.json

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