@spencerls/react-native-nfc 1.0.4 → 1.0.5

package/dist/index.d.ts

@@ -1,82 +1,6 @@
 import * as react_native_nfc_manager from 'react-native-nfc-manager';
 import { TagEvent, NfcTech, NdefRecord } from 'react-native-nfc-manager';
 
-type StrictTagEvent = TagEvent & {
-    id: string;
-};
-
-type NfcMode = "idle" | "starting" | "active" | "stopping" | "technology";
-
-interface NfcState {
-    mode: NfcMode;
-    tag: TagEvent | null;
-}
-
-type NfcListener = (state: NfcState) => void;
-declare class NfcService {
-    private state;
-    private listeners;
-    constructor();
-    private setState;
-    getState(): NfcState;
-    subscribe(fn: NfcListener): () => void;
-    startReader(readerModeFlags: number, onTag?: (tag: TagEvent) => void): Promise<void>;
-    stopReader(): Promise<void>;
-    withTechnology<T>(tech: NfcTech | NfcTech[], handler: () => Promise<T>): Promise<T>;
-}
-declare const nfcService: NfcService;
-
-/**
- * NFC root namespace providing access to:
- * - NfcService
- * - ISO15693 NFC-V ops
- * - NFC-A ops
- * - NDEF operations
- */
-declare const nfc: {
-    readonly service: NfcService;
-    /** ISO15693 protocol helpers and high-level operations */
-    readonly v: {
-        readonly utils: {
-            readonly tech: react_native_nfc_manager.NfcTech.NfcV | react_native_nfc_manager.NfcTech[];
-            readonly Flags: {
-                readonly HIGH_DATA_RATE: 2;
-                readonly ADDRESSED: 32;
-            };
-            readonly Commands: {
-                readonly READ_SINGLE_BLOCK: 32;
-                readonly WRITE_SINGLE_BLOCK: 33;
-                readonly GET_SYSTEM_INFO: 43;
-            };
-            readonly flags: (...bits: number[]) => number;
-            readonly reverseUid: (tagIdHex: string) => number[];
-            readonly buildReadBlock: (uidReversed: number[], blockNumber: number) => number[];
-            readonly buildWriteBlock: (uidReversed: number[], blockNumber: number, data: Uint8Array) => number[];
-            readonly buildGetSystemInfo: (uidReversed: number[]) => number[];
-            readonly parseReadResponse: (resp: number[]) => Uint8Array;
-            readonly parseWriteResponse: (resp: number[]) => void;
-            readonly parseSystemInfo: (resp: number[]) => any;
-            readonly detectManufacturer: (uid: string) => string;
-        };
-        readonly withVTag: <T>(handler: (tag: StrictTagEvent) => Promise<T>) => Promise<T>;
-        readonly writeBlockNfcV: (blockNumber: number, data: Uint8Array) => Promise<void>;
-        readonly readBlockNfcV: (blockNumber: number) => Promise<Uint8Array<ArrayBufferLike>>;
-        readonly getSystemInfoNfcV: () => Promise<any>;
-    };
-    /** NFC-A / Type 2 helpers and operations */
-    readonly a: {
-        readonly utils: {};
-        readonly transceive: (data: number[]) => Promise<number[]>;
-    };
-    /** NDEF read/write utilities and operations */
-    readonly ndef: {
-        readonly utils: {};
-        readonly writeNdef: (records: react_native_nfc_manager.NdefRecord[]) => Promise<void>;
-        readonly writeTextNdef: (text: string) => Promise<void>;
-        readonly writeUriNdef: (uri: string) => Promise<void>;
-    };
-};
-
 declare const operations$2: {
     transceive(data: number[]): Promise<number[]>;
 };
@@ -87,26 +11,18 @@ declare namespace index$2 {
   export { operations$2 as operations, utils$2 as utils };
 }
 
