@spencerls/react-native-nfc 1.0.4 → 1.0.6

package/dist/index.js

@@ -27,27 +27,49 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/services/nfc/index.ts
+// src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  ndef: () => ndef_exports,
+  NfcProvider: () => NfcProvider,
   nfc: () => nfc,
   nfcA: () => a_exports,
+  nfcNdef: () => ndef_exports,
   nfcService: () => nfcService,
-  nfcV: () => v_exports
+  nfcV: () => v_exports,
+  useNfc: () => useNfc,
+  useNfcContext: () => useNfcContext,
+  useNfcReader: () => useNfcReader,
+  useNfcState: () => useNfcState,
+  useNfcTechnology: () => useNfcTechnology
 });
 module.exports = __toCommonJS(index_exports);
 
-// 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
+var import_react_native_nfc_manager2 = __toESM(require("react-native-nfc-manager"));
+
+// src/nfc/service.ts
 var import_react_native = require("react-native");
 var import_react_native_nfc_manager = __toESM(require("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;
     import_react_native_nfc_manager.default.start();
   }
-  // --- internal state mgmt ---
+  // -----------------------------
+  // Internal state management
+  // -----------------------------
   setState(partial) {
     this.state = { ...this.state, ...partial };
     for (const listener of this.listeners) listener(this.state);
@@ -62,17 +84,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" });
-    import_react_native_nfc_manager.default.setEventListener(import_react_native_nfc_manager.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 });
+    import_react_native_nfc_manager.default.setEventListener(
+      import_react_native_nfc_manager.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 (import_react_native.Platform.OS === "ios") {
+              await this._restartIosReader();
+            }
+          }, cooldown);
+        }
+      }
+    );
     try {
       await import_react_native_nfc_manager.default.registerTagEvent({
         isReaderModeEnabled: true,
@@ -83,23 +133,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 import_react_native_nfc_manager.default.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 (import_react_native.Platform.OS !== "ios") return;
+    if (this.lastUsedReaderFlags == null) return;
+    try {
+      await import_react_native_nfc_manager.default.unregisterTagEvent();
+      await import_react_native_nfc_manager.default.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") {
@@ -107,15 +187,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 import_react_native_nfc_manager.default.requestTechnology(tech, {
         alertMessage: "Hold near NFC tag"
-        // iOS
       });
       const result = await handler();
-      if (import_react_native.Platform.OS === "ios")
+      if (import_react_native.Platform.OS === "ios") {
         await import_react_native_nfc_manager.default.setAlertMessageIOS("Success!");
+      }
       return result;
     } catch (err) {
       const message = typeof err === "string" ? err : (err == null ? void 0 : err.message) || "Unknown NFC error";
@@ -123,24 +203,15 @@ var NfcService = class {
     } finally {
       try {
         await import_react_native_nfc_manager.default.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
-var import_react_native_nfc_manager2 = __toESM(require("react-native-nfc-manager"));
+// src/nfc/a/operations.ts
 var operations = {
   async transceive(data) {
     return nfcService.withTechnology(import_react_native_nfc_manager2.NfcTech.NfcA, async () => {
@@ -149,56 +220,27 @@ var operations = {
   }
 };
 
-// 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
-var import_react_native_nfc_manager3 = __toESM(require("react-native-nfc-manager"));
-var operations2 = {
-  async writeNdef(records) {
-    await nfcService.withTechnology([import_react_native_nfc_manager3.NfcTech.Ndef, import_react_native_nfc_manager3.NfcTech.NfcA], async () => {
-      const bytes = import_react_native_nfc_manager3.Ndef.encodeMessage(records);
-      await import_react_native_nfc_manager3.default.ndefHandler.writeNdefMessage(bytes);
-    });
-  },
-  writeTextNdef(text) {
-    const record = import_react_native_nfc_manager3.Ndef.textRecord(text);
-    return this.writeNdef([record]);
-  },
-  writeUriNdef(uri) {
-    const record = import_react_native_nfc_manager3.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
-var import_react_native_nfc_manager6 = __toESM(require("react-native-nfc-manager"));
-
-// src/services/nfc/v/internal.ts
+// src/nfc/v/operations.ts
 var import_react_native_nfc_manager5 = __toESM(require("react-native-nfc-manager"));
 
-// src/services/nfc/v/utils.ts
+// src/nfc/v/internal.ts
+var import_react_native_nfc_manager4 = __toESM(require("react-native-nfc-manager"));
+
+// src/nfc/v/utils.ts
 var import_react_native2 = require("react-native");
-var import_react_native_nfc_manager4 = require("react-native-nfc-manager");
-var utils3 = {
-  tech: import_react_native2.Platform.OS === "ios" ? [import_react_native_nfc_manager4.NfcTech.Iso15693IOS] : import_react_native_nfc_manager4.NfcTech.NfcV,
+var import_react_native_nfc_manager3 = require("react-native-nfc-manager");
+var utils2 = {
+  tech: import_react_native2.Platform.OS === "ios" ? [import_react_native_nfc_manager3.NfcTech.Iso15693IOS] : import_react_native_nfc_manager3.NfcTech.NfcV,
   Flags: {
     HIGH_DATA_RATE: 2,
     ADDRESSED: 32
@@ -223,7 +265,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;
   },
@@ -270,8 +312,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));
   },
@@ -283,8 +329,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)}`);
     }
   },
   /**
@@ -293,10 +343,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) {
@@ -311,8 +369,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++];
@@ -332,31 +396,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 import_react_native_nfc_manager5.default.transceive(cmd);
-  return utils3.parseReadResponse(resp);
+  const uid = utils2.reverseUid(tag.id);
+  const cmd = utils2.buildReadBlock(uid, blockNumber);
+  const resp = await import_react_native_nfc_manager4.default.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 import_react_native_nfc_manager5.default.transceive(cmd);
-  return utils3.parseWriteResponse(resp);
+  const uid = utils2.reverseUid(tag.id);
+  const cmd = utils2.buildWriteBlock(uid, blockNumber, data);
+  const resp = await import_react_native_nfc_manager4.default.transceive(cmd);
+  return utils2.parseWriteResponse(resp);
 }
 async function getSystemInfoRaw(tag) {
-  const uid = utils3.reverseUid(tag.id);
-  const cmd = utils3.buildGetSystemInfo(uid);
-  const resp = await import_react_native_nfc_manager5.default.transceive(cmd);
-  return utils3.parseSystemInfo(resp);
+  const uid = utils2.reverseUid(tag.id);
+  const cmd = utils2.buildGetSystemInfo(uid);
+  const resp = await import_react_native_nfc_manager4.default.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 import_react_native_nfc_manager6.default.getTag();
+    return nfcService.withTechnology(utils2.tech, async () => {
+      const tag = await import_react_native_nfc_manager5.default.getTag();
       if (!(tag == null ? void 0 : tag.id)) throw new Error("No NFC-V tag detected");
       return handler(tag);
     });
@@ -372,14 +436,43 @@ 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
+var import_react_native_nfc_manager6 = __toESM(require("react-native-nfc-manager"));
+var operations3 = {
+  async writeNdef(records) {
+    await nfcService.withTechnology([import_react_native_nfc_manager6.NfcTech.Ndef, import_react_native_nfc_manager6.NfcTech.NfcA], async () => {
+      const bytes = import_react_native_nfc_manager6.Ndef.encodeMessage(records);
+      await import_react_native_nfc_manager6.default.ndefHandler.writeNdefMessage(bytes);
+    });
+  },
+  writeTextNdef(text) {
+    const record = import_react_native_nfc_manager6.Ndef.textRecord(text);
+    return this.writeNdef([record]);
+  },
+  writeUriNdef(uri) {
+    const record = import_react_native_nfc_manager6.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: {
@@ -388,16 +481,100 @@ var nfc = {
   },
   /** NDEF read/write utilities and operations */
   ndef: {
-    ...operations2,
-    utils: utils2
+    ...operations3,
+    utils: utils3
   }
 };
+
+// src/react/nfc-provider.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var NfcContext = (0, import_react.createContext)(null);
+function NfcProvider({ children }) {
+  const [state, setState] = (0, import_react.useState)(nfcService.getState());
+  (0, import_react.useEffect)(() => {
+    const unsubscribe = nfcService.subscribe(setState);
+    return unsubscribe;
+  }, []);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(NfcContext.Provider, { value: { state, service: nfcService }, children });
+}
+function useNfcContext() {
+  const ctx = (0, import_react.useContext)(NfcContext);
+  if (!ctx) throw new Error("useNfcContext must be inside <NfcProvider>");
+  return ctx;
+}
+
+// src/react/use-nfc.ts
+var import_react2 = require("react");
+function useNfc(onTag, options) {
+  (0, import_react2.useEffect)(() => {
+    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
+var import_react3 = require("react");
+function useNfcReader() {
+  const start = (0, import_react3.useCallback)(
+    (flags, onTag, cooldownMs) => {
+      nfcService.startReader(flags, onTag, { cooldownMs });
+    },
+    []
+  );
+  const stop = (0, import_react3.useCallback)(() => {
+    nfcService.stopReader();
+  }, []);
+  return { start, stop };
+}
+
+// src/react/use-nfc-state.ts
+var import_react4 = require("react");
+function useNfcState() {
+  const [nfcState, setNfcState] = (0, import_react4.useState)(nfcService.getState());
+  (0, import_react4.useEffect)(() => nfcService.subscribe(setNfcState), []);
+  return nfcState;
+}
+
+// src/react/use-nfc-technology.ts
+var import_react_native_nfc_manager7 = __toESM(require("react-native-nfc-manager"));
+function useNfcTechnology() {
+  async function writeNdef(records) {
+    return nfcService.withTechnology(import_react_native_nfc_manager7.NfcTech.Ndef, async () => {
+      const bytes = import_react_native_nfc_manager7.Ndef.encodeMessage(records);
+      await import_react_native_nfc_manager7.default.ndefHandler.writeNdefMessage(bytes);
+    });
+  }
+  async function runWithTech(tech, fn) {
+    return nfcService.withTechnology(tech, fn);
+  }
+  return {
+    writeNdef,
+    runWithTech
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ndef,
+  NfcProvider,
   nfc,
   nfcA,
+  nfcNdef,
   nfcService,
-  nfcV
+  nfcV,
+  useNfc,
+  useNfcContext,
+  useNfcReader,
+  useNfcState,
+  useNfcTechnology
 });
 //# sourceMappingURL=index.js.map