@spencerls/react-native-nfc 1.0.4 → 1.0.6

package/dist/index.mjs

@@ -4,18 +4,34 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/services/nfc/service.ts
+// src/nfc/a/index.ts
+var a_exports = {};
+__export(a_exports, {
+  operations: () => operations,
+  utils: () => utils
+});
+
+// src/nfc/a/operations.ts
+import NfcManager2, { NfcTech } from "react-native-nfc-manager";
+
+// src/nfc/service.ts
 import { Platform } from "react-native";
 import NfcManager, {
   NfcEvents
 } from "react-native-nfc-manager";
 var NfcService = class {
+  // needed for iOS restart
   constructor() {
     this.state = { mode: "idle", tag: null };
     this.listeners = /* @__PURE__ */ new Set();
+    this.isProcessingTag = false;
+    this.currentCooldownMs = 1500;
+    this.lastUsedReaderFlags = null;
     NfcManager.start();
   }
-  // --- internal state mgmt ---
+  // -----------------------------
+  // Internal state management
+  // -----------------------------
   setState(partial) {
     this.state = { ...this.state, ...partial };
     for (const listener of this.listeners) listener(this.state);
@@ -30,17 +46,45 @@ var NfcService = class {
       this.listeners.delete(fn);
     };
   }
-  // --- Reader lifecycle ---
-  async startReader(readerModeFlags, onTag) {
+  // -----------------------------
+  // START READER
+  // -----------------------------
+  async startReader(readerModeFlags, onTag, options) {
+    var _a;
     if (this.state.mode !== "idle") {
       console.warn(`[NFC] Cannot start reader while ${this.state.mode}`);
       return;
     }
-    this.setState({ mode: "starting" });
-    NfcManager.setEventListener(NfcEvents.DiscoverTag, (tag) => {
-      this.setState({ tag });
-      onTag == null ? void 0 : onTag(tag);
-    });
+    this.currentOnTag = onTag;
+    this.currentCooldownMs = (_a = options == null ? void 0 : options.cooldownMs) != null ? _a : 1500;
+    this.lastUsedReaderFlags = readerModeFlags;
+    this.isProcessingTag = false;
+    this.setState({ mode: "starting", tag: null });
+    NfcManager.setEventListener(
+      NfcEvents.DiscoverTag,
+      async (tag) => {
+        if (!tag) return;
+        if (this.isProcessingTag) return;
+        this.isProcessingTag = true;
+        this.setState({ tag, mode: "active" });
+        try {
+          if (this.currentOnTag) {
+            await this.currentOnTag(tag);
+          }
+        } catch (err) {
+          console.warn("[NFC] onTag handler error:", err);
+        } finally {
+          const cooldown = this.currentCooldownMs;
+          setTimeout(async () => {
+            this.isProcessingTag = false;
+            this.setState({ tag: null, mode: "active" });
+            if (Platform.OS === "ios") {
+              await this._restartIosReader();
+            }
+          }, cooldown);
+        }
+      }
+    );
     try {
       await NfcManager.registerTagEvent({
         isReaderModeEnabled: true,
@@ -51,23 +95,53 @@ var NfcService = class {
       }
     } catch (err) {
       console.warn("[NFC] startReader error:", err);
-      this.setState({ mode: "idle" });
+      this._resetReaderState();
     }
   }
+  // -----------------------------
+  // STOP READER
+  // -----------------------------
   async stopReader() {
     if (["idle", "stopping"].includes(this.state.mode)) return;
     this.setState({ mode: "stopping" });
     try {
       await NfcManager.unregisterTagEvent();
-    } catch {
+    } catch (err) {
+      console.warn("[NFC] unregisterTagEvent error:", err);
+    }
+    this._resetReaderState();
+  }
+  _resetReaderState() {
+    this.setState({ mode: "idle", tag: null });
+    this.currentOnTag = void 0;
+    this.isProcessingTag = false;
+  }
+  // -----------------------------
+  // iOS RESTART
+  // -----------------------------
+  async _restartIosReader() {
+    if (Platform.OS !== "ios") return;
+    if (this.lastUsedReaderFlags == null) return;
+    try {
+      await NfcManager.unregisterTagEvent();
+      await NfcManager.registerTagEvent({
+        isReaderModeEnabled: true,
+        readerModeFlags: this.lastUsedReaderFlags
+      });
+      this.setState({ mode: "active" });
+    } catch (err) {
+      console.warn("[NFC] iOS restart error:", err);
+      this._resetReaderState();
     }
-    this.setState({ mode: "idle" });
   }
+  // -----------------------------
+  // Technology sessions (NDEF, NfcV, etc.)
+  // -----------------------------
   async withTechnology(tech, handler) {
     if (this.state.mode === "technology") {
-      throw new Error(`[NFC] Technology is already in use!`);
+      throw new Error("[NFC] Technology is already in use!");
     }
-    if (this.state.mode === "starting" || this.state.mode === "active" || this.state.mode === "stopping") {
+    if (["starting", "active", "stopping"].includes(this.state.mode)) {
       await this.stopReader();
     }
     if (this.state.mode !== "idle") {
@@ -75,15 +149,15 @@ var NfcService = class {
         `[NFC] Cannot start technology session in mode ${this.state.mode}`
       );
     }
-    this.setState({ mode: "technology" });
+    this.setState({ mode: "technology", tag: null });
     try {
       await NfcManager.requestTechnology(tech, {
         alertMessage: "Hold near NFC tag"
-        // iOS
       });
       const result = await handler();
-      if (Platform.OS === "ios")
+      if (Platform.OS === "ios") {
         await NfcManager.setAlertMessageIOS("Success!");
+      }
       return result;
     } catch (err) {
       const message = typeof err === "string" ? err : (err == null ? void 0 : err.message) || "Unknown NFC error";
@@ -91,85 +165,44 @@ var NfcService = class {
     } finally {
       try {
         await NfcManager.cancelTechnologyRequest();
-      } catch (cancelErr) {
-        console.warn("[NFC] cancelTechnologyRequest failed:", cancelErr);
+      } catch {
       }
-      this.setState({ mode: "idle" });
+      this.setState({ mode: "idle", tag: null });
     }
   }
 };
 var nfcService = new NfcService();
 
-// src/services/nfc/a/index.ts
-var a_exports = {};
-__export(a_exports, {
-  operations: () => operations,
-  utils: () => utils
-});
-
-// src/services/nfc/a/operations.ts
-import NfcManager2, { NfcTech as NfcTech2 } from "react-native-nfc-manager";
+// src/nfc/a/operations.ts
 var operations = {
   async transceive(data) {
-    return nfcService.withTechnology(NfcTech2.NfcA, async () => {
+    return nfcService.withTechnology(NfcTech.NfcA, async () => {
       return await NfcManager2.transceive(data);
     });
   }
 };
 
-// src/services/nfc/a/utils.ts
+// src/nfc/a/utils.ts
 var utils = {};
 
-// src/services/nfc/ndef/index.ts
-var ndef_exports = {};
-__export(ndef_exports, {
-  operations: () => operations2,
-  utils: () => utils2
-});
-
-// src/services/nfc/ndef/operations.ts
-import NfcManager3, {
-  Ndef,
-  NfcTech as NfcTech3
-} from "react-native-nfc-manager";
-var operations2 = {
-  async writeNdef(records) {
-    await nfcService.withTechnology([NfcTech3.Ndef, NfcTech3.NfcA], async () => {
-      const bytes = Ndef.encodeMessage(records);
-      await NfcManager3.ndefHandler.writeNdefMessage(bytes);
-    });
-  },
-  writeTextNdef(text) {
-    const record = Ndef.textRecord(text);
-    return this.writeNdef([record]);
-  },
-  writeUriNdef(uri) {
-    const record = Ndef.uriRecord(uri);
-    return this.writeNdef([record]);
-  }
-};
-
-// src/services/nfc/ndef/utils.ts
-var utils2 = {};
-
-// src/services/nfc/v/index.ts
+// src/nfc/v/index.ts
 var v_exports = {};
 __export(v_exports, {
-  operations: () => operations3,
-  utils: () => utils3
+  operations: () => operations2,
+  utils: () => utils2
 });
 
-// src/services/nfc/v/operations.ts
-import NfcManager5 from "react-native-nfc-manager";
-
-// src/services/nfc/v/internal.ts
+// src/nfc/v/operations.ts
 import NfcManager4 from "react-native-nfc-manager";
 
-// src/services/nfc/v/utils.ts
+// src/nfc/v/internal.ts
+import NfcManager3 from "react-native-nfc-manager";
+
+// src/nfc/v/utils.ts
 import { Platform as Platform2 } from "react-native";
-import { NfcTech as NfcTech4 } from "react-native-nfc-manager";
-var utils3 = {
-  tech: Platform2.OS === "ios" ? [NfcTech4.Iso15693IOS] : NfcTech4.NfcV,
+import { NfcTech as NfcTech2 } from "react-native-nfc-manager";
+var utils2 = {
+  tech: Platform2.OS === "ios" ? [NfcTech2.Iso15693IOS] : NfcTech2.NfcV,
   Flags: {
     HIGH_DATA_RATE: 2,
     ADDRESSED: 32
@@ -194,7 +227,7 @@ var utils3 = {
   reverseUid(tagIdHex) {
     const bytes = [];
     for (let i = 0; i < tagIdHex.length; i += 2) {
-      bytes.unshift(parseInt(tagIdHex.substring(i, i + 2), 16));
+      bytes.unshift(Number.parseInt(tagIdHex.substring(i, i + 2), 16));
     }
     return bytes;
   },
@@ -241,8 +274,12 @@ var utils3 = {
     if (!resp || resp.length === 0) {
       throw new Error("Empty NFC-V response");
     }
-    if (resp[0] !== 0) {
-      throw new Error(`Read failed. Status: 0x${resp[0].toString(16)}`);
+    const status = resp[0];
+    if (status === void 0) {
+      throw new Error("Invalid NFC-V response: missing status byte");
+    }
+    if (status !== 0) {
+      throw new Error(`Read failed. Status: 0x${status.toString(16)}`);
     }
     return new Uint8Array(resp.slice(1));
   },
@@ -254,8 +291,12 @@ var utils3 = {
     if (!resp || resp.length === 0) {
       throw new Error("Empty NFC-V response");
     }
-    if (resp[0] !== 0) {
-      throw new Error(`Write failed. Status: 0x${resp[0].toString(16)}`);
+    const status = resp[0];
+    if (status === void 0) {
+      throw new Error("Invalid NFC-V response: missing status byte");
+    }
+    if (status !== 0) {
+      throw new Error(`Write failed. Status: 0x${status.toString(16)}`);
     }
   },
   /**
@@ -264,10 +305,18 @@ var utils3 = {
    */
   parseSystemInfo(resp) {
     var _a;
-    if (!resp || resp.length < 2 || resp[0] !== 0) {
+    if (!resp || resp.length < 2) {
+      throw new Error("Invalid System Info response");
+    }
+    const status = resp[0];
+    if (status === void 0 || status !== 0) {
       throw new Error("Invalid System Info response");
     }
-    const infoFlags = resp[1] & 15;
+    const flagsByte = resp[1];
+    if (flagsByte === void 0) {
+      throw new Error("Invalid System Info response: missing flags byte");
+    }
+    const infoFlags = flagsByte & 15;
     let offset = 2;
     const result = {};
     if (resp.length >= offset + 8) {
@@ -282,8 +331,14 @@ var utils3 = {
       result.afi = resp[offset++];
     }
     if (infoFlags & 4 && resp.length >= offset + 2) {
-      result.numberOfBlocks = resp[offset++] + 1;
-      result.blockSize = resp[offset++] + 1;
+      const numBlocks = resp[offset++];
+      const blkSize = resp[offset++];
+      if (numBlocks !== void 0) {
+        result.numberOfBlocks = numBlocks + 1;
+      }
+      if (blkSize !== void 0) {
+        result.blockSize = blkSize + 1;
+      }
     }
     if (infoFlags & 8 && resp.length > offset) {
       result.icReference = resp[offset++];
@@ -303,31 +358,31 @@ var utils3 = {
   }
 };
 
-// src/services/nfc/v/internal.ts
+// src/nfc/v/internal.ts
 async function readBlockRaw(tag, blockNumber) {
-  const uid = utils3.reverseUid(tag.id);
-  const cmd = utils3.buildReadBlock(uid, blockNumber);
-  const resp = await NfcManager4.transceive(cmd);
-  return utils3.parseReadResponse(resp);
+  const uid = utils2.reverseUid(tag.id);
+  const cmd = utils2.buildReadBlock(uid, blockNumber);
+  const resp = await NfcManager3.transceive(cmd);
+  return utils2.parseReadResponse(resp);
 }
 async function writeBlockRaw(tag, blockNumber, data) {
-  const uid = utils3.reverseUid(tag.id);
-  const cmd = utils3.buildWriteBlock(uid, blockNumber, data);
-  const resp = await NfcManager4.transceive(cmd);
-  return utils3.parseWriteResponse(resp);
+  const uid = utils2.reverseUid(tag.id);
+  const cmd = utils2.buildWriteBlock(uid, blockNumber, data);
+  const resp = await NfcManager3.transceive(cmd);
+  return utils2.parseWriteResponse(resp);
 }
 async function getSystemInfoRaw(tag) {
-  const uid = utils3.reverseUid(tag.id);
-  const cmd = utils3.buildGetSystemInfo(uid);
-  const resp = await NfcManager4.transceive(cmd);
-  return utils3.parseSystemInfo(resp);
+  const uid = utils2.reverseUid(tag.id);
+  const cmd = utils2.buildGetSystemInfo(uid);
+  const resp = await NfcManager3.transceive(cmd);
+  return utils2.parseSystemInfo(resp);
 }
 
-// src/services/nfc/v/operations.ts
-var operations3 = {
+// src/nfc/v/operations.ts
+var operations2 = {
   async withVTag(handler) {
-    return nfcService.withTechnology(utils3.tech, async () => {
-      const tag = await NfcManager5.getTag();
+    return nfcService.withTechnology(utils2.tech, async () => {
+      const tag = await NfcManager4.getTag();
       if (!(tag == null ? void 0 : tag.id)) throw new Error("No NFC-V tag detected");
       return handler(tag);
     });
@@ -343,14 +398,46 @@ var operations3 = {
   }
 };
 
-// src/services/nfc/namespace.ts
+// src/nfc/ndef/index.ts
+var ndef_exports = {};
+__export(ndef_exports, {
+  operations: () => operations3,
+  utils: () => utils3
+});
+
+// src/nfc/ndef/operations.ts
+import NfcManager5, {
+  Ndef,
+  NfcTech as NfcTech3
+} from "react-native-nfc-manager";
+var operations3 = {
+  async writeNdef(records) {
+    await nfcService.withTechnology([NfcTech3.Ndef, NfcTech3.NfcA], async () => {
+      const bytes = Ndef.encodeMessage(records);
+      await NfcManager5.ndefHandler.writeNdefMessage(bytes);
+    });
+  },
+  writeTextNdef(text) {
+    const record = Ndef.textRecord(text);
+    return this.writeNdef([record]);
+  },
+  writeUriNdef(uri) {
+    const record = Ndef.uriRecord(uri);
+    return this.writeNdef([record]);
+  }
+};
+
+// src/nfc/ndef/utils.ts
+var utils3 = {};
+
+// src/nfc/namespace.ts
 var nfc = {
   service: nfcService,
   /** ISO15693 protocol helpers and high-level operations */
   v: {
-    ...operations3,
+    ...operations2,
     // NfcVOperations, nfcV
-    utils: utils3
+    utils: utils2
   },
   /** NFC-A / Type 2 helpers and operations */
   a: {
@@ -359,15 +446,107 @@ var nfc = {
   },
   /** NDEF read/write utilities and operations */
   ndef: {
-    ...operations2,
-    utils: utils2
+    ...operations3,
+    utils: utils3
   }
 };
+
+// src/react/nfc-provider.tsx
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useState
+} from "react";
+import { jsx } from "react/jsx-runtime";
+var NfcContext = createContext(null);
+function NfcProvider({ children }) {
+  const [state, setState] = useState(nfcService.getState());
+  useEffect(() => {
+    const unsubscribe = nfcService.subscribe(setState);
+    return unsubscribe;
+  }, []);
+  return /* @__PURE__ */ jsx(NfcContext.Provider, { value: { state, service: nfcService }, children });
+}
+function useNfcContext() {
+  const ctx = useContext(NfcContext);
+  if (!ctx) throw new Error("useNfcContext must be inside <NfcProvider>");
+  return ctx;
+}
+
+// src/react/use-nfc.ts
+import { useEffect as useEffect2 } from "react";
+function useNfc(onTag, options) {
+  useEffect2(() => {
+    const flags = options.flags;
+    nfcService.startReader(
+      flags,
+      async (tag) => {
+        if (!tag.id) return;
+        onTag(tag.id);
+      },
+      { cooldownMs: options == null ? void 0 : options.cooldownMs }
+    );
+    return () => {
+      nfcService.stopReader();
+    };
+  }, [onTag]);
+}
+
+// src/react/use-nfc-reader.ts
+import { useCallback } from "react";
+function useNfcReader() {
+  const start = useCallback(
+    (flags, onTag, cooldownMs) => {
+      nfcService.startReader(flags, onTag, { cooldownMs });
+    },
+    []
+  );
+  const stop = useCallback(() => {
+    nfcService.stopReader();
+  }, []);
+  return { start, stop };
+}
+
+// src/react/use-nfc-state.ts
+import { useEffect as useEffect3, useState as useState2 } from "react";
+function useNfcState() {
+  const [nfcState, setNfcState] = useState2(nfcService.getState());
+  useEffect3(() => nfcService.subscribe(setNfcState), []);
+  return nfcState;
+}
+
+// src/react/use-nfc-technology.ts
+import NfcManager6, {
+  Ndef as Ndef2,
+  NfcTech as NfcTech4
+} from "react-native-nfc-manager";
+function useNfcTechnology() {
+  async function writeNdef(records) {
+    return nfcService.withTechnology(NfcTech4.Ndef, async () => {
+      const bytes = Ndef2.encodeMessage(records);
+      await NfcManager6.ndefHandler.writeNdefMessage(bytes);
+    });
+  }
+  async function runWithTech(tech, fn) {
+    return nfcService.withTechnology(tech, fn);
+  }
+  return {
+    writeNdef,
+    runWithTech
+  };
+}
 export {
-  ndef_exports as ndef,
+  NfcProvider,
   nfc,
   a_exports as nfcA,
+  ndef_exports as nfcNdef,
   nfcService,
-  v_exports as nfcV
+  v_exports as nfcV,
+  useNfc,
+  useNfcContext,
+  useNfcReader,
+  useNfcState,
+  useNfcTechnology
 };
 //# sourceMappingURL=index.mjs.map