craft-native 0.0.290 → 0.0.293

package/dist/android/src/index.d.ts

@@ -177,7 +177,7 @@ export interface CraftAndroidConfig {
     };
 }
 /** The shared health data types (the iOS builder's HealthKit names). */
-export type HealthConnectType = 'steps' | 'heartRate' | 'activeEnergy' | 'distance' | 'workouts' | 'restingHeartRate' | 'heartRateVariability' | 'bodyMass' | 'sleep' | 'mindful' | 'dietaryEnergy' | 'dietaryProtein' | 'dietaryCarbohydrates' | 'dietaryFat';
+export type HealthConnectType = 'steps' | 'heartRate' | 'activeEnergy' | 'distance' | 'workouts' | 'restingHeartRate' | 'heartRateVariability' | 'bodyMass' | 'sleep' | 'mindful' | 'dietaryEnergy' | 'dietaryProtein' | 'dietaryCarbohydrates' | 'dietaryFat' | 'bloodGlucose' | 'insulinDelivery';
 /**
  * The Health Connect permissions behind each type, for reading and for
  * writing. CraftNativeHealth.kt asks for the same ones; a permission the

package/dist/android/src/index.js

@@ -480,7 +480,9 @@ var HEALTH_CONNECT_PERMISSIONS = {
   dietaryEnergy: { read: ["READ_NUTRITION"], write: ["WRITE_NUTRITION"] },
   dietaryProtein: { read: ["READ_NUTRITION"], write: ["WRITE_NUTRITION"] },
   dietaryCarbohydrates: { read: ["READ_NUTRITION"], write: ["WRITE_NUTRITION"] },
-  dietaryFat: { read: ["READ_NUTRITION"], write: ["WRITE_NUTRITION"] }
+  dietaryFat: { read: ["READ_NUTRITION"], write: ["WRITE_NUTRITION"] },
+  bloodGlucose: { read: ["READ_BLOOD_GLUCOSE"], write: [] },
+  insulinDelivery: { read: [], write: [] }
 };
 var DEFAULT_HEALTH_CONNECT = { read: ["steps", "heartRate", "activeEnergy", "distance", "workouts"], write: ["workouts"] };
 function healthConnectPermissions(config) {

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

@@ -17,6 +17,7 @@ import androidx.health.connect.client.aggregate.AggregationResult
 import androidx.health.connect.client.feature.ExperimentalMindfulnessSessionApi
 import androidx.health.connect.client.permission.HealthPermission
 import androidx.health.connect.client.records.ActiveCaloriesBurnedRecord
+import androidx.health.connect.client.records.BloodGlucoseRecord
 import androidx.health.connect.client.records.DistanceRecord
 import androidx.health.connect.client.records.ElevationGainedRecord
 import androidx.health.connect.client.records.ExerciseSessionRecord
@@ -162,6 +163,10 @@ internal class CraftNativeHealth(
                 getDailyStatistics(type, options(1))
             }
             "getHeartRateSamples" -> answer(completion) { getHeartRateSamples(options(0)) }
+            "getSamples" -> answer(completion) {
+                val type = args.opt(0) as? String ?: throw invalid("getSamples needs a type")
+                getSamples(type, options(1))
+            }
             "getSleepIntervals" -> answer(completion) { getSleepIntervals(options(0)) }
             "saveMindfulSession" -> answer(completion) { saveMindfulSession(options(0)) }
             "getMindfulSessions" -> answer(completion) { getMindfulSessions(options(0)) }
@@ -438,7 +443,8 @@ internal class CraftNativeHealth(
     /** The types whose every read permission is granted, in the order of TYPES. */
     private suspend fun grantedTypes(): Any {
         val granted = client().permissionController.getGrantedPermissions()
-        return JSONArray(TYPES.filter { type -> granted.containsAll(readPermissions(type)) })
+        // A type Health Connect cannot hold (insulin) is never granted.
+        return JSONArray(TYPES.filter { type -> readPermissions(type).let { it.isNotEmpty() && granted.containsAll(it) } })
     }
 
     /**
@@ -783,6 +789,53 @@ internal class CraftNativeHealth(
         return rows
     }
 
+    /**
+     * Every glucose reading or carb entry between two instants, oldest first,
+     * as the writing app saved it: its record id (so a sync stores it once),
+     * value, source and device. Glucose comes in mg/dL with its meal relation
+     * and specimen when the source said. Health Connect has no insulin type,
+     * so `insulinDelivery` answers an empty list rather than failing a sync
+     * that asks for all three.
+     */
+    private suspend fun getSamples(type: String, options: JSONObject): Any {
+        if (type !in SAMPLE_TYPES) throw invalid("getSamples reads bloodGlucose, insulinDelivery or dietaryCarbohydrates")
+        val end = options.instant("endDate") ?: Instant.now()
+        val start = options.instant("startDate") ?: end.minus(Duration.ofDays(7))
+        val cap = (options.int("limit") ?: 10_000).coerceIn(1, 50_000)
+        val rows = JSONArray()
+        if (type == "insulinDelivery") return rows
+        val client = client()
+        fun row(id: String, value: Double, unit: String, from: Instant, to: Instant, metadata: Metadata): JSONObject {
+            val origin = metadata.dataOrigin.packageName
+            val item = JSONObject()
+                .put("id", id)
+                .put("value", value)
+                .put("unit", unit)
+                .put("startDate", from.ms())
+                .put("endDate", to.ms())
+                .put("sourceName", sourceName(origin))
+                .put("sourceBundleId", origin)
+                .put("ownApp", origin == context.packageName)
+            putDevice(item, metadata.device, withModel = false)
+            return item
+        }
+        if (type == "bloodGlucose") {
+            for (record in readAll(client, BloodGlucoseRecord::class, range(start, end), cap = cap)) {
+                val item = row(record.metadata.id, record.level.inMilligramsPerDeciliter, "mg/dL", record.time, record.time, record.metadata)
+                mealTimeName(record.relationToMeal)?.let { item.put("mealTime", it) }
+                specimenName(record.specimenSource)?.let { item.put("specimen", it) }
+                rows.put(item)
+            }
+            return rows
+        }
+        for (record in readAll(client, NutritionRecord::class, range(start, end), cap = cap)) {
+            val grams = record.totalCarbohydrate?.inGrams ?: continue
+            if (grams <= 0) continue
+            rows.put(row(record.metadata.id, grams, "g", record.startTime, record.endTime, record.metadata))
+        }
+        return rows
+    }
+
     /**
      * Sleep between two instants, oldest first, as the sources wrote it: each
      * stage with its name and whether it counts as asleep. A session with no
@@ -996,7 +1049,28 @@ internal class CraftNativeHealth(
             "steps", "heartRate", "activeEnergy", "distance", "workouts", "restingHeartRate",
             "heartRateVariability", "bodyMass", "sleep", "mindful",
             "dietaryEnergy", "dietaryProtein", "dietaryCarbohydrates", "dietaryFat",
+            "bloodGlucose", "insulinDelivery",
         )
+        /** What `getSamples` reads one record at a time. */
+        private val SAMPLE_TYPES = setOf("bloodGlucose", "insulinDelivery", "dietaryCarbohydrates")
+
+        private fun mealTimeName(relation: Int): String? = when (relation) {
+            BloodGlucoseRecord.RELATION_TO_MEAL_BEFORE_MEAL -> "beforeMeal"
+            BloodGlucoseRecord.RELATION_TO_MEAL_AFTER_MEAL -> "afterMeal"
+            BloodGlucoseRecord.RELATION_TO_MEAL_FASTING -> "fasting"
+            BloodGlucoseRecord.RELATION_TO_MEAL_GENERAL -> "general"
+            else -> null
+        }
+
+        private fun specimenName(source: Int): String? = when (source) {
+            BloodGlucoseRecord.SPECIMEN_SOURCE_CAPILLARY_BLOOD -> "capillaryBlood"
+            BloodGlucoseRecord.SPECIMEN_SOURCE_INTERSTITIAL_FLUID -> "interstitialFluid"
+            BloodGlucoseRecord.SPECIMEN_SOURCE_PLASMA -> "plasma"
+            BloodGlucoseRecord.SPECIMEN_SOURCE_SERUM -> "serum"
+            BloodGlucoseRecord.SPECIMEN_SOURCE_TEARS -> "tears"
+            BloodGlucoseRecord.SPECIMEN_SOURCE_WHOLE_BLOOD -> "wholeBlood"
+            else -> null
+        }
         private val DIETARY_TYPES = setOf("dietaryEnergy", "dietaryProtein", "dietaryCarbohydrates", "dietaryFat")
 
         private val AWAKE_STAGES = setOf(
@@ -1142,6 +1216,8 @@ internal class CraftNativeHealth(
             "sleep" -> setOf(HealthPermission.getReadPermission(SleepSessionRecord::class))
             "mindful" -> setOf(HealthPermission.getReadPermission(MindfulnessSessionRecord::class))
             in DIETARY_TYPES -> setOf(HealthPermission.getReadPermission(NutritionRecord::class))
+            "bloodGlucose" -> setOf(HealthPermission.getReadPermission(BloodGlucoseRecord::class))
+            // Health Connect has no insulin record: nothing to ask for.
             else -> emptySet()
         }
 

package/dist/api/mobile.d.ts

@@ -1546,11 +1546,48 @@ export type HealthDataType = 'steps' | 'heartRate' | 'activeEnergy' | 'distance'
 /** Food logged by any app, per day: kcal eaten, then grams of protein, carbohydrate and fat. */
  | 'dietaryEnergy' | 'dietaryProtein' | 'dietaryCarbohydrates' | 'dietaryFat'
 /** Mindful minutes (meditation, breathing): read with getMindfulSessions, written with saveMindfulSession. */
- | 'mindful';
+ | 'mindful'
+/** Blood glucose from a CGM or meter, in mg/dL: read with getSamples. Read only. */
+ | 'bloodGlucose'
+/**
+ * Insulin from a pump, pen or closed loop, in international units, each
+ * marked basal or bolus: read with getSamples. Read only. HealthKit only:
+ * Health Connect has no insulin type, so Android answers none.
+ */
+ | 'insulinDelivery';
 /** The types with one value per day. `sleep` is hours asleep, counted on the day you woke. */
-export type HealthDailyType = Exclude<HealthDataType, 'workouts' | 'mindful'>;
+export type HealthDailyType = Exclude<HealthDataType, 'workouts' | 'mindful' | 'bloodGlucose' | 'insulinDelivery'>;
 /** Quantity types that can be written with `health.saveData()`. */
-export type HealthQuantityType = Exclude<HealthDataType, 'workouts' | 'sleep' | 'mindful'>;
+export type HealthQuantityType = Exclude<HealthDataType, 'workouts' | 'sleep' | 'mindful' | 'bloodGlucose' | 'insulinDelivery'>;
+/** The types `health.getSamples()` reads one sample at a time: glucose, insulin and carbs, as a diabetes app needs them. */
+export type HealthSampleType = 'bloodGlucose' | 'insulinDelivery' | 'dietaryCarbohydrates';
+export interface HealthSamplesQuery extends HealthSampleQuery {
+    /** At most this many, oldest first. Defaults to 10000, capped at 50000. Start defaults to 7 days ago. */
+    limit?: number;
+}
+/** One glucose reading, insulin dose or carb entry as the writing app saved it. */
+export interface HealthQuantitySample {
+    /** HealthKit's UUID or Health Connect's record id: stable across reads. */
+    id: string;
+    /** In `unit`: mg/dL for glucose, IU for insulin, g for carbs. */
+    value: number;
+    unit: 'mg/dL' | 'IU' | 'g';
+    /** Epoch milliseconds. */
+    startDate: number;
+    /** Epoch milliseconds; the same as `startDate` for an instant reading. A basal delivery spans its segment. */
+    endDate: number;
+    sourceName: string;
+    sourceBundleId: string;
+    /** True when this app wrote it. */
+    ownApp: boolean;
+    deviceName?: string;
+    /** Insulin only: what the dose was for. */
+    insulinReason?: 'basal' | 'bolus';
+    /** Glucose only: when it was taken relative to a meal, when the source said. */
+    mealTime?: 'beforeMeal' | 'afterMeal' | 'fasting' | 'general';
+    /** Glucose only (Health Connect): what was sampled, when the source said. */
+    specimen?: 'capillaryBlood' | 'interstitialFluid' | 'plasma' | 'serum' | 'tears' | 'wholeBlood';
+}
 export interface HealthAuthorizationOptions {
     /** `false` asks to read only. Default: also allowed to save workouts. */
     write?: boolean;
@@ -1737,7 +1774,7 @@ export interface HealthLiveWorkoutEvent {
     message?: string;
 }
 /** The health reads and writes a host may or may not have, depending on the app build it runs in. */
-export type HealthReadMethod = 'getWorkouts' | 'getDailyStatistics' | 'getHeartRateSamples' | 'getSleepIntervals' | 'saveData' | 'saveMindfulSession' | 'getMindfulSessions' | 'startHeartRateUpdates' | 'stopHeartRateUpdates' | 'startWorkout' | 'pauseWorkout' | 'resumeWorkout' | 'endWorkout';
+export type HealthReadMethod = 'getWorkouts' | 'getDailyStatistics' | 'getHeartRateSamples' | 'getSamples' | 'getSleepIntervals' | 'saveData' | 'saveMindfulSession' | 'getMindfulSessions' | 'startHeartRateUpdates' | 'stopHeartRateUpdates' | 'startWorkout' | 'pauseWorkout' | 'resumeWorkout' | 'endWorkout';
 export declare const health: {
     /**
      * Whether this app build answers `method`. An app installed before a read
@@ -1760,6 +1797,13 @@ export declare const health: {
     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[]>;
+    /**
+     * Every glucose reading, insulin dose or carb entry between two instants,
+     * oldest first, each with its own id so a sync can store it once. Needs
+     * the type's read grant. Health Connect has no insulin, so Android answers
+     * an empty list for `insulinDelivery`.
+     */
+    getSamples(type: HealthSampleType, options?: HealthSamplesQuery): Promise<HealthQuantitySample[]>;
     /** Sleep between two instants, oldest first: time in bed and each asleep or awake stage. iOS only for now. */
     getSleepIntervals(options?: HealthSampleQuery): Promise<HealthSleepInterval[]>;
     /**

package/dist/cli.js

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

package/dist/index.cjs

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

package/dist/index.js

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

package/dist/ios/templates/CraftApp.swift

@@ -3116,6 +3116,22 @@ struct CraftWebView: UIViewRepresentable {
                 } else {
                     rejectCallback(callbackId, error: "HealthKit is disabled", code: "CAPABILITY_DISABLED")
                 }
+            // Glucose, insulin and carbs, one sample at a time (CraftHealth.swift).
+            case "getHealthSamples":
+                if config.enableHealthKit {
+                    if let dataType = body["type"] as? String {
+                        CraftHealth.shared.getSamples(
+                            type: dataType,
+                            startDate: body["startDate"] as? Double,
+                            endDate: body["endDate"] as? Double,
+                            limit: body["limit"] as? Int
+                        ) { [weak self] in self?.answer(callbackId, $0) }
+                    } else {
+                        rejectCallback(callbackId, error: "getHealthSamples was called without a type", code: "INVALID_ARGUMENT")
+                    }
+                } else {
+                    rejectCallback(callbackId, error: "HealthKit is disabled", code: "CAPABILITY_DISABLED")
+                }
             case "getHealthSleepIntervals":
                 if config.enableHealthKit {
                     getHealthSleepIntervals(
@@ -5749,6 +5765,10 @@ struct CraftWebView: UIViewRepresentable {
                         options = options || {};
                         return craft._invoke('getHealthHeartRateSamples', {startDate: options.startDate, endDate: options.endDate, limit: options.limit});
                     },
+                    getSamples: function(type, options) {
+                        options = options || {};
+                        return craft._invoke('getHealthSamples', {type: type, startDate: options.startDate, endDate: options.endDate, limit: options.limit});
+                    },
                     getSleepIntervals: function(options) {
                         options = options || {};
                         return craft._invoke('getHealthSleepIntervals', {startDate: options.startDate, endDate: options.endDate});

package/dist/ios/templates/CraftHealth.swift

@@ -106,6 +106,9 @@ final class CraftHealth {
             getDailyStatistics(type: type, startDate: options(1)["startDate"] as? Double, endDate: options(1)["endDate"] as? Double, completion: completion)
         case "getHeartRateSamples":
             getHeartRateSamples(startDate: options(0)["startDate"] as? Double, endDate: options(0)["endDate"] as? Double, limit: options(0)["limit"] as? Int, completion: completion)
+        case "getSamples":
+            guard let type = args.first as? String else { return completion(.failure(CraftHealthError(message: "getSamples needs a type", code: "INVALID_ARGUMENT"))) }
+            getSamples(type: type, startDate: options(1)["startDate"] as? Double, endDate: options(1)["endDate"] as? Double, limit: options(1)["limit"] as? Int, completion: completion)
         case "getSleepIntervals":
             getSleepIntervals(startDate: options(0)["startDate"] as? Double, endDate: options(0)["endDate"] as? Double, completion: completion)
         case "saveMindfulSession":
@@ -196,6 +199,12 @@ final class CraftHealth {
                     readTypes.insert(mindfulType)
                     shareTypes.insert(mindfulType)
                 }
+            case "bloodGlucose", "insulinDelivery":
+                // A CGM, meter, pump or closed loop's own writes: read
+                // only, never written back, so the sheet only asks to read.
+                if let diabetesType = Self.healthQuantity(type)?.type {
+                    readTypes.insert(diabetesType)
+                }
             case "dietaryEnergy", "dietaryProtein", "dietaryCarbohydrates", "dietaryFat":
                 // What a food log (MyFitnessPal, Lose It!, Cronometer...)
                 // writes to Apple Health. Request the write grant too unless
@@ -404,6 +413,8 @@ final class CraftHealth {
         case "dietaryProtein": return (HKQuantityType.quantityType(forIdentifier: .dietaryProtein), .gram(), .cumulativeSum)
         case "dietaryCarbohydrates": return (HKQuantityType.quantityType(forIdentifier: .dietaryCarbohydrates), .gram(), .cumulativeSum)
         case "dietaryFat": return (HKQuantityType.quantityType(forIdentifier: .dietaryFatTotal), .gram(), .cumulativeSum)
+        case "bloodGlucose": return (HKQuantityType.quantityType(forIdentifier: .bloodGlucose), HKUnit(from: "mg/dL"), .discreteAverage)
+        case "insulinDelivery": return (HKQuantityType.quantityType(forIdentifier: .insulinDelivery), .internationalUnit(), .cumulativeSum)
         default: return nil
         }
     }
@@ -613,6 +624,71 @@ final class CraftHealth {
         healthStore.execute(query)
     }
 
+    /// The types `getSamples` reads, and the unit each answers in.
+    private static let sampleUnits: [String: String] = ["bloodGlucose": "mg/dL", "insulinDelivery": "IU", "dietaryCarbohydrates": "g"]
+
+    /// Every glucose reading, insulin dose or carb entry between two
+    /// instants, oldest first, as the writing app saved it: its UUID (so a
+    /// sync stores it once), value, source and device, plus what a diabetes
+    /// app needs to tell readings and doses apart: an insulin dose's reason
+    /// (basal or bolus) and a glucose reading's meal time.
+    func getSamples(type: String, startDate: Double?, endDate: Double?, limit: Int?, completion rawCompletion: @escaping Completion) {
+        let completion = completeOnMain(rawCompletion)
+        guard let healthStore = healthStore else {
+            completion(.failure(CraftHealthError(message: "HealthKit not available")))
+            return
+        }
+        guard let unitName = Self.sampleUnits[type], let spec = Self.healthQuantity(type), let sampleType = spec.type else {
+            completion(.failure(CraftHealthError(message: "getSamples reads bloodGlucose, insulinDelivery or dietaryCarbohydrates", code: "INVALID_ARGUMENT")))
+            return
+        }
+
+        let end = endDate.map { Date(timeIntervalSince1970: $0 / 1000) } ?? Date()
+        let start = startDate.map { Date(timeIntervalSince1970: $0 / 1000) } ?? Calendar.current.date(byAdding: .day, value: -7, 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 ownBundle = Bundle.main.bundleIdentifier
+
+        let query = HKSampleQuery(sampleType: sampleType, predicate: predicate, limit: cap, sortDescriptors: [oldestFirst]) { _, samples, error in
+            if let error = error, (error as? HKError)?.code != .errorNoData {
+                completion(.failure(CraftHealthError(message: error.localizedDescription)))
+                return
+            }
+            let rows: [[String: Any]] = (samples as? [HKQuantitySample] ?? []).map { sample in
+                let source = sample.sourceRevision.source
+                var item: [String: Any] = [
+                    "id": sample.uuid.uuidString,
+                    "value": sample.quantity.doubleValue(for: spec.unit),
+                    "unit": unitName,
+                    "startDate": sample.startDate.timeIntervalSince1970 * 1000,
+                    "endDate": sample.endDate.timeIntervalSince1970 * 1000,
+                    "sourceName": source.name,
+                    "sourceBundleId": source.bundleIdentifier,
+                    "ownApp": ownBundle != nil && source.bundleIdentifier == ownBundle,
+                ]
+                if let device = sample.device?.name { item["deviceName"] = device }
+                if let reason = sample.metadata?[HKMetadataKeyInsulinDeliveryReason] as? NSNumber {
+                    switch HKInsulinDeliveryReason(rawValue: reason.intValue) {
+                    case .basal: item["insulinReason"] = "basal"
+                    case .bolus: item["insulinReason"] = "bolus"
+                    default: break
+                    }
+                }
+                if let meal = sample.metadata?[HKMetadataKeyBloodGlucoseMealTime] as? NSNumber {
+                    switch HKBloodGlucoseMealTime(rawValue: meal.intValue) {
+                    case .preprandial: item["mealTime"] = "beforeMeal"
+                    case .postprandial: item["mealTime"] = "afterMeal"
+                    default: break
+                    }
+                }
+                return item
+            }
+            completion(.success(rows))
+        }
+        healthStore.execute(query)
+    }
+
     /// One heart-rate sample as a page sees it, from a read or the stream
     /// alike: bpm, when, the app and device that wrote it, a series' count,
     /// lowest and highest, and what the wearer was doing when the watch says.

package/dist/mobile.js

@@ -1715,6 +1715,12 @@ var health = {
       throw new Error("Reading heart-rate samples is unavailable");
     return craft.health.getHeartRateSamples(options);
   },
+  async getSamples(type, options = {}) {
+    const craft = getCraftRoot();
+    if (!craft?.health?.getSamples)
+      throw new Error("Reading health samples is unavailable");
+    return craft.health.getSamples(type, options);
+  },
   async getSleepIntervals(options = {}) {
     const craft = getCraftRoot();
     if (!craft?.health?.getSleepIntervals)

package/package.json

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