community-cordova-plugin-nfc 1.8.0 → 1.9.0

package/CHANGELOG.md

@@ -3,7 +3,26 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-## [1.8.0](https://github.com/EYALIN/community-cordova-plugin-nfc/compare/v1.7.1...v1.8.0) (unreleased)
+## [1.9.0](https://github.com/EYALIN/community-cordova-plugin-nfc/compare/v1.8.0...v1.9.0) (2026-10-09)
+
+### Features
+
+* **iOS: `nfc.erase` and `nfc.makeReadOnly`** (PLU-257). Both were Android-only; on iOS 13+, call
+  them after `scanNdef`/`scanTag({keepSessionOpen: true})` resolves. `erase` writes an empty NDEF
+  record, failing with `READ_ONLY` or `NOT_SUPPORTED` as appropriate; `makeReadOnly` locks the tag
+  via `writeLockWithCompletionHandler:`, resolving `{alreadyLocked: true}` if the tag is already
+  locked and failing with `NOT_SUPPORTED` if the tag can't be locked. Both accept an optional
+  `{alertMessage}` on iOS. Below iOS 13, both fail with `NOT_SUPPORTED`.
+* **iOS: `nfc.transceive` reaches MIFARE tags** (PLU-258), via `NFCMiFareTag.sendMiFareCommand` -
+  the response has no `sw1`/`sw2` appended, unlike the existing ISO 7816 path. As an experiment,
+  the same MIFARE path is also tried on a tag from an NDEF-session scan when it happens to conform
+  to the MIFARE protocol; that fallback is unverified on real hardware.
+* **`nfc.capabilities()`** on every platform: `{erase, makeReadOnly, ntagPassword, platform}`.
+  `true`/`true` on Android; on iOS, `erase`/`makeReadOnly` are `true` from 13 onward. `ntagPassword`
+  is `true` on Android and **`false` on iOS** even on 13+ - the MIFARE `transceive` path those
+  helpers would need (PLU-255/PLU-258) is not yet confirmed against a real NTAG213/215.
+
+## [1.8.0](https://github.com/EYALIN/community-cordova-plugin-nfc/compare/v1.7.1...v1.8.0) (2026-09-27)
 
 ### Fixes
 

package/README.md

@@ -20,6 +20,13 @@ or if you're asking for new features or priority bug fixes. Thank you!
 - **Advanced Tag Analysis** (v1.5.0+) - Read raw memory, get NTAG version, counter, signature
 - **TypeScript Support** - Full TypeScript definitions included
 
+## What's New in 1.9.0
+
+iOS: `nfc.erase` and `nfc.makeReadOnly` now work (13+, PLU-257). `nfc.transceive` can also reach a
+MIFARE tag (PLU-258), the basis for the Android NTAG password helpers, though that path is not yet
+verified on real hardware. New `nfc.capabilities()` on every platform reports which of these are
+actually supported, instead of trying an operation and parsing the error.
+
 ## What's New in 1.8.0
 
 Crash and connection fixes on Android, coded errors on both platforms, correct NTAG helpers, iOS
@@ -247,7 +254,10 @@ await nfc.close();
 
 ## Password protection, originality, ISO 15693, MIFARE Classic (1.8.0)
 
