@spencerls/react-native-nfc 1.0.7 → 1.0.9

package/dist/index.mjs

@@ -4,28 +4,161 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/nfc/a/index.ts
-var a_exports = {};
-__export(a_exports, {
-  operations: () => operations,
-  utils: () => utils
+// src/nfc/ndef/builder.ts
+import {
+  Ndef
+} from "react-native-nfc-manager";
+var mimeTypes = {
+  TEXT: "text/plain",
+  JSON: "application/json"
+};
+var Builder = class _Builder {
+  static records(b) {
+    return b(_Builder);
+  }
+  static message(b) {
+    return Ndef.encodeMessage(b(_Builder));
+  }
+  static record(init) {
+    const { tnf, type, id = [], payload = [] } = init;
+    const toBytes = (v) => typeof v === "string" ? Array.from(Buffer.from(v, "utf8")) : v;
+    return {
+      tnf,
+      type: toBytes(type),
+      id: toBytes(id),
+      payload: toBytes(payload)
+    };
+  }
+  static textRecord(text, lang = "en", encoding = "utf8", id) {
+    const record = Ndef.textRecord(text, lang, encoding);
+    if (id) record.id = Array.from(Buffer.from(id, "utf8"));
+    return record;
+  }
+  static uriRecord(uri, id) {
+    return Ndef.uriRecord(uri, id);
+  }
+  static jsonRecord(payload, id) {
+    return _Builder.mimeRecord(mimeTypes.JSON, payload, id);
+  }
+  static mimeRecord(mimeType, payload, id) {
+    const payloadBytes = typeof payload === "string" ? Array.from(Buffer.from(payload, "utf8")) : payload instanceof Uint8Array ? Array.from(payload) : payload;
+    const idBytes = id ? Array.from(Buffer.from(id, "utf8")) : [];
+    return _Builder.record({
+      tnf: Ndef.TNF_MIME_MEDIA,
+      type: mimeType,
+      id: idBytes,
+      payload: payloadBytes
+    });
+  }
+  static externalRecord(domain, type, payload, id) {
+    const recordType = `${domain}:${type}`;
+    const payloadBytes = typeof payload === "string" ? Array.from(Buffer.from(payload, "utf8")) : payload instanceof Uint8Array ? Array.from(payload) : payload;
+    const idBytes = id ? Array.from(Buffer.from(id, "utf8")) : [];
+    return _Builder.record({
+      tnf: Ndef.TNF_EXTERNAL_TYPE,
+      type: recordType,
+      id: idBytes,
+      payload: payloadBytes
+    });
+  }
+  static createEmpty() {
+    return _Builder.record({
+      tnf: Ndef.TNF_EMPTY,
+      type: [],
+      id: [],
+      payload: []
+    });
+  }
+};
+
+// src/nfc/ndef/internal/operations.ts
+var operations_exports = {};
+__export(operations_exports, {
+  readMessage: () => readMessage,
+  write: () => write
 });
+import nfcManager, { Ndef as Ndef2 } from "react-native-nfc-manager";
 
-// src/nfc/a/operations.ts
-import NfcManager2, { NfcTech } from "react-native-nfc-manager";
+// src/nfc/ndef/error.ts
+var NdefError = class extends Error {
+  constructor(message) {
+    super(`[NDEF] ${message}`);
+  }
+};
 
-// src/nfc/service.ts
+// src/nfc/ndef/internal/operations.ts
+function assertMessage(msg) {
+  if (!msg.ndefMessage || msg.ndefMessage.length === 0) {
+    throw new NdefError("NDEF message contains no NDEF records");
+  }
+}
+async function readMessage() {
+  const msg = await nfcManager.ndefHandler.getNdefMessage();
+  if (!msg) throw new NdefError("No NDEF message detected");
+  assertMessage(msg);
+  return msg;
+}
+async function write(records) {
+  if (records.length === 0) {
+    throw new NdefError("Cannot write an empty records array");
+  }
+  const bytes = Ndef2.encodeMessage(records);
+  await nfcManager.ndefHandler.writeNdefMessage(bytes);
+}
+
+// src/nfc/ndef/internal/tech.ts
 import { Platform } from "react-native";
-import NfcManager, {
+import { NfcTech } from "react-native-nfc-manager";
+var tech = Platform.OS === "android" ? [NfcTech.Ndef, NfcTech.NfcA] : [NfcTech.Ndef];
+
+// src/nfc/ndef/internal/index.ts
+var nfcNdefTag = {
+  ...operations_exports,
+  tech
+};
+
+// src/nfc/ndef/operations.ts
+var operations_exports4 = {};
+__export(operations_exports4, {
+  getStatus: () => getStatus,
+  makeReadOnly: () => makeReadOnly,
+  readFull: () => readFull,
+  readMessage: () => readMessage2,
+  write: () => write2,
+  writeExternal: () => writeExternal,
+  writeJson: () => writeJson,
+  writeMime: () => writeMime,
+  writeText: () => writeText,
+  writeUri: () => writeUri
+});
+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;
-    NfcManager.start();
+    this.readerModeFlags_ANDROID = null;
+    nfcManager2.start();
+  }
+  enableReaderMode_ANDROID(flags) {
+    if (Platform2.OS !== "android") return;
+    this.readerModeFlags_ANDROID = flags;
   }
   // -----------------------------
   // Internal state management
@@ -47,7 +180,7 @@ var NfcService = class {
   // -----------------------------
   // START READER (Soft Continuous Mode)
   // -----------------------------
-  async startReader(readerModeFlags, onTag, options) {
+  async startReader(onTag, options) {
     var _a;
     if (this.state.mode !== "idle") {
       console.warn(`[NFC] Cannot start reader while ${this.state.mode}`);
@@ -57,7 +190,7 @@ var NfcService = class {
     this.currentCooldownMs = (_a = options == null ? void 0 : options.cooldownMs) != null ? _a : 1500;
     this.isProcessingTag = false;
     this.setState({ mode: "starting", tag: null });
-    NfcManager.setEventListener(
+    nfcManager2.setEventListener(
       NfcEvents.DiscoverTag,
       async (tag) => {
         var _a2;
@@ -71,18 +204,26 @@ var NfcService = class {
           console.warn("[NFC] onTag handler error:", err);
         } finally {
           const cooldown = this.currentCooldownMs;
-          setTimeout(() => {
+          if (this.cooldownTimer) {
+            clearTimeout(this.cooldownTimer);
+          }
+          this.cooldownTimer = setTimeout(() => {
             this.isProcessingTag = false;
-            this.setState({ tag: null, mode: "active" });
+            this.setState({ tag: null });
+            this.cooldownTimer = void 0;
           }, cooldown);
         }
       }
     );
     try {
-      await NfcManager.registerTagEvent({
-        isReaderModeEnabled: true,
-        readerModeFlags
-      });
+      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" });
       }
@@ -97,14 +238,24 @@ var NfcService = class {
   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 NfcManager.unregisterTagEvent();
+      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;
@@ -112,318 +263,431 @@ var NfcService = class {
   // -----------------------------
   // Technology sessions (NDEF, NfcV, etc.)
   // -----------------------------
-  async withTechnology(tech, handler) {
+  async withTechnology(tech3, handler) {
     if (this.state.mode === "technology") {
-      throw new Error("[NFC] Technology is already in use!");
+      throw new NfcError("Technology is already in use!");
     }
-    if (["starting", "active", "stopping"].includes(this.state.mode)) {
+    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 Error(
-        `[NFC] Cannot start technology session in mode ${this.state.mode}`
+      throw new NfcError(
+        `Cannot start technology session in mode ${this.state.mode}`
       );
     }
-    this.setState({ mode: "technology", tag: null });
+    this.setState({ mode: "technology" });
     try {
-      await NfcManager.requestTechnology(tech, {
+      await nfcManager2.requestTechnology(tech3, {
         alertMessage: "Hold near NFC tag"
       });
       const result = await handler();
-      if (Platform.OS === "ios") {
-        await NfcManager.setAlertMessageIOS("Success!");
+      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 Error(`[NFC] withTechnology error: ${message}`);
+      throw new NfcError(`withTechnology error: ${message}`);
     } finally {
       try {
-        await NfcManager.cancelTechnologyRequest();
+        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/a/operations.ts
-var operations = {
-  async transceive(data) {
-    return nfcService.withTechnology(NfcTech.NfcA, async () => {
-      return await NfcManager2.transceive(data);
-    });
-  }
-};
+// src/nfc/tag/internal/operations.ts
+var operations_exports2 = {};
+__export(operations_exports2, {
+  getTag: () => getTag
+});
+import nfcManager3 from "react-native-nfc-manager";
+async function getTag() {
+  const tagEvent = await nfcManager3.getTag();
+  if (!tagEvent) throw new Error("No tag detected");
+  return tagEvent;
+}
 
-// src/nfc/a/utils.ts
-var utils = {};
+// src/nfc/tag/internal/index.ts
+var nfcTag = {
+  ...operations_exports2
+};
 
-// src/nfc/v/index.ts
-var v_exports = {};
-__export(v_exports, {
-  operations: () => operations2,
-  utils: () => utils2
+// src/nfc/tag/operations.ts
+var operations_exports3 = {};
+__export(operations_exports3, {
+  getTag: () => getTag2
 });
+async function getTag2(tech3) {
+  return nfcService.withTechnology(tech3, nfcTag.getTag);
+}
 
-// src/nfc/v/operations.ts
-import NfcManager4 from "react-native-nfc-manager";
+// src/nfc/ndef/operations.ts
+async function getStatus() {
+  return await nfcManager4.ndefHandler.getNdefStatus();
+}
+async function readMessage2() {
+  return await nfcService.withTechnology(
+    nfcNdefTag.tech,
+    nfcNdefTag.readMessage
+  );
+}
+async function readFull() {
+  return await nfcService.withTechnology(nfcNdefTag.tech, async () => {
+    const tag = await nfcTag.getTag();
+    const message = await nfcNdefTag.readMessage();
+    return { message, tag };
+  });
+}
+async function write2(records) {
+  if (!records || records.length === 0) {
+    throw new NdefError("write: no NDEF records provided");
+  }
+  await nfcService.withTechnology(
+    nfcNdefTag.tech,
+    async () => await nfcNdefTag.write(records)
+  );
+}
+async function writeText(text, lang, encoding, id) {
+  const rec = Builder.textRecord(text, lang, encoding, id);
+  await write2([rec]);
+}
+async function writeUri(uri, id) {
+  const rec = Builder.uriRecord(uri, id);
+  await write2([rec]);
+}
+async function writeJson(data, id) {
+  let json;
+  try {
+    json = JSON.stringify(data);
+  } catch (e) {
+    throw new NdefError(`writeJson: value is not JSON serializable: ${e}`);
+  }
+  const rec = Builder.jsonRecord(json, id);
+  await write2([rec]);
+}
+async function writeMime(mimeType, payload, id) {
+  if (!mimeType || typeof mimeType !== "string") {
+    throw new NdefError("writeMime: mimeType must be a non-empty string");
+  }
+  const rec = Builder.mimeRecord(mimeType, payload, id);
+  await write2([rec]);
+}
+async function writeExternal(domain, type, payload, id) {
+  if (!domain || typeof domain !== "string") {
+    throw new NdefError("writeExternal: domain must be a non-empty string");
+  }
+  if (!type || typeof type !== "string") {
+    throw new NdefError("writeExternal: type must be a non-empty string");
+  }
+  const rec = Builder.externalRecord(domain, type, payload, id);
+  await write2([rec]);
+}
+async function makeReadOnly() {
+  await nfcService.withTechnology(
+    nfcNdefTag.tech,
+    nfcManager4.ndefHandler.makeReadOnly
+  );
+}
 
-// src/nfc/v/internal.ts
-import NfcManager3 from "react-native-nfc-manager";
+// src/nfc/v/internal/operations.ts
+var operations_exports5 = {};
+__export(operations_exports5, {
+  getSystemInfo: () => getSystemInfo,
+  readBlock: () => readBlock,
+  readBlocks: () => readBlocks,
+  transceive: () => transceive,
+  writeBlock: () => writeBlock,
+  writeBlocks: () => writeBlocks
+});
+import nfcManager5 from "react-native-nfc-manager";
 
-// src/nfc/v/utils.ts
-import { Platform as Platform2 } from "react-native";
-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
-    // If needed later: OPTION: 0x40 (not commonly used)
-  },
-  Commands: {
-    READ_SINGLE_BLOCK: 32,
-    WRITE_SINGLE_BLOCK: 33,
-    GET_SYSTEM_INFO: 43
-  },
-  /**
-   * Combine multiple flag bits into one byte.
-   * Example: Flags.ADDRESSED | Flags.HIGH_DATA_RATE
-   */
-  flags(...bits) {
-    return bits.reduce((acc, bit) => acc | bit, 0);
-  },
-  /**
-   * Convert tag.id hex string (MSB->LSB) into reversed byte array (LSB->MSB)
-   * ISO15693 requires reversed UID for addressed commands.
-   */
-  reverseUid(tagIdHex) {
-    const bytes = [];
-    for (let i = 0; i < tagIdHex.length; i += 2) {
-      bytes.unshift(Number.parseInt(tagIdHex.substring(i, i + 2), 16));
-    }
-    return bytes;
-  },
-  /**
-   * Build READ_SINGLE_BLOCK command.
-   * FLAGS: addressed + high data rate by default.
-   */
-  buildReadBlock(uidReversed, blockNumber) {
-    const flags = this.flags(this.Flags.ADDRESSED, this.Flags.HIGH_DATA_RATE);
-    return [
-      flags,
-      this.Commands.READ_SINGLE_BLOCK,
-      ...uidReversed,
-      blockNumber
-    ];
-  },
-  /**
-   * Build WRITE_SINGLE_BLOCK command.
-   * Note: data must match the block size (usually 4 or 8 bytes).
-   */
-  buildWriteBlock(uidReversed, blockNumber, data) {
-    const flags = this.flags(this.Flags.ADDRESSED, this.Flags.HIGH_DATA_RATE);
-    return [
-      flags,
-      this.Commands.WRITE_SINGLE_BLOCK,
-      ...uidReversed,
-      blockNumber,
-      ...data
-    ];
-  },
-  /**
-   * Build GET_SYSTEM_INFO command.
-   */
-  buildGetSystemInfo(uidReversed) {
-    return [this.Flags.HIGH_DATA_RATE, this.Commands.GET_SYSTEM_INFO];
-  },
-  /**
-   * Parse a READ_SINGLE_BLOCK response.
-   * Response format:
-   *  - byte[0] = status (0x00 = success)
-   *  - byte[1..] = block payload bytes
-   */
-  parseReadResponse(resp) {
-    if (!resp || resp.length === 0) {
-      throw new Error("Empty NFC-V response");
-    }
-    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));
-  },
-  /**
-   * Parse WRITE_SINGLE_BLOCK response.
-   * Successful write has resp[0] === 0x00.
-   */
-  parseWriteResponse(resp) {
-    if (!resp || resp.length === 0) {
-      throw new Error("Empty NFC-V response");
-    }
-    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)}`);
-    }
-  },
-  /**
-   * Parse GET_SYSTEM_INFO response.
-   * Returns: UID, DSFID, AFI, numberOfBlocks, blockSize, manufacturer
-   */
-  parseSystemInfo(resp) {
-    var _a;
-    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 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) {
-      const uidBytes = resp.slice(offset, offset + 8);
-      result.uid = uidBytes.slice().reverse().map((b) => b.toString(16).padStart(2, "0")).join("").toUpperCase();
-      offset += 8;
-    }
-    if (infoFlags & 1 && resp.length > offset) {
-      result.dsfid = resp[offset++];
-    }
-    if (infoFlags & 2 && resp.length > offset) {
-      result.afi = resp[offset++];
-    }
-    if (infoFlags & 4 && resp.length >= offset + 2) {
-      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++];
-    }
-    if (!result.blockSize) result.blockSize = 4;
-    result.manufacturer = this.detectManufacturer((_a = result.uid) != null ? _a : "");
-    return result;
-  },
-  /** Identify common manufacturers based on UID prefix */
-  detectManufacturer(uid) {
-    if (uid.startsWith("E004") || uid.startsWith("E006") || uid.startsWith("E016"))
-      return "EM Microelectronic";
-    if (uid.startsWith("E002")) return "STMicroelectronics";
-    if (uid.startsWith("E007")) return "Texas Instruments";
-    if (uid.startsWith("E010")) return "NXP";
-    return "Unknown";
+// src/nfc/v/error.ts
+var VError = class extends Error {
+  constructor(message) {
+    super(`[V] ${message}`);
   }
 };
 
-// src/nfc/v/internal.ts
-async function readBlockRaw(tag, blockNumber) {
-  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 = 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 = utils2.reverseUid(tag.id);
-  const cmd = utils2.buildGetSystemInfo(uid);
-  const resp = await NfcManager3.transceive(cmd);
-  return utils2.parseSystemInfo(resp);
+// src/nfc/v/internal/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  COMMANDS: () => COMMANDS,
+  FLAGS: () => FLAGS,
+  buildFlags: () => buildFlags,
+  buildGetSystemInfo: () => buildGetSystemInfo,
+  buildReadBlock: () => buildReadBlock,
+  buildWriteBlock: () => buildWriteBlock,
+  detectManufacturer: () => detectManufacturer,
+  parseReadResponse: () => parseReadResponse,
+  parseSystemInfo: () => parseSystemInfo,
+  parseWriteResponse: () => parseWriteResponse,
+  reverseUid: () => reverseUid
+});
+var FLAGS = {
+  HIGH_DATA_RATE: 2,
+  ADDRESSED: 32
+  // If needed later: OPTION: 0x40 (not commonly used)
+};
+var COMMANDS = {
+  READ_SINGLE_BLOCK: 32,
+  WRITE_SINGLE_BLOCK: 33,
+  GET_SYSTEM_INFO: 43
+};
+function buildFlags(...bits) {
+  return bits.reduce((acc, bit) => acc | bit, 0);
+}
+function reverseUid(tagIdHex) {
+  const bytes = [];
+  for (let i = 0; i < tagIdHex.length; i += 2) {
+    bytes.unshift(Number.parseInt(tagIdHex.substring(i, i + 2), 16));
+  }
+  return bytes;
+}
+function buildReadBlock(uidReversed, blockNumber) {
+  const flags = buildFlags(FLAGS.ADDRESSED, FLAGS.HIGH_DATA_RATE);
+  return [flags, COMMANDS.READ_SINGLE_BLOCK, ...uidReversed, blockNumber];
+}
+function buildWriteBlock(uidReversed, blockNumber, data) {
+  const flags = buildFlags(FLAGS.ADDRESSED, FLAGS.HIGH_DATA_RATE);
+  return [
+    flags,
+    COMMANDS.WRITE_SINGLE_BLOCK,
+    ...uidReversed,
+    blockNumber,
+    ...data
+  ];
+}
+function buildGetSystemInfo() {
+  return [FLAGS.HIGH_DATA_RATE, COMMANDS.GET_SYSTEM_INFO];
+}
+function parseReadResponse(resp) {
+  if (!resp || resp.length === 0) {
+    throw new Error("Empty NFC-V response");
+  }
+  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));
+}
+function parseWriteResponse(resp) {
+  if (!resp || resp.length === 0) {
+    throw new Error("Empty NFC-V response");
+  }
+  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)}`);
+  }
+}
+function parseSystemInfo(resp) {
+  var _a;
+  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 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) {
+    const uidBytes = resp.slice(offset, offset + 8);
+    result.uid = uidBytes.slice().reverse().map((b) => b.toString(16).padStart(2, "0")).join("").toUpperCase();
+    offset += 8;
+  }
+  if (infoFlags & 1 && resp.length > offset) {
+    result.dsfid = resp[offset++];
+  }
+  if (infoFlags & 2 && resp.length > offset) {
+    result.afi = resp[offset++];
+  }
+  if (infoFlags & 4 && resp.length >= offset + 2) {
+    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++];
+  }
+  if (!result.blockSize) result.blockSize = 4;
+  result.manufacturer = detectManufacturer((_a = result.uid) != null ? _a : "");
+  return result;
+}
+function detectManufacturer(uid) {
+  if (uid.startsWith("E004") || uid.startsWith("E006") || uid.startsWith("E016"))
+    return "EM Microelectronic";
+  if (uid.startsWith("E002")) return "STMicroelectronics";
+  if (uid.startsWith("E007")) return "Texas Instruments";
+  if (uid.startsWith("E010")) return "NXP";
+  return "Unknown";
 }
 
-// src/nfc/v/operations.ts
-var operations2 = {
-  async withVTag(handler) {
-    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);
-    });
-  },
-  async writeBlockNfcV(blockNumber, data) {
-    return this.withVTag((tag) => writeBlockRaw(tag, blockNumber, data));
-  },
-  async readBlockNfcV(blockNumber) {
-    return this.withVTag((tag) => readBlockRaw(tag, blockNumber));
-  },
-  async getSystemInfoNfcV() {
-    return this.withVTag((tag) => getSystemInfoRaw(tag));
+// src/nfc/v/internal/operations.ts
+async function transceive(bytes) {
+  return await nfcManager5.nfcVHandler.transceive(bytes);
+}
+async function readBlock(tagId, blockNumber) {
+  const uid = reverseUid(tagId);
+  const cmd = buildReadBlock(uid, blockNumber);
+  const resp = await transceive(cmd);
+  return parseReadResponse(resp);
+}
+async function readBlocks(tagId, startBlock, endBlock) {
+  const data = new Uint8Array();
+  let offset = 0;
+  for (let i = startBlock; i < endBlock; i++) {
+    const block = await readBlock(tagId, i);
+    data.set(block, offset);
+    offset += block.length;
   }
-};
+  return data;
+}
+async function writeBlock(tagId, blockNumber, data) {
+  const uid = reverseUid(tagId);
+  const cmd = buildWriteBlock(uid, blockNumber, data);
+  const resp = await transceive(cmd);
+  parseWriteResponse(resp);
+}
+async function writeBlocks(tagId, blockNumber, data) {
+  for (let i = 0; i < data.length; i++) {
+    const blockData = data[i];
+    if (blockData === void 0) {
+      throw new VError(`No data provided for block at index ${i}`);
+    }
+    await writeBlock(tagId, blockNumber + i, blockData);
+  }
+}
+async function getSystemInfo() {
+  const cmd = buildGetSystemInfo();
+  const resp = await transceive(cmd);
+  return parseSystemInfo(resp);
+}
 
-// src/nfc/ndef/index.ts
-var ndef_exports = {};
-__export(ndef_exports, {
-  operations: () => operations3,
-  utils: () => utils3
-});
+// src/nfc/v/internal/tech.ts
+import { Platform as Platform3 } from "react-native";
+import { NfcTech as NfcTech2 } from "react-native-nfc-manager";
+var tech2 = Platform3.OS === "ios" ? [NfcTech2.Iso15693IOS] : NfcTech2.NfcV;
 
-// 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/v/internal/index.ts
+var nfcVTag = {
+  ...operations_exports5,
+  tech: tech2,
+  utils: utils_exports
 };
 
-// src/nfc/ndef/utils.ts
-var utils3 = {};
+// src/nfc/v/operations.ts
+var operations_exports6 = {};
+__export(operations_exports6, {
+  getSystemInfo: () => getSystemInfo2,
+  readBlock: () => readBlock2,
+  readBlocks: () => readBlocks2,
+  writeBlock: () => writeBlock2,
+  writeBlocks: () => writeBlocks2
+});
+async function writeBlock2(blockNumber, data) {
+  await nfcService.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 () => {
+    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 () => {
+    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 () => {
+    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);
+}
 
 // src/nfc/namespace.ts
 var nfc = {
   service: nfcService,
-  /** ISO15693 protocol helpers and high-level operations */
-  v: {
-    ...operations2,
-    // NfcVOperations, nfcV
-    utils: utils2
-  },
-  /** NFC-A / Type 2 helpers and operations */
-  a: {
-    ...operations,
-    utils
-  },
-  /** NDEF read/write utilities and operations */
-  ndef: {
-    ...operations3,
-    utils: utils3
-  }
+  v: { ...operations_exports6 },
+  ndef: { ...operations_exports4, Builder },
+  tag: { ...operations_exports3 }
 };
 
 // src/react/nfc-provider.tsx
@@ -453,9 +717,7 @@ function useNfcContext() {
 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);
@@ -472,8 +734,8 @@ function useNfc(onTag, options) {
 import { useCallback } from "react";
 function useNfcReader() {
   const start = useCallback(
-    (flags, onTag, cooldownMs) => {
-      nfcService.startReader(flags, onTag, { cooldownMs });
+    (onTag, cooldownMs) => {
+      nfcService.startReader(onTag, { cooldownMs });
     },
     []
   );
@@ -492,19 +754,19 @@ function useNfcState() {
 }
 
 // src/react/use-nfc-technology.ts
-import NfcManager6, {
-  Ndef as Ndef2,
-  NfcTech as NfcTech4
+import NfcManager, {
+  Ndef as Ndef3,
+  NfcTech as NfcTech3
 } 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);
+    return nfcService.withTechnology(NfcTech3.Ndef, async () => {
+      const bytes = Ndef3.encodeMessage(records);
+      await NfcManager.ndefHandler.writeNdefMessage(bytes);
     });
   }
-  async function runWithTech(tech, fn) {
-    return nfcService.withTechnology(tech, fn);
+  async function runWithTech(tech3, fn) {
+    return nfcService.withTechnology(tech3, fn);
   }
   return {
     writeNdef,
@@ -514,10 +776,10 @@ function useNfcTechnology() {
 export {
   NfcProvider,
   nfc,
-  a_exports as nfcA,
-  ndef_exports as nfcNdef,
+  nfcNdefTag,
   nfcService,
-  v_exports as nfcV,
+  nfcTag,
+  nfcVTag,
   useNfc,
   useNfcContext,
   useNfcReader,