bleam 0.0.6 → 0.0.8

package/dist/{config-ClDGHNb3.d.ts → config-Cms0rvqg.d.ts}

@@ -12,6 +12,7 @@ interface BleamConfig {
   version?: string;
   buildNumber?: string;
   bundleIdentifier?: string;
+  appGroups?: string[];
   teamId?: string;
   appearance?: BleamAppearance;
 }

package/dist/{config-D3gPaVMb.d.cts → config-CufOVJV3.d.cts}

@@ -12,6 +12,7 @@ interface BleamConfig {
   version?: string;
   buildNumber?: string;
   bundleIdentifier?: string;
+  appGroups?: string[];
   teamId?: string;
   appearance?: BleamAppearance;
 }

package/dist/config.d.cts

@@ -1,2 +1,2 @@
-import { a as HexColor, c as defineConfig, i as BleamUserInterfaceStyle, n as BleamConfig, o as appConfig, r as BleamInternalExpoConfig, s as createExpoConfig, t as BleamAppearance } from "./config-D3gPaVMb.cjs";
+import { a as HexColor, c as defineConfig, i as BleamUserInterfaceStyle, n as BleamConfig, o as appConfig, r as BleamInternalExpoConfig, s as createExpoConfig, t as BleamAppearance } from "./config-CufOVJV3.cjs";
 export { BleamAppearance, BleamConfig, BleamInternalExpoConfig, BleamUserInterfaceStyle, HexColor, appConfig, createExpoConfig, defineConfig };

package/dist/config.d.ts

@@ -1,2 +1,2 @@
-import { a as HexColor, c as defineConfig, i as BleamUserInterfaceStyle, n as BleamConfig, o as appConfig, r as BleamInternalExpoConfig, s as createExpoConfig, t as BleamAppearance } from "./config-ClDGHNb3.js";
+import { a as HexColor, c as defineConfig, i as BleamUserInterfaceStyle, n as BleamConfig, o as appConfig, r as BleamInternalExpoConfig, s as createExpoConfig, t as BleamAppearance } from "./config-Cms0rvqg.js";
 export { BleamAppearance, BleamConfig, BleamInternalExpoConfig, BleamUserInterfaceStyle, HexColor, appConfig, createExpoConfig, defineConfig };

package/dist/crypto.d.cts

