craft-native 0.0.151 → 0.0.153

package/dist/api/mobile.d.ts

@@ -825,6 +825,118 @@ export declare const music: {
      */
     onChange(callback: (nowPlaying: NowPlaying) => void): () => void;
 };
+export type HeartRateAuthorization = 'authorized' | 'denied' | 'restricted' | 'notDetermined' | 'unavailable';
+export type BluetoothState = 'poweredOn' | 'poweredOff' | 'unauthorized' | 'unsupported' | 'resetting' | 'unknown';
+export type HeartRateConnection = 'disconnected' | 'connecting' | 'connected' | 'reconnecting';
+export interface HeartRateDevice {
+    id: string;
+    name: string;
+    /** Signal strength, dBm; 0 for a strap the phone is already connected to. */
+    rssi: number | null;
+}
+export interface HeartRateRecordingState {
+    id: string | null;
+    active: boolean;
+    paused: boolean;
+    /** ms since the epoch. */
+    startedAt: number | null;
+    sampleCount: number | null;
+}
+export interface HeartRateState {
+    /** False off a phone, in a build without `enableHeartRate`, or on a phone without Bluetooth. */
+    available: boolean;
+    bluetooth: BluetoothState;
+    authorization: HeartRateAuthorization;
+    scanning: boolean;
+    connection: HeartRateConnection;
+    /** The strap connected, or being connected to. */
+    device: HeartRateDevice | null;
+    /** The strap `reconnect()` asks for. */
+    lastDevice: HeartRateDevice | null;
+    /** The latest reading while it is fresh (ten seconds), else null. */
+    bpm: number | null;
+    lastReadingAt: number | null;
+    recording: HeartRateRecordingState;
+}
+export interface HeartRateReading {
+    bpm: number;
+    /** Milliseconds between beats, oldest first; empty when the strap sends none. */
+    rrIntervals: number[];
+    /** Whether the strap touches skin; null when it cannot tell. */
+    contact: boolean | null;
+    energyExpended: number | null;
+    /** ms since the epoch. */
+    timestamp: number;
+    deviceId: string | null;
+}
+/** A reading as a recording keeps it. */
+export interface HeartRateSample {
+    /** ms since the epoch. */
+    timestamp: number;
+    bpm: number;
+    /** Milliseconds between beats, when the strap sent them. */
+    rr?: number[];
+}
+export type HeartRateMethod = 'getState' | 'requestAuthorization' | 'scan' | 'stopScan' | 'getDevices' | 'connect' | 'reconnect' | 'disconnect' | 'startRecording' | 'pauseRecording' | 'resumeRecording' | 'stopRecording' | 'getRecordingState' | 'readRecording';
+export declare function normalizeHeartRateDevice(value: unknown): HeartRateDevice | null;
+/** A state from native, made safe to render whatever an older or newer build sent. */
+export declare function normalizeHeartRateState(value: unknown): HeartRateState;
+/** A reading event's detail, or null for one that is not a usable reading. */
+export declare function normalizeHeartRateReading(value: unknown): HeartRateReading | null;
+/** A recording's samples, oldest first, one per timestamp, implausible ones left out. */
+export declare function normalizeHeartRateSamples(value: unknown): HeartRateSample[];
+export declare const heartRate: {
+    /** Whether this app can read a heart-rate strap. */
+    isAvailable(): boolean;
+    /** Whether this app build answers `method`; an older build may lack one. */
+    supports(method: HeartRateMethod): boolean;
+    /** Bluetooth, the connection, the strap and its latest reading, without asking anything. */
+    getState: () => Promise<HeartRateState>;
+    /**
+     * Ask for Bluetooth: iOS's prompt the first time, its remembered answer
+     * after that. Scanning and connecting ask too; call this from the person's
+     * tap to ask first.
+     */
+    requestAuthorization: () => Promise<HeartRateAuthorization>;
+    /** Look for straps for `timeout` seconds (15 by default); `onDevice` hears each one. */
+    scan: (options?: {
+        timeout?: number;
+    }) => Promise<HeartRateState>;
+    stopScan: () => Promise<HeartRateState>;
+    /** What the last scan found, strongest signal first. */
+    getDevices: () => Promise<HeartRateDevice[]>;
+    /**
+     * Connect to a strap from `scan` and subscribe to its readings; it is
+     * remembered for `reconnect()`. Rejects with code TIMEOUT when it does not
+     * answer within 15 s, while still asking for it: a strap wakes up when worn.
+     */
+    connect: (id: string) => Promise<HeartRateState>;
+    /** Ask for the remembered strap again, without waiting for it. */
+    reconnect: () => Promise<HeartRateState>;
+    /** Stop asking for the strap; `forget` also drops it from memory. */
+    disconnect: (options?: {
+        forget?: boolean;
+    }) => Promise<HeartRateState>;
+    /** Keep every reading natively from now on: screen locked, page suspended or app closed. */
+    startRecording: () => Promise<HeartRateRecordingState>;
+    pauseRecording: () => Promise<HeartRateRecordingState>;
+    resumeRecording: () => Promise<HeartRateRecordingState>;
+    /** Ends the recording and hands back every reading it kept. */
+    stopRecording: () => Promise<HeartRateRecordingState & {
+        samples: HeartRateSample[];
+    }>;
+    getRecordingState: () => Promise<HeartRateRecordingState>;
+    /** The recording so far; only what came after `since` (ms) when given. */
+    readRecording: (options?: {
+        since?: number;
+    }) => Promise<HeartRateSample[]>;
+    /** Every reading from the connected strap, about once a second. */
+    onReading: (callback: (reading: HeartRateReading) => void) => (() => void);
+    /** Each strap a scan finds. */
+    onDevice: (callback: (device: HeartRateDevice) => void) => (() => void);
+    /** Bluetooth, scanning or the connection changed. */
+    onState: (callback: (state: HeartRateState) => void) => (() => void);
+};
 export declare const deepLinks: {
     getInitialURL(): Promise<string | null>;
     /**
@@ -1308,6 +1420,7 @@ declare const mobile: {
     brightness: typeof brightness;
     speech: typeof speech;
     music: typeof music;
+    heartRate: typeof heartRate;
     deepLinks: typeof deepLinks;
     network: typeof network;
     appReview: typeof appReview;

package/dist/cli.js

@@ -3303,7 +3303,7 @@ function pinCraftNativeDependency(packagePath, craftVersion) {
 `);
 }
 // package.json
-var version = "0.0.151";
+var version = "0.0.153";
 
 // 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.151";
+var version = "0.0.153";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;
@@ -5325,6 +5325,7 @@ var notifications = {
 };
 var speakingOnTheWeb = new Set;
 var musicWatch = { listeners: new Set, stop: null };
+var heartRateWatch = { readings: new Set, devices: new Set, states: new Set, stop: null };
 function onCraftEvent(eventName, callback) {
   if (typeof globalThis === "undefined")
     return () => {};

package/dist/index.js

@@ -58,7 +58,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.151";
+var version = "0.0.153";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;
@@ -5085,6 +5085,7 @@ var notifications = {
 };
 var speakingOnTheWeb = new Set;
 var musicWatch = { listeners: new Set, stop: null };
+var heartRateWatch = { readings: new Set, devices: new Set, states: new Set, stop: null };
 function onCraftEvent(eventName, callback) {
   if (typeof globalThis === "undefined")
     return () => {};

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

@@ -68,6 +68,15 @@ export interface CraftConfig {
      * `craft.music.requestAuthorization()`, never at launch.
      */
     enableAppleMusic?: boolean;
+    /**
+     * Read a Bluetooth heart-rate strap, or a watch broadcasting its heart rate
+     * (the standard Heart Rate Service), through `craft.heartRate`: scan,
+     * connect, live readings with RR intervals, and a recording kept natively.
+     * Adds the `bluetooth-central` background mode, so readings keep coming
+     * during a workout with the screen locked. iOS asks for Bluetooth the first
+     * time the page scans or connects.
+     */
+    enableHeartRate?: boolean;
     /**
      * Purpose strings in the app's own words, by Info.plist key
      * (`{ NSAppleMusicUsageDescription: 'Shows the song playing during a workout.' }`).

package/dist/ios/src/index.js

@@ -170,6 +170,7 @@ var DEFAULT_CONFIG = {
   enableAR: false,
   enableMLKit: false,
   enableAppleMusic: false,
+  enableHeartRate: false,
   iosVersion: "16.0",
   watchosVersion: "9.0",
   teamId: "",
@@ -226,7 +227,7 @@ function renderUsageDescriptions(config) {
     [config.enableBackgroundLocation, "NSLocationAlwaysAndWhenInUseUsageDescription", `${config.appName} continues recording your route when the screen is locked or the app is in the background.`],
     [config.enableContacts, "NSContactsUsageDescription", `${config.appName} accesses contacts only when you choose a contact feature.`],
     [config.enableCalendar, "NSCalendarsUsageDescription", `${config.appName} accesses your calendar only when you choose a calendar feature.`],
-    [config.enableBluetooth, "NSBluetoothAlwaysUsageDescription", `${config.appName} uses Bluetooth to connect to nearby devices.`],
+    [config.enableBluetooth || config.enableHeartRate, "NSBluetoothAlwaysUsageDescription", config.enableHeartRate ? `${config.appName} connects to your heart-rate monitor over Bluetooth to show and record your heart rate during a workout.` : `${config.appName} uses Bluetooth to connect to nearby devices.`],
     [config.enableMotionSensors, "NSMotionUsageDescription", `${config.appName} uses motion data for activity features.`],
     [config.enableNFC, "NFCReaderUsageDescription", `${config.appName} reads NFC tags when you start a scan.`],
     [config.enableLocalNetwork, "NSLocalNetworkUsageDescription", `${config.appName} connects to your own devices on this network.`],
@@ -309,6 +310,8 @@ function renderBackgroundModes(config) {
     modes.add("processing");
   if (config.enablePushNotifications)
     modes.add("remote-notification");
+  if (config.enableHeartRate)
+    modes.add("bluetooth-central");
   if (!modes.size)
     return "";
   return `    <key>UIBackgroundModes</key>
@@ -787,9 +790,11 @@ async function init(options) {
   cpSync(join(TEMPLATES_DIR, "CraftNativeActions.swift"), join(output, "Sources", "CraftNativeActions.swift"));
   cpSync(join(TEMPLATES_DIR, "CraftHealth.swift"), join(output, "Sources", "CraftHealth.swift"));
   cpSync(join(TEMPLATES_DIR, "CraftMusic.swift"), join(output, "Sources", "CraftMusic.swift"));
+  cpSync(join(TEMPLATES_DIR, "CraftHeartRate.swift"), join(output, "Sources", "CraftHeartRate.swift"));
   cpSync(join(TEMPLATES_DIR, "CraftNativeMutation.swift"), join(output, "Sources", "CraftNativeMutation.swift"));
   cpSync(join(TEMPLATES_DIR, "CraftNativeUI.swift"), join(output, "Sources", "CraftNativeUI.swift"));
   cpSync(join(TEMPLATES_DIR, "CraftNativeServices.swift"), join(output, "Sources", "CraftNativeServices.swift"));
+  cpSync(join(TEMPLATES_DIR, "CraftNativeFiles.swift"), join(output, "Sources", "CraftNativeFiles.swift"));
   cpSync(join(TEMPLATES_DIR, "CraftWebAudio.swift"), join(output, "Sources", "CraftWebAudio.swift"));
   cpSync(join(TEMPLATES_DIR, "CraftHybrid.swift"), join(output, "Sources", "CraftHybrid.swift"));
   const infoPlistTemplate = readFileSync(join(TEMPLATES_DIR, "Info.plist.template"), "utf-8");

package/dist/ios/templates/CraftApp.swift

@@ -1119,6 +1119,9 @@ struct CraftConfig: Codable {
     var enableMLKit: Bool = false
     /// The Music app's song and transport through `craft.music` (CraftMusic.swift).
     var enableAppleMusic: Bool = false
+    /// A Bluetooth heart-rate strap (or a watch broadcasting its heart rate)
+    /// through `craft.heartRate` (CraftHeartRate.swift).
+    var enableHeartRate: Bool = false
     var devServerURL: String? = nil
     var trustedOrigins: [String] = []
     /// The longest the launch splash stays up when the page neither says it is
@@ -1641,6 +1644,16 @@ struct CraftWebView: UIViewRepresentable {
             if config.enableMotionSensors {
                 motionManager = CMMotionManager()
             }
+            if config.enableHeartRate {
+                // The strap's readings and connection changes reach the page,
+                // and through sendToWeb every native screen too. False once
+                // this coordinator is gone: native screens still hear them.
+                CraftHeartRate.shared.pageSink = { [weak self] detail in
+                    guard let self else { return false }
+                    self.sendToWeb("craftHeartRate", data: detail)
+                    return true
+                }
+            }
             if config.enableWatchApp {
                 setupWatchConnectivity()
             }
@@ -2213,6 +2226,22 @@ struct CraftWebView: UIViewRepresentable {
                 } else {
                     rejectCallback(callbackId, error: "Apple Music is disabled", code: "CAPABILITY_DISABLED")
                 }
+            // MARK: - Heart rate (CraftHeartRate.swift)
+            // Gated on enableHeartRate. One action for every method, as a
+            // native screen's HeartRate module calls them; asking for
+            // Bluetooth has its own, which waits on the person.
+            case "heartRate", "heartRateRequestAuthorization":
+                if !config.enableHeartRate {
+                    rejectCallback(callbackId, error: "Heart rate is disabled", code: "CAPABILITY_DISABLED")
+                } else {
+                    let method = action == "heartRate" ? body["method"] as? String ?? "" : "requestAuthorization"
+                    CraftHeartRate.shared.perform(method: method, args: [body["options"] as? [String: Any] ?? [:]]) { [weak self] result in
+                        switch result {
+                        case .success(let value): self?.resolveCallback(callbackId, result: value)
+                        case .failure(let failure): self?.rejectCallback(callbackId, error: failure.message, code: failure.code)
+                        }
+                    }
+                }
             // MARK: - Orientation Lock
             case "lockOrientation":
                 if config.enableOrientationLock {
@@ -3198,6 +3227,7 @@ struct CraftWebView: UIViewRepresentable {
                     flashlight: true,
                     brightness: true,
                     music: \(config.enableAppleMusic),
+                    heartRate: \(config.enableHeartRate),
                     speech: true,
                     network: true,
                     deviceInfo: true,
@@ -4737,6 +4767,7 @@ struct CraftWebView: UIViewRepresentable {
                 var personFacing = {
                     requestHealthAuthorization: true,
                     musicRequestAuthorization: true,
+                    heartRateRequestAuthorization: true,
                     requestPermission: true,
                     signInWithApple: true,
                     dialogAlert: true,
@@ -4951,6 +4982,30 @@ struct CraftWebView: UIViewRepresentable {
                     },
                     observe: function(enabled) { return craft._invoke('musicObserve', {enabled: enabled !== false}); }
                 };
+                // A Bluetooth heart-rate strap, or a watch broadcasting its
+                // heart rate. Readings, devices found by scan() and connection
+                // changes arrive as craftHeartRate events ({type: 'reading' |
+                // 'device' | 'state'}); startRecording() keeps every reading
+                // natively, screen locked or app closed, until stopRecording().
+                (function() {
+                    function heartRate(method, options) { return craft._invoke('heartRate', {method: method, options: options || {}}); }
+                    craft.heartRate = {
+                        getState: function() { return heartRate('getState'); },
+                        requestAuthorization: function() { return craft._invoke('heartRateRequestAuthorization'); },
+                        scan: function(options) { return heartRate('scan', {timeout: options && typeof options.timeout === 'number' ? options.timeout : null}); },
+                        stopScan: function() { return heartRate('stopScan'); },
+                        getDevices: function() { return heartRate('getDevices'); },
+                        connect: function(id) { return heartRate('connect', {id: typeof id === 'string' ? id : id && id.id}); },
+                        reconnect: function() { return heartRate('reconnect'); },
+                        disconnect: function(options) { return heartRate('disconnect', {forget: !!(options && options.forget)}); },
+                        startRecording: function() { return heartRate('startRecording'); },
+                        pauseRecording: function() { return heartRate('pauseRecording'); },
+                        resumeRecording: function() { return heartRate('resumeRecording'); },
+                        stopRecording: function() { return heartRate('stopRecording'); },
+                        getRecordingState: function() { return heartRate('getRecordingState'); },
+                        readRecording: function(options) { return heartRate('readRecording', {since: options && typeof options.since === 'number' ? options.since : null}); }
+                    };
+                })();
                 craft.liveActivity = {
                     start: function(options) { return craft._invoke('startLiveActivity', options || {}); },
                     update: function(idOrState, state) {
@@ -8450,7 +8505,7 @@ final class CraftZigRuntime: NSObject {
 enum CraftWebServices {
     private static var waiting: [String: (Result<Any, CraftNativeActionError>) -> Void] = [:]
     /// Coordinator events a native screen hears too.
-    static let forwardedEvents: Set<String> = ["craftLocationUpdate", "craftLocationError", "craftMusicChange"]
+    static let forwardedEvents: Set<String> = ["craftLocationUpdate", "craftLocationError", "craftMusicChange", "craftHeartRate"]
     static let event = Notification.Name("craftWebServicesEvent")
 
     static var isAvailable: Bool { CraftSwiftShim.coordinator != nil }