@octane-xplat/files 0.10.0 → 0.11.1

package/dist/web/files.js

@@ -0,0 +1,144 @@
+import { assertSafeFileName, concatBytes, exactBuffer, fileTooLarge, throwIfAborted } from "./file-bytes.js";
+import { desktopHost } from "@octane-xplat/platform/host/web";
+//#region src/files.web.ts
+var objectBlobs = /* @__PURE__ */ new Map();
+function mintObjectUrl(blob) {
+	const uri = URL.createObjectURL(blob);
+	objectBlobs.set(uri, blob);
+	return uri;
+}
+function chooseFiles(accept, multiple) {
+	return new Promise((resolve) => {
+		const input = document.createElement("input");
+		input.type = "file";
+		input.accept = accept;
+		input.multiple = multiple;
+		input.onchange = () => {
+			const refs = [];
+			for (const file of Array.from(input.files ?? [])) refs.push({
+				name: file.name,
+				uri: mintObjectUrl(file)
+			});
+			resolve(refs);
+		};
+		input.oncancel = () => resolve([]);
+		input.click();
+	});
+}
+async function fetchBytes(uri, opts) {
+	const response = await fetch(uri, { signal: opts?.signal });
+	if (!response.ok) throw new Error(`Unable to read file: ${uri}`);
+	if (opts?.maxBytes == null) return new Uint8Array(await response.arrayBuffer());
+	const reader = response.body?.getReader();
+	if (!reader) {
+		const bytes = new Uint8Array(await response.arrayBuffer());
+		if (bytes.byteLength > opts.maxBytes) throw fileTooLarge(uri, opts.maxBytes);
+		return bytes;
+	}
+	const chunks = [];
+	let total = 0;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			total += value.byteLength;
+			if (total > opts.maxBytes) {
+				await reader.cancel().catch(() => {});
+				throw fileTooLarge(uri, opts.maxBytes);
+			}
+			chunks.push(value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	return concatBytes(chunks, total);
+}
+var files = {
+	async pickMultiple(accept = "*/*", _opts) {
+		return chooseFiles(accept, true);
+	},
+	async pick(accept = "*/*", opts) {
+		const host = desktopHost();
+		if (host && await host.supports("files", "pick")) return host.files.pick(accept, { startingFolder: opts?.startingFolder });
+		return (await chooseFiles(accept, false))[0] ?? null;
+	},
+	async readText(ref) {
+		const host = desktopHost();
+		if (host && await host.supports("files", "readText")) {
+			const text = await host.files.readText(ref.uri);
+			if (text === null) throw new Error(`Unable to read host file: ${ref.uri}`);
+			return text;
+		}
+		return (await fetch(ref.uri)).text();
+	},
+	async readBytes(ref, opts) {
+		throwIfAborted(opts?.signal);
+		const blob = objectBlobs.get(ref.uri);
+		if (blob) {
+			if (opts?.maxBytes != null && blob.size > opts.maxBytes) throw fileTooLarge(ref.uri, opts.maxBytes);
+			const bytes = new Uint8Array(await blob.arrayBuffer());
+			throwIfAborted(opts?.signal);
+			return bytes;
+		}
+		return fetchBytes(ref.uri, opts);
+	},
+	/** Desktop hosts write the selected path; plain web starts a download. */
+	async writeText(name, text) {
+		assertSafeFileName(name);
+		const host = desktopHost();
+		if (host && await host.supports("files", "writeText")) {
+			const file = await host.files.writeText(name, text);
+			if (!file) throw new Error("Host file save was cancelled");
+			return file;
+		}
+		const uri = mintObjectUrl(new Blob([text], { type: "text/plain" }));
+		const a = document.createElement("a");
+		a.href = uri;
+		a.download = name;
+		a.click();
+		return {
+			name,
+			uri
+		};
+	},
+	/** The desktop host contract is text-only, so bytes always download. */
+	async writeBytes(name, bytes) {
+		assertSafeFileName(name);
+		const uri = mintObjectUrl(new Blob([exactBuffer(bytes)], { type: "application/octet-stream" }));
+		const a = document.createElement("a");
+		a.href = uri;
+		a.download = name;
+		a.click();
+		return {
+			name,
+			uri
+		};
+	},
+	async export(name, bytes, opts) {
+		assertSafeFileName(name);
+		const picker = window.showSaveFilePicker;
+		if (typeof picker !== "function") return "unavailable";
+		const extension = name.includes(".") ? `.${name.split(".").pop()}` : null;
+		const types = opts?.mimeType && extension ? [{ accept: { [opts.mimeType]: [extension] } }] : void 0;
+		try {
+			const writable = await (await picker.call(window, {
+				suggestedName: name,
+				types
+			})).createWritable();
+			await writable.write(bytes);
+			await writable.close();
+			return "saved";
+		} catch (error) {
+			if (error?.name === "AbortError") return "cancelled";
+			throw error;
+		}
+	},
+	release(ref) {
+		if (ref.uri.startsWith("blob:")) {
+			objectBlobs.delete(ref.uri);
+			URL.revokeObjectURL(ref.uri);
+		}
+	}
+};
+//#endregion
+export { files };

package/dist/web/index.js

@@ -0,0 +1,3 @@
+import { FileInput } from "./FileInput.js";
+import { files } from "./files.js";
+export { FileInput, files };

package/dist/web/octane-client-build.json

@@ -0,0 +1,8 @@
+{
+  "version": 1,
+  "buildId": "2929db87-50ff-4e14-869f-567470f2d2ad",
+  "mode": "production",
+  "capabilities": {
+    "independentHydration": false
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@octane-xplat/files",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "description": "Native + web file pick and read/write for Octane xplat — matching web + NativeScript implementations",
   "keywords": [
     "android",
@@ -22,6 +22,7 @@
     "directory": "packages/files"
   },
   "files": [
+    "dist",
     "src",
     "types"
   ],
@@ -32,24 +33,64 @@
         "types": "./types/index.macos.d.ts",
         "default": "./src/index.macos.ts"
       },
+      "linux": "./dist/linux/index.js",
       "types": "./types/index.d.ts",
-      "default": "./src/index.ts"
+      "web": "./dist/web/index.js",
+      "native": "./dist/native/index.js",
+      "default": "./dist/native/index.js"
     },
-    "./*": "./src/*"
+    "./*": {
+      "linux": "./dist/linux/*.js",
+      "types": "./src/*.ts",
+      "web": "./dist/web/*.js",
+      "native": "./dist/native/*.js",
+      "default": "./dist/native/*.js"
+    },
+    "./*.ts": {
+      "types": "./src/*.ts",
+      "default": "./dist/native/*.js"
+    },
+    "./*.web.ts": {
+      "types": "./src/*.web.ts",
+      "default": "./dist/web/*.js"
+    },
+    "./*.macos.ts": "./src/*.macos.ts",
+    "./*.linux.ts": {
+      "types": "./src/*.linux.ts",
+      "default": "./dist/linux/*.js"
+    },
+    "./*.tsrx": {
+      "types": "./src/*.tsrx",
+      "default": "./dist/native/*.js"
+    },
+    "./*.web.tsrx": {
+      "types": "./src/*.web.tsrx",
+      "default": "./dist/web/*.js"
+    },
+    "./*.macos.tsrx": "./src/*.macos.tsrx",
+    "./*.linux.tsrx": {
+      "types": "./src/*.linux.tsrx",
+      "default": "./dist/linux/*.js"
+    },
+    "./*.web": "./dist/web/*.js",
+    "./*.macos": "./src/*.macos.ts",
+    "./*.linux": "./dist/linux/*.js"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
     "@nativescript-community/ui-document-picker": "1.1.29",
-    "@octane-xplat/platform": "0.10.0"
+    "@octane-xplat/platform": "0.11.1"
   },
   "devDependencies": {
     "@nativescript-community/octane": "0.2.4",
     "@nativescript/core": "9.1.2",
-    "@nativescript/types": "9.0.0",
-    "@octane-xplat/ui": "0.10.0",
-    "octane": "0.6.3"
+    "@nativescript/types": "9.1.4",
+    "@octane-xplat/ui": "0.11.1",
+    "octane": "0.6.3",
+    "@octanejs/vite-plugin": "0.1.61",
+    "vite": "8.3.0"
   },
   "peerDependencies": {
     "@nativescript-community/octane": ">=0.2.1 <1",
@@ -72,6 +113,7 @@
     }
   },
   "scripts": {
-    "test:packed": "node tests/packed-consumer.mjs"
+    "test:packed": "node tests/packed-consumer.mjs",
+    "build": "vite build && vite build --mode native && vite build --mode linux && node ../../scripts/check-native-dist.mjs"
   }
 }

