one/dist/esm/platform/file-system/opfs.native.js

One is a React framework for web, iOS, and Android apps.

function _async_iterator(iterable) {
	var method, async, sync, retry = 2;
	for ("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;) {
		if (async && null != (method = iterable[async])) return method.call(iterable);
		if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable));
		async = "@@asyncIterator", sync = "@@iterator";
	}
	throw new TypeError("Object is not async iterable");
}
function AsyncFromSyncIterator(s) {
	function AsyncFromSyncIteratorContinuation(r) {
		if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object."));
		var done = r.done;
		return Promise.resolve(r.value).then(function(value) {
			return {
				value,
				done
			};
		});
	}
	return AsyncFromSyncIterator = function(s2) {
		this.s = s2, this.n = s2.next;
	}, AsyncFromSyncIterator.prototype = {
		s: null,
		n: null,
		next: function() {
			return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
		},
		return: function(value) {
			var ret = this.s.return;
			return void 0 === ret ? Promise.resolve({
				value,
				done: true
			}) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));
		},
		throw: function(value) {
			var thr = this.s.return;
			return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));
		}
	}, new AsyncFromSyncIterator(s);
}
var folders = [
	"documents",
	"cache",
	"applicationSupport",
	"temporary"
];
var directories = Object.fromEntries(folders.map(function(name) {
	return [name, `opfs://one/${name}/`];
}));
function parts(uri) {
	var url = new URL(uri);
	if (url.protocol !== "opfs:" || url.host !== "one" || url.search || url.hash) {
		throw new Error("FileSystem: expected an opfs://one/ URI");
	}
	var names = url.pathname.split("/").filter(Boolean).map(decodeURIComponent);
	if (!folders.includes(names[0]) || names.some(function(name) {
		return name === "." || name === ".." || /[/\\\0]/.test(name);
	})) {
		throw new Error("FileSystem: invalid path");
	}
	return names;
}
async function root() {
	var _navigator_storage;
	if (!((_navigator_storage = navigator.storage) === null || _navigator_storage === void 0 ? void 0 : _navigator_storage.getDirectory)) throw new Error("FileSystem: Origin Private File System is unavailable");
	var handle = await navigator.storage.getDirectory();
	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
	try {
		for (var _iterator = folders[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
			var name = _step.value;
			await handle.getDirectoryHandle(name, { create: true });
		}
	} catch (err) {
		_didIteratorError = true;
		_iteratorError = err;
	} finally {
		try {
			if (!_iteratorNormalCompletion && _iterator.return != null) {
				_iterator.return();
			}
		} finally {
			if (_didIteratorError) {
				throw _iteratorError;
			}
		}
	}
	return handle;
}
async function parent(names) {
	var create = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
	var handle = await root();
	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
	try {
		for (var _iterator = names.slice(0, -1)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
			var name = _step.value;
			handle = await handle.getDirectoryHandle(name, { create });
		}
	} catch (err) {
		_didIteratorError = true;
		_iteratorError = err;
	} finally {
		try {
			if (!_iteratorNormalCompletion && _iterator.return != null) {
				_iterator.return();
			}
		} finally {
			if (_didIteratorError) {
				throw _iteratorError;
			}
		}
	}
	return handle;
}
async function entry(names) {
	var handle = await parent(names);
	var name = names.at(-1);
	try {
		return await handle.getFileHandle(name);
	} catch (error) {
		if (error.name !== "TypeMismatchError") throw error;
		return handle.getDirectoryHandle(name);
	}
}
async function info(uri) {
	var names = parts(uri);
	try {
		var handle = await entry(names);
		if (handle.kind === "directory") return {
			uri,
			exists: true,
			isDirectory: true
		};
		var file = await handle.getFile();
		return {
			uri,
			exists: true,
			isDirectory: false,
			size: file.size,
			modifiedAt: file.lastModified
		};
	} catch (error) {
		if (error.name !== "NotFoundError") throw error;
		return {
			uri,
			exists: false,
			isDirectory: false
		};
	}
}
async function write(handle, data) {
	var writable = await handle.createWritable();
	try {
		await writable.write(data);
		await writable.close();
	} catch (error) {
		await writable.abort().catch(function() {});
		throw error;
	}
}
async function copyEntry(source, target, name) {
	if (source.kind === "file") {
		await write(await target.getFileHandle(name, { create: true }), await source.getFile());
	} else {
		var directory = await target.getDirectoryHandle(name, { create: true });
		{
			var _iteratorAbruptCompletion = false, _didIteratorError = false, _iteratorError, _return;
			try {
				var _iterator = _async_iterator(source.entries());
				if (_iterator === null || typeof _iterator !== "object" && typeof _iterator !== "function") throw new TypeError("Iterator result is not an object");
				for (var _next = _iterator.next, _step;; _iteratorAbruptCompletion = false) {
					_step = await Reflect.apply(_next, _iterator, []);
					if (_step === null || typeof _step !== "object" && typeof _step !== "function") throw new TypeError("Iterator result is not an object");
					_iteratorAbruptCompletion = !_step.done;
					if (!_iteratorAbruptCompletion) break;
					var _value = _step.value;
					var [childName, child] = _value;
					await copyEntry(child, directory, childName);
				}
			} catch (err) {
				_didIteratorError = true;
				_iteratorError = err;
			} finally {
				try {
					if (_iteratorAbruptCompletion && (_return = _iterator.return) != null) {
						_step = await Reflect.apply(_return, _iterator, []);
						if (_step === null || typeof _step !== "object" && typeof _step !== "function") throw new TypeError("Iterator result is not an object");
					}
				} finally {
					if (_didIteratorError) {
						throw _iteratorError;
					}
				}
			}
		}
	}
}
async function transfer(fromUri, toUri, move) {
	var from = parts(fromUri), to = parts(toUri);
	if (move && from.length === 1) throw new Error("FileSystem: app root directories are protected");
	if (to.length <= from.length && to.every(function(name, i) {
		return name === from[i];
	}) || from.every(function(name, i) {
		return name === to[i];
	})) throw new Error("FileSystem: overlapping paths");
	var source = await entry(from);
	if ((await info(toUri)).exists) throw new Error("FileSystem: destination already exists");
	var destination = await parent(to);
	try {
		await copyEntry(source, destination, to.at(-1));
	} catch (error) {
		await destination.removeEntry(to.at(-1), { recursive: true }).catch(function() {});
		throw error;
	}
	if (move) await (await parent(from)).removeEntry(from.at(-1), { recursive: true });
}
var tail = Promise.resolve();
function serial(work) {
	var next = tail.then(work);
	tail = next.catch(function() {});
	return next;
}

export { directories, entry, folders, info, parent, parts, root, serial, transfer, write };
//# sourceMappingURL=opfs.native.js.map