@spencerls/react-native-nfc 1.0.8 → 1.0.9

package/dist/index.d.ts

@@ -1,105 +1,46 @@
 import * as react_native_nfc_manager from 'react-native-nfc-manager';
-import { TagEvent, NfcTech, NdefRecord } from 'react-native-nfc-manager';
+import { NdefRecord, ISOLangCode, TNF, TagEvent, NfcTech, NdefStatus } from 'react-native-nfc-manager';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { PropsWithChildren } from 'react';
 
-declare const operations$2: {
-    transceive(data: number[]): Promise<number[]>;
-};
-
-declare const utils$2: {};
-
-declare namespace index$2 {
-  export { operations$2 as operations, utils$2 as utils };
+declare class Builder {
+    static records(b: NdefBuilder): NdefRecord[];
+    static message(b: NdefBuilder): number[];
+    static record(init: BuildRecordInit): NdefRecord;
+    static textRecord(text: string, lang?: ISOLangCode, encoding?: "utf8" | "utf16", id?: string): NdefRecord;
+    static uriRecord(uri: string, id?: string): NdefRecord;
+    static jsonRecord(payload: string | Uint8Array | number[], id?: string): NdefRecord;
+    static mimeRecord(mimeType: string, payload: string | Uint8Array | number[], id?: string): NdefRecord;
+    static externalRecord(domain: string, type: string, payload: string | Uint8Array | number[], id?: string): NdefRecord;
+    static createEmpty(): NdefRecord;
 }
 
-type StrictTagEvent = TagEvent & {
-    id: string;
-};
-
-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$1: {
-    readonly tech: NfcTech.NfcV | 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;
-    };
-    /**
-     * Combine multiple flag bits into one byte.
-     * Example: Flags.ADDRESSED | Flags.HIGH_DATA_RATE
-     */
-    readonly flags: (...bits: number[]) => number;
-    /**
-     * Convert tag.id hex string (MSB->LSB) into reversed byte array (LSB->MSB)
-     * ISO15693 requires reversed UID for addressed commands.
-     */
-    readonly reverseUid: (tagIdHex: string) => number[];
-    /**
-     * Build READ_SINGLE_BLOCK command.
-     * FLAGS: addressed + high data rate by default.
-     */
-    readonly buildReadBlock: (uidReversed: number[], blockNumber: number) => number[];
-    /**
-     * Build WRITE_SINGLE_BLOCK command.
-     * Note: data must match the block size (usually 4 or 8 bytes).
-     */
-    readonly buildWriteBlock: (uidReversed: number[], blockNumber: number, data: Uint8Array) => number[];
-    /**
-     * Build GET_SYSTEM_INFO command.
-     */
-    readonly buildGetSystemInfo: (uidReversed: number[]) => number[];
-    /**
-     * Parse a READ_SINGLE_BLOCK response.
-     * Response format:
-     *  - byte[0] = status (0x00 = success)
-     *  - byte[1..] = block payload bytes
-     */
-    readonly parseReadResponse: (resp: number[]) => Uint8Array;
-    /**
-     * Parse WRITE_SINGLE_BLOCK response.
-     * Successful write has resp[0] === 0x00.
-     */
-    readonly parseWriteResponse: (resp: number[]) => void;
-    /**
-     * Parse GET_SYSTEM_INFO response.
-     * Returns: UID, DSFID, AFI, numberOfBlocks, blockSize, manufacturer
-     */
-    readonly parseSystemInfo: (resp: number[]) => any;
-    /** Identify common manufacturers based on UID prefix */
-    readonly detectManufacturer: (uid: string) => string;
-};
-
-declare namespace index$1 {
-  export { operations$1 as operations, utils$1 as utils };
+type NdefBuilder = (r: typeof Builder) => NdefRecord[];
+interface BuildRecordInit {
+    tnf: TNF;
+    type: string | number[];
+    id?: string | number[];
+    payload?: string | number[];
+}
+interface NdefMessageResult {
+    ndefMessage: NdefRecord[];
+    type: number;
+    maxSize: number;
+    isWritable: boolean;
+    canMakeReadOnly: boolean;
 }
 
-declare const operations: {
-    writeNdef(records: NdefRecord[]): Promise<void>;
-    writeTextNdef(text: string): Promise<void>;
-    writeUriNdef(uri: string): Promise<void>;
+type SystemInfo = {
+    uid?: string;
+    dsfid?: number;
+    afi?: number;
+    numberOfBlocks?: number;
+    blockSize?: number;
+    icReference?: number;
+    manufacturer?: string;
 };
 
-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 };
-}
-
 type NfcMode = "idle" | "starting" | "active" | "stopping" | "technology";