-All Android-only (iOS can only transceive ISO 7816 APDUs), after `nfc.connect(tech)` on a scanned tag.
+All Android-only, after `nfc.connect(tech)` on a scanned tag. On iOS, `nfc.transceive` can reach
+a MIFARE tag via `NFCMiFareTag` (v1.9.0, PLU-258), which is what these helpers would need, but that
+path is unverified on real NTAG213/215 hardware - `nfc.capabilities().ntagPassword` reports `false`
+on iOS until it is proven, and these higher-level helpers themselves are not wired to iOS yet.
 Bytes can be given as a hex string, a byte array or a `Uint8Array`.
 
 ```js
@@ -342,6 +352,10 @@ or a hook):
 | `NFCReadOnlyTag` | Tag is read only. | writing to a locked tag |
 | `NFCDataWriteFailed` | Write failed. | the write failed |
 | `NFCUnknownNdefTag` | Unknown NDEF tag status. | unexpected NDEF status |
+| `NFCTagAlreadyReadOnly` | Tag is already read only. | `makeReadOnly` on an already-locked tag (v1.9.0) |
+| `NFCLockNotSupported` | This tag does not support being locked. | `makeReadOnly` on a tag whose hardware can't lock (v1.9.0) |
+| `NFCLockFailed` | Failed to lock tag. | the lock write failed (v1.9.0) |
+| `NFCTagLocked` | Tag is now read only. | a lock succeeded (v1.9.0) |
 
 Example `he.lproj/Localizable.strings`:
 
@@ -377,6 +391,7 @@ English message.
 - [nfc.scanNdef](#nfcscanndef)
 - [nfc.scanTag](#nfcscanTag)
 - [nfc.cancelScan](#nfccancelscan)
+- [nfc.capabilities](#nfccapabilities)
 
 ## ReaderMode
 
@@ -642,12 +657,14 @@ On iOS you can optionally write to NFC tag using the read session
 
 Makes a NFC tag read only.  **Warning this is permanent.**
 
-    nfc.makeReadOnly([onSuccess], [onFailure]);
+    nfc.makeReadOnly([onSuccess], [onFailure], [options]);
 
 ### Parameters
 
 - __onSuccess__: (Optional) The callback that is called when the tag is locked.
 - __onFailure__: (Optional) The callback that is called if there was an error.
+- __options__: (Optional, **iOS only**, v1.9.0) `{ alertMessage: "..." }` overrides the text shown
+  on the system NFC sheet while locking. Ignored on Android.
 
 ### Description
 
@@ -679,9 +696,22 @@ Example usage
 
     },
 
+On **iOS** (13+), call it after `nfc.scanNdef({keepSessionOpen: true})` or
+`nfc.scanTag({keepSessionOpen: true})` resolves - there is no NDEF event handler, so lock the tag
+from that resolved handler instead:
+
+    const tag = await nfc.scanNdef({ keepSessionOpen: true });
+    await nfc.makeReadOnly(null, null, { alertMessage: "Locking tag…" });
+
+A tag that is already read only resolves successfully (`{alreadyLocked: true}`) rather than
+failing. A tag whose hardware doesn't support locking fails with `NOT_SUPPORTED`. Below iOS 13,
+`makeReadOnly` always fails with `NOT_SUPPORTED`. Check `nfc.capabilities().makeReadOnly` to
+detect support ahead of time.
+
 ### Supported Platforms
 
 - Android
+- iOS 13+ (v1.9.0, PLU-257)
 
 ## nfc.share
 
@@ -734,22 +764,31 @@ Function `nfc.unshare` stops sharing data via peer-to-peer.
 
 Erase a NDEF tag
 
-    nfc.erase([onSuccess], [onFailure]);
+    nfc.erase([onSuccess], [onFailure], [options]);
 
 ### Parameters
 
 - __onSuccess__: (Optional) The callback that is called when sharing stops.
 - __onFailure__: (Optional) The callback that is called if there was an error.
+- __options__: (Optional, **iOS only**, v1.9.0) `{ alertMessage: "..." }` overrides the text shown
+  on the system NFC sheet while erasing. Ignored on Android.
 
 ### Description
 
 Function `nfc.erase` erases a tag by writing an empty message.  Will format unformatted tags before writing.
 
-This method *must* be called from within an NDEF Event Handler.
+On **Android** this method *must* be called from within an NDEF Event Handler.
+
+On **iOS** (13+), call it after `nfc.scanNdef({keepSessionOpen: true})` or
+`nfc.scanTag({keepSessionOpen: true})` resolves, the same way as `nfc.makeReadOnly` above. A
+read-only tag fails with `READ_ONLY`; a tag whose hardware doesn't support writing fails with
+`NOT_SUPPORTED`. Below iOS 13, `erase` always fails with `NOT_SUPPORTED`. Check
+`nfc.capabilities().erase` to detect support ahead of time.
 
 ### Supported Platforms
 
 - Android
+- iOS 13+ (v1.9.0, PLU-257)
 ## nfc.handover
 
 Send a file to another device via NFC handover.
@@ -1009,6 +1048,47 @@ Function `cancelScan` stops the [NFCReaderSession](https://developer.apple.com/d
 
 - iOS
 
+## nfc.capabilities
+
+Reports which optional NFC features this platform actually implements, so the app can decide
+what to offer instead of trying an operation and parsing the error. Added v1.9.0 (PLU-258).
+
+    nfc.capabilities([onSuccess], [onFailure]);
+
+### Parameters
+
+- __onSuccess__: (Optional) Called with `{erase, makeReadOnly, ntagPassword, platform}`.
+- __onFailure__: (Optional) The callback that is called if there was an error.
+
+### Returns
+
+ - Promise<{erase: boolean, makeReadOnly: boolean, ntagPassword: boolean, platform: string}> when
+   called without callbacks.
+
+### Description
+
+- `erase` / `makeReadOnly`: `true` on Android always, and on iOS from 13 onward; `false` on iOS
+  below 13 and on any other platform.
+- `ntagPassword`: whether `ntagAuthenticate` / `ntagSetPassword` / `ntagRemovePassword` (and the
+  underlying raw `transceive` they use) are expected to work. `true` on Android. **`false` on
+  iOS**, even on 13+ - the `NFCMiFareTag` raw-command path those helpers need (PLU-255/PLU-258)
+  hasn't been confirmed against a real NTAG213/215 yet. Re-check this value after that is proven
+  on device; it may become conditional on iOS version at that point.
+- `platform`: `cordova.platformId`.
+
+### Quick Example
+
+    const caps = await nfc.capabilities();
+    if (caps.makeReadOnly) {
+        showLockButton();
+    }
+
+### Supported Platforms
+
+- Android
+- iOS
+- any other platform (always reports every feature as unsupported)
+
 
 # Reader Mode Functions
 
@@ -1183,10 +1263,23 @@ Send raw command to the tag and receive the response.
 
 ### Description
 
-Function `transceive` sends raw commands to the tag and receives the response. `nfc.connect` must be called before calling `transceive`. Data passed to transceive can be a hex string representation of bytes or an ArrayBuffer. The response is returned as an ArrayBuffer in the promise. 
+Function `transceive` sends raw commands to the tag and receives the response. On **Android**, `nfc.connect` must be called before calling `transceive`. Data passed to transceive can be a hex string representation of bytes or an ArrayBuffer. The response is returned as an ArrayBuffer in the promise. 
 
 See Android's documentation [IsoDep.transceive()](https://developer.android.com/reference/android/nfc/tech/IsoDep.html#transceive(byte[])), [NfcV.transceive()](https://developer.android.com/reference/android/nfc/tech/NfcV.html#transceive(byte[])), [MifareUltralight.transceive()](https://developer.android.com/reference/android/nfc/tech/MifareUltralight.html#transceive(byte[])) for more info.
 
+On **iOS** (13+), there is no `connect` - call `transceive` after `nfc.scanTag({keepSessionOpen: true})`
+resolves. The tag is dispatched automatically:
+
+- An **ISO 7816** tag (since 1.7.0): the response has `sw1`/`sw2` appended, matching Android's
+  `IsoDep.transceive`.
+- A **MIFARE** tag (v1.9.0, PLU-258), via `NFCMiFareTag.sendMiFareCommand` - this is what
+  `ntagAuthenticate` / `ntagSetPassword` / `ntagRemovePassword` need on iOS. The response is the
+  raw bytes the tag sent back, with **no** `sw1`/`sw2` appended. As an experiment, this path is
+  also tried on the tag from an NDEF-session scan when it happens to conform to the MIFARE
+  protocol, since CoreNFC doesn't document whether that can occur; this fallback is **unverified
+  on real hardware**. Check `nfc.capabilities().ntagPassword` before relying on it - it is `false`
+  by default on iOS until proven.
+
 ### Parameters
 
 - __data__: a string of hex data or an ArrayBuffer
@@ -1210,6 +1303,7 @@ See Android's documentation [IsoDep.transceive()](https://developer.android.com/
 ### Supported Platforms
 
 - Android
+- iOS 13+ (ISO 7816 since 1.7.0; MIFARE since v1.9.0, PLU-258)
 
 ## nfc.close
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "community-cordova-plugin-nfc",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "Community Cordova NFC Plugin - Read and write NDEF messages, advanced tag analysis, raw memory access",
   "main": "./types/index.d.ts",
   "types": "./types/index.d.ts",

package/plugin.xml

@@ -7,7 +7,7 @@
     xmlns="http://apache.org/cordova/ns/plugins/1.0"
     xmlns:android="http://schemas.android.com/apk/res/android"
     id="community-cordova-plugin-nfc"
-    version="1.8.0">
+    version="1.9.0">
 
     <name>NFC</name>
     <description>Community Cordova NFC Plugin - Read and write NDEF messages, advanced tag analysis, raw memory access</description>

package/src/ios/NfcPlugin.h

@@ -32,9 +32,17 @@
 - (void)enabled:(CDVInvokedUrlCommand *)command;
 - (void)writeTag:(CDVInvokedUrlCommand *)command;
 
-// ISO 7816 APDU exchange (added v1.7.0) - mirrors Android nfc.transceive
+// erase / makeReadOnly (added v1.9.0, PLU-257) - mirror Android nfc.erase / nfc.makeReadOnly
+- (void)eraseTag:(CDVInvokedUrlCommand *)command;
+- (void)makeReadOnly:(CDVInvokedUrlCommand *)command;
+
+// ISO 7816 APDU / MIFARE raw command exchange (v1.7.0, extended v1.9.0 for MIFARE - PLU-258) -
+// mirrors Android nfc.transceive
 - (void)transceive:(CDVInvokedUrlCommand *)command;
 
+// Feature detection (added v1.9.0, PLU-258)
+- (void)capabilities:(CDVInvokedUrlCommand *)command;
+
 // Internal implementation
 - (void)channel:(CDVInvokedUrlCommand *)command;
 

package/src/ios/NfcPlugin.m

@@ -7,6 +7,15 @@
 #import "NfcPlugin.h"
 #import <CoreNFC/CoreNFC.h>
 
+// What the current/next NDEF session is for. Replaces overloading self.messageToWrite (e.g. using
+// its presence/content as a signal) to tell a read apart from a write/erase/lock - PLU-257.
+typedef NS_ENUM(NSInteger, NfcSessionMode) {
+    NfcSessionModeRead = 0,
+    NfcSessionModeWrite,
+    NfcSessionModeErase,
+    NfcSessionModeLock
+};
+
 @interface NfcPlugin() {
     NSString* sessionCallbackId;
     NSString* channelCallbackId;
@@ -15,8 +24,11 @@
     // Held when an ISO 7816 tag is connected and keepSessionOpen=YES so that
     // subsequent JS calls to nfc.transceive() can exchange APDUs. (v1.7.0)
     id<NFCISO7816Tag> connectedISO7816Tag API_AVAILABLE(ios(13.0));
+    // Held when a MIFARE/NTAG tag is connected and keepSessionOpen=YES so that nfc.transceive()
+    // can send raw MIFARE commands (NTAG password helpers, GET_VERSION, ...) - PLU-258.
+    id<NFCMiFareTag> connectedMiFareTag API_AVAILABLE(ios(13.0));
 }
-@property (nonatomic, assign) BOOL writeMode;
+@property (nonatomic, assign) NfcSessionMode sessionMode;
 @property (nonatomic, assign) BOOL shouldUseTagReaderSession;
 @property (nonatomic, assign) BOOL sendCallbackOnSessionStart;
 @property (nonatomic, assign) BOOL returnTagInCallback;
@@ -106,8 +118,8 @@
 
 - (void)writeTag:(CDVInvokedUrlCommand*)command API_AVAILABLE(ios(13.0)){
     NSLog(@"writeTag");
-    
-    self.writeMode = YES;
+
+    self.sessionMode = NfcSessionModeWrite;
     self.shouldUseTagReaderSession = NO;
     BOOL reusingSession = NO;
     
@@ -168,6 +180,88 @@
     }
 }
 
+// nfc.erase() on iOS (PLU-257): writes a single TNF_EMPTY record, same as Android's eraseTag -
+// see com.chariotsolutions.nfc.plugin.NfcPlugin#eraseTag. Mirrors writeTag:'s session reuse.
+- (void)eraseTag:(CDVInvokedUrlCommand*)command {
+    NSLog(@"eraseTag");
+
+    if (@available(iOS 13.0, *)) {
+        // continues below
+    } else {
+        CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsDictionary:[self errorWithCode:@"NOT_SUPPORTED" message:@"erase requires iOS 13 or later."]];
+        [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
+        return;
+    }
+
+    self.sessionMode = NfcSessionModeErase;
+    self.shouldUseTagReaderSession = NO;
+    BOOL reusingSession = NO;
+
+    NFCNDEFPayload *emptyRecord = [[NFCNDEFPayload alloc] initWithFormat:NFCTypeNameFormatEmpty type:[NSData data] identifier:[NSData data] payload:[NSData data]];
+    self.messageToWrite = [[NFCNDEFMessage alloc] initWithNDEFRecords:@[emptyRecord]];
+
+    NSDictionary *options = [command argumentAtIndex:0];
+
+    if (self.nfcSession && self.nfcSession.isReady) {
+        reusingSession = YES;
+    } else {
+        self.nfcSession = [[NFCNDEFReaderSession alloc]initWithDelegate:self queue:dispatch_get_main_queue() invalidateAfterFirstRead:FALSE];
+    }
+
+    NSString *alertMessage = [options isKindOfClass:[NSDictionary class]] ? [options objectForKey:@"alertMessage"] : nil;
+    self.nfcSession.alertMessage = ([alertMessage isKindOfClass:[NSString class]] && alertMessage.length > 0)
+        ? alertMessage
+        : [self localizeString:@"NFCHoldNearWritableTag" defaultValue:@"Hold near writable NFC tag to update."];
+    sessionCallbackId = [command.callbackId copy];
+
+    if (reusingSession) {
+        self.keepSessionOpen = NO;
+        [self eraseNDEFTag:self.nfcSession status:connectedTagStatus tag:connectedTag];
+    } else {
+        [self.nfcSession beginSession];
+    }
+}
+
+// nfc.makeReadOnly() on iOS (PLU-257): permanently locks the tag via NFCNDEFTag.writeLock
+// (iOS 13+). Already-read-only counts as success, same as Android returning without error when
+// the tag is already locked.
+- (void)makeReadOnly:(CDVInvokedUrlCommand*)command {
+    NSLog(@"makeReadOnly");
+
+    if (@available(iOS 13.0, *)) {
+        // continues below
+    } else {
+        CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsDictionary:[self errorWithCode:@"NOT_SUPPORTED" message:@"makeReadOnly requires iOS 13 or later."]];
+        [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
+        return;
+    }
+
+    self.sessionMode = NfcSessionModeLock;
+    self.shouldUseTagReaderSession = NO;
+    BOOL reusingSession = NO;
+
+    NSDictionary *options = [command argumentAtIndex:0];
+
+    if (self.nfcSession && self.nfcSession.isReady) {
+        reusingSession = YES;
+    } else {
+        self.nfcSession = [[NFCNDEFReaderSession alloc]initWithDelegate:self queue:dispatch_get_main_queue() invalidateAfterFirstRead:FALSE];
+    }
+
+    NSString *alertMessage = [options isKindOfClass:[NSDictionary class]] ? [options objectForKey:@"alertMessage"] : nil;
+    self.nfcSession.alertMessage = ([alertMessage isKindOfClass:[NSString class]] && alertMessage.length > 0)
+        ? alertMessage
+        : [self localizeString:@"NFCHoldNearWritableTag" defaultValue:@"Hold near writable NFC tag to update."];
+    sessionCallbackId = [command.callbackId copy];
+
+    if (reusingSession) {
+        self.keepSessionOpen = NO;
+        [self lockNDEFTag:self.nfcSession status:connectedTagStatus tag:connectedTag];
+    } else {
+        [self.nfcSession beginSession];
+    }
+}
+
 - (void)cancelScan:(CDVInvokedUrlCommand*)command API_AVAILABLE(ios(11.0)){
     NSLog(@"cancelScan");
     [self rejectPendingScan];
@@ -178,11 +272,35 @@
     connectedTagStatus = NFCNDEFStatusNotSupported;
     if (@available(iOS 13.0, *)) {
         connectedISO7816Tag = NULL;
+        connectedMiFareTag = NULL;
     }
     CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK];
     [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
 }
 
+// nfc.capabilities() (PLU-258): lets an app feature-detect before calling erase/makeReadOnly/the
+// NTAG password helpers instead of trying and parsing the error.
+- (void)capabilities:(CDVInvokedUrlCommand *)command {
+    NSLog(@"capabilities");
+    BOOL ios13OrLater = NO;
+    if (@available(iOS 13.0, *)) {
+        ios13OrLater = YES;
+    }
+    NSDictionary *result = @{
+        @"erase": @(ios13OrLater),
+        @"makeReadOnly": @(ios13OrLater),
+        // PLU-255: scanTag's NFCTagReaderSession never delivered didDetectTags on the owner's
+        // iPhone 17 Pro / iOS 26, so raw MIFARE transceive (rawTransceive, the NTAG password
+        // helpers) is unproven on iOS. Keep this false until a real device confirms the tag-reader
+        // path (or the NDEF-session experiment in -transceive:) actually delivers a MIFARE tag,
+        // then flip it to ios13OrLater here.
+        @"ntagPassword": @NO,
+        @"platform": @"ios"
+    };
+    CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDictionary:result];
+    [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
+}
+
 - (void)invalidateSession:(CDVInvokedUrlCommand*)command {
     NSLog(@"invalidateSession");
     NSLog(@"WARNING: invalidateSession is deprecated. Use cancelScan.");
@@ -226,6 +344,11 @@
 // Requires an ISO 7816-compatible tag detected via scanTag({keepSessionOpen:true}).
 // Resolves with an ArrayBuffer containing the APDU response data with sw1/sw2
 // appended (Android IsoDep semantics).
+//
+// PLU-258: also supports a MIFARE/NTAG tag via NFCMiFareTag.sendMiFareCommand, which is what the
+// www rawTransceive/rawAuthenticate/rawSetPassword NTAG password helpers need. Unlike the ISO 7816
+// branch, the raw response has no sw1/sw2 appended - it is exactly what the tag sent back, matching
+// Android's raw NTAG command responses.
 - (void)transceive:(CDVInvokedUrlCommand *)command {
     NSLog(@"transceive");
 
@@ -236,12 +359,6 @@
             return;
         }
 
-        if (connectedISO7816Tag == nil) {
-            CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsDictionary:[self errorWithCode:@"NOT_CONNECTED" message:@"No ISO 7816 tag connected. Only ISO 7816-compatible tags support transceive on iOS."]];
-            [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
-            return;
-        }
-
         // Cordova-iOS converts a JS ArrayBuffer argument into an NSData.
         id arg = [command argumentAtIndex:0];
         NSData *apduData = nil;
@@ -252,37 +369,75 @@
             apduData = [self uint8ArrayToNSData:(NSArray *)arg];
         }
 
-        if (apduData == nil || apduData.length < 4) {
-            CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsDictionary:[self errorWithCode:@"INVALID_ARGUMENT" message:@"Invalid APDU: expected at least 4 bytes (CLA INS P1 P2)."]];
-            [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
-            return;
-        }
+        NSString *callbackId = [command.callbackId copy];
 
-        NFCISO7816APDU *apdu = [[NFCISO7816APDU alloc] initWithData:apduData];
-        if (apdu == nil) {
-            CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsDictionary:[self errorWithCode:@"INVALID_ARGUMENT" message:@"Invalid APDU encoding."]];
-            [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
+        if (connectedISO7816Tag != nil) {
+            if (apduData == nil || apduData.length < 4) {
+                CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsDictionary:[self errorWithCode:@"INVALID_ARGUMENT" message:@"Invalid APDU: expected at least 4 bytes (CLA INS P1 P2)."]];
+                [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
+                return;
+            }
+
+            NFCISO7816APDU *apdu = [[NFCISO7816APDU alloc] initWithData:apduData];
+            if (apdu == nil) {
+                CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsDictionary:[self errorWithCode:@"INVALID_ARGUMENT" message:@"Invalid APDU encoding."]];
+                [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
+                return;
+            }
+
+            [connectedISO7816Tag sendCommandAPDU:apdu completionHandler:^(NSData * _Nonnull responseData, uint8_t sw1, uint8_t sw2, NSError * _Nullable error) {
+                if (error) {
+                    NSLog(@"transceive error: %@", error);
+                    CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsDictionary:[self errorFromNSError:error]];
+                    [self.commandDelegate sendPluginResult:pluginResult callbackId:callbackId];
+                    return;
+                }
+
+                // Match Android IsoDep.transceive: response data with sw1/sw2 appended.
+                NSMutableData *full = [NSMutableData dataWithData:responseData ?: [NSData data]];
+                [full appendBytes:&sw1 length:1];
+                [full appendBytes:&sw2 length:1];
+
+                CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsArrayBuffer:full];
+                [self.commandDelegate sendPluginResult:pluginResult callbackId:callbackId];
+            }];
             return;
         }
 
-        NSString *callbackId = [command.callbackId copy];
+        id<NFCMiFareTag> mifareTag = connectedMiFareTag;
+        if (mifareTag == nil && self->connectedTag != nil && [self->connectedTag conformsToProtocol:@protocol(NFCMiFareTag)]) {
+            // Experiment (PLU-258): CoreNFC doesn't document the NDEF-session tag (from
+            // scanNdef/scanTag without the ISO7816 branch below) as also conforming to
+            // NFCMiFareTag, but a concrete tag can implement more than one CoreNFC protocol at
+            // once, so this runtime check is free to try and may let rawTransceive work on a tag
+            // read via scanNdef({keepSessionOpen:true}) even when the dedicated tag-reader-session
+            // path (PLU-255) doesn't fire. Unverified on a real device.
+            mifareTag = (id<NFCMiFareTag>)self->connectedTag;
+        }
 
-        [connectedISO7816Tag sendCommandAPDU:apdu completionHandler:^(NSData * _Nonnull responseData, uint8_t sw1, uint8_t sw2, NSError * _Nullable error) {
-            if (error) {
-                NSLog(@"transceive error: %@", error);
-                CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsDictionary:[self errorFromNSError:error]];
-                [self.commandDelegate sendPluginResult:pluginResult callbackId:callbackId];
+        if (mifareTag != nil) {
+            if (apduData == nil || apduData.length == 0) {
+                CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsDictionary:[self errorWithCode:@"INVALID_ARGUMENT" message:@"Invalid MIFARE command: expected at least 1 byte."]];
+                [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
                 return;
             }
 
-            // Match Android IsoDep.transceive: response data with sw1/sw2 appended.
-            NSMutableData *full = [NSMutableData dataWithData:responseData ?: [NSData data]];
-            [full appendBytes:&sw1 length:1];
-            [full appendBytes:&sw2 length:1];
+            [mifareTag sendMiFareCommand:apduData completionHandler:^(NSData * _Nonnull responseData, NSError * _Nullable error) {
+                if (error) {
+                    NSLog(@"transceive (MIFARE) error: %@", error);
+                    CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsDictionary:[self errorFromNSError:error]];
+                    [self.commandDelegate sendPluginResult:pluginResult callbackId:callbackId];
+                    return;
+                }
 
-            CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsArrayBuffer:full];
-            [self.commandDelegate sendPluginResult:pluginResult callbackId:callbackId];
-        }];
+                CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsArrayBuffer:responseData ?: [NSData data]];
+                [self.commandDelegate sendPluginResult:pluginResult callbackId:callbackId];
+            }];
+            return;
+        }
+
+        CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsDictionary:[self errorWithCode:@"NOT_CONNECTED" message:@"No ISO 7816 or MIFARE tag connected. Only ISO 7816-compatible and MIFARE/NTAG tags support transceive on iOS."]];
+        [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
     } else {
         CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsDictionary:[self errorWithCode:@"NOT_SUPPORTED" message:@"transceive requires iOS 13 or later."]];
         [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
@@ -383,6 +538,15 @@
             return;
         }
 
+        // MIFARE/NTAG + keepSessionOpen (PLU-258): hold the tag for nfc.transceive() raw MIFARE
+        // commands (the NTAG password helpers), same shape as the ISO 7816 branch above.
+        if (tag.type == NFCTagTypeMiFare && self.keepSessionOpen) {
+            self->connectedMiFareTag = [tag asNFCMiFareTag];
+            session.alertMessage = [self localizeString:@"NFCTagRead" defaultValue:@"Tag successfully read."];
+            [self fireTagEvent:tagMetaData];
+            return;
+        }
+
         [self processNDEFTag:session tag:ndefTag metaData:tagMetaData];
     }];
 }
@@ -420,6 +584,7 @@
     connectedTagStatus = NFCNDEFStatusNotSupported;
     if (@available(iOS 13.0, *)) {
         connectedISO7816Tag = NULL;
+        connectedMiFareTag = NULL;
     }
     if (old.isReady) {
         [old invalidateSession];
@@ -527,8 +692,8 @@
 
 - (void)beginScanSession:(CDVInvokedUrlCommand*)command {
 
-    self.writeMode = NO;
-    
+    self.sessionMode = NfcSessionModeRead;
+
     NSLog(@"shouldUseTagReaderSession %d", self.shouldUseTagReaderSession);
     NSLog(@"callbackOnSessionStart %d", self.sendCallbackOnSessionStart);
     NSLog(@"returnTagInCallback %d", self.returnTagInCallback);
@@ -584,15 +749,25 @@
             return;
         }
                 
-        if (self.writeMode) {
-            [self writeNDEFTag:session status:status tag:tag];
-        } else {
-            // save tag & status so we can re-use in write
-            if (self.keepSessionOpen) {
-                self->connectedTagStatus = status;
-                self->connectedTag = tag;
-            }
-            [self readNDEFTag:session status:status tag:tag metaData:metaData];
+        switch (self.sessionMode) {
+            case NfcSessionModeWrite:
+                [self writeNDEFTag:session status:status tag:tag];
+                break;
+            case NfcSessionModeErase:
+                [self eraseNDEFTag:session status:status tag:tag];
+                break;
+            case NfcSessionModeLock:
+                [self lockNDEFTag:session status:status tag:tag];
+                break;
+            case NfcSessionModeRead:
+            default:
+                // save tag & status so we can re-use in write
+                if (self.keepSessionOpen) {
+                    self->connectedTagStatus = status;
+                    self->connectedTag = tag;
+                }
+                [self readNDEFTag:session status:status tag:tag metaData:metaData];
+                break;
         }
 
     }];
@@ -660,6 +835,79 @@
     }
 }
 
+// nfc.erase() (PLU-257): same write path as writeNDEFTag, but self.messageToWrite is the single
+// TNF_EMPTY record built in -eraseTag:, and NOT_SUPPORTED (not NOT_NDEF) covers a tag that
+// doesn't support NDEF at all - matching Android's eraseTag error code.
+- (void)eraseNDEFTag:(NFCReaderSession * _Nonnull)session status:(NFCNDEFStatus)status tag:(id<NFCNDEFTag>)tag API_AVAILABLE(ios(13.0)) {
+    switch (status) {
+        case NFCNDEFStatusNotSupported:
+            [self closeSession:session withErrorCode:@"NOT_SUPPORTED" message:[self localizeString:@"NFCNotNdefCompliant" defaultValue:@"Tag is not NDEF compliant."]];
+            break;
+        case NFCNDEFStatusReadOnly:
+            [self closeSession:session withErrorCode:@"READ_ONLY" message:[self localizeString:@"NFCReadOnlyTag" defaultValue:@"Tag is read only."]];
+            break;
+        case NFCNDEFStatusReadWrite: {
+
+            [tag writeNDEF: self.messageToWrite completionHandler:^(NSError * _Nullable error) {
+                if (error) {
+                    NSLog(@"%@", error);
+                    [self closeSession:session withErrorCode:@"IO_ERROR" message:[self localizeString:@"NFCDataWriteFailed" defaultValue:@"Write failed."]];
+                } else {
+                    session.alertMessage = [self localizeString:@"NFCDataWrote" defaultValue:@"Wrote data to NFC tag."];
+                    CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK];
+                    [self.commandDelegate sendPluginResult:pluginResult callbackId:self->sessionCallbackId];
+                    [self closeSession:session];
+                }
+            }];
+            break;
+
+        }
+        default:
+            [self closeSession:session withErrorCode:@"UNKNOWN" message:[self localizeString:@"NFCUnknownNdefTag" defaultValue:@"Unknown NDEF tag status."]];
+    }
+}
+
+// nfc.makeReadOnly() (PLU-257): NFCNDEFTag.writeLockWithCompletionHandler (iOS 13+) permanently
+// locks the tag. A tag that is already read-only is reported as success with alreadyLocked:true,
+// same as Android returning without error when the tag can't be locked again.
+- (void)lockNDEFTag:(NFCReaderSession * _Nonnull)session status:(NFCNDEFStatus)status tag:(id<NFCNDEFTag>)tag API_AVAILABLE(ios(13.0)) {
+    switch (status) {
+        case NFCNDEFStatusNotSupported:
+            [self closeSession:session withErrorCode:@"NOT_SUPPORTED" message:[self localizeString:@"NFCNotNdefCompliant" defaultValue:@"Tag is not NDEF compliant."]];
+            break;
+        case NFCNDEFStatusReadOnly: {
+            session.alertMessage = [self localizeString:@"NFCTagAlreadyReadOnly" defaultValue:@"Tag is already read only."];
+            NSDictionary *result = @{ @"alreadyLocked": @YES };
+            CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDictionary:result];
+            [self.commandDelegate sendPluginResult:pluginResult callbackId:self->sessionCallbackId];
+            [self closeSession:session];
+            break;
+        }
+        case NFCNDEFStatusReadWrite: {
+            if (![tag respondsToSelector:@selector(writeLockWithCompletionHandler:)]) {
+                [self closeSession:session withErrorCode:@"NOT_SUPPORTED" message:[self localizeString:@"NFCLockNotSupported" defaultValue:@"This tag does not support being locked."]];
+                break;
+            }
+
+            [tag writeLockWithCompletionHandler:^(NSError * _Nullable error) {
+                if (error) {
+                    NSLog(@"%@", error);
+                    [self closeSession:session withErrorCode:@"IO_ERROR" message:[self localizeString:@"NFCLockFailed" defaultValue:@"Failed to lock tag."]];
+                } else {
+                    session.alertMessage = [self localizeString:@"NFCTagLocked" defaultValue:@"Tag is now read only."];
+                    NSDictionary *result = @{ @"alreadyLocked": @NO };
+                    CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDictionary:result];
+                    [self.commandDelegate sendPluginResult:pluginResult callbackId:self->sessionCallbackId];
+                    [self closeSession:session];
+                }
+            }];
+            break;
+        }
+        default:
+            [self closeSession:session withErrorCode:@"UNKNOWN" message:[self localizeString:@"NFCUnknownNdefTag" defaultValue:@"Unknown NDEF tag status."]];
+    }
+}
+
 #pragma mark - Tag Reader Helper Functions
 
 // Gets the tag meta data - type and uid
@@ -771,6 +1019,7 @@
     connectedTagStatus = NFCNDEFStatusNotSupported;
     if (@available(iOS 13.0, *)) {
         connectedISO7816Tag = NULL;
+        connectedMiFareTag = NULL;
     }
     [self markSessionClosing:session];
     [session invalidateSession];
@@ -796,6 +1045,7 @@
     connectedTagStatus = NFCNDEFStatusNotSupported;
     if (@available(iOS 13.0, *)) {
         connectedISO7816Tag = NULL;
+        connectedMiFareTag = NULL;
     }
 
     [self markSessionClosing:session];

package/types/index.d.ts

@@ -275,6 +275,28 @@ export interface IWriteOptions {
     [key: string]: unknown;
 }
 
+/** Options for erase() / makeReadOnly() on iOS (added v1.9.0, PLU-257) */
+export interface IEraseOptions {
+    [key: string]: unknown;
+}
+
+/** Result of nfc.capabilities() (added v1.9.0, PLU-258) */
+export interface INfcCapabilities {
+    /** nfc.erase() is implemented on this platform */
+    erase: boolean;
+    /** nfc.makeReadOnly() is implemented on this platform */
+    makeReadOnly: boolean;
+    /**
+     * NTAG password set/remove is implemented on this platform. Always true on Android
+     * (ntagSetPassword/ntagRemovePassword). False on iOS by default (PLU-255): the
+     * NFCMiFareTag raw-command path transceive() uses for the password commands is
+     * unverified against real NTAG213/215 hardware.
+     */
+    ntagPassword: boolean;
+    /** cordova.platformId */
+    platform: string;
+}
+
 /** Callback-style success/failure pair */
 export type SuccessCallback<T = unknown> = (result?: T) => void;
 export type FailureCallback = (error: NfcFailure) => void;
@@ -325,13 +347,19 @@ export interface INfcPlugin {
     write(ndefMessage: INdefRecord[]): Promise<void>;
     write(ndefMessage: INdefRecord[], win?: SuccessCallback, fail?: FailureCallback, options?: IWriteOptions): void;
 
-    /** Make the last scanned tag read-only (permanent!) - Android */
+    /**
+     * Make the last scanned tag read-only (permanent!) - Android, and iOS 13+ after
+     * scanNdef/scanTag({keepSessionOpen: true}) (v1.9.0, PLU-257; options only used on iOS).
+     */
     makeReadOnly(): Promise<void>;
-    makeReadOnly(win?: SuccessCallback, fail?: FailureCallback): void;
+    makeReadOnly(win?: SuccessCallback, fail?: FailureCallback, options?: IEraseOptions): void;
 
-    /** Erase the last scanned tag (writes an empty NDEF record) - Android */
+    /**
+     * Erase the last scanned tag (writes an empty NDEF record) - Android, and iOS 13+ after
+     * scanNdef/scanTag({keepSessionOpen: true}) (v1.9.0, PLU-257; options only used on iOS).
+     */
     erase(): Promise<void>;
-    erase(win?: SuccessCallback, fail?: FailureCallback): void;
+    erase(win?: SuccessCallback, fail?: FailureCallback, options?: IEraseOptions): void;
 
     /** Android Beam was removed in Android 10: always fails with NOT_SUPPORTED */
     share(ndefMessage: INdefRecord[]): Promise<void>;
@@ -386,9 +414,26 @@ export interface INfcPlugin {
     /** Close the connect() session */
     close(): Promise<void>;
 
-    /** Send a raw command. Android: any connected tech; iOS: ISO 7816 APDUs after scanTag({keepSessionOpen:true}) */
+    /**
+     * Send a raw command. Android: any connected tech. iOS: after scanTag({keepSessionOpen: true}),
+     * ISO 7816 APDUs against an ISO7816 tag, or (v1.9.0, PLU-258) MIFARE commands against a tag
+     * that reports as MIFARE. As an experiment covering tags the reader session classifies some
+     * other way, it also tries the MIFARE path, unverified on real hardware, whenever the connected
+     * tag happens to conform to NFCMiFareTag. Unlike the ISO 7816 path, the MIFARE response does
+     * NOT have SW1/SW2 appended.
+     */
     transceive(command: ArrayBuffer | ArrayBufferView | number[] | string): Promise<ArrayBuffer>;
 
+    // ========== Feature detection ==========
+
+    /**
+     * Report which optional features this platform actually implements (added v1.9.0, PLU-258).
+     * Use this instead of `cordova.platformId` checks to decide whether to offer erase,
+     * makeReadOnly or NTAG password UI.
+     */
+    capabilities(): Promise<INfcCapabilities>;
+    capabilities(win?: SuccessCallback<INfcCapabilities>, fail?: FailureCallback): void;
+
     // ========== iOS error codes ==========
 
     /** NFCReaderError codes carried by iOS reader-session errors (with nfc.useErrorObjects(true)) */

package/www/phonegap-nfc.js

@@ -170,6 +170,20 @@ function execOrPromise(win, fail, action, args) {
     nfcExec(win, fail, action, args);
 }
 
+// Same callback-or-Promise duality as execOrPromise(), but for an API that answers from a plain
+// JS value instead of a native exec call (capabilities() on Android / unsupported platforms).
+function resolveOrCall(win, fail, value) {
+    if (typeof win === 'function') {
+        win(value);
+        return undefined;
+    }
+    // [PLU-257 round-1] No success callback was given (win is not a function) - whether or not a
+    // `fail` was passed, there is no failure channel for a synthesized answer like this one, so a
+    // fail-only call (win undefined, fail a function) must still behave like execOrPromise and
+    // hand back a Promise rather than silently dropping `value`.
+    return Promise.resolve(value);
+}
+
 var ndef = {
 
     // see android.nfc.NdefRecord for documentation about constants
@@ -595,7 +609,10 @@ var nfc = {
         return execOrPromise(win, fail, "writeTag", [ndefMessage]);
     },
 
-    makeReadOnly: function (win, fail) {
+    makeReadOnly: function (win, fail, options) {
+        if (cordova.platformId === "ios") {
+            return execOrPromise(win, fail, "makeReadOnly", [options]);
+        }
         return execOrPromise(win, fail, "makeReadOnly", []);
     },
 
@@ -619,10 +636,38 @@ var nfc = {
         return execOrPromise(win, fail, "stopHandover", []);
     },
 
-    erase: function (win, fail) {
+    erase: function (win, fail, options) {
+        if (cordova.platformId === "ios") {
+            return execOrPromise(win, fail, "eraseTag", [options]);
+        }
         return execOrPromise(win, fail, "eraseTag", [[]]);
     },
 
+    // Feature detection (added v1.9.0, PLU-258). Android implements erase, makeReadOnly and the
+    // NTAG password helpers (ntagAuthenticate/ntagSetPassword/ntagRemovePassword) natively, so
+    // those report true unconditionally there. iOS reports its own support (erase/makeReadOnly
+    // need iOS 13+); ntagPassword is hardcoded false on iOS - the NFCMiFareTag raw-command path
+    // used for NTAG password commands (PLU-255) is unverified against real NTAG213/215 hardware.
+    capabilities: function (win, fail) {
+        if (cordova.platformId === "android") {
+            return resolveOrCall(win, fail, {
+                erase: true,
+                makeReadOnly: true,
+                ntagPassword: true,
+                platform: "android"
+            });
+        }
+        if (cordova.platformId === "ios") {
+            return execOrPromise(win, fail, "capabilities", []);
+        }
+        return resolveOrCall(win, fail, {
+            erase: false,
+            makeReadOnly: false,
+            ntagPassword: false,
+            platform: cordova.platformId
+        });
+    },
+
     enabled: function (win, fail) {
         return execOrPromise(win, fail, "enabled", [[]]);
     },