@chipmobilesdk/rn-local-db 0.2.0 → 0.2.1

package/src/platform/bytes.ts

@@ -1,144 +1,144 @@
-/**
- * Byte handling without Node's `Buffer`.
- *
- * Hermes has no global `Buffer`, and `react-native-quick-crypto` installs one
- * only when the app calls its `install()` — which nothing in this package or its
- * documentation asked for. Until 0.2.0 attachment writes and reads used the
- * global anyway, so on a device every attachment operation threw. Everything
- * here is plain `Uint8Array` and a self-contained base64 codec, identical on
- * Hermes and in Node.
- */
-
-const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-const LOOKUP = (() => {
-	const table = new Int16Array(128).fill(-1);
-	for (let index = 0; index < ALPHABET.length; index += 1) {
-		table[ALPHABET.charCodeAt(index)] = index;
-	}
-	// The URL-safe variants decode too, since some file APIs return them.
-	table['-'.charCodeAt(0)] = 62;
-	table['_'.charCodeAt(0)] = 63;
-	return table;
-})();
-
-/* eslint-disable no-bitwise -- base64 is bit packing; there is no clearer way to write it. */
-
-/** Characters per `String.fromCharCode` call; large spreads overflow the stack. */
-const CHUNK = 0x8000;
-
-export function base64ToBytes(base64: string): Uint8Array {
-	if (typeof globalThis.atob === 'function') {
-		let binary: string | undefined;
-		try {
-			binary = globalThis.atob(base64.replace(/-/g, '+').replace(/_/g, '/'));
-		} catch {
-			// atob is strict where Buffer was lenient; fall through to the
-			// tolerant decoder rather than turn stray characters into a crash.
-		}
-		if (binary !== undefined) {
-			const bytes = new Uint8Array(binary.length);
-			for (let index = 0; index < binary.length; index += 1) {
-				bytes[index] = binary.charCodeAt(index);
-			}
-			return bytes;
-		}
-	}
-	// Decode directly, skipping padding and anything outside the alphabet.
-	const bytes = new Uint8Array(Math.ceil((base64.length * 3) / 4));
-	let out = 0;
-	let buffer = 0;
-	let bits = 0;
-	for (let index = 0; index < base64.length; index += 1) {
-		const code = base64.charCodeAt(index);
-		const value = code < 128 ? LOOKUP[code]! : -1;
-		if (value < 0) continue;
-		buffer = (buffer << 6) | value;
-		bits += 6;
-		if (bits >= 8) {
-			bits -= 8;
-			bytes[out++] = (buffer >> bits) & 0xff;
-		}
-	}
-	return bytes.subarray(0, out);
-}
-
-export function bytesToBase64(bytes: Uint8Array): string {
-	if (typeof globalThis.btoa === 'function') {
-		const parts: string[] = [];
-		for (let index = 0; index < bytes.length; index += CHUNK) {
-			parts.push(String.fromCharCode(...bytes.subarray(index, index + CHUNK)));
-		}
-		return globalThis.btoa(parts.join(''));
-	}
-	const parts: string[] = [];
-	for (let start = 0; start < bytes.length; start += CHUNK * 3) {
-		let piece = '';
-		const end = Math.min(bytes.length, start + CHUNK * 3);
-		let index = start;
-		for (; index + 2 < end; index += 3) {
-			const triple = (bytes[index]! << 16) | (bytes[index + 1]! << 8) | bytes[index + 2]!;
-			piece +=
-				ALPHABET[triple >> 18]! +
-				ALPHABET[(triple >> 12) & 63]! +
-				ALPHABET[(triple >> 6) & 63]! +
-				ALPHABET[triple & 63]!;
-		}
-		const remaining = end - index;
-		if (remaining === 1) {
-			const value = bytes[index]!;
-			piece += `${ALPHABET[value >> 2]}${ALPHABET[(value & 3) << 4]}==`;
-		} else if (remaining === 2) {
-			const value = (bytes[index]! << 8) | bytes[index + 1]!;
-			piece += `${ALPHABET[value >> 10]}${ALPHABET[(value >> 4) & 63]}${ALPHABET[(value & 15) << 2]}=`;
-		}
-		parts.push(piece);
-	}
-	return parts.join('');
-}
-
-/** UTF-8 encoding. `TextEncoder` is in Hermes and Node; the loop is the fallback. */
-export function utf8Bytes(value: string): Uint8Array {
-	if (typeof TextEncoder !== 'undefined') {
-		return new TextEncoder().encode(value);
-	}
-	const encoded = unescape(encodeURIComponent(value));
-	const bytes = new Uint8Array(encoded.length);
-	for (let index = 0; index < encoded.length; index += 1) {
-		bytes[index] = encoded.charCodeAt(index);
-	}
-	return bytes;
-}
-
-/** UTF-8 decoding, the inverse of `utf8Bytes`. */
-export function utf8String(bytes: Uint8Array): string {
-	if (typeof TextDecoder !== 'undefined') {
-		return new TextDecoder().decode(bytes);
-	}
-	let binary = '';
-	for (const byte of bytes) {
-		binary += String.fromCharCode(byte);
-	}
-	return decodeURIComponent(escape(binary));
-}
-
-/* eslint-enable no-bitwise */
-
-export function concatBytes(parts: readonly Uint8Array[]): Uint8Array {
-	const total = parts.reduce((sum, part) => sum + part.length, 0);
-	const joined = new Uint8Array(total);
-	let offset = 0;
-	for (const part of parts) {
-		joined.set(part, offset);
-		offset += part.length;
-	}
-	return joined;
-}
-
-/** The ASCII text of `length` bytes from `start`, for magic numbers. */
-export function asciiAt(bytes: Uint8Array, start: number, length: number): string {
-	let text = '';
-	for (let index = start; index < start + length && index < bytes.length; index += 1) {
-		text += String.fromCharCode(bytes[index]!);
-	}
-	return text;
-}
+/**
+ * Byte handling without Node's `Buffer`.
+ *
+ * Hermes has no global `Buffer`, and `react-native-quick-crypto` installs one
+ * only when the app calls its `install()` — which nothing in this package or its
+ * documentation asked for. Until 0.2.0 attachment writes and reads used the
+ * global anyway, so on a device every attachment operation threw. Everything
+ * here is plain `Uint8Array` and a self-contained base64 codec, identical on
+ * Hermes and in Node.
+ */
+
+const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const LOOKUP = (() => {
+	const table = new Int16Array(128).fill(-1);
+	for (let index = 0; index < ALPHABET.length; index += 1) {
+		table[ALPHABET.charCodeAt(index)] = index;
+	}
+	// The URL-safe variants decode too, since some file APIs return them.
+	table['-'.charCodeAt(0)] = 62;
+	table['_'.charCodeAt(0)] = 63;
+	return table;
+})();
+
+/* eslint-disable no-bitwise -- base64 is bit packing; there is no clearer way to write it. */
+
+/** Characters per `String.fromCharCode` call; large spreads overflow the stack. */
+const CHUNK = 0x8000;
+
+export function base64ToBytes(base64: string): Uint8Array {
+	if (typeof globalThis.atob === 'function') {
+		let binary: string | undefined;
+		try {
+			binary = globalThis.atob(base64.replace(/-/g, '+').replace(/_/g, '/'));
+		} catch {
+			// atob is strict where Buffer was lenient; fall through to the
+			// tolerant decoder rather than turn stray characters into a crash.
+		}
+		if (binary !== undefined) {
+			const bytes = new Uint8Array(binary.length);
+			for (let index = 0; index < binary.length; index += 1) {
+				bytes[index] = binary.charCodeAt(index);
+			}
+			return bytes;
+		}
+	}
+	// Decode directly, skipping padding and anything outside the alphabet.
+	const bytes = new Uint8Array(Math.ceil((base64.length * 3) / 4));
+	let out = 0;
+	let buffer = 0;
+	let bits = 0;
+	for (let index = 0; index < base64.length; index += 1) {
+		const code = base64.charCodeAt(index);
+		const value = code < 128 ? LOOKUP[code]! : -1;
+		if (value < 0) continue;
+		buffer = (buffer << 6) | value;
+		bits += 6;
+		if (bits >= 8) {
+			bits -= 8;
+			bytes[out++] = (buffer >> bits) & 0xff;
+		}
+	}
+	return bytes.subarray(0, out);
+}
+
+export function bytesToBase64(bytes: Uint8Array): string {
+	if (typeof globalThis.btoa === 'function') {
+		const parts: string[] = [];
+		for (let index = 0; index < bytes.length; index += CHUNK) {
+			parts.push(String.fromCharCode(...bytes.subarray(index, index + CHUNK)));
+		}
+		return globalThis.btoa(parts.join(''));
+	}
+	const parts: string[] = [];
+	for (let start = 0; start < bytes.length; start += CHUNK * 3) {
+		let piece = '';
+		const end = Math.min(bytes.length, start + CHUNK * 3);
+		let index = start;
+		for (; index + 2 < end; index += 3) {
+			const triple = (bytes[index]! << 16) | (bytes[index + 1]! << 8) | bytes[index + 2]!;
+			piece +=
+				ALPHABET[triple >> 18]! +
+				ALPHABET[(triple >> 12) & 63]! +
+				ALPHABET[(triple >> 6) & 63]! +
+				ALPHABET[triple & 63]!;
+		}
+		const remaining = end - index;
+		if (remaining === 1) {
+			const value = bytes[index]!;
+			piece += `${ALPHABET[value >> 2]}${ALPHABET[(value & 3) << 4]}==`;
+		} else if (remaining === 2) {
+			const value = (bytes[index]! << 8) | bytes[index + 1]!;
+			piece += `${ALPHABET[value >> 10]}${ALPHABET[(value >> 4) & 63]}${ALPHABET[(value & 15) << 2]}=`;
+		}
+		parts.push(piece);
+	}
+	return parts.join('');
+}
+
+/** UTF-8 encoding. `TextEncoder` is in Hermes and Node; the loop is the fallback. */
+export function utf8Bytes(value: string): Uint8Array {
+	if (typeof TextEncoder !== 'undefined') {
+		return new TextEncoder().encode(value);
+	}
+	const encoded = unescape(encodeURIComponent(value));
+	const bytes = new Uint8Array(encoded.length);
+	for (let index = 0; index < encoded.length; index += 1) {
+		bytes[index] = encoded.charCodeAt(index);
+	}
+	return bytes;
+}
+
+/** UTF-8 decoding, the inverse of `utf8Bytes`. */
+export function utf8String(bytes: Uint8Array): string {
+	if (typeof TextDecoder !== 'undefined') {
+		return new TextDecoder().decode(bytes);
+	}
+	let binary = '';
+	for (const byte of bytes) {
+		binary += String.fromCharCode(byte);
+	}
+	return decodeURIComponent(escape(binary));
+}
+
+/* eslint-enable no-bitwise */
+
+export function concatBytes(parts: readonly Uint8Array[]): Uint8Array {
+	const total = parts.reduce((sum, part) => sum + part.length, 0);
+	const joined = new Uint8Array(total);
+	let offset = 0;
+	for (const part of parts) {
+		joined.set(part, offset);
+		offset += part.length;
+	}
+	return joined;
+}
+
+/** The ASCII text of `length` bytes from `start`, for magic numbers. */
+export function asciiAt(bytes: Uint8Array, start: number, length: number): string {
+	let text = '';
+	for (let index = start; index < start + length && index < bytes.length; index += 1) {
+		text += String.fromCharCode(bytes[index]!);
+	}
+	return text;
+}

