craft-native 0.0.138 → 0.0.140

package/dist/api/mobile.d.ts

@@ -1130,7 +1130,57 @@ export interface HealthDailyValue {
     value: number;
     unit: string;
 }
+export interface HealthSampleQuery {
+    /** Epoch milliseconds. Defaults to a day before `endDate`. */
+    startDate?: number;
+    /** Epoch milliseconds. Defaults to now. */
+    endDate?: number;
+}
+export interface HealthHeartRateQuery extends HealthSampleQuery {
+    /** At most this many, oldest first. Defaults to 10000, capped at 50000. */
+    limit?: number;
+}
+/** One heart-rate reading from Apple Health, in beats per minute. */
+export interface HealthHeartRateSample {
+    bpm: number;
+    /** Epoch milliseconds. */
+    startDate: number;
+    /** Epoch milliseconds; the same as `startDate` for a single reading. */
+    endDate: number;
+    /** The app that wrote it, e.g. the watch's own name. */
+    sourceName: string;
+    /** The device that measured it, when the source says ("Apple Watch"). */
+    deviceName?: string;
+    deviceModel?: string;
+    /** A series of readings (a watch workout) also carries its count, lowest and highest. */
+    count?: number;
+    min?: number;
+    max?: number;
+    /** What the wearer was doing, when the watch says. */
+    motionContext?: 'sedentary' | 'active';
+}
+/** A sleep analysis stage: in bed, awake, or asleep (staged or not). */
+export type HealthSleepStage = 'inBed' | 'awake' | 'asleep' | 'core' | 'deep' | 'rem';
+/** One stretch of a night as a source recorded it. */
+export interface HealthSleepInterval {
+    /** Epoch milliseconds. */
+    startDate: number;
+    /** Epoch milliseconds. */
+    endDate: number;
+    stage: HealthSleepStage;
+    /** Every asleep stage; false for time in bed and time awake. */
+    asleep: boolean;
+    sourceName: string;
+    deviceName?: string;
+}
+/** The health reads a host may or may not have, depending on the app build it runs in. */
+export type HealthReadMethod = 'getWorkouts' | 'getDailyStatistics' | 'getHeartRateSamples' | 'getSleepIntervals';
 export declare const health: {
+    /**
+     * Whether this app build answers `method`. An app installed before a read
+     * existed has none, so a page checks before offering what needs it.
+     */
+    supports(method: HealthReadMethod): boolean;
     /**
      * Ask for the health data a page needs. `{ write: false }` asks to read
      * only, for an app that never writes back; by default it may also save
@@ -1143,6 +1193,10 @@ export declare const health: {
     getWorkouts(options?: HealthWorkoutQuery): Promise<HealthWorkoutSample[]>;
     /** One value per local day between two dates. iOS only for now. */
     getDailyStatistics(type: HealthDailyType, options?: HealthDataOptions): Promise<HealthDailyValue[]>;
+    /** Every heart-rate reading between two instants, oldest first. iOS only for now. */
+    getHeartRateSamples(options?: HealthHeartRateQuery): Promise<HealthHeartRateSample[]>;
+    /** Sleep between two instants, oldest first: time in bed and each asleep or awake stage. iOS only for now. */
+    getSleepIntervals(options?: HealthSampleQuery): Promise<HealthSleepInterval[]>;
 };
 export interface LiveActivityState {
     status?: string;

package/dist/cli.js

@@ -3303,7 +3303,7 @@ function pinCraftNativeDependency(packagePath, craftVersion) {
 `);
 }
 // package.json
-var version = "0.0.138";
+var version = "0.0.140";
 
 // 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.138";
+var version = "0.0.140";
 
 // 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.138";
+var version = "0.0.140";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/ios/templates/CraftApp.swift

@@ -2358,6 +2358,27 @@ struct CraftWebView: UIViewRepresentable {
                 } else {
                     rejectCallback(callbackId, error: "HealthKit is disabled", code: "CAPABILITY_DISABLED")
                 }
+            case "getHealthHeartRateSamples":
+                if config.enableHealthKit {
+                    getHealthHeartRateSamples(
+                        startDate: body["startDate"] as? Double,
+                        endDate: body["endDate"] as? Double,
+                        limit: body["limit"] as? Int,
+                        callbackId: callbackId
+                    )
+                } else {
+                    rejectCallback(callbackId, error: "HealthKit is disabled", code: "CAPABILITY_DISABLED")
+                }
+            case "getHealthSleepIntervals":
+                if config.enableHealthKit {
+                    getHealthSleepIntervals(
+                        startDate: body["startDate"] as? Double,
+                        endDate: body["endDate"] as? Double,
+                        callbackId: callbackId
+                    )
+                } else {
+                    rejectCallback(callbackId, error: "HealthKit is disabled", code: "CAPABILITY_DISABLED")
+                }
 
             // MARK: - Live Activities
             case "startLiveActivity":
@@ -4854,6 +4875,14 @@ struct CraftWebView: UIViewRepresentable {
                     getDailyStatistics: function(type, options) {
                         options = options || {};
                         return craft._invoke('getHealthDailyStatistics', {type: type, startDate: options.startDate, endDate: options.endDate});
+                    },
+                    getHeartRateSamples: function(options) {
+                        options = options || {};
+                        return craft._invoke('getHealthHeartRateSamples', {startDate: options.startDate, endDate: options.endDate, limit: options.limit});
+                    },
+                    getSleepIntervals: function(options) {
+                        options = options || {};
+                        return craft._invoke('getHealthSleepIntervals', {startDate: options.startDate, endDate: options.endDate});
                     }
                 };
                 craft.liveActivity = {
@@ -7260,6 +7289,117 @@ struct CraftWebView: UIViewRepresentable {
             healthStore.execute(query)
         }
 
+        /// Every heart-rate reading between two instants, oldest first: the
+        /// beats per minute, when it was taken, and the app and device that
+        /// wrote it. A watch's workout readings can arrive as one series
+        /// sample; those also carry their count, lowest and highest.
+        private func getHealthHeartRateSamples(startDate: Double?, endDate: Double?, limit: Int?, callbackId: String?) {
+            guard let healthStore = healthStore else {
+                rejectCallback(callbackId, error: "HealthKit not available")
+                return
+            }
+            guard let heartType = HKQuantityType.quantityType(forIdentifier: .heartRate) else {
+                rejectCallback(callbackId, error: "Heart rate is unavailable")
+                return
+            }
+
+            let end = endDate.map { Date(timeIntervalSince1970: $0 / 1000) } ?? Date()
+            let start = startDate.map { Date(timeIntervalSince1970: $0 / 1000) } ?? Calendar.current.date(byAdding: .day, value: -1, to: end)!
+            let predicate = HKQuery.predicateForSamples(withStart: start, end: end, options: [])
+            let oldestFirst = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: true)
+            let cap = max(1, min(limit ?? 10_000, 50_000))
+
+            let query = HKSampleQuery(sampleType: heartType, predicate: predicate, limit: cap, sortDescriptors: [oldestFirst]) { [weak self] _, samples, error in
+                if let error = error, (error as? HKError)?.code != .errorNoData {
+                    self?.rejectCallback(callbackId, error: error.localizedDescription)
+                    return
+                }
+
+                let bpm = HKUnit.count().unitDivided(by: .minute())
+                let rows: [[String: Any]] = (samples as? [HKQuantitySample] ?? []).map { sample in
+                    var item: [String: Any] = [
+                        "bpm": sample.quantity.doubleValue(for: bpm),
+                        "startDate": sample.startDate.timeIntervalSince1970 * 1000,
+                        "endDate": sample.endDate.timeIntervalSince1970 * 1000,
+                        "sourceName": sample.sourceRevision.source.name,
+                    ]
+                    if let device = sample.device?.name { item["deviceName"] = device }
+                    if let model = sample.device?.model { item["deviceModel"] = model }
+                    if let series = sample as? HKDiscreteQuantitySample, series.count > 1 {
+                        item["count"] = series.count
+                        item["min"] = series.minimumQuantity.doubleValue(for: bpm)
+                        item["max"] = series.maximumQuantity.doubleValue(for: bpm)
+                    }
+                    if let raw = sample.metadata?[HKMetadataKeyHeartRateMotionContext] as? NSNumber {
+                        switch HKHeartRateMotionContext(rawValue: raw.intValue) {
+                        case .sedentary: item["motionContext"] = "sedentary"
+                        case .active: item["motionContext"] = "active"
+                        default: break
+                        }
+                    }
+                    return item
+                }
+                self?.resolveCallback(callbackId, result: rows)
+            }
+            healthStore.execute(query)
+        }
+
+        /// A stable name for each sleep analysis value: in bed, awake, or one
+        /// of the asleep stages (`asleep` when the source does not stage it).
+        private static func sleepStageName(_ value: Int) -> String {
+            switch HKCategoryValueSleepAnalysis(rawValue: value) {
+            case .inBed: return "inBed"
+            case .awake: return "awake"
+            case .asleepCore: return "core"
+            case .asleepDeep: return "deep"
+            case .asleepREM: return "rem"
+            default: return "asleep"
+            }
+        }
+
+        /// Sleep between two instants, oldest first, as the sources wrote it:
+        /// time in bed and every asleep or awake stretch, each with its stage
+        /// and whether it counts as asleep, so a page can mark the night.
+        private func getHealthSleepIntervals(startDate: Double?, endDate: Double?, callbackId: String?) {
+            guard let healthStore = healthStore else {
+                rejectCallback(callbackId, error: "HealthKit not available")
+                return
+            }
+            guard let sleepType = HKObjectType.categoryType(forIdentifier: .sleepAnalysis) else {
+                rejectCallback(callbackId, error: "Sleep data is unavailable")
+                return
+            }
+
+            let end = endDate.map { Date(timeIntervalSince1970: $0 / 1000) } ?? Date()
+            let start = startDate.map { Date(timeIntervalSince1970: $0 / 1000) } ?? Calendar.current.date(byAdding: .day, value: -1, to: end)!
+            // Any interval that overlaps the range, so a night that began
+            // before it still counts.
+            let predicate = HKQuery.predicateForSamples(withStart: start, end: end, options: [])
+            let oldestFirst = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: true)
+
+            let query = HKSampleQuery(sampleType: sleepType, predicate: predicate, limit: HKObjectQueryNoLimit, sortDescriptors: [oldestFirst]) { [weak self] _, samples, error in
+                if let error = error, (error as? HKError)?.code != .errorNoData {
+                    self?.rejectCallback(callbackId, error: error.localizedDescription)
+                    return
+                }
+
+                let notAsleep: Set<Int> = [HKCategoryValueSleepAnalysis.inBed.rawValue, HKCategoryValueSleepAnalysis.awake.rawValue]
+                let rows: [[String: Any]] = (samples as? [HKCategorySample] ?? []).map { sample in
+                    var item: [String: Any] = [
+                        "startDate": sample.startDate.timeIntervalSince1970 * 1000,
+                        "endDate": sample.endDate.timeIntervalSince1970 * 1000,
+                        "stage": Self.sleepStageName(sample.value),
+                        "asleep": !notAsleep.contains(sample.value),
+                        "sourceName": sample.sourceRevision.source.name,
+                    ]
+                    if let device = sample.device?.name { item["deviceName"] = device }
+                    return item
+                }
+                self?.resolveCallback(callbackId, result: rows)
+            }
+            healthStore.execute(query)
+        }
+
         // MARK: - Live Activities
         private func startLiveActivity(body: [String: Any], callbackId: String?) {
             guard #available(iOS 16.2, *), ActivityAuthorizationInfo().areActivitiesEnabled else {

package/dist/ios/templates/CraftNativeScreen.swift

@@ -1310,8 +1310,11 @@ private final class CraftNativeGradientLayer: CAGradientLayer {
         layer.follow(view)
         guard existing == nil else { return }
         view.layer.insertSublayer(layer, at: 0)
+        // The layer's bounds, not the view's: UIKit does not promise KVO for
+        // UIView.bounds, and a screen laid out by frame never reported it, so
+        // every gradient stayed zero-sized. CALayer's own bounds always do.
         layer.observations = [
-            view.observe(\.bounds) { [weak layer] view, _ in layer?.follow(view) },
+            view.layer.observe(\.bounds) { [weak layer, weak view] _, _ in if let view { layer?.follow(view) } },
             view.layer.observe(\.cornerRadius) { [weak layer, weak view] _, _ in if let view { layer?.follow(view) } },
         ]
     }
@@ -2744,7 +2747,6 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 return textView
             }
             let field = UITextField()
-            field.borderStyle = .roundedRect
             field.addTarget(self, action: #selector(textChanged(_:)), for: .editingChanged)
             field.addTarget(self, action: #selector(textFocused(_:)), for: .editingDidBegin)
             field.addTarget(self, action: #selector(textBlurred(_:)), for: .editingDidEnd)
@@ -3282,6 +3284,12 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         updateDimension(width, constraint: &node.widthConstraint, anchor: view.widthAnchor)
         updateDimension(height, constraint: &node.heightConstraint, anchor: view.heightAnchor)
         view.backgroundColor = color(style["backgroundColor"]) ?? .clear
+        // A field the style dresses itself (`border-0`, a border or a
+        // background, as a search field inside its own pill is) draws no
+        // system box of its own; a bare one keeps the rounded rectangle.
+        if let field = view as? UITextField {
+            field.borderStyle = style["borderWidth"] != nil || style["backgroundColor"] != nil ? .none : .roundedRect
+        }
         CraftNativeGradientLayer.apply(
             to: view,
             direction: style["gradientDirection"] as? String,

package/dist/mobile.js

@@ -1036,6 +1036,9 @@ var pushNotifications = {
   }
 };
 var health = {
+  supports(method) {
+    return typeof getCraftRoot()?.health?.[method] === "function";
+  },
   async requestAuthorization(types, options = {}) {
     const craft = getCraftRoot();
     if (!craft?.health?.requestAuthorization)
@@ -1065,6 +1068,18 @@ var health = {
     if (!craft?.health?.getDailyStatistics)
       throw new Error("Daily health statistics are unavailable");
     return craft.health.getDailyStatistics(type, options);
+  },
+  async getHeartRateSamples(options = {}) {
+    const craft = getCraftRoot();
+    if (!craft?.health?.getHeartRateSamples)
+      throw new Error("Reading heart-rate samples is unavailable");
+    return craft.health.getHeartRateSamples(options);
+  },
+  async getSleepIntervals(options = {}) {
+    const craft = getCraftRoot();
+    if (!craft?.health?.getSleepIntervals)
+      throw new Error("Reading sleep intervals is unavailable");
+    return craft.health.getSleepIntervals(options);
   }
 };
 async function updateLiveActivity(idOrState, state) {

package/package.json

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