one/dist/cjs/platform/file-system/validate.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 validate_exports = {};
__export(validate_exports, {
	assertAlgorithm: () => assertAlgorithm,
	assertByteLength: () => assertByteLength,
	assertDestination: () => assertDestination,
	assertEncoding: () => assertEncoding,
	assertMode: () => assertMode,
	assertName: () => assertName,
	assertOffset: () => assertOffset,
	assertReadable: () => assertReadable,
	assertUri: () => assertUri,
	assertWritable: () => assertWritable,
	assertWriteBytes: () => assertWriteBytes,
	assertWriteContent: () => assertWriteContent
});
module.exports = __toCommonJS(validate_exports);
var import_types = require("./types.native.js");
var modes = new Set(Object.values(import_types.FileMode));
var algorithms = /* @__PURE__ */ new Set([
	"MD5",
	"SHA-1",
	"SHA-256",
	"SHA-384",
	"SHA-512"
]);
var encodings = /* @__PURE__ */ new Set(["utf8", "base64"]);
function assertUri(uri, owner) {
	if (typeof uri !== "string") throw new Error(`${owner}: expected a uri string`);
	var parsed;
	try {
		parsed = new URL(uri);
	} catch (unused) {
		throw new Error(`${owner}: expected an absolute file uri`);
	}
	if (parsed.protocol !== "file:" && parsed.protocol !== "opfs:" || !parsed.pathname.startsWith("/") || parsed.search || parsed.hash) {
		throw new Error(`${owner}: expected an absolute file uri`);
	}
}
function assertMode(mode, owner) {
	if (typeof mode !== "string" || !modes.has(mode)) {
		throw new Error(`${owner}: expected a FileMode`);
	}
}
function assertEncoding(encoding, owner) {
	if (typeof encoding !== "string" || !encodings.has(encoding)) {
		throw new Error(`${owner}: expected encoding 'utf8' or 'base64'`);
	}
}
function assertAlgorithm(algorithm, owner) {
	if (typeof algorithm !== "string" || !algorithms.has(algorithm)) {
		throw new Error(`${owner}: expected a digest algorithm`);
	}
}
function assertByteLength(length, owner) {
	if (typeof length !== "number" || !Number.isInteger(length) || length < 0) {
		throw new Error(`${owner}: expected a nonnegative integer byte length`);
	}
}
function assertOffset(offset, owner) {
	if (typeof offset !== "number" || !Number.isFinite(offset) || offset < 0) {
		throw new Error(`${owner}: expected a finite nonnegative offset`);
	}
}
function assertName(name, owner) {
	if (typeof name !== "string" || name === "" || name.includes("/") || name === "." || name === "..") {
		throw new Error(`${owner}: expected a single path segment`);
	}
}
function assertWriteContent(content, owner) {
	if (typeof content !== "string" && !(content instanceof Uint8Array) && !(content instanceof ArrayBuffer)) {
		throw new Error(`${owner}: expected a string, Uint8Array or ArrayBuffer`);
	}
}
function assertWriteBytes(bytes, owner) {
	if (!(bytes instanceof Uint8Array) && !(bytes instanceof ArrayBuffer)) {
		throw new Error(`${owner}: expected a Uint8Array or ArrayBuffer`);
	}
}
function assertReadable(mode, verb) {
	if (mode !== import_types.FileMode.ReadOnly && mode !== import_types.FileMode.ReadWrite) {
		throw new Error(`${verb}: the handle is not readable`);
	}
}
function assertWritable(mode, verb) {
	if (mode === import_types.FileMode.ReadOnly) {
		throw new Error(`${verb}: the handle is not writable`);
	}
}
function assertDestination(destination, owner) {
	if (typeof destination !== "object" || destination === null || typeof destination.uri !== "string") {
		throw new Error(`${owner}: expected a File or Directory destination`);
	}
}

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