craft-native 0.0.150 → 0.0.152

package/dist/mobile.js

@@ -823,6 +823,164 @@ var music = {
     };
   }
 };
+var HR_AUTHORIZATIONS = ["authorized", "denied", "restricted", "notDetermined", "unavailable"];
+var HR_BLUETOOTH = ["poweredOn", "poweredOff", "unauthorized", "unsupported", "resetting", "unknown"];
+var HR_CONNECTIONS = ["disconnected", "connecting", "connected", "reconnecting"];
+function hrRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function hrNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function hrBpm(value) {
+  const bpm = hrNumber(value);
+  return bpm !== null && bpm >= 20 && bpm <= 250 ? Math.round(bpm) : null;
+}
+function hrIntervals(value) {
+  return Array.isArray(value) ? value.filter((ms) => typeof ms === "number" && Number.isFinite(ms) && ms > 0 && ms < 5000) : [];
+}
+function normalizeHeartRateDevice(value) {
+  const raw = hrRecord(value);
+  if (typeof raw.id !== "string" || !raw.id)
+    return null;
+  return { id: raw.id, name: typeof raw.name === "string" && raw.name.trim() ? raw.name : "Heart rate monitor", rssi: hrNumber(raw.rssi) };
+}
+function normalizeHeartRateRecording(value) {
+  const raw = hrRecord(value);
+  return {
+    id: typeof raw.id === "string" ? raw.id : null,
+    active: raw.active === true,
+    paused: raw.paused === true,
+    startedAt: hrNumber(raw.startedAt),
+    sampleCount: hrNumber(raw.sampleCount)
+  };
+}
+function normalizeHeartRateState(value) {
+  const raw = hrRecord(value);
+  return {
+    available: raw.available !== false && Object.keys(raw).length > 0,
+    bluetooth: HR_BLUETOOTH.includes(raw.bluetooth) ? raw.bluetooth : "unknown",
+    authorization: HR_AUTHORIZATIONS.includes(raw.authorization) ? raw.authorization : "unavailable",
+    scanning: raw.scanning === true,
+    connection: HR_CONNECTIONS.includes(raw.connection) ? raw.connection : "disconnected",
+    device: normalizeHeartRateDevice(raw.device),
+    lastDevice: normalizeHeartRateDevice(raw.lastDevice),
+    bpm: hrBpm(raw.bpm),
+    lastReadingAt: hrNumber(raw.lastReadingAt),
+    recording: normalizeHeartRateRecording(raw.recording)
+  };
+}
+function normalizeHeartRateReading(value) {
+  const raw = hrRecord(value);
+  const bpm = hrBpm(raw.bpm);
+  if (bpm === null)
+    return null;
+  return {
+    bpm,
+    rrIntervals: hrIntervals(raw.rrIntervals),
+    contact: typeof raw.contact === "boolean" ? raw.contact : null,
+    energyExpended: hrNumber(raw.energyExpended),
+    timestamp: hrNumber(raw.timestamp) ?? Date.now(),
+    deviceId: typeof raw.deviceId === "string" ? raw.deviceId : null
+  };
+}
+function normalizeHeartRateSamples(value) {
+  if (!Array.isArray(value))
+    return [];
+  const seen = new Set;
+  const samples = [];
+  for (const item of value) {
+    const raw = hrRecord(item);
+    const timestamp = hrNumber(raw.timestamp);
+    const bpm = hrBpm(raw.bpm);
+    if (timestamp === null || bpm === null || seen.has(timestamp))
+      continue;
+    seen.add(timestamp);
+    const rr = hrIntervals(raw.rr);
+    samples.push(rr.length ? { timestamp, bpm, rr } : { timestamp, bpm });
+  }
+  return samples.sort((a, b) => a.timestamp - b.timestamp);
+}
+function noHeartRate() {
+  return normalizeHeartRateState({ available: false });
+}
+function nativeHeartRate() {
+  const craft = getCraftRoot();
+  if (!craft?.heartRate || craft.capabilities?.heartRate === false)
+    return;
+  return craft.heartRate;
+}
+var heartRateWatch = { readings: new Set, devices: new Set, states: new Set, stop: null };
+function hrNotify(listeners, value) {
+  for (const listener of [...listeners]) {
+    try {
+      listener(value);
+    } catch {}
+  }
+}
+function hrSubscribe(set, callback) {
+  if (!nativeHeartRate() || typeof window === "undefined")
+    return () => {};
+  set.add(callback);
+  if (!heartRateWatch.stop) {
+    const onEvent = (event) => {
+      const detail = hrRecord(event.detail);
+      if (detail.type === "reading") {
+        const reading = normalizeHeartRateReading(detail);
+        if (reading)
+          hrNotify(heartRateWatch.readings, reading);
+      } else if (detail.type === "device") {
+        const device2 = normalizeHeartRateDevice(detail.device);
+        if (device2)
+          hrNotify(heartRateWatch.devices, device2);
+      } else if (detail.type === "state") {
+        hrNotify(heartRateWatch.states, normalizeHeartRateState(detail));
+      }
+    };
+    window.addEventListener("craftHeartRate", onEvent);
+    heartRateWatch.stop = () => window.removeEventListener("craftHeartRate", onEvent);
+  }
+  return () => {
+    if (!set.delete(callback))
+      return;
+    if (heartRateWatch.readings.size + heartRateWatch.devices.size + heartRateWatch.states.size > 0)
+      return;
+    heartRateWatch.stop?.();
+    heartRateWatch.stop = null;
+  };
+}
+async function heartRateCall(method, fallback, normalize, ...args) {
+  const native = nativeHeartRate();
+  if (typeof native?.[method] !== "function")
+    return fallback();
+  return normalize(await native[method](...args));
+}
+var noRecording = () => normalizeHeartRateRecording({});
+var heartRate = {
+  isAvailable() {
+    return typeof nativeHeartRate()?.getState === "function";
+  },
+  supports(method) {
+    return typeof nativeHeartRate()?.[method] === "function";
+  },
+  getState: () => heartRateCall("getState", noHeartRate, normalizeHeartRateState),
+  requestAuthorization: () => heartRateCall("requestAuthorization", () => "unavailable", (value) => HR_AUTHORIZATIONS.includes(value) ? value : "unavailable"),
+  scan: (options = {}) => heartRateCall("scan", noHeartRate, normalizeHeartRateState, options),
+  stopScan: () => heartRateCall("stopScan", noHeartRate, normalizeHeartRateState),
+  getDevices: () => heartRateCall("getDevices", () => [], (value) => Array.isArray(value) ? value.map(normalizeHeartRateDevice).filter((device2) => device2 !== null) : []),
+  connect: (id) => heartRateCall("connect", noHeartRate, normalizeHeartRateState, id),
+  reconnect: () => heartRateCall("reconnect", noHeartRate, normalizeHeartRateState),
+  disconnect: (options = {}) => heartRateCall("disconnect", noHeartRate, normalizeHeartRateState, options),
+  startRecording: () => heartRateCall("startRecording", noRecording, normalizeHeartRateRecording),
+  pauseRecording: () => heartRateCall("pauseRecording", noRecording, normalizeHeartRateRecording),
+  resumeRecording: () => heartRateCall("resumeRecording", noRecording, normalizeHeartRateRecording),
+  stopRecording: () => heartRateCall("stopRecording", () => ({ ...noRecording(), samples: [] }), (value) => ({ ...normalizeHeartRateRecording(value), samples: normalizeHeartRateSamples(hrRecord(value).samples) })),
+  getRecordingState: () => heartRateCall("getRecordingState", noRecording, normalizeHeartRateRecording),
+  readRecording: (options = {}) => heartRateCall("readRecording", () => [], normalizeHeartRateSamples, options),
+  onReading: (callback) => hrSubscribe(heartRateWatch.readings, callback),
+  onDevice: (callback) => hrSubscribe(heartRateWatch.devices, callback),
+  onState: (callback) => hrSubscribe(heartRateWatch.states, callback)
+};
 var deepLinks = {
   async getInitialURL() {
     return normalizeDeepLinkURL(await getCraftRoot()?.deepLinks?.getInitialURL?.());
@@ -1314,6 +1472,10 @@ export {
   permissions,
   notifications,
   normalizeNowPlaying,
+  normalizeHeartRateState,
+  normalizeHeartRateSamples,
+  normalizeHeartRateReading,
+  normalizeHeartRateDevice,
   normalizeDeepLinkURL,
   network,
   music,
@@ -1323,6 +1485,7 @@ export {
   keepAwake,
   isSnapshotName,
   hybrid,
+  heartRate,
   health,
   haptics,
   dialog,

package/package.json

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