craft-native 0.0.158 → 0.0.161

package/dist/api/mobile.d.ts

@@ -1238,9 +1238,13 @@ export declare const pushNotifications: {
      */
     onReceive(callback: (data: Record<string, unknown>) => void): () => void;
 };
-export type HealthDataType = 'steps' | 'heartRate' | 'activeEnergy' | 'distance' | 'workouts' | 'restingHeartRate' | 'heartRateVariability' | 'bodyMass' | 'sleep';
+export type HealthDataType = 'steps' | 'heartRate' | 'activeEnergy' | 'distance' | 'workouts' | 'restingHeartRate' | 'heartRateVariability' | 'bodyMass' | 'sleep'
+/** Food logged by any app, per day: kcal eaten, then grams of protein, carbohydrate and fat. Read only. */
+ | 'dietaryEnergy' | 'dietaryProtein' | 'dietaryCarbohydrates' | 'dietaryFat'
+/** Mindful minutes (meditation, breathing): read with getMindfulSessions, written with saveMindfulSession. */
+ | 'mindful';
 /** The types with one value per day. `sleep` is hours asleep, counted on the day you woke. */
-export type HealthDailyType = Exclude<HealthDataType, 'workouts'>;
+export type HealthDailyType = Exclude<HealthDataType, 'workouts' | 'mindful'>;
 export interface HealthAuthorizationOptions {
     /** `false` asks to read only. Default: also allowed to save workouts. */
     write?: boolean;
@@ -1348,8 +1352,49 @@ export interface HealthSleepInterval {
     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';
+/** A meditation or breathing session to record as mindful minutes. */
+export interface HealthMindfulSession {
+    /**
+     * The app's own id for the session (up to 128 characters), kept as the
+     * sample's external UUID. Saving the same id again keeps the first sample.
+     */
+    id: string;
+    /** Epoch milliseconds. */
+    startDate: number;
+    /** Epoch milliseconds, after `startDate` and at most a day later. */
+    endDate: number;
+}
+export interface HealthMindfulSessionResult {
+    /** HealthKit's UUID for the sample. */
+    id: string;
+    /** The id it was saved with. */
+    externalId: string;
+    /** True when this id was saved before and that sample was kept. */
+    existing: boolean;
+}
+export interface HealthMindfulSessionQuery extends HealthSampleQuery {
+    /** At most this many, oldest first. Defaults to 1000, capped at 5000. Start defaults to 30 days ago. */
+    limit?: number;
+}
+/** A mindful session in Apple Health, from any app that writes them. */
+export interface HealthMindfulSample {
+    /** HealthKit's UUID. */
+    id: string;
+    /** Epoch milliseconds. */
+    startDate: number;
+    /** Epoch milliseconds. */
+    endDate: number;
+    durationSeconds: number;
+    sourceName: string;
+    sourceBundleId: string;
+    /** True when this app wrote it. */
+    ownApp: boolean;
+    /** The id the writing app saved it with, when it gave one. */
+    externalId?: string;
+    deviceName?: 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' | 'saveMindfulSession' | 'getMindfulSessions';
 export declare const health: {
     /**
      * Whether this app build answers `method`. An app installed before a read
@@ -1372,6 +1417,14 @@ export declare const health: {
     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[]>;
+    /**
+     * Record a meditation or breathing session as mindful minutes. Needs the
+     * `mindful` grant with writing allowed. Saving the same `id` again keeps
+     * the first sample. iOS only for now.
+     */
+    saveMindfulSession(session: HealthMindfulSession): Promise<HealthMindfulSessionResult>;
+    /** Mindful sessions between two instants, oldest first, each marked `ownApp` when this app wrote it. iOS only for now. */
+    getMindfulSessions(options?: HealthMindfulSessionQuery): Promise<HealthMindfulSample[]>;
 };
 export interface LiveActivityState {
     status?: string;

package/dist/cli.js

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

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

@@ -3,6 +3,8 @@
  *
  * Generates native iOS apps from web content using WKWebView.
  */
+/** This package's version, which the app names in its user agent (`Craft/<version>`). */
+export declare function resolveCraftVersion(startDir?: string): string;
 export type CraftAppearance = 'light' | 'dark' | 'system';
 export interface CraftConfig {
     appName: string;

package/dist/ios/src/index.js

@@ -144,13 +144,22 @@ function createNativeMutationValidator() {
 
 // ../ios/src/index.ts
 var TEMPLATES_DIR = join2(dirname2(import.meta.dir), "templates");
-var CRAFT_VERSION = (() => {
-  try {
-    return JSON.parse(readFileSync2(join2(dirname2(import.meta.dir), "package.json"), "utf8")).version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
+function resolveCraftVersion(startDir = import.meta.dir) {
+  let directory = resolve(startDir);
+  while (true) {
+    try {
+      const packageJSON = JSON.parse(readFileSync2(join2(directory, "package.json"), "utf8"));
+      if (packageJSON.name === "@craft-native/ios" && typeof packageJSON.version === "string" && packageJSON.version.length > 0)
+        return packageJSON.version;
+    } catch {}
+    const parent = dirname2(directory);
+    if (parent === directory)
+      break;
+    directory = parent;
   }
-})();
+  return "0.0.0";
+}
+var CRAFT_VERSION = resolveCraftVersion();
 function normalizeNativePath(raw) {
   if (typeof raw !== "string")
     return null;
@@ -1277,6 +1286,7 @@ export {
   run,
   restoreShell,
   resolveRuntimeDir,
+  resolveCraftVersion,
   resolveAppearance,
   renderWatchEntitlements,
   renderUsageDescriptions,

package/dist/ios/templates/CraftApp.swift

@@ -2548,6 +2548,22 @@ struct CraftWebView: UIViewRepresentable {
                 } else {
                     rejectCallback(callbackId, error: "HealthKit is disabled", code: "CAPABILITY_DISABLED")
                 }
+            case "saveHealthMindfulSession":
+                if config.enableHealthKit {
+                    CraftHealth.shared.saveMindfulSession(body: body) { [weak self] in self?.answer(callbackId, $0) }
+                } else {
+                    rejectCallback(callbackId, error: "HealthKit is disabled", code: "CAPABILITY_DISABLED")
+                }
+            case "getHealthMindfulSessions":
+                if config.enableHealthKit {
+                    CraftHealth.shared.getMindfulSessions(
+                        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: "HealthKit is disabled", code: "CAPABILITY_DISABLED")
+                }
 
             // MARK: - Live Activities
             case "startLiveActivity":
@@ -5056,6 +5072,14 @@ struct CraftWebView: UIViewRepresentable {
                     getSleepIntervals: function(options) {
                         options = options || {};
                         return craft._invoke('getHealthSleepIntervals', {startDate: options.startDate, endDate: options.endDate});
+                    },
+                    saveMindfulSession: function(session) {
+                        session = session || {};
+                        return craft._invoke('saveHealthMindfulSession', {id: session.id, startDate: session.startDate, endDate: session.endDate});
+                    },
+                    getMindfulSessions: function(options) {
+                        options = options || {};
+                        return craft._invoke('getHealthMindfulSessions', {startDate: options.startDate, endDate: options.endDate, limit: options.limit});
                     }
                 };
                 // The Music app's song and transport. Nothing is read until

package/dist/ios/templates/CraftHealth.swift

@@ -43,6 +43,10 @@ final class CraftHealth {
             getHeartRateSamples(startDate: options(0)["startDate"] as? Double, endDate: options(0)["endDate"] as? Double, limit: options(0)["limit"] as? Int, completion: completion)
         case "getSleepIntervals":
             getSleepIntervals(startDate: options(0)["startDate"] as? Double, endDate: options(0)["endDate"] as? Double, completion: completion)
+        case "saveMindfulSession":
+            saveMindfulSession(body: options(0), completion: completion)
+        case "getMindfulSessions":
+            getMindfulSessions(startDate: options(0)["startDate"] as? Double, endDate: options(0)["endDate"] as? Double, limit: options(0)["limit"] as? Int, completion: completion)
         default:
             completion(.failure(CraftHealthError(message: "Unsupported Health method", code: "UNKNOWN_ACTION")))
         }
@@ -106,6 +110,20 @@ final class CraftHealth {
                 if let sleepType = HKObjectType.categoryType(forIdentifier: .sleepAnalysis) {
                     readTypes.insert(sleepType)
                 }
+            case "mindful":
+                // Mindful minutes: a meditation or breathing session. Read
+                // to show them, and (unless read only) written by an app
+                // that times them.
+                if let mindfulType = HKObjectType.categoryType(forIdentifier: .mindfulSession) {
+                    readTypes.insert(mindfulType)
+                    shareTypes.insert(mindfulType)
+                }
+            case "dietaryEnergy", "dietaryProtein", "dietaryCarbohydrates", "dietaryFat":
+                // What a food log (MyFitnessPal, Lose It!, Cronometer...)
+                // writes to Apple Health: read only, never written back.
+                if let dietaryType = Self.healthQuantity(type)?.type {
+                    readTypes.insert(dietaryType)
+                }
             default:
                 break
             }
@@ -261,6 +279,11 @@ final class CraftHealth {
         case "restingHeartRate": return (HKQuantityType.quantityType(forIdentifier: .restingHeartRate), bpm, .discreteAverage)
         case "heartRateVariability": return (HKQuantityType.quantityType(forIdentifier: .heartRateVariabilitySDNN), .secondUnit(with: .milli), .discreteAverage)
         case "bodyMass": return (HKQuantityType.quantityType(forIdentifier: .bodyMass), .gramUnit(with: .kilo), .mostRecent)
+        // A day's food, summed over every meal any app logged: kcal and grams.
+        case "dietaryEnergy": return (HKQuantityType.quantityType(forIdentifier: .dietaryEnergyConsumed), .kilocalorie(), .cumulativeSum)
+        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)
         default: return nil
         }
     }
@@ -548,4 +571,104 @@ final class CraftHealth {
         healthStore.execute(query)
     }
 
+    /// Saves a mindful session (Mindful Minutes in the Health app): a
+    /// meditation or breathing session that ran from `startDate` to
+    /// `endDate`, epoch milliseconds. `id` is the app's own id for it, kept
+    /// as the sample's external UUID, so saving the same session twice (a
+    /// retry, a second device) keeps the first sample instead of adding
+    /// another: the answer then says `existing: true`.
+    func saveMindfulSession(body: [String: Any], completion: @escaping Completion) {
+        guard let healthStore = healthStore else {
+            completion(.failure(CraftHealthError(message: "HealthKit not available")))
+            return
+        }
+        guard let mindfulType = HKObjectType.categoryType(forIdentifier: .mindfulSession) else {
+            completion(.failure(CraftHealthError(message: "Mindful sessions are unavailable")))
+            return
+        }
+        guard let id = body["id"] as? String, !id.isEmpty, id.count <= 128,
+              let startValue = body["startDate"] as? Double,
+              let endValue = body["endDate"] as? Double,
+              endValue > startValue,
+              endValue - startValue <= 24 * 3600 * 1000 else {
+            completion(.failure(CraftHealthError(message: "A valid id, startDate and endDate (at most a day apart) are required", code: "INVALID_ARGUMENT")))
+            return
+        }
+
+        let start = Date(timeIntervalSince1970: startValue / 1000)
+        let end = Date(timeIntervalSince1970: endValue / 1000)
+        // Only this app's own samples can be the same session.
+        let predicate = NSCompoundPredicate(andPredicateWithSubpredicates: [
+            HKQuery.predicateForObjects(withMetadataKey: HKMetadataKeyExternalUUID, allowedValues: [id]),
+            HKQuery.predicateForObjects(from: HKSource.default()),
+        ])
+        let lookup = HKSampleQuery(sampleType: mindfulType, predicate: predicate, limit: 1, sortDescriptors: nil) { _, samples, _ in
+            if let kept = samples?.first {
+                completion(.success(["id": kept.uuid.uuidString, "externalId": id, "existing": true]))
+                return
+            }
+            let sample = HKCategorySample(
+                type: mindfulType,
+                value: HKCategoryValue.notApplicable.rawValue,
+                start: start,
+                end: end,
+                metadata: [HKMetadataKeyExternalUUID: id]
+            )
+            healthStore.save(sample) { success, error in
+                if success {
+                    completion(.success(["id": sample.uuid.uuidString, "externalId": id, "existing": false]))
+                } else {
+                    completion(.failure(CraftHealthError(message: error?.localizedDescription ?? "Mindful session could not be saved")))
+                }
+            }
+        }
+        healthStore.execute(lookup)
+    }
+
+    /// Mindful sessions between two instants, oldest first, from every app
+    /// that writes them (the Mindfulness app, Calm, this one). Each says
+    /// whether this app wrote it (`ownApp`) and carries the external id it
+    /// was saved with, so a page can tell its own sessions from the rest.
+    func getMindfulSessions(startDate: Double?, endDate: Double?, limit: Int?, completion: @escaping Completion) {
+        guard let healthStore = healthStore else {
+            completion(.failure(CraftHealthError(message: "HealthKit not available")))
+            return
+        }
+        guard let mindfulType = HKObjectType.categoryType(forIdentifier: .mindfulSession) else {
+            completion(.failure(CraftHealthError(message: "Mindful sessions are 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: -30, to: end)!
+        let predicate = HKQuery.predicateForSamples(withStart: start, end: end, options: [])
+        let oldestFirst = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: true)
+        let cap = max(1, min(limit ?? 1000, 5000))
+        let ownBundle = Bundle.main.bundleIdentifier
+
+        let query = HKSampleQuery(sampleType: mindfulType, 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 ?? []).map { sample in
+                let source = sample.sourceRevision.source
+                var item: [String: Any] = [
+                    "id": sample.uuid.uuidString,
+                    "startDate": sample.startDate.timeIntervalSince1970 * 1000,
+                    "endDate": sample.endDate.timeIntervalSince1970 * 1000,
+                    "durationSeconds": sample.endDate.timeIntervalSince(sample.startDate),
+                    "sourceName": source.name,
+                    "sourceBundleId": source.bundleIdentifier,
+                    "ownApp": ownBundle != nil && source.bundleIdentifier == ownBundle,
+                ]
+                if let external = sample.metadata?[HKMetadataKeyExternalUUID] as? String { item["externalId"] = external }
+                if let device = sample.device?.name { item["deviceName"] = device }
+                return item
+            }
+            completion(.success(rows))
+        }
+        healthStore.execute(query)
+    }
+
 }

package/dist/ios/templates/CraftHybrid.swift

@@ -1457,6 +1457,19 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
         return popRecognizers(of: nav).contains { $0 === recognizer }
     }
 
+    private func nativeScreenContainsHorizontalScroll(_ screen: CraftNativeScreenController) -> Bool {
+        guard let root = screen.viewIfLoaded else { return false }
+        func visit(_ view: UIView) -> Bool {
+            if let scroll = view as? UIScrollView,
+               scroll.isScrollEnabled,
+               scroll.alwaysBounceHorizontal || scroll.contentSize.width > scroll.bounds.width + 1 {
+                return true
+            }
+            return view.subviews.contains(where: visit)
+        }
+        return visit(root)
+    }
+
     /// The edge swipe goes ahead of the web view's own gestures, which
     /// otherwise hold every touch over the page until the page has answered it.
     func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool {
@@ -1470,6 +1483,12 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
     func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool {
         guard let nav = visibleStack, isPopRecognizer(gestureRecognizer),
               nav.viewControllers.count > 1, nav.transitionCoordinator == nil else { return false }
+        if let native = nav.topViewController as? CraftNativeScreenController,
+           gestureRecognizer !== nav.interactivePopGestureRecognizer,
+           nativeScreenContainsHorizontalScroll(native) {
+            let moved = (gestureRecognizer as? UIPanGestureRecognizer)?.translation(in: nav.view).x ?? 0
+            if gestureRecognizer.location(in: nav.view).x - moved > 32 { return false }
+        }
         guard let slot = nav.topViewController as? CraftHybridWebSlot else { return true }
         // Over the page, only from its left edge: a swipe across the page is
         // the page's (a carousel, a slider).