package/src/file-bytes.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest'
+import { assertSafeFileName, concatBytes, exactBuffer, throwIfAborted } from './file-bytes'
+
+describe('assertSafeFileName', () => {
+	it('accepts plain file names', () => {
+		for (const name of ['a.txt', 'report 1.pdf', 'x.y.z.bin', 'résumé.md']) {
+			expect(() => assertSafeFileName(name)).not.toThrow()
+		}
+	})
+
+	it('rejects empty, dot, and traversal names', () => {
+		for (const name of ['', '.', '..', '../x', 'a/b', 'a\\b', '..\\x', 'a\0b']) {
+			expect(() => assertSafeFileName(name)).toThrow(/Unsafe file name/)
+		}
+	})
+})
+
+describe('throwIfAborted', () => {
+	it('passes for live or absent signals', () => {
+		expect(() => throwIfAborted(undefined)).not.toThrow()
+		const controller = new AbortController()
+		expect(() => throwIfAborted(controller.signal)).not.toThrow()
+	})
+
+	it('throws AbortError for aborted signals', () => {
+		const controller = new AbortController()
+		controller.abort()
+		expect(() => throwIfAborted(controller.signal)).toThrowError(
+			expect.objectContaining({ name: 'AbortError' }),
+		)
+	})
+})
+
+describe('concatBytes / exactBuffer', () => {
+	it('concatenates chunks in order', () => {
+		const joined = concatBytes(
+			[new Uint8Array([1, 2]), new Uint8Array([3]), new Uint8Array([4, 5])],
+			5,
+		)
+
+		expect([...joined]).toEqual([1, 2, 3, 4, 5])
+	})
+
+	it('returns the buffer only when the view covers it', () => {
+		const buffer = new Uint8Array([9, 8, 7, 6]).buffer
+		expect(exactBuffer(new Uint8Array(buffer))).toBe(buffer)
+
+		const windowed = new Uint8Array(buffer, 1, 2)
+		const exact = exactBuffer(windowed)
+		expect(exact.byteLength).toBe(2)
+		expect([...new Uint8Array(exact)]).toEqual([8, 7])
+	})
+})

