craft-native 0.0.236 → 0.0.238

package/dist/mobile.js

@@ -355,6 +355,107 @@ var secureStorage = {
     Object.keys(localStorage).filter((k) => k.startsWith("secure_")).forEach((k) => localStorage.removeItem(k));
   }
 };
+function storageHost(method) {
+  const host = getCraftRoot()?.storage;
+  if (typeof host?.[method] !== "function")
+    throw Object.assign(new Error("This host does not provide native storage"), { code: "STORAGE_UNSUPPORTED" });
+  return host;
+}
+var crypto = {
+  async randomUUID() {
+    const root = getCraftRoot();
+    if (!root)
+      return secureUUID();
+    const caps = root.capabilities;
+    const advertised = Array.isArray(caps) ? caps.includes("crypto") : caps?.crypto === true;
+    if (!advertised || typeof root.crypto?.randomUUID !== "function")
+      throw Object.assign(new Error("This host does not provide secure UUIDs"), { code: "CRYPTO_UNSUPPORTED" });
+    const id = await root.crypto.randomUUID();
+    if (typeof id !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(id))
+      throw Object.assign(new Error("The host returned an invalid secure UUID"), { code: "CRYPTO_INVALID_RESPONSE" });
+    return id;
+  }
+};
+var storage = {
+  supportsSetIfAbsent() {
+    const root = getCraftRoot();
+    const caps = root?.capabilities;
+    const supported = Array.isArray(caps) ? caps.includes("storageSetIfAbsent") : caps?.storageSetIfAbsent === true;
+    return supported && typeof root?.storage?.setIfAbsent === "function";
+  },
+  supportsCompareAndSet() {
+    const root = getCraftRoot();
+    const caps = root?.capabilities;
+    const supported = Array.isArray(caps) ? caps.includes("storageCompareAndSet") : caps?.storageCompareAndSet === true;
+    return supported && typeof root?.storage?.compareAndSet === "function";
+  },
+  async get(key) {
+    return storageHost("get").get(key);
+  },
+  async set(key, value) {
+    return storageHost("set").set(key, value);
+  },
+  async remove(key) {
+    return storageHost("remove").remove(key);
+  },
+  async clear() {
+    return storageHost("clear").clear();
+  },
+  async keys() {
+    return storageHost("keys").keys();
+  },
+  async setIfAbsent(key, value) {
+    if (!storage.supportsSetIfAbsent())
+      throw Object.assign(new Error("This app build cannot atomically register an intent"), { code: "STORAGE_SET_IF_ABSENT_UNSUPPORTED" });
+    if (typeof key !== "string" || !key.trim() || JSON.stringify(value) === undefined)
+      throw Object.assign(new Error("setIfAbsent needs a key and JSON value"), { code: "INVALID_ARGUMENT" });
+    return storageHost("setIfAbsent").setIfAbsent(key, value);
+  },
+  async compareAndSet(key, expectedValue, nextValue) {
+    if (!storage.supportsCompareAndSet())
+      throw Object.assign(new Error("This app build cannot atomically checkpoint existing storage"), { code: "STORAGE_COMPARE_AND_SET_UNSUPPORTED" });
+    if (typeof key !== "string" || !key.trim() || JSON.stringify(expectedValue) === undefined || JSON.stringify(nextValue) === undefined)
+      throw Object.assign(new Error("compareAndSet needs a key and JSON values"), { code: "INVALID_ARGUMENT" });
+    return storageHost("compareAndSet").compareAndSet(key, expectedValue, nextValue);
+  }
+};
+function recordingOwnershipSupported(namespace) {
+  const root = getCraftRoot();
+  const flag = namespace === "location" ? "locationRecordingOwnership" : "heartRateRecordingOwnership";
+  const caps = root?.capabilities;
+  const advertised = Array.isArray(caps) ? caps.includes(flag) : caps?.[flag] === true;
+  return advertised && ["pauseRecording", "resumeRecording", "stopRecording", "readRecording", "getRecordingState", "acknowledgeRecording"].every((method) => typeof root?.[namespace]?.[method] === "function");
+}
+function recordingIntentSupported(namespace) {
+  const root = getCraftRoot();
+  const flag = namespace === "location" ? "locationRecordingIntentIdentity" : "heartRateRecordingIntentIdentity";
+  const caps = root?.capabilities;
+  const advertised = Array.isArray(caps) ? caps.includes(flag) : caps?.[flag] === true;
+  return advertised && recordingOwnershipSupported(namespace) && typeof root?.[namespace]?.startRecording === "function";
+}
+function validateRecordingStart(namespace, options) {
+  if (!Object.prototype.hasOwnProperty.call(options, "recordingId"))
+    return;
+  if (typeof options.recordingId !== "string" || !options.recordingId.trim())
+    throw Object.assign(new Error("recordingId must be a nonempty recording ID"), { code: "INVALID_ARGUMENT" });
+  if (!recordingIntentSupported(namespace))
+    throw Object.assign(new Error("This app build cannot start the persisted recording intent"), { code: "RECORDING_INTENT_IDENTITY_UNSUPPORTED" });
+}
+function verifyRecordingStart(options, result) {
+  if (options.recordingId !== undefined && result.id !== options.recordingId)
+    throw Object.assign(new Error("The native recording does not match the persisted intent"), { code: "RECORDING_CONFLICT" });
+  return result;
+}
+function validateRecordingOwnership(namespace, options) {
+  if (!options || !Object.prototype.hasOwnProperty.call(options, "expectedId"))
+    return;
+  if (typeof options.expectedId !== "string" || !options.expectedId.trim())
+    throw Object.assign(new Error("expectedId must be a nonempty recording ID"), { code: "INVALID_ARGUMENT" });
+  if ((getCraftRoot() || namespace === "heartRate") && !recordingOwnershipSupported(namespace))
+    throw Object.assign(new Error("This app build cannot enforce recording ownership"), { code: "RECORDING_OWNERSHIP_UNSUPPORTED" });
+  if (namespace === "location" && !getCraftRoot() && options.expectedId !== webLocationRecording.id)
+    throw Object.assign(new Error("The active location recording has changed"), { code: "RECORDING_CONFLICT" });
+}
 var webLocationRecording = {
   id: null,
   active: false,
@@ -364,6 +465,8 @@ var webLocationRecording = {
 };
 var webLocationRecordingWatchId = null;
 var location = {
+  supportsRecordingOwnership: () => recordingOwnershipSupported("location"),
+  supportsRecordingIntentIdentity: () => recordingIntentSupported("location"),
   async getCurrentPosition(options = {}) {
     const craft = getCraftMobile();
     if (typeof window !== "undefined" && craft?.location) {
@@ -412,9 +515,12 @@ var location = {
     navigator.geolocation.clearWatch(watchId);
   },
   async startRecording(options = {}) {
+    validateRecordingStart("location", options);
     const craft = getCraftMobile();
     if (typeof window !== "undefined" && craft?.location?.startRecording)
-      return craft.location.startRecording(options);
+      return verifyRecordingStart(options, await craft.location.startRecording(options));
+    if (webLocationRecording.active)
+      throw Object.assign(new Error("A location recording is already active"), { code: "RECORDING_ALREADY_ACTIVE" });
     if (webLocationRecordingWatchId !== null)
       navigator.geolocation.clearWatch(webLocationRecordingWatchId);
     webLocationRecording = {
@@ -430,24 +536,27 @@ var location = {
     }, options);
     return { ...webLocationRecording, sampleCount: 0 };
   },
-  async pauseRecording() {
+  async pauseRecording(options) {
+    validateRecordingOwnership("location", options);
     const craft = getCraftMobile();
     if (typeof window !== "undefined" && craft?.location?.pauseRecording)
-      return craft.location.pauseRecording();
+      return craft.location.pauseRecording(options);
     webLocationRecording.paused = true;
     return { ...webLocationRecording, sampleCount: webLocationRecording.locations.length };
   },
-  async resumeRecording() {
+  async resumeRecording(options) {
+    validateRecordingOwnership("location", options);
     const craft = getCraftMobile();
     if (typeof window !== "undefined" && craft?.location?.resumeRecording)
-      return craft.location.resumeRecording();
+      return craft.location.resumeRecording(options);
     webLocationRecording.paused = false;
     return { ...webLocationRecording, sampleCount: webLocationRecording.locations.length };
   },
-  async stopRecording() {
+  async stopRecording(options) {
+    validateRecordingOwnership("location", options);
     const craft = getCraftMobile();
     if (typeof window !== "undefined" && craft?.location?.stopRecording)
-      return craft.location.stopRecording();
+      return craft.location.stopRecording(options);
     if (webLocationRecordingWatchId !== null) {
       location.clearWatch(webLocationRecordingWatchId);
       webLocationRecordingWatchId = null;
@@ -456,16 +565,30 @@ var location = {
     webLocationRecording.paused = false;
     return { ...webLocationRecording, locations: [...webLocationRecording.locations] };
   },
-  async getRecordingState() {
+  async getRecordingState(options) {
+    validateRecordingOwnership("location", options);
     const craft = getCraftMobile();
     if (typeof window !== "undefined" && craft?.location?.getRecordingState)
-      return craft.location.getRecordingState();
+      return craft.location.getRecordingState(options);
     return { ...webLocationRecording, sampleCount: webLocationRecording.locations.length };
   },
-  async readRecording() {
+  async acknowledgeRecording(options) {
+    if (!options || !Object.prototype.hasOwnProperty.call(options, "expectedId"))
+      throw Object.assign(new Error("Acknowledgement needs expectedId"), { code: "INVALID_ARGUMENT" });
+    validateRecordingOwnership("location", options);
+    const craft = getCraftMobile();
+    if (craft?.location?.acknowledgeRecording)
+      return craft.location.acknowledgeRecording(options);
+    if (webLocationRecording.active)
+      throw Object.assign(new Error("The recording is still active"), { code: "RECORDING_ALREADY_ACTIVE" });
+    webLocationRecording = { id: null, active: false, paused: false, startedAt: null, locations: [] };
+    return true;
+  },
+  async readRecording(options) {
+    validateRecordingOwnership("location", options);
     const craft = getCraftMobile();
     if (typeof window !== "undefined" && craft?.location?.readRecording)
-      return craft.location.readRecording();
+      return craft.location.readRecording(options);
     return [...webLocationRecording.locations];
   }
 };
@@ -1023,6 +1146,8 @@ async function heartRateCall(method, fallback, normalize, ...args) {
 }
 var noRecording = () => normalizeHeartRateRecording({});
 var heartRate = {
+  supportsRecordingOwnership: () => recordingOwnershipSupported("heartRate"),
+  supportsRecordingIntentIdentity: () => recordingIntentSupported("heartRate"),
   isAvailable() {
     return typeof nativeHeartRate()?.getState === "function";
   },
@@ -1037,12 +1162,37 @@ var heartRate = {
   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),
+  async startRecording(options) {
+    const supplied = options ?? {};
+    validateRecordingStart("heartRate", supplied);
+    return verifyRecordingStart(supplied, await heartRateCall("startRecording", noRecording, normalizeHeartRateRecording, ...options === undefined ? [] : [options]));
+  },
+  async pauseRecording(options) {
+    validateRecordingOwnership("heartRate", options);
+    return heartRateCall("pauseRecording", noRecording, normalizeHeartRateRecording, ...options === undefined ? [] : [options]);
+  },
+  async resumeRecording(options) {
+    validateRecordingOwnership("heartRate", options);
+    return heartRateCall("resumeRecording", noRecording, normalizeHeartRateRecording, ...options === undefined ? [] : [options]);
+  },
+  async stopRecording(options) {
+    validateRecordingOwnership("heartRate", options);
+    return heartRateCall("stopRecording", () => ({ ...noRecording(), samples: [] }), (value) => ({ ...normalizeHeartRateRecording(value), samples: normalizeHeartRateSamples(hrRecord(value).samples) }), ...options === undefined ? [] : [options]);
+  },
+  async getRecordingState(options) {
+    validateRecordingOwnership("heartRate", options);
+    return heartRateCall("getRecordingState", noRecording, normalizeHeartRateRecording, ...options === undefined ? [] : [options]);
+  },
+  async acknowledgeRecording(options) {
+    if (!options || !Object.prototype.hasOwnProperty.call(options, "expectedId"))
+      throw Object.assign(new Error("Acknowledgement needs expectedId"), { code: "INVALID_ARGUMENT" });
+    validateRecordingOwnership("heartRate", options);
+    return heartRateCall("acknowledgeRecording", () => false, (value) => value === true, options);
+  },
+  async readRecording(options = {}) {
+    validateRecordingOwnership("heartRate", options);
+    return heartRateCall("readRecording", () => [], normalizeHeartRateSamples, options);
+  },
   onReading: (callback) => hrSubscribe(heartRateWatch.readings, callback),
   onDevice: (callback) => hrSubscribe(heartRateWatch.devices, callback),
   onState: (callback) => hrSubscribe(heartRateWatch.states, callback)
@@ -1646,6 +1796,7 @@ export {
   watchConnectivity,
   tabBar,
   symbols,
+  storage,
   statusBar,
   splash,
   speech,
@@ -1679,6 +1830,7 @@ export {
   dialog,
   device,
   deepLinks,
+  crypto,
   crashReporter,
   contextMenu,
   chrome,

package/package.json

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