-declare const operations$1: {
-    writeNdef(records: NdefRecord[]): Promise<void>;
-    writeTextNdef(text: string): Promise<void>;
-    writeUriNdef(uri: string): Promise<void>;
+type StrictTagEvent = TagEvent & {
+    id: string;
 };
 
-declare const utils$1: {};
-
-declare namespace index$1 {
-  export { operations$1 as operations, utils$1 as utils };
-}
-
-declare const operations: {
+declare const operations$1: {
     withVTag<T>(handler: (tag: StrictTagEvent) => Promise<T>): Promise<T>;
     writeBlockNfcV(blockNumber: number, data: Uint8Array): Promise<void>;
     readBlockNfcV(blockNumber: number): Promise<Uint8Array<ArrayBufferLike>>;
     getSystemInfoNfcV(): Promise<any>;
 };
 
-declare const utils: {
+declare const utils$1: {
     readonly tech: NfcTech.NfcV | NfcTech[];
     readonly Flags: {
         readonly HIGH_DATA_RATE: 2;
@@ -162,10 +78,102 @@ declare const utils: {
     readonly detectManufacturer: (uid: string) => string;
 };
 
+declare namespace index$1 {
+  export { operations$1 as operations, utils$1 as utils };
+}
+
+declare const operations: {
+    writeNdef(records: NdefRecord[]): Promise<void>;
+    writeTextNdef(text: string): Promise<void>;
+    writeUriNdef(uri: string): Promise<void>;
+};
+
+declare const utils: {};
+
 declare const index_operations: typeof operations;
 declare const index_utils: typeof utils;
 declare namespace index {
   export { index_operations as operations, index_utils as utils };
 }
 
-export { type NfcMode, type NfcState, index$1 as ndef, nfc, index$2 as nfcA, nfcService, index as nfcV };
+type NfcMode = "idle" | "starting" | "active" | "stopping" | "technology";
+
+interface NfcState {
+    mode: NfcMode;
+    tag: TagEvent | null;
+}
+
+type NfcListener = (state: NfcState) => void;
+declare class NfcService {
+    private state;
+    private listeners;
+    private isProcessingTag;
+    private currentOnTag?;
+    private currentCooldownMs;
+    private lastUsedReaderFlags;
+    constructor();
+    private setState;
+    getState(): NfcState;
+    subscribe(fn: NfcListener): () => void;
+    startReader(readerModeFlags: number, onTag?: (tag: TagEvent) => Promise<void> | void, options?: {
+        cooldownMs?: number;
+    }): Promise<void>;
+    stopReader(): Promise<void>;
+    private _resetReaderState;
+    private _restartIosReader;
+    withTechnology<T>(tech: NfcTech | NfcTech[], handler: () => Promise<T>): Promise<T>;
+}
+declare const nfcService: NfcService;
+
+/**
+ * NFC root namespace providing access to:
+ * - NfcService
+ * - ISO15693 NFC-V ops
+ * - NFC-A ops
+ * - NDEF operations
+ */
+declare const nfc: {
+    readonly service: NfcService;
+    /** ISO15693 protocol helpers and high-level operations */
+    readonly v: {
+        readonly utils: {
+            readonly tech: react_native_nfc_manager.NfcTech.NfcV | react_native_nfc_manager.NfcTech[];
+            readonly Flags: {
+                readonly HIGH_DATA_RATE: 2;
+                readonly ADDRESSED: 32;
+            };
+            readonly Commands: {
+                readonly READ_SINGLE_BLOCK: 32;
+                readonly WRITE_SINGLE_BLOCK: 33;
+                readonly GET_SYSTEM_INFO: 43;
+            };
+            readonly flags: (...bits: number[]) => number;
+            readonly reverseUid: (tagIdHex: string) => number[];
+            readonly buildReadBlock: (uidReversed: number[], blockNumber: number) => number[];
+            readonly buildWriteBlock: (uidReversed: number[], blockNumber: number, data: Uint8Array) => number[];
+            readonly buildGetSystemInfo: (uidReversed: number[]) => number[];
+            readonly parseReadResponse: (resp: number[]) => Uint8Array;
+            readonly parseWriteResponse: (resp: number[]) => void;
+            readonly parseSystemInfo: (resp: number[]) => any;
+            readonly detectManufacturer: (uid: string) => string;
+        };
+        readonly withVTag: <T>(handler: (tag: StrictTagEvent) => Promise<T>) => Promise<T>;
+        readonly writeBlockNfcV: (blockNumber: number, data: Uint8Array) => Promise<void>;
+        readonly readBlockNfcV: (blockNumber: number) => Promise<Uint8Array<ArrayBufferLike>>;
+        readonly getSystemInfoNfcV: () => Promise<any>;
+    };
+    /** NFC-A / Type 2 helpers and operations */
+    readonly a: {
+        readonly utils: {};
+        readonly transceive: (data: number[]) => Promise<number[]>;
+    };
+    /** NDEF read/write utilities and operations */
+    readonly ndef: {
+        readonly utils: {};
+        readonly writeNdef: (records: react_native_nfc_manager.NdefRecord[]) => Promise<void>;
+        readonly writeTextNdef: (text: string) => Promise<void>;
+        readonly writeUriNdef: (uri: string) => Promise<void>;
+    };
+};
+
+export { type NfcMode, type NfcState, nfc, index$2 as nfcA, index as nfcNdef, nfcService, index$1 as nfcV };

package/dist/index.js

@@ -27,27 +27,43 @@ 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/nfc/index.ts
 var index_exports = {};
 __export(index_exports, {
-  ndef: () => ndef_exports,
   nfc: () => nfc,
   nfcA: () => a_exports,
+  nfcNdef: () => ndef_exports,
   nfcService: () => nfcService,
   nfcV: () => v_exports
 });
 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 +78,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 +127,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.setState({ mode: "idle" });
+    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();
+    }
+  }
+  // -----------------------------
+  // 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 +181,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 +197,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 +214,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 +259,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 +306,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 +323,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 +337,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 infoFlags = resp[1] & 15;
+    const status = resp[0];
+    if (status === void 0 || status !== 0) {
+      throw new Error("Invalid System Info response");
+    }
+    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 +363,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 +390,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 +430,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,15 +475,15 @@ var nfc = {
   },
   /** NDEF read/write utilities and operations */
   ndef: {
-    ...operations2,
-    utils: utils2
+    ...operations3,
+    utils: utils3
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ndef,
   nfc,
   nfcA,
+  nfcNdef,
   nfcService,
   nfcV
 });