@spencerls/react-native-nfc 1.0.9 → 1.0.11

package/dist/index.mjs

@@ -133,226 +133,14 @@ __export(operations_exports4, {
 });
 import nfcManager4 from "react-native-nfc-manager";
 
-// src/nfc/service.ts
-import { Platform as Platform2 } from "react-native";
-import nfcManager2, {
-  NfcEvents
-} from "react-native-nfc-manager";
-
-// src/nfc/error.ts
-var NfcError = class extends Error {
-  constructor(message) {
-    super(`[NFC] ${message}`);
-  }
-};
-
-// src/nfc/service.ts
-var NfcService = class {
-  constructor() {
-    this.state = { mode: "idle", tag: null };
-    this.listeners = /* @__PURE__ */ new Set();
-    this.isProcessingTag = false;
-    this.currentCooldownMs = 1500;
-    this.readerModeFlags_ANDROID = null;
-    nfcManager2.start();
-  }
-  enableReaderMode_ANDROID(flags) {
-    if (Platform2.OS !== "android") return;
-    this.readerModeFlags_ANDROID = flags;
-  }
-  // -----------------------------
-  // Internal state management
-  // -----------------------------
-  setState(partial) {
-    this.state = { ...this.state, ...partial };
-    for (const listener of this.listeners) listener(this.state);
-  }
-  getState() {
-    return this.state;
-  }
-  subscribe(fn) {
-    this.listeners.add(fn);
-    fn(this.state);
-    return () => {
-      this.listeners.delete(fn);
-    };
-  }
-  // -----------------------------
-  // START READER (Soft Continuous Mode)
-  // -----------------------------
-  async startReader(onTag, options) {
-    var _a;
-    if (this.state.mode !== "idle") {
-      console.warn(`[NFC] Cannot start reader while ${this.state.mode}`);
-      return;
-    }
-    this.currentOnTag = onTag;
-    this.currentCooldownMs = (_a = options == null ? void 0 : options.cooldownMs) != null ? _a : 1500;
-    this.isProcessingTag = false;
-    this.setState({ mode: "starting", tag: null });
-    nfcManager2.setEventListener(
-      NfcEvents.DiscoverTag,
-      async (tag) => {
-        var _a2;
-        if (!tag) return;
-        if (this.isProcessingTag) return;
-        this.isProcessingTag = true;
-        this.setState({ tag, mode: "active" });
-        try {
-          await ((_a2 = this.currentOnTag) == null ? void 0 : _a2.call(this, tag));
-        } catch (err) {
-          console.warn("[NFC] onTag handler error:", err);
-        } finally {
-          const cooldown = this.currentCooldownMs;
-          if (this.cooldownTimer) {
-            clearTimeout(this.cooldownTimer);
-          }
-          this.cooldownTimer = setTimeout(() => {
-            this.isProcessingTag = false;
-            this.setState({ tag: null });
-            this.cooldownTimer = void 0;
-          }, cooldown);
-        }
-      }
-    );
-    try {
-      if (this.readerModeFlags_ANDROID) {
-        await nfcManager2.registerTagEvent({
-          isReaderModeEnabled: true,
-          readerModeFlags: this.readerModeFlags_ANDROID
-        });
-      } else {
-        await nfcManager2.registerTagEvent();
-      }
-      if (this.state.mode === "starting") {
-        this.setState({ mode: "active" });
-      }
-    } catch (err) {
-      console.warn("[NFC] startReader error:", err);
-      this._resetReaderState();
-    }
-  }
-  // -----------------------------
-  // STOP READER (explicit only)
-  // -----------------------------
-  async stopReader() {
-    if (["idle", "stopping"].includes(this.state.mode)) return;
-    this.setState({ mode: "stopping" });
-    nfcManager2.setEventListener(NfcEvents.DiscoverTag, () => {
-    });
-    if (this.cooldownTimer) {
-      clearTimeout(this.cooldownTimer);
-      this.cooldownTimer = void 0;
-    }
-    try {
-      await nfcManager2.unregisterTagEvent();
-    } catch (err) {
-      console.warn("[NFC] unregisterTagEvent error:", err);
-    }
-    this._resetReaderState();
-  }
-  _resetReaderState() {
-    if (this.cooldownTimer) {
-      clearTimeout(this.cooldownTimer);
-      this.cooldownTimer = void 0;
-    }
-    this.setState({ mode: "idle", tag: null });
-    this.currentOnTag = void 0;
-    this.isProcessingTag = false;
-  }
-  // -----------------------------
-  // Technology sessions (NDEF, NfcV, etc.)
-  // -----------------------------
-  async withTechnology(tech3, handler) {
-    if (this.state.mode === "technology") {
-      throw new NfcError("Technology is already in use!");
-    }
-    if (this.readerModeFlags_ANDROID) {
-      return this.withTechnologyReaderMode_ANDROID(
-        tech3,
-        handler,
-        this.readerModeFlags_ANDROID
-      );
-    }
-    const readerWasActive = ["starting", "active", "stopping"].includes(
-      this.state.mode
-    );
-    const savedOnTag = this.currentOnTag;
-    const savedCooldown = this.currentCooldownMs;
-    if (readerWasActive) {
-      await this.stopReader();
-    }
-    if (this.state.mode !== "idle") {
-      throw new NfcError(
-        `Cannot start technology session in mode ${this.state.mode}`
-      );
-    }
-    this.setState({ mode: "technology" });
-    try {
-      await nfcManager2.requestTechnology(tech3, {
-        alertMessage: "Hold near NFC tag"
-      });
-      const result = await handler();
-      if (Platform2.OS === "ios") {
-        await nfcManager2.setAlertMessageIOS("Success!");
-      }
-      return result;
-    } catch (err) {
-      const message = typeof err === "string" ? err : (err == null ? void 0 : err.message) || "Unknown NFC error";
-      throw new NfcError(`withTechnology error: ${message}`);
-    } finally {
-      try {
-        await nfcManager2.cancelTechnologyRequest();
-      } catch {
-      }
-      this.setState({ mode: "idle", tag: null });
-      if (readerWasActive) {
-        try {
-          await this.startReader(savedOnTag, { cooldownMs: savedCooldown });
-        } catch (err) {
-          console.warn(
-            "[NFC] Failed to restart reader after tech session",
-            err
-          );
-        }
-      }
-    }
-  }
-  async withTechnologyReaderMode_ANDROID(tech3, handler, flags) {
-    const readerWasActive = ["starting", "active", "stopping"].includes(
-      this.state.mode
-    );
-    this.isProcessingTag = true;
-    this.setState({ mode: "technology" });
-    try {
-      await nfcManager2.requestTechnology(tech3, {
-        isReaderModeEnabled: true,
-        readerModeFlags: flags
-      });
-      return await handler();
-    } catch (err) {
-      const message = typeof err === "string" ? err : (err == null ? void 0 : err.message) || "Unknown NFC error";
-      throw new NfcError(`withTechnologyReaderMode_ANDROID error: ${message}`);
-    } finally {
-      try {
-        await nfcManager2.cancelTechnologyRequest();
-      } catch {
-      }
-      this.isProcessingTag = false;
-      this.setState({ mode: readerWasActive ? "active" : "idle" });
-    }
-  }
-};
-var nfcService = new NfcService();
-
 // src/nfc/tag/internal/operations.ts
 var operations_exports2 = {};
 __export(operations_exports2, {
   getTag: () => getTag
 });
