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

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

"use strict";

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
	for (var name in all) __defProp(target, name, {
		get: all[name],
		enumerable: true
	});
};
var __copyProps = (to, from, except, desc) => {
	if (from && typeof from === "object" || typeof from === "function") {
		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
			get: () => from[key],
			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
		});
	}
	return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var opfs_exports = {};
__export(opfs_exports, {
	directories: () => directories,
	entry: () => entry,
	folders: () => folders,
	info: () => info,
	parent: () => parent,
	parts: () => parts,
	root: () => root,
	serial: () => serial,
	transfer: () => transfer,
	write: () => write
});
module.exports = __toCommonJS(opfs_exports);
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;
}

//# sourceMappingURL=opfs.native.js.map