bleam 0.0.6 → 0.0.8

package/dist/files-Ds1wT8C2.js

@@ -0,0 +1,445 @@
+import { t as ensureNativeScript } from "./native-runtime-C85Nuc4F.js";
+
+//#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 ??= ensureNativeScript().createRetainer();
+	return downloadRetainer;
+}
+function fileUri$1(path) {
+	return path.startsWith("file://") ? path : `file://${path}`;
+}
+function nsString(value) {
+	return NSString.stringWithString(value);
+}
+function fileManager() {
+	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 = 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) => {
+		ensureNativeScript().runOnUI(() => {
+			const pickerTypes = request.type === "image" ? ["public.image"] : ["public.item"];
+			const picker = UIDocumentPickerViewController.alloc().initWithDocumentTypesInMode(pickerTypes, UIDocumentPickerMode.Import);
+			picker.allowsMultipleSelection = request.multiple;
+			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
+export { files as i, DownloadTask as n, FileRef as r, DirectoryRef as t };

package/dist/files-DwA7pzr3.d.cts

@@ -0,0 +1,99 @@
+//#region src/files.d.ts
+type NativeDirectories = {
+  cache: string;
+  documents: string;
+  models: string;
+  shared: string;
+  temporary: string;
+};
+type FileType = 'file' | 'directory' | 'missing';
+type FileStat = {
+  exists: boolean;
+  type: FileType;
+  path: string;
+  uri: string;
+  size?: number;
+  createdAt?: number;
+  modifiedAt?: number;
+};
+type DownloadProgress = {
+  id: string;
+  path: string;
+  bytesWritten: number;
+  totalBytes?: number;
+  fraction?: number;
+};
+type DownloadOptions = {
+  id?: string;
+  headers?: Record<string, string>;
+  expectedBytes?: number;
+  atomic?: boolean;
+  resume?: boolean;
+  signal?: AbortSignal;
+  onProgress?: (progress: DownloadProgress) => void;
+};
+type PickFileType = 'any' | 'image';
+type PickOptions = {
+  type?: PickFileType;
+  multiple?: boolean;
+  destination: string | DirectoryRef;
+};
+type CreateDirectoryOptions = {
+  recursive?: boolean;
+};
+type RemoveOptions = {
+  recursive?: boolean;
+};
+type WriteOptions = {
+  atomic?: boolean;
+};
+type FilePaths = {
+  readonly cache: string;
+  readonly documents: string;
+  readonly models: string;
+  readonly shared: string;
+  readonly temporary: string;
+};
+declare class FileRef {
+  readonly path: string;
+  readonly uri: string;
+  constructor(path: string);
+  exists(): Promise<boolean>;
+  stat(): Promise<FileStat>;
+  text(): Promise<string>;
+  json<T = unknown>(): Promise<T>;
+  write(contents: string, options?: WriteOptions): Promise<void>;
+  delete(): Promise<void>;
+  download(url: string, options?: DownloadOptions): DownloadTask;
+}
+declare class DirectoryRef {
+  readonly path: string;
+  readonly uri: string;
+  constructor(path: string);
+  file(...parts: string[]): FileRef;
+  directory(...parts: string[]): DirectoryRef;
+  exists(): Promise<boolean>;
+  stat(): Promise<FileStat>;
+  create(options?: CreateDirectoryOptions): Promise<void>;
+  delete(options?: RemoveOptions): Promise<void>;
+}
+declare class DownloadTask {
+  readonly url: string;
+  readonly destination: string;
+  readonly options: DownloadOptions;
+  readonly id: string;
+  readonly result: Promise<FileRef>;
+  private readonly onAbort;
+  constructor(url: string, destination: string, options?: DownloadOptions);
+  cancel(): Promise<void>;
+  private start;
+}
+declare const files: {
+  paths: FilePaths;
+  directories(): Promise<NativeDirectories>;
+  pick(options: PickOptions): Promise<FileRef[]>;
+  file(...parts: Array<string | DirectoryRef>): FileRef;
+  directory(...parts: Array<string | DirectoryRef>): DirectoryRef;
+};
+//#endregion
+export { DownloadTask as a, FileStat as c, PickOptions as d, RemoveOptions as f, DownloadProgress as i, FileType as l, files as m, DirectoryRef as n, FilePaths as o, WriteOptions as p, DownloadOptions as r, FileRef as s, CreateDirectoryOptions as t, PickFileType as u };

package/dist/files-VrkQlKIT.d.ts

@@ -0,0 +1,99 @@
+//#region src/files.d.ts
+type NativeDirectories = {
+  cache: string;
+  documents: string;
+  models: string;
+  shared: string;
+  temporary: string;
+};
+type FileType = 'file' | 'directory' | 'missing';
+type FileStat = {
+  exists: boolean;
+  type: FileType;
+  path: string;
+  uri: string;
+  size?: number;
+  createdAt?: number;
+  modifiedAt?: number;
+};
+type DownloadProgress = {
+  id: string;
+  path: string;
+  bytesWritten: number;
+  totalBytes?: number;
+  fraction?: number;
+};
+type DownloadOptions = {
+  id?: string;
+  headers?: Record<string, string>;
+  expectedBytes?: number;
+  atomic?: boolean;
+  resume?: boolean;
+  signal?: AbortSignal;
+  onProgress?: (progress: DownloadProgress) => void;
+};
+type PickFileType = 'any' | 'image';
+type PickOptions = {
+  type?: PickFileType;
+  multiple?: boolean;
+  destination: string | DirectoryRef;
+};
+type CreateDirectoryOptions = {
+  recursive?: boolean;
+};
+type RemoveOptions = {
+  recursive?: boolean;
+};
+type WriteOptions = {
+  atomic?: boolean;
+};
+type FilePaths = {
+  readonly cache: string;
+  readonly documents: string;
+  readonly models: string;
+  readonly shared: string;
+  readonly temporary: string;
+};
+declare class FileRef {
+  readonly path: string;
+  readonly uri: string;
+  constructor(path: string);
+  exists(): Promise<boolean>;
+  stat(): Promise<FileStat>;
+  text(): Promise<string>;
+  json<T = unknown>(): Promise<T>;
+  write(contents: string, options?: WriteOptions): Promise<void>;
+  delete(): Promise<void>;
+  download(url: string, options?: DownloadOptions): DownloadTask;
+}
+declare class DirectoryRef {
+  readonly path: string;
+  readonly uri: string;
+  constructor(path: string);
+  file(...parts: string[]): FileRef;
+  directory(...parts: string[]): DirectoryRef;
+  exists(): Promise<boolean>;
+  stat(): Promise<FileStat>;
+  create(options?: CreateDirectoryOptions): Promise<void>;
+  delete(options?: RemoveOptions): Promise<void>;
+}
+declare class DownloadTask {
+  readonly url: string;
+  readonly destination: string;
+  readonly options: DownloadOptions;
+  readonly id: string;
+  readonly result: Promise<FileRef>;
+  private readonly onAbort;
+  constructor(url: string, destination: string, options?: DownloadOptions);
+  cancel(): Promise<void>;
+  private start;
+}
+declare const files: {
+  paths: FilePaths;
+  directories(): Promise<NativeDirectories>;
+  pick(options: PickOptions): Promise<FileRef[]>;
+  file(...parts: Array<string | DirectoryRef>): FileRef;
+  directory(...parts: Array<string | DirectoryRef>): DirectoryRef;
+};
+//#endregion
+export { DownloadTask as a, FileStat as c, PickOptions as d, RemoveOptions as f, DownloadProgress as i, FileType as l, files as m, DirectoryRef as n, FilePaths as o, WriteOptions as p, DownloadOptions as r, FileRef as s, CreateDirectoryOptions as t, PickFileType as u };

package/dist/files.cjs

@@ -0,0 +1,7 @@
+require('./native-runtime-CsXnXkQn.cjs');
+const require_files = require('./files-Bo7h9fik.cjs');
+
+exports.DirectoryRef = require_files.DirectoryRef;
+exports.DownloadTask = require_files.DownloadTask;
+exports.FileRef = require_files.FileRef;
+exports.files = require_files.files;

package/dist/files.d.cts

@@ -0,0 +1,2 @@
+import { a as DownloadTask, c as FileStat, d as PickOptions, f as RemoveOptions, i as DownloadProgress, l as FileType, m as files, n as DirectoryRef, o as FilePaths, p as WriteOptions, r as DownloadOptions, s as FileRef, t as CreateDirectoryOptions, u as PickFileType } from "./files-DwA7pzr3.cjs";
+export { CreateDirectoryOptions, DirectoryRef, DownloadOptions, DownloadProgress, DownloadTask, FilePaths, FileRef, FileStat, FileType, PickFileType, PickOptions, RemoveOptions, WriteOptions, files };

package/dist/files.d.ts

@@ -0,0 +1,2 @@
+import { a as DownloadTask, c as FileStat, d as PickOptions, f as RemoveOptions, i as DownloadProgress, l as FileType, m as files, n as DirectoryRef, o as FilePaths, p as WriteOptions, r as DownloadOptions, s as FileRef, t as CreateDirectoryOptions, u as PickFileType } from "./files-VrkQlKIT.js";
+export { CreateDirectoryOptions, DirectoryRef, DownloadOptions, DownloadProgress, DownloadTask, FilePaths, FileRef, FileStat, FileType, PickFileType, PickOptions, RemoveOptions, WriteOptions, files };

package/dist/files.js

@@ -0,0 +1,4 @@
+import "./native-runtime-C85Nuc4F.js";
+import { i as files, n as DownloadTask, r as FileRef, t as DirectoryRef } from "./files-Ds1wT8C2.js";
+
+export { DirectoryRef, DownloadTask, FileRef, files };

package/dist/index.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/index.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 };