package/src/file-bytes.ts

@@ -0,0 +1,68 @@
+/**
+ * Shared helpers for the binary file primitives (readBytes/writeBytes/export).
+ * DOM-free so the native leaf can use it too.
+ */
+
+/** File names used for sandbox writes and export temp files must be bare
+ *  names, not paths — a `/`, `\`, or `..` segment escapes the sandbox. */
+export function assertSafeFileName(name: string): void {
+	if (
+		typeof name !== 'string' ||
+		name.length === 0 ||
+		name === '.' ||
+		name === '..' ||
+		name.includes('/') ||
+		name.includes('\\') ||
+		name.includes('\0')
+	) {
+		throw new Error(`Unsafe file name: ${JSON.stringify(name)}`)
+	}
+}
+
+export function fileTooLarge(name: string, maxBytes: number): Error {
+	return new Error(`${name}: file exceeds the ${maxBytes}-byte limit`)
+}
+
+/** Named rejection for a second `files.export` while one is in flight. */
+export function exportBusy(): Error {
+	const error = new Error('files.export: an export is already in progress')
+	error.name = 'ExportBusyError'
+	return error
+}
+
+export function throwIfAborted(signal: AbortSignal | undefined): void {
+	if (!signal?.aborted) {
+		return
+	}
+
+	const thrower = (signal as { throwIfAborted?: () => void }).throwIfAborted
+	if (typeof thrower === 'function') {
+		thrower.call(signal)
+	}
+
+	const error = new Error('The operation was aborted')
+	error.name = 'AbortError'
+	throw error
+}
+
+/** Concatenate Uint8Array chunks into one exact-length array. */
+export function concatBytes(chunks: Uint8Array[], total: number): Uint8Array {
+	const out = new Uint8Array(total)
+	let offset = 0
+	for (const chunk of chunks) {
+		out.set(chunk, offset)
+		offset += chunk.byteLength
+	}
+
+	return out
+}
+
+/** Return an ArrayBuffer covering exactly this view's byte range — native
+ *  marshallers treat the argument as the whole buffer. */
+export function exactBuffer(bytes: Uint8Array): ArrayBuffer {
+	if (bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) {
+		return bytes.buffer as ArrayBuffer
+	}
+
+	return bytes.slice().buffer as ArrayBuffer
+}