package/src/platform/fs.ts

@@ -1,89 +1,89 @@
-/**
- * The filesystem peer, behind one lazy accessor.
- *
- * Required lazily for the same reason the engine is: a consuming app that
- * only ever runs the in-memory adapter in tests must not have to install a
- * native module to import this package. Confining the require to `platform/`
- * also keeps the native surface four directories wide, which is the layering
- * rule the ESLint config enforces.
- */
-
-import { DiagnosticCodes } from '../contract/errors';
-import { raise } from '../diagnostics/errors';
-
-export type FileStat = {
-	path: string;
-	size: number;
-	mtime: number;
-	isFile(): boolean;
-	isDirectory(): boolean;
-};
-
-export type MkdirOptions = {
-	/** iOS only. Set at creation so nothing beneath it is ever backed up. */
-	NSURLIsExcludedFromBackupKey?: boolean;
-};
-
-/**
- * Only what the package actually uses. The peer's upload and download
- * helpers are deliberately absent from this type: the package must never
- * make a network request (FR-084, SC-016), and a surface that cannot express
- * one is a stronger guarantee than a rule that says not to.
- */
-export type FileSystem = {
-	DocumentDirectoryPath: string;
-	mkdir(path: string, options?: MkdirOptions): Promise<void>;
-	writeFile(path: string, contents: string, encoding?: string): Promise<void>;
-	appendFile(path: string, contents: string, encoding?: string): Promise<void>;
-	readFile(path: string, encoding?: string): Promise<string>;
-	/** Chunked read at an offset — what FR-107a's flat memory bound rests on. */
-	read(path: string, length: number, position: number, encoding?: string): Promise<string>;
-	stat(path: string): Promise<FileStat>;
-	readdir(path: string): Promise<string[]>;
-	unlink(path: string): Promise<void>;
-	exists(path: string): Promise<boolean>;
-};
-
-let override: FileSystem | null = null;
-let cached: FileSystem | null = null;
-
-/** Swap the peer. Tests and the demo app's in-memory mode only. */
-export function setFileSystem(module: FileSystem | null): void {
-	override = module;
-	cached = null;
-}
-
-export function fileSystem(): FileSystem {
-	if (override) {
-		return override;
-	}
-	if (!cached) {
-		try {
-			cached = require('@dr.pogodin/react-native-fs') as FileSystem;
-		} catch (error) {
-			raise(DiagnosticCodes.STORAGE_ACCESS, {
-				message: 'filesystem peer is not installed',
-				cause: error,
-			});
-		}
-	}
-	return cached!;
-}
-
-export async function pathExists(path: string): Promise<boolean> {
-	try {
-		return await fileSystem().exists(path);
-	} catch {
-		return false;
-	}
-}
-
-/** Remove a path, treating "already gone" as success (FR-062). */
-export async function removeIfPresent(path: string): Promise<boolean> {
-	try {
-		await fileSystem().unlink(path);
-		return true;
-	} catch {
-		return false;
-	}
-}
+/**
+ * The filesystem peer, behind one lazy accessor.
+ *
+ * Required lazily for the same reason the engine is: a consuming app that
+ * only ever runs the in-memory adapter in tests must not have to install a
+ * native module to import this package. Confining the require to `platform/`
+ * also keeps the native surface four directories wide, which is the layering
+ * rule the ESLint config enforces.
+ */
+
+import { DiagnosticCodes } from '../contract/errors';
+import { raise } from '../diagnostics/errors';
+
+export type FileStat = {
+	path: string;
+	size: number;
+	mtime: number;
+	isFile(): boolean;
+	isDirectory(): boolean;
+};
+
+export type MkdirOptions = {
+	/** iOS only. Set at creation so nothing beneath it is ever backed up. */
+	NSURLIsExcludedFromBackupKey?: boolean;
+};
+
+/**
+ * Only what the package actually uses. The peer's upload and download
+ * helpers are deliberately absent from this type: the package must never
+ * make a network request (FR-084, SC-016), and a surface that cannot express
+ * one is a stronger guarantee than a rule that says not to.
+ */
+export type FileSystem = {
+	DocumentDirectoryPath: string;
+	mkdir(path: string, options?: MkdirOptions): Promise<void>;
+	writeFile(path: string, contents: string, encoding?: string): Promise<void>;
+	appendFile(path: string, contents: string, encoding?: string): Promise<void>;
+	readFile(path: string, encoding?: string): Promise<string>;
+	/** Chunked read at an offset — what FR-107a's flat memory bound rests on. */
+	read(path: string, length: number, position: number, encoding?: string): Promise<string>;
+	stat(path: string): Promise<FileStat>;
+	readdir(path: string): Promise<string[]>;
+	unlink(path: string): Promise<void>;
+	exists(path: string): Promise<boolean>;
+};
+
+let override: FileSystem | null = null;
+let cached: FileSystem | null = null;
+
+/** Swap the peer. Tests and the demo app's in-memory mode only. */
+export function setFileSystem(module: FileSystem | null): void {
+	override = module;
+	cached = null;
+}
+
+export function fileSystem(): FileSystem {
+	if (override) {
+		return override;
+	}
+	if (!cached) {
+		try {
+			cached = require('@dr.pogodin/react-native-fs') as FileSystem;
+		} catch (error) {
+			raise(DiagnosticCodes.STORAGE_ACCESS, {
+				message: 'filesystem peer is not installed',
+				cause: error,
+			});
+		}
+	}
+	return cached!;
+}
+
+export async function pathExists(path: string): Promise<boolean> {
+	try {
+		return await fileSystem().exists(path);
+	} catch {
+		return false;
+	}
+}
+
+/** Remove a path, treating "already gone" as success (FR-062). */
+export async function removeIfPresent(path: string): Promise<boolean> {
+	try {
+		await fileSystem().unlink(path);
+		return true;
+	} catch {
+		return false;
+	}
+}