@@ -1,5 +1,3 @@
-import "./native-runtime-CbPzrs8j.cjs";
-
 //#region src/crypto.d.ts
 interface BleamCrypto {
   randomUUID(): string;

package/dist/crypto.d.ts

@@ -1,4 +1,4 @@
-import "./native-runtime-DxHSrsTX.js";
+import "@nativescript/react-native";
 
 //#region src/crypto.d.ts
 interface BleamCrypto {

package/dist/dev-protocol.d.cts

@@ -10,7 +10,20 @@ interface BleamManifest {
   dev: boolean;
 }
 declare const BLEAM_MANIFEST_PATH = "/bleam/manifest.json";
+type BleamDevLogLevel = 'debug' | 'info' | 'warn' | 'error';
+type BleamDevLogSource = 'cli' | 'metro' | 'runtime' | 'js' | 'native' | 'xpc';
+interface BleamDevLogEvent {
+  type: 'log';
+  id: string;
+  time: string;
+  source: BleamDevLogSource;
+  level: BleamDevLogLevel;
+  category?: string;
+  message: string;
+  details?: unknown;
+  jobId?: string;
+}
 declare function createBleamDevBundleUrl(origin: string): string;
 declare function isBleamManifest(value: unknown): value is BleamManifest;
 //#endregion
-export { BLEAM_MANIFEST_PATH, BleamManifest, BleamPlatform, createBleamDevBundleUrl, isBleamManifest };
+export { BLEAM_MANIFEST_PATH, BleamDevLogEvent, BleamDevLogLevel, BleamDevLogSource, BleamManifest, BleamPlatform, createBleamDevBundleUrl, isBleamManifest };

package/dist/dev-protocol.d.ts

@@ -10,7 +10,20 @@ interface BleamManifest {
   dev: boolean;
 }
 declare const BLEAM_MANIFEST_PATH = "/bleam/manifest.json";
+type BleamDevLogLevel = 'debug' | 'info' | 'warn' | 'error';
+type BleamDevLogSource = 'cli' | 'metro' | 'runtime' | 'js' | 'native' | 'xpc';
+interface BleamDevLogEvent {
+  type: 'log';
+  id: string;
+  time: string;
+  source: BleamDevLogSource;
+  level: BleamDevLogLevel;
+  category?: string;
+  message: string;
+  details?: unknown;
+  jobId?: string;
+}
 declare function createBleamDevBundleUrl(origin: string): string;
 declare function isBleamManifest(value: unknown): value is BleamManifest;
 //#endregion
-export { BLEAM_MANIFEST_PATH, BleamManifest, BleamPlatform, createBleamDevBundleUrl, isBleamManifest };
+export { BLEAM_MANIFEST_PATH, BleamDevLogEvent, BleamDevLogLevel, BleamDevLogSource, BleamManifest, BleamPlatform, createBleamDevBundleUrl, isBleamManifest };

package/dist/files-Bo7h9fik.cjs

@@ -0,0 +1,468 @@
+const require_native_runtime = require('./native-runtime-CsXnXkQn.cjs');
+
+//#region src/native-files.ts
+const downloads = /* @__PURE__ */ new Map();
+let session;
+let sessionDelegate;
+let downloadRetainer;
+function settlePicker(callback) {
+	setTimeout(callback, 0);
+}
+function retainer() {
+	downloadRetainer ??= require_native_runtime.ensureNativeScript().createRetainer();
+	return downloadRetainer;
+}
+function fileUri$1(path) {
+	return path.startsWith("file://") ? path : `file://${path}`;
+}
+function nsString(value) {
+	return NSString.stringWithString(value);
+}
+function fileManager() {
+	require_native_runtime.ensureNativeScript();
+	return NSFileManager.defaultManager;
+}
+function ensureDirectory(path) {
+	fileManager().createDirectoryAtPathWithIntermediateDirectoriesAttributesError(path, true, null, null);
+}
+function parentDirectory(path) {
+	return nsString(path).stringByDeletingLastPathComponent;
+}
+function appGroupIdentifier() {
+	return String(NSBundle.mainBundle.objectForInfoDictionaryKey("AppGroupIdentifier") ?? "group.dev.bleam.app");
+}
+function containerPath() {
+	const url = fileManager().containerURLForSecurityApplicationGroupIdentifier(appGroupIdentifier());
+	if (!url?.path) throw new Error("Shared container is unavailable");
+	return String(url.path);
+}
+function searchPath(directory) {
+	const value = NSSearchPathForDirectoriesInDomains(directory, NSSearchPathDomainMask.UserDomain, true)?.objectAtIndex(0);
+	if (typeof value !== "string") throw new Error("Native directory unavailable");
+	return value;
+}
+function nativeDirectories() {
+	const shared = containerPath();
+	return {
+		cache: searchPath(NSSearchPathDirectory.Caches),
+		documents: searchPath(NSSearchPathDirectory.Document),
+		models: nsString(shared).stringByAppendingPathComponent("Models"),
+		shared,
+		temporary: NSTemporaryDirectory()
+	};
+}
+function nativeStat(path) {
+	if (!fileManager().fileExistsAtPath(path)) return {
+		exists: false,
+		type: "missing",
+		path,
+		uri: fileUri$1(path)
+	};
+	const attributes = fileManager().attributesOfItemAtPathError(path, null);
+	const size = Number(attributes?.objectForKey(NSFileSize) ?? void 0);
+	const createdAt = attributes?.objectForKey(NSFileCreationDate);
+	const modifiedAt = attributes?.objectForKey(NSFileModificationDate);
+	return {
+		exists: true,
+		type: attributes?.objectForKey(NSFileType) === NSFileTypeDirectory ? "directory" : "file",
+		path,
+		uri: fileUri$1(path),
+		size: Number.isFinite(size) ? size : void 0,
+		createdAt: createdAt ? createdAt.timeIntervalSince1970 * 1e3 : void 0,
+		modifiedAt: modifiedAt ? modifiedAt.timeIntervalSince1970 * 1e3 : void 0
+	};
+}
+async function nativeMkdir(path, recursive) {
+	fileManager().createDirectoryAtPathWithIntermediateDirectoriesAttributesError(path, recursive, null, null);
+}
+async function nativeRemove(path, recursive) {
+	const stat = nativeStat(path);
+	if (!stat.exists) return;
+	if (stat.type === "directory" && !recursive) {
+		const items = fileManager().contentsOfDirectoryAtPathError(path, null);
+		if (Number(items?.count ?? 0) > 0) throw new Error(`Directory is not empty: ${path}`);
+	}
+	fileManager().removeItemAtPathError(path, null);
+}
+async function nativeReadText(path) {
+	return String(NSString.stringWithContentsOfFileEncodingError(path, NSUTF8StringEncoding, null));
+}
+async function nativeWriteText(path, contents, atomic) {
+	ensureDirectory(parentDirectory(path));
+	if (!nsString(contents).writeToFileAtomicallyEncodingError(path, atomic, NSUTF8StringEncoding, null)) throw new Error(`Failed to write file: ${path}`);
+}
+function taskId(task) {
+	return Number(task.taskIdentifier);
+}
+function downloadSession() {
+	if (session) return session;
+	sessionDelegate = require_native_runtime.ensureNativeScript().createDelegate("NSURLSessionDataDelegate", {
+		URLSessionDataTaskDidReceiveResponseCompletionHandler(_session, task, response, completion) {
+			const state = downloads.get(taskId(task));
+			if (!state) {
+				completion(NSURLSessionResponseDisposition.Cancel);
+				return;
+			}
+			const http = response;
+			if (http.statusCode && (http.statusCode < 200 || http.statusCode >= 300)) {
+				completion(NSURLSessionResponseDisposition.Cancel);
+				state.output.close();
+				retainer().release(state.output);
+				state.reject(/* @__PURE__ */ new Error(`Download failed: HTTP ${http.statusCode}`));
+				downloads.delete(taskId(task));
+				return;
+			}
+			state.output.open();
+			completion(NSURLSessionResponseDisposition.Allow);
+		},
+		URLSessionDataTaskDidReceiveData(_session, task, data) {
+			const state = downloads.get(taskId(task));
+			if (!state) return;
+			const bytes = data.bytes;
+			const written = state.output.writeMaxLength(bytes, data.length);
+			if (written < 0) {
+				task.cancel();
+				state.output.close();
+				retainer().release(state.output);
+				state.reject(/* @__PURE__ */ new Error(`Failed to write download: ${state.path}`));
+				downloads.delete(taskId(task));
+				return;
+			}
+			state.writtenBytes += written;
+			state.onProgress?.({
+				id: state.id,
+				path: state.path,
+				bytesWritten: state.writtenBytes,
+				totalBytes: state.expectedBytes
+			});
+		},
+		URLSessionTaskDidCompleteWithError(_session, task, error) {
+			const state = downloads.get(taskId(task));
+			if (!state) return;
+			downloads.delete(taskId(task));
+			state.output.close();
+			retainer().release(state.output);
+			if (error) {
+				state.reject(error);
+				return;
+			}
+			if (state.expectedBytes !== void 0 && state.writtenBytes !== state.expectedBytes) {
+				state.reject(/* @__PURE__ */ new Error(`Downloaded ${state.writtenBytes} bytes, expected ${state.expectedBytes}`));
+				return;
+			}
+			if (!state.temporaryPath || state.temporaryPath === state.path) {
+				state.resolve(nativeStat(state.path));
+				return;
+			}
+			fileManager().removeItemAtPathError(state.path, null);
+			if (!fileManager().moveItemAtPathToPathError(state.temporaryPath, state.path, null)) {
+				state.reject(/* @__PURE__ */ new Error(`Failed to move download into place: ${state.path}`));
+				return;
+			}
+			state.resolve(nativeStat(state.path));
+		}
+	}, { retainer: retainer() });
+	const configuration = NSURLSessionConfiguration.defaultSessionConfiguration;
+	session = NSURLSession.sessionWithConfigurationDelegateDelegateQueue(configuration, sessionDelegate, null);
+	return session;
+}
+function nativeCancelDownload(id) {
+	for (const state of downloads.values()) if (state.id === id) state.task?.cancel();
+}
+async function nativeDownload(request) {
+	ensureDirectory(parentDirectory(request.destination));
+	const url = NSURL.URLWithString(request.url);
+	if (!url) throw new Error(`Invalid download URL: ${request.url}`);
+	const temporaryPath = request.atomic ? `${request.destination}.download-${request.id}` : request.destination;
+	fileManager().removeItemAtPathError(temporaryPath, null);
+	const output = NSOutputStream.outputStreamToFileAtPathAppend(temporaryPath, false);
+	if (!output) throw new Error(`Failed to create output stream: ${temporaryPath}`);
+	retainer().retain(output);
+	const nativeRequest = NSMutableURLRequest.requestWithURL(url);
+	for (const [key, value] of Object.entries(request.headers ?? {})) nativeRequest.setValueForHTTPHeaderField(value, key);
+	return new Promise((resolve, reject) => {
+		const task = downloadSession().dataTaskWithRequest(nativeRequest);
+		const state = {
+			id: request.id,
+			path: request.destination,
+			temporaryPath,
+			expectedBytes: request.expectedBytes,
+			writtenBytes: 0,
+			output,
+			task,
+			resolve,
+			reject,
+			onProgress: request.onProgress
+		};
+		downloads.set(taskId(task), state);
+		task.resume();
+	});
+}
+function topVisibleViewController(root = UIApplication.sharedApplication.keyWindow?.rootViewController) {
+	let current = root ?? null;
+	while (current?.presentedViewController) current = current.presentedViewController;
+	const selected = current?.selectedViewController;
+	if (selected) return topVisibleViewController(selected);
+	const visible = current?.visibleViewController;
+	if (visible) return topVisibleViewController(visible);
+	return current;
+}
+function copyPickedFile(url, destination) {
+	ensureDirectory(destination);
+	const name = String(url.lastPathComponent ?? `picked-${Date.now()}`);
+	const target = nsString(destination).stringByAppendingPathComponent(name);
+	fileManager().removeItemAtPathError(target, null);
+	if (!fileManager().copyItemAtURLToURLError(url, NSURL.fileURLWithPath(target), null)) throw new Error(`Failed to copy picked file: ${name}`);
+	return nativeStat(target);
+}
+async function nativePick(request) {
+	return new Promise((resolve, reject) => {
+		require_native_runtime.ensureNativeScript().runOnUI(() => {
+			const pickerTypes = request.type === "image" ? ["public.image"] : ["public.item"];
+			const picker = UIDocumentPickerViewController.alloc().initWithDocumentTypesInMode(pickerTypes, UIDocumentPickerMode.Import);
+			picker.allowsMultipleSelection = request.multiple;
+			require_native_runtime.ensureNativeScript().createDelegate("UIDocumentPickerDelegate", {
+				documentPickerDidPickDocumentsAtURLs(controller, urls) {
+					try {
+						const values = [];
+						const count = Number(urls.count ?? 0);
+						for (let index = 0; index < count; index += 1) values.push(copyPickedFile(urls.objectAtIndex(index), request.destination));
+						controller.dismissViewControllerAnimatedCompletion(true, () => null);
+						settlePicker(() => resolve(values));
+					} catch (error) {
+						settlePicker(() => reject(error));
+					}
+				},
+				documentPickerWasCancelled(controller) {
+					controller.dismissViewControllerAnimatedCompletion(true, () => null);
+					settlePicker(() => resolve([]));
+				}
+			}, { assignTo: {
+				object: picker,
+				property: "delegate"
+			} });
+			const presenter = topVisibleViewController();
+			if (!presenter) {
+				settlePicker(() => reject(/* @__PURE__ */ new Error("No view controller available for file picker")));
+				return;
+			}
+			presenter.presentViewControllerAnimatedCompletion(picker, true, () => null);
+		});
+	});
+}
+
+//#endregion
+//#region src/files.ts
+const paths = {
+	get cache() {
+		return nativeDirectories().cache;
+	},
+	get documents() {
+		return nativeDirectories().documents;
+	},
+	get models() {
+		return nativeDirectories().models;
+	},
+	get shared() {
+		return nativeDirectories().shared;
+	},
+	get temporary() {
+		return nativeDirectories().temporary;
+	}
+};
+let directoryPromise;
+async function directories() {
+	directoryPromise ??= Promise.resolve(nativeDirectories());
+	return directoryPromise;
+}
+function joinPath(...parts) {
+	const [first, ...rest] = parts.map((part) => typeof part === "string" ? part : part.path);
+	if (!first) throw new Error("Expected path");
+	return rest.reduce((path, part) => {
+		const next = part.replace(/^\/+/, "");
+		if (!next) return path;
+		return `${path.replace(/\/+$/, "")}/${next}`;
+	}, first);
+}
+function fileUri(path) {
+	return path.startsWith("file://") ? path : `file://${path}`;
+}
+function downloadId() {
+	return `download-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+function statFromNative(value) {
+	if (!value || typeof value !== "object") throw new Error("Invalid native file stat");
+	const record = value;
+	const path = stringValue(record.path, "path");
+	const type = stringValue(record.type, "type");
+	if (type !== "file" && type !== "directory" && type !== "missing") throw new Error(`Invalid native file type: ${type}`);
+	return {
+		exists: Boolean(record.exists),
+		type,
+		path,
+		uri: stringValue(record.uri, "uri"),
+		size: optionalNumber(record.size),
+		createdAt: optionalNumber(record.createdAt),
+		modifiedAt: optionalNumber(record.modifiedAt)
+	};
+}
+function stringValue(value, name) {
+	if (typeof value !== "string") throw new Error(`Expected ${name}`);
+	return value;
+}
+function optionalNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function progressFromNative(value) {
+	const totalBytes = optionalNumber(value.totalBytes);
+	return {
+		id: value.id,
+		path: value.path,
+		bytesWritten: value.bytesWritten,
+		totalBytes,
+		fraction: totalBytes && totalBytes > 0 ? value.bytesWritten / totalBytes : void 0
+	};
+}
+function pickDestinationPath(destination) {
+	return typeof destination === "string" ? destination : destination.path;
+}
+function pickedFilesFromNative(value) {
+	if (!Array.isArray(value)) throw new Error("Invalid native pick result");
+	return value.map((item) => {
+		return new FileRef(statFromNative(item).path);
+	});
+}
+var FileRef = class {
+	uri;
+	constructor(path) {
+		this.path = path;
+		this.uri = fileUri(path);
+	}
+	async exists() {
+		return (await this.stat()).type === "file";
+	}
+	async stat() {
+		return statFromNative(nativeStat(this.path));
+	}
+	async text() {
+		const value = await nativeReadText(this.path);
+		if (typeof value !== "string") throw new Error("Expected native file text");
+		return value;
+	}
+	async json() {
+		return JSON.parse(await this.text());
+	}
+	async write(contents, options = {}) {
+		await nativeWriteText(this.path, contents, options.atomic ?? true);
+	}
+	async delete() {
+		await nativeRemove(this.path, false);
+	}
+	download(url, options = {}) {
+		return new DownloadTask(url, this.path, options);
+	}
+};
+var DirectoryRef = class DirectoryRef {
+	uri;
+	constructor(path) {
+		this.path = path;
+		this.uri = fileUri(path);
+	}
+	file(...parts) {
+		return new FileRef(joinPath(this.path, ...parts));
+	}
+	directory(...parts) {
+		return new DirectoryRef(joinPath(this.path, ...parts));
+	}
+	async exists() {
+		return (await this.stat()).type === "directory";
+	}
+	async stat() {
+		return statFromNative(nativeStat(this.path));
+	}
+	async create(options = {}) {
+		await nativeMkdir(this.path, options.recursive ?? true);
+	}
+	async delete(options = {}) {
+		await nativeRemove(this.path, options.recursive ?? true);
+	}
+};
+var DownloadTask = class {
+	id;
+	result;
+	onAbort = () => {
+		this.cancel();
+	};
+	constructor(url, destination, options = {}) {
+		this.url = url;
+		this.destination = destination;
+		this.options = options;
+		this.id = options.id ?? downloadId();
+		options.signal?.addEventListener("abort", this.onAbort, { once: true });
+		this.result = this.start().finally(() => {
+			options.signal?.removeEventListener("abort", this.onAbort);
+		});
+	}
+	async cancel() {
+		nativeCancelDownload(this.id);
+	}
+	async start() {
+		return new FileRef(statFromNative(await nativeDownload({
+			id: this.id,
+			url: this.url,
+			destination: this.destination,
+			headers: this.options.headers,
+			expectedBytes: this.options.expectedBytes,
+			atomic: this.options.atomic ?? true,
+			resume: this.options.resume ?? true,
+			onProgress: (event) => {
+				if (event.id === this.id) this.options.onProgress?.(progressFromNative(event));
+			}
+		})).path);
+	}
+};
+const files = {
+	paths,
+	async directories() {
+		return directories();
+	},
+	async pick(options) {
+		return pickedFilesFromNative(await nativePick({
+			type: options.type ?? "any",
+			multiple: options.multiple ?? false,
+			destination: pickDestinationPath(options.destination)
+		}));
+	},
+	file(...parts) {
+		return new FileRef(joinPath(...parts));
+	},
+	directory(...parts) {
+		return new DirectoryRef(joinPath(...parts));
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'DirectoryRef', {
+  enumerable: true,
+  get: function () {
+    return DirectoryRef;
+  }
+});
+Object.defineProperty(exports, 'DownloadTask', {
+  enumerable: true,
+  get: function () {
+    return DownloadTask;
+  }
+});
+Object.defineProperty(exports, 'FileRef', {
+  enumerable: true,
+  get: function () {
+    return FileRef;
+  }
+});
+Object.defineProperty(exports, 'files', {
+  enumerable: true,
+  get: function () {
+    return files;
+  }
+});