-import nfcManager3 from "react-native-nfc-manager";
+import nfcManager2 from "react-native-nfc-manager";
 async function getTag() {
-  const tagEvent = await nfcManager3.getTag();
+  const tagEvent = await nfcManager2.getTag();
   if (!tagEvent) throw new Error("No tag detected");
   return tagEvent;
 }
@@ -367,8 +155,67 @@ var operations_exports3 = {};
 __export(operations_exports3, {
   getTag: () => getTag2
 });
+
+// src/nfc/primitives.ts
+import nfcManager3 from "react-native-nfc-manager";
+var _NfcPrimitives = class _NfcPrimitives {
+  static async cleanTechnology() {
+    await _NfcPrimitives.stopTechnology();
+    _NfcPrimitives.isCancellingTechnology = false;
+  }
+  static async startTechnology(tech3, options) {
+    if (_NfcPrimitives.isRequestingTechnology) {
+      throw new Error("Technology already started");
+    }
+    _NfcPrimitives.isRequestingTechnology = true;
+    try {
+      console.log("Technology started");
+      await nfcManager3.requestTechnology(tech3, options);
+    } finally {
+      _NfcPrimitives.isRequestingTechnology = false;
+    }
+  }
+  static async stopTechnology() {
+    if (_NfcPrimitives.isCancellingTechnology) return;
+    _NfcPrimitives.isCancellingTechnology = true;
+    try {
+      await nfcManager3.cancelTechnologyRequest();
+      console.log("Technology stopped");
+    } catch (_e) {
+    } finally {
+      _NfcPrimitives.isCancellingTechnology = false;
+    }
+  }
+  static async withTechnology(tech3, callback, options) {
+    let res;
+    try {
+      await _NfcPrimitives.startTechnology(tech3, options);
+      res = await callback();
+    } finally {
+      await _NfcPrimitives.stopTechnology();
+    }
+    return res;
+  }
+  static async getTag() {
+    return await nfcManager3.getTag();
+  }
+  static async registerTagEvent(options) {
+    await nfcManager3.registerTagEvent(options);
+  }
+  static async unregisterTagEvent() {
+    await nfcManager3.unregisterTagEvent();
+  }
+  static setEventListener(event, handler) {
+    nfcManager3.setEventListener(event, handler);
+  }
+};
+_NfcPrimitives.isRequestingTechnology = false;
+_NfcPrimitives.isCancellingTechnology = false;
+var NfcPrimitives = _NfcPrimitives;
+
+// src/nfc/tag/operations.ts
 async function getTag2(tech3) {
-  return nfcService.withTechnology(tech3, nfcTag.getTag);
+  return NfcPrimitives.withTechnology(tech3, nfcTag.getTag);
 }
 
 // src/nfc/ndef/operations.ts