-
 interface NfcState {
     mode: NfcMode;
     tag: TagEvent | null;
@@ -129,54 +70,162 @@ declare class NfcService {
 }
 declare const nfcService: NfcService;
 
+declare function readMessage$1(): Promise<NdefMessageResult>;
+declare function write$1(records: NdefRecord[]): Promise<void>;
+
+declare const nfcNdefTag: {
+    readonly tech: react_native_nfc_manager.NfcTech[];
+    readonly readMessage: typeof readMessage$1;
+    readonly write: typeof write$1;
+};
+
+declare function getStatus(): Promise<{
+    status: NdefStatus;
+    capacity: number;
+}>;
+declare function readMessage(): Promise<NdefMessageResult>;
+declare function readFull(): Promise<{
+    message: NdefMessageResult;
+    tag: TagEvent;
+}>;
+declare function write(records: NdefRecord[]): Promise<void>;
+declare function writeText(text: string, lang?: ISOLangCode, encoding?: "utf8" | "utf16", id?: string): Promise<void>;
+declare function writeUri(uri: string, id?: string): Promise<void>;
+declare function writeJson(data: unknown, id?: string): Promise<void>;
+declare function writeMime(mimeType: string, payload: string | Uint8Array | number[], id?: string): Promise<void>;
+declare function writeExternal(domain: string, type: string, payload: string | Uint8Array | number[], id?: string): Promise<void>;
+declare function makeReadOnly(): Promise<void>;
+
+declare function getTag$1(): Promise<react_native_nfc_manager.TagEvent>;
+
+declare const nfcTag: {
+    readonly getTag: typeof getTag$1;
+};
+
+declare function getTag(tech: NfcTech | NfcTech[]): Promise<TagEvent>;
+
+declare function transceive(bytes: number[]): Promise<number[]>;
+declare function readBlock$1(tagId: string, blockNumber: number): Promise<Uint8Array>;
+declare function readBlocks$1(tagId: string, startBlock: number, endBlock: number): Promise<Uint8Array<ArrayBuffer>>;
+declare function writeBlock$1(tagId: string, blockNumber: number, data: Uint8Array): Promise<void>;
+declare function writeBlocks$1(tagId: string, blockNumber: number, data: Uint8Array[]): Promise<void>;
+declare function getSystemInfo$1(): Promise<SystemInfo>;
+
+declare const FLAGS: {
+    HIGH_DATA_RATE: number;
+    ADDRESSED: number;
+};
+declare const COMMANDS: {
+    READ_SINGLE_BLOCK: number;
+    WRITE_SINGLE_BLOCK: number;
+    GET_SYSTEM_INFO: number;
+};
+/**
+ * Combine multiple flag bits into one byte.
+ * Example: Flags.ADDRESSED | Flags.HIGH_DATA_RATE
+ */
+declare function buildFlags(...bits: number[]): number;
+/**
+ * Convert tag.id hex string (MSB->LSB) into reversed byte array (LSB->MSB)
+ * ISO15693 requires reversed UID for addressed commands.
+ */
+declare function reverseUid(tagIdHex: string): number[];
+/**
+ * Build READ_SINGLE_BLOCK command.
+ * FLAGS: addressed + high data rate by default.
+ */
+declare function buildReadBlock(uidReversed: number[], blockNumber: number): number[];
+/**
+ * Build WRITE_SINGLE_BLOCK command.
+ * Note: data must match the block size (usually 4 or 8 bytes).
+ */
+declare function buildWriteBlock(uidReversed: number[], blockNumber: number, data: Uint8Array): number[];
+/**
+ * Build GET_SYSTEM_INFO command.
+ */
+declare function buildGetSystemInfo(): number[];
+/**
+ * Parse a READ_SINGLE_BLOCK response.
+ * Response format:
+ *  - byte[0] = status (0x00 = success)
+ *  - byte[1..] = block payload bytes
+ */
+declare function parseReadResponse(resp: number[]): Uint8Array;
+/**
+ * Parse WRITE_SINGLE_BLOCK response.
+ * Successful write has resp[0] === 0x00.
+ */
+declare function parseWriteResponse(resp: number[]): void;
+/**
+ * Parse GET_SYSTEM_INFO response.
+ * Returns: UID, DSFID, AFI, numberOfBlocks, blockSize, manufacturer
+ */
+declare function parseSystemInfo(resp: number[]): SystemInfo;
+/** Identify common manufacturers based on UID prefix */
+declare function detectManufacturer(uid: string): string;
+
+declare const utils_COMMANDS: typeof COMMANDS;
+declare const utils_FLAGS: typeof FLAGS;
+declare const utils_buildFlags: typeof buildFlags;
+declare const utils_buildGetSystemInfo: typeof buildGetSystemInfo;
+declare const utils_buildReadBlock: typeof buildReadBlock;
+declare const utils_buildWriteBlock: typeof buildWriteBlock;
+declare const utils_detectManufacturer: typeof detectManufacturer;
+declare const utils_parseReadResponse: typeof parseReadResponse;
+declare const utils_parseSystemInfo: typeof parseSystemInfo;
+declare const utils_parseWriteResponse: typeof parseWriteResponse;
+declare const utils_reverseUid: typeof reverseUid;
+declare namespace utils {
+  export { utils_COMMANDS as COMMANDS, utils_FLAGS as FLAGS, utils_buildFlags as buildFlags, utils_buildGetSystemInfo as buildGetSystemInfo, utils_buildReadBlock as buildReadBlock, utils_buildWriteBlock as buildWriteBlock, utils_detectManufacturer as detectManufacturer, utils_parseReadResponse as parseReadResponse, utils_parseSystemInfo as parseSystemInfo, utils_parseWriteResponse as parseWriteResponse, utils_reverseUid as reverseUid };
+}
+
+declare const nfcVTag: {
+    readonly tech: react_native_nfc_manager.NfcTech.NfcV | react_native_nfc_manager.NfcTech[];
+    readonly utils: typeof utils;
+    readonly transceive: typeof transceive;
+    readonly readBlock: typeof readBlock$1;
+    readonly readBlocks: typeof readBlocks$1;
+    readonly writeBlock: typeof writeBlock$1;
+    readonly writeBlocks: typeof writeBlocks$1;
+    readonly getSystemInfo: typeof getSystemInfo$1;
+};
+
+declare function writeBlock(blockNumber: number, data: Uint8Array): Promise<void>;
+declare function writeBlocks(blockNumber: number, data: Uint8Array[]): Promise<void>;
+declare function readBlock(blockNumber: number): Promise<Uint8Array>;
+declare function readBlocks(startBlock: number, endBlock: number): Promise<Uint8Array>;
+declare function getSystemInfo(): Promise<SystemInfo>;
+
 /**
  * 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[]>;
+        readonly writeBlock: typeof writeBlock;
+        readonly writeBlocks: typeof writeBlocks;
+        readonly readBlock: typeof readBlock;
+        readonly readBlocks: typeof readBlocks;
+        readonly getSystemInfo: typeof getSystemInfo;
     };
-    /** 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>;
+        readonly Builder: typeof Builder;
+        readonly getStatus: typeof getStatus;
+        readonly readMessage: typeof readMessage;
+        readonly readFull: typeof readFull;
+        readonly write: typeof write;
+        readonly writeText: typeof writeText;
+        readonly writeUri: typeof writeUri;
+        readonly writeJson: typeof writeJson;
+        readonly writeMime: typeof writeMime;
+        readonly writeExternal: typeof writeExternal;
+        readonly makeReadOnly: typeof makeReadOnly;
+    };
+    readonly tag: {
+        readonly getTag: typeof getTag;
     };
 };
 
@@ -203,4 +252,4 @@ declare function useNfcTechnology(): {
     runWithTech: (tech: NfcTech | NfcTech[], fn: () => Promise<void>) => Promise<void>;
 };
 
-export { type NfcMode, NfcProvider, type NfcState, nfc, index$2 as nfcA, index as nfcNdef, nfcService, index$1 as nfcV, useNfc, useNfcContext, useNfcReader, useNfcState, useNfcTechnology };
+export { type BuildRecordInit, type NdefBuilder, type NdefMessageResult, type NfcMode, NfcProvider, type NfcState, type SystemInfo, nfc, nfcNdefTag, nfcService, nfcTag, nfcVTag, useNfc, useNfcContext, useNfcReader, useNfcState, useNfcTechnology };