@@ -376,13 +223,13 @@ async function getStatus() {
   return await nfcManager4.ndefHandler.getNdefStatus();
 }
 async function readMessage2() {
-  return await nfcService.withTechnology(
+  return await NfcPrimitives.withTechnology(
     nfcNdefTag.tech,
     nfcNdefTag.readMessage
   );
 }
 async function readFull() {
-  return await nfcService.withTechnology(nfcNdefTag.tech, async () => {
+  return await NfcPrimitives.withTechnology(nfcNdefTag.tech, async () => {
     const tag = await nfcTag.getTag();
     const message = await nfcNdefTag.readMessage();
     return { message, tag };
@@ -392,7 +239,7 @@ async function write2(records) {
   if (!records || records.length === 0) {
     throw new NdefError("write: no NDEF records provided");
   }
-  await nfcService.withTechnology(
+  await NfcPrimitives.withTechnology(
     nfcNdefTag.tech,
     async () => await nfcNdefTag.write(records)
   );
@@ -433,12 +280,317 @@ async function writeExternal(domain, type, payload, id) {
   await write2([rec]);
 }
 async function makeReadOnly() {
-  await nfcService.withTechnology(
+  await NfcPrimitives.withTechnology(
     nfcNdefTag.tech,
     nfcManager4.ndefHandler.makeReadOnly
   );
 }
 
+// src/nfc/service/state/index.ts
+var NfcStateMachine = class {
+  constructor() {
+    this.state = "idle" /* IDLE */;
+    this.currentJob = null;
+  }
+  async transition(to, strategy) {
+    if (!this.currentJob) {
+      throw new Error("No current job");
+    }
+    if (!strategy.canHandle(this.currentJob)) {
+      throw new Error(
+        `Strategy ${strategy.constructor.name} cannot handle ${this.currentJob.type}`
+      );
+    }
+    console.log(`\u{1F504} ${this.state} \u2192 ${to}`);
+    this.state = to;
+  }
+  getState() {
+    return this.state;
+  }
+  setCurrentJob(job) {
+    this.currentJob = job;
+  }
+  async transitionToIdle() {
+    console.log("\u{1F504} Transitioning to idle");
+    this.state = "idle" /* IDLE */;
+    this.currentJob = null;
+  }
+  async stop() {
+    if (this.state === "idle" /* IDLE */) return;
+    if (!this.isLoopingState()) return;
+    console.log("\u{1F504} Transitioning to stopping");
+    this.state = "stopping" /* STOPPING */;
+  }
+  isLoopingState() {
+    return ["tech_loop" /* TECH_LOOP */, "tag_event_loop" /* TAG_EVENT_LOOP */].includes(this.state);
+  }
+};
+
+// src/nfc/error.ts
+var NfcError = class extends Error {
+  constructor(message) {
+    super(`[NFC] ${message}`);
+  }
+};
+
+// src/nfc/service/strategies/error.ts
+var NfcStrategyError = class extends NfcError {
+  constructor(message, strategy) {
+    super(`[${strategy}] ${message}`);
+  }
+};
+
+// src/nfc/service/strategies/tag-event.ts
+import { NfcEvents } from "react-native-nfc-manager";
+var TagEventStrategy = class {
+  canHandle(job) {
+    return job.type === "tag_event" /* TAG_EVENT */;
+  }
+  async execute(job, stateMachine) {
+    const { onTag, options } = job;
+    NfcPrimitives.setEventListener(NfcEvents.DiscoverTag, null);
+    try {
+      await NfcPrimitives.registerTagEvent(options);
+    } catch (err) {
+      NfcPrimitives.setEventListener(NfcEvents.DiscoverTag, null);
+      throw new NfcStrategyError(
+        `TagEvent registration failed: ${err.message}`,
+        this.constructor.name
+      );
+    }
+    return new Promise((resolve, reject) => {
+      let done = false;
+      const handler = async (tag) => {
+        if (done) return;
+        done = true;
+        try {
+          await onTag(tag);
+          resolve();
+        } catch (err) {
+          reject(
+            new NfcStrategyError(
+              `Tag processing failed: ${err.message}`,
+              this.constructor.name
+            )
+          );
+        } finally {
+          NfcPrimitives.setEventListener(NfcEvents.DiscoverTag, null);
+          try {
+            await NfcPrimitives.unregisterTagEvent();
+          } catch {
+          }
+        }
+      };
+      NfcPrimitives.setEventListener(NfcEvents.DiscoverTag, handler);
+    });
+  }
+};
+
+// src/nfc/service/strategies/tag-event-loop.ts
+import { NfcEvents as NfcEvents2 } from "react-native-nfc-manager";
+var TagEventLoopStrategy = class {
+  canHandle(job) {
+    return job.type === "tag_event_loop" /* TAG_EVENT_LOOP */;
+  }
+  async execute(job, stateMachine) {
+    const { onTag, options } = job;
+    let isProcessingTag = false;
+    let cooldownTimer;
+    const handleTagEvent = async (tag) => {
+      if (!tag || isProcessingTag) return;
+      isProcessingTag = true;
+      try {
+        await onTag(tag);
+      } catch (err) {
+        console.warn("[NFC] Tag processing failed:", err);
+      } finally {
+        isProcessingTag = false;
+      }
+    };
+    NfcPrimitives.setEventListener(NfcEvents2.DiscoverTag, handleTagEvent);
+    try {
+      await NfcPrimitives.registerTagEvent(options);
+      await new Promise((resolve) => {
+        const interval = setInterval(() => {
+          if (stateMachine.getState() === "stopping" /* STOPPING */) {
+            clearInterval(interval);
+            resolve();
+          }
+        }, 100);
+      });
+    } catch (err) {
+      throw new NfcStrategyError(
+        `TagEvent loop failed: ${err.message}`,
+        this.constructor.name
+      );
+    } finally {
+      NfcPrimitives.setEventListener(NfcEvents2.DiscoverTag, null);
+      await NfcPrimitives.unregisterTagEvent().catch(() => {
+      });
+      if (cooldownTimer) clearTimeout(cooldownTimer);
+    }
+  }
+};
+
+// src/nfc/service/strategies/tech.ts
+var TechStrategy = class {
+  canHandle(job) {
+    return job.type === "tech" /* TECH */;
+  }
+  async execute(job, stateMachine) {
+    const { tech: tech3, withTechnology, afterTechnology, options } = job;
+    await NfcPrimitives.withTechnology(tech3, withTechnology, options);
+    if (afterTechnology) {
+      await afterTechnology();
+    }
+  }
+};
+
+// src/nfc/service/strategies/tech-loop.ts
+var TechLoopStrategy = class {
+  canHandle(job) {
+    return job.type === "tech_loop" /* TECH_LOOP */;
+  }
+  async execute(job, stateMachine) {
+    const { tech: tech3, withTechnology, afterTechnology, options } = job;
+    while (true) {
+      if (stateMachine.getState() === "stopping" /* STOPPING */) break;
+      try {
+        await NfcPrimitives.withTechnology(tech3, withTechnology, options);
+      } catch (e) {
+        if (await handleStartTechError(e)) {
+          continue;
+        }
+        break;
+      }
+      if (afterTechnology) {
+        await afterTechnology();
+      }
+    }
+  }
+};
+async function handleStartTechError(e) {
+  if (e.message.includes("UserCancel")) {
+    console.log("withTechnology() Cancelled");
+    return true;
+  }
+  if (e.message === "Technology already started") {
+    console.warn("withTechnology() Already started");
+    await NfcPrimitives.stopTechnology();
+    return true;
+  }
+  console.error("withTechnology() failed", e.message);
+  return false;
+}
+
+// src/nfc/service/index.ts
+var NfcService = class _NfcService {
+  constructor() {
+    this.strategies = [
+      new TagEventStrategy(),
+      new TagEventLoopStrategy(),
+      new TechStrategy(),
+      new TechLoopStrategy()
+    ];
+    this.stateMachine = new NfcStateMachine();
+    this.jobRetry = null;
+    this.isExecutingJobs = false;
+  }
+  static getInstance() {
+    if (!_NfcService.instance) _NfcService.instance = new _NfcService();
+    return _NfcService.instance;
+  }
+  async startTech(tech3, withTechnology, afterTechnology, options) {
+    const job = {
+      type: "tech" /* TECH */,
+      tech: tech3,
+      withTechnology,
+      afterTechnology,
+      options
+    };
+    await this.executeOrQueue(job);
+  }
+  async startTechLoop(tech3, withTechnology, afterTechnology, options) {
+    const job = {
+      type: "tech_loop" /* TECH_LOOP */,
+      tech: tech3,
+      withTechnology,
+      afterTechnology,
+      options
+    };
+    this.executeOrQueue(job);
+  }
+  async startTagEvent(onTag) {
+    const job = {
+      type: "tag_event" /* TAG_EVENT */,
+      onTag
+    };
+    await this.executeOrQueue(job);
+  }
+  async startTagEventLoop(onTag, options) {
+    const job = {
+      type: "tag_event_loop" /* TAG_EVENT_LOOP */,
+      onTag,
+      options
+    };
+    await this.executeOrQueue(job);
+  }
+  async stop() {
+    console.log("\u{1F6D1} Stopping NFC");
+    this.jobRetry = null;
+    await this.stateMachine.stop();
+  }
+  async executeOrQueue(job) {
+    const state = this.stateMachine.getState();
+    if (state === "stopping" /* STOPPING */) {
+      console.log("\u{1F504} Setting retry job:", job.type);
+      this.jobRetry = job;
+      return;
+    }
+    await this.executeJob(job);
+  }
+  async executeJob(job) {
+    if (this.isExecutingJobs) return;
+    this.isExecutingJobs = true;
+    let _nextJob = job;
+    while (_nextJob) {
+      const strategy = this.strategies.find((s) => s.canHandle(job));
+      if (!strategy) throw new Error(`No strategy for ${job.type}`);
+      this.stateMachine.setCurrentJob(job);
+      try {
+        const targetState = mapJobTypeToState(job.type);
+        await this.stateMachine.transition(targetState, strategy);
+        console.log(`\u{1F680} Starting ${job.type} via ${strategy.constructor.name}`);
+        await strategy.execute(job, this.stateMachine);
+        console.log(`\u2705 Completed ${job.type}`);
+      } catch (error) {
+        console.error(`\u274C ${job.type} failed:`, error);
+        throw error;
+      } finally {
+        await this.stateMachine.transitionToIdle();
+        if (this.jobRetry) {
+          console.log("\u{1F504} Retrying job:", this.jobRetry.type);
+        }
+        _nextJob = this.jobRetry;
+      }
+    }
+    this.isExecutingJobs = false;
+  }
+};
+function mapJobTypeToState(type) {
+  switch (type) {
+    case "tech" /* TECH */:
+      return "tech" /* TECH */;
+    case "tech_loop" /* TECH_LOOP */:
+      return "tech_loop" /* TECH_LOOP */;
+    case "tag_event" /* TAG_EVENT */:
+      return "tag_event" /* TAG_EVENT */;
+    case "tag_event_loop" /* TAG_EVENT_LOOP */:
+      return "tag_event_loop" /* TAG_EVENT_LOOP */;
+  }
+}
+var nfcService = NfcService.getInstance();
+
 // src/nfc/v/internal/operations.ts
 var operations_exports5 = {};
 __export(operations_exports5, {
@@ -630,9 +782,9 @@ async function getSystemInfo() {
 }
 
 // src/nfc/v/internal/tech.ts
-import { Platform as Platform3 } from "react-native";
+import { Platform as Platform2 } from "react-native";
 import { NfcTech as NfcTech2 } from "react-native-nfc-manager";
-var tech2 = Platform3.OS === "ios" ? [NfcTech2.Iso15693IOS] : NfcTech2.NfcV;
+var tech2 = Platform2.OS === "ios" ? [NfcTech2.Iso15693IOS] : [NfcTech2.NfcV];
 
 // src/nfc/v/internal/index.ts
 var nfcVTag = {
@@ -651,35 +803,35 @@ __export(operations_exports6, {
   writeBlocks: () => writeBlocks2
 });
 async function writeBlock2(blockNumber, data) {
-  await nfcService.withTechnology(nfcVTag.tech, async () => {
+  await NfcPrimitives.withTechnology(nfcVTag.tech, async () => {
     const tag = await nfcTag.getTag();
     if (!(tag == null ? void 0 : tag.id)) throw new VError("No NFC-V tag id detected");
     await nfcVTag.writeBlock(tag.id, blockNumber, data);
   });
 }
 async function writeBlocks2(blockNumber, data) {
-  await nfcService.withTechnology(nfcVTag.tech, async () => {
+  await NfcPrimitives.withTechnology(nfcVTag.tech, async () => {
     const tag = await nfcTag.getTag();
     if (!(tag == null ? void 0 : tag.id)) throw new VError("No NFC-V tag id detected");
     nfcVTag.writeBlocks(tag.id, blockNumber, data);
   });
 }
 async function readBlock2(blockNumber) {
-  return await nfcService.withTechnology(nfcVTag.tech, async () => {
+  return await NfcPrimitives.withTechnology(nfcVTag.tech, async () => {
     const tag = await nfcTag.getTag();
     if (!(tag == null ? void 0 : tag.id)) throw new VError("No NFC-V tag id detected");
     return await nfcVTag.readBlock(tag.id, blockNumber);
   });
 }
 async function readBlocks2(startBlock, endBlock) {
-  return await nfcService.withTechnology(nfcVTag.tech, async () => {
+  return await NfcPrimitives.withTechnology(nfcVTag.tech, async () => {
     const tag = await nfcTag.getTag();
     if (!(tag == null ? void 0 : tag.id)) throw new Error("No NFC-V tag id detected");
     return await nfcVTag.readBlocks(tag.id, startBlock, endBlock);
   });
 }
 async function getSystemInfo2() {
-  return await nfcService.withTechnology(nfcVTag.tech, nfcVTag.getSystemInfo);
+  return await NfcPrimitives.withTechnology(nfcVTag.tech, nfcVTag.getSystemInfo);
 }
 
 // src/nfc/namespace.ts
@@ -690,100 +842,77 @@ var nfc = {
   tag: { ...operations_exports3 }
 };
 
-// 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-tech.ts
+import { useCallback } from "react";
+function useNfcTech(tech3, withTechnology, afterTechnology, options) {
+  const startTech = useCallback(() => {
+    nfcService.startTech(tech3, withTechnology, afterTechnology, options || {}).catch(console.error);
+  }, [tech3, withTechnology, afterTechnology, options]);
+  return { startTech };
 }
 
-// src/react/use-nfc.ts
-import { useEffect as useEffect2 } from "react";
-function useNfc(onTag, options) {
-  useEffect2(() => {
-    nfcService.startReader(
-      async (tag) => {
-        if (!tag.id) return;
-        onTag(tag.id);
-      },
-      { cooldownMs: options == null ? void 0 : options.cooldownMs }
+// src/react/use-nfc-tech-loop.ts
+import { useCallback as useCallback2, useEffect, useState } from "react";
+function useNfcTechLoop(tech3, withTechnology, afterTechnology, options) {
+  const [isRunning, setIsRunning] = useState(false);
+  const start = useCallback2(async () => {
+    await nfcService.startTechLoop(
+      tech3,
+      withTechnology,
+      afterTechnology,
+      options || {}
     );
+    setIsRunning(true);
+  }, [tech3, withTechnology, afterTechnology, options]);
+  const stop = useCallback2(async () => {
+    await nfcService.stop();
+    setIsRunning(false);
+  }, []);
+  useEffect(() => {
     return () => {
-      nfcService.stopReader();
+      nfcService.stop();
     };
-  }, [onTag]);
-}
-
-// src/react/use-nfc-reader.ts
-import { useCallback } from "react";
-function useNfcReader() {
-  const start = useCallback(
-    (onTag, cooldownMs) => {
-      nfcService.startReader(onTag, { cooldownMs });
-    },
-    []
-  );
-  const stop = useCallback(() => {
-    nfcService.stopReader();
   }, []);
-  return { start, stop };
+  return { start, stop, isRunning };
 }
 
-// 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-tag-event.ts
+import { useCallback as useCallback3 } from "react";
+function useNfcTagEvent(onTag) {
+  const startTech = useCallback3(() => {
+    nfcService.startTagEvent(onTag).catch(console.error);
+  }, [onTag]);
+  return { startTech };
 }
 
-// src/react/use-nfc-technology.ts
-import NfcManager, {
-  Ndef as Ndef3,
-  NfcTech as NfcTech3
-} from "react-native-nfc-manager";
-function useNfcTechnology() {
-  async function writeNdef(records) {
-    return nfcService.withTechnology(NfcTech3.Ndef, async () => {
-      const bytes = Ndef3.encodeMessage(records);
-      await NfcManager.ndefHandler.writeNdefMessage(bytes);
-    });
-  }
-  async function runWithTech(tech3, fn) {
-    return nfcService.withTechnology(tech3, fn);
-  }
-  return {
-    writeNdef,
-    runWithTech
-  };
+// src/react/use-nfc-tag-event-loop.ts
+import { useCallback as useCallback4, useEffect as useEffect2, useState as useState2 } from "react";
+function useNfcTagEventLoop(onTag, options) {
+  const [isRunning, setIsRunning] = useState2(false);
+  const start = useCallback4(async () => {
+    await nfcService.startTagEventLoop(onTag, options);
+    setIsRunning(true);
+  }, [onTag, options]);
+  const stop = useCallback4(async () => {
+    await nfcService.stop();
+    setIsRunning(false);
+  }, []);
+  useEffect2(() => {
+    return () => {
+      nfcService.stop();
+    };
+  }, []);
+  return { start, stop, isRunning };
 }
 export {
-  NfcProvider,
   nfc,
   nfcNdefTag,
   nfcService,
   nfcTag,
   nfcVTag,
-  useNfc,
-  useNfcContext,
-  useNfcReader,
-  useNfcState,
-  useNfcTechnology
+  useNfcTagEvent,
+  useNfcTagEventLoop,
+  useNfcTech,
+  useNfcTechLoop
 };
 //# sourceMappingURL=index.mjs.map