@geode/opengeodeweb-front 10.34.0-rc.2 → 10.34.0-rc.21

package/.build/server/utils/path.js

@@ -0,0 +1,108 @@
+import { appMode } from "../../shared/app_mode.js";
+import { commandExistsSync } from "./scripts.js";
+import path from "node:path";
+import fs from "node:fs";
+import { setTimeout } from "node:timers/promises";
+import os from "node:os";
+import { v4 } from "uuid";
+//#region server/utils/path.ts
+function executableName(execName) {
+	if (process.platform === "win32") return `${execName}.exe`;
+	return execName;
+}
+function findExecutableInDir(baseDir, execName, osExecutableName) {
+	const oneFilePath = path.join(baseDir, osExecutableName);
+	if (fs.existsSync(oneFilePath) && fs.statSync(oneFilePath).isFile()) {
+		console.log(`[executablePath] Found OneFile executable: ${oneFilePath}`);
+		return oneFilePath;
+	}
+	const oneDirPath = path.join(baseDir, execName, osExecutableName);
+	if (fs.existsSync(oneDirPath) && fs.statSync(oneDirPath).isFile()) {
+		console.log(`[executablePath] Found OneDir executable: ${oneDirPath}`);
+		return oneDirPath;
+	}
+	console.log(`[executablePath] Executable not found in ${baseDir} (tried OneFile and OneDir): ${execName}`);
+}
+function executablePath(execPath, execName) {
+	const osExecutableName = executableName(execName);
+	const resourcesPath = process.env.RESOURCES_PATH;
+	const mode = process.env.MODE;
+	const nodeEnv = process.env.NODE_ENV;
+	console.log("[executablePath]", {
+		execPath,
+		execName,
+		mode,
+		nodeEnv,
+		resourcesPath
+	});
+	if (commandExistsSync(osExecutableName)) {
+		console.log(`[executablePath] Found executable in PATH: ${osExecutableName}`);
+		return osExecutableName;
+	}
+	const foundAtExecPath = findExecutableInDir(execPath, execName, osExecutableName);
+	if (foundAtExecPath !== void 0 && foundAtExecPath !== "") return foundAtExecPath;
+	if (mode === appMode.DESKTOP && nodeEnv === "production") {
+		if (resourcesPath !== void 0 && resourcesPath !== "") {
+			const foundInResources = findExecutableInDir(resourcesPath, execName, osExecutableName);
+			if (foundInResources !== void 0 && foundInResources !== "") return foundInResources;
+		}
+		throw new Error(`Executable not found in execPath (${execPath}) or resourcesPath (${resourcesPath}): ${osExecutableName}`);
+	}
+	throw new Error(`Executable not found: ${osExecutableName}`);
+}
+function createPath(dirPath) {
+	if (!fs.existsSync(dirPath)) {
+		fs.mkdirSync(dirPath, { recursive: true });
+		console.log(`${dirPath} directory created successfully!`);
+	}
+	return dirPath;
+}
+function generateProjectFolderPath(projectName) {
+	return path.join(os.tmpdir(), projectName.replaceAll("/", "_"), v4());
+}
+function extensionFolderPath(projectFolderPath, extensionId) {
+	return path.join(projectFolderPath, "extensions", extensionId);
+}
+async function lookForLocalExtensionDistPath(rootPath, extentionRepoName, frontendFile) {
+	const localExtensionPath = path.join(rootPath, "..", extentionRepoName);
+	const localExtensionDistPath = path.join(localExtensionPath, "dist");
+	if (!fs.existsSync(localExtensionDistPath)) return;
+	console.log(`[extensionFrontendPath] Found existing folder: ${localExtensionDistPath}, deleting it...`);
+	fs.rmSync(localExtensionDistPath, {
+		recursive: true,
+		force: true
+	});
+	const now = /* @__PURE__ */ new Date();
+	fs.utimesSync(path.join(localExtensionPath, "package.json"), now, now);
+	const rebuiltFilePath = path.join(localExtensionDistPath, frontendFile);
+	const MAX_DELETE_FOLDER_RETRIES = 10;
+	const MILLISECONDS_PER_RETRY = 1e3;
+	for (let i = 0; i <= MAX_DELETE_FOLDER_RETRIES; i += 1) {
+		if (fs.existsSync(rebuiltFilePath)) {
+			console.log(`Found rebuilt file: ${rebuiltFilePath}`);
+			return rebuiltFilePath;
+		}
+		console.log(`Waiting for rebuild... attempt ${i}/${MAX_DELETE_FOLDER_RETRIES}`);
+		await setTimeout(MILLISECONDS_PER_RETRY);
+	}
+}
+async function extensionFrontendPath(unzippedExtensionPath, frontendFile, rootPath, extensionId) {
+	console.log("[extensionFrontendPath]", {
+		unzippedExtensionPath,
+		frontendFile,
+		rootPath,
+		extensionId
+	});
+	const localFilePath = await lookForLocalExtensionDistPath(rootPath, extensionId.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("-"), frontendFile);
+	if (localFilePath !== void 0 && localFilePath !== "") return localFilePath;
+	const unzippedfrontendFilePath = path.join(unzippedExtensionPath, frontendFile);
+	if (fs.existsSync(unzippedfrontendFilePath)) return unzippedfrontendFilePath;
+	throw new Error(`Failed to find ${unzippedfrontendFilePath}`);
+}
+function extensionBackendPath(unzippedExtensionPath, backendExecutableName) {
+	const backendExecutablePath = path.join(unzippedExtensionPath, executableName(backendExecutableName));
+	console.log("runExtensions", { backendExecutablePath });
+	return backendExecutablePath;
+}
+//#endregion
+export { createPath, executableName, executablePath, extensionBackendPath, extensionFolderPath, extensionFrontendPath, generateProjectFolderPath };

package/.build/server/utils/scripts.js

@@ -0,0 +1,134 @@
+import { appMode } from "../../shared/app_mode.js";
+import { setAppBaseUrl } from "../../shared/scripts.js";
+import path from "node:path";
+import fs from "node:fs";
+import child_process from "node:child_process";
+import { on } from "node:events";
+import readline from "node:readline";
+import { getPort } from "get-port-please";
+//#region server/utils/scripts.ts
+const MAX_ERROR_BUFFER_BYTES = 65536;
+async function getAvailablePort() {
+	return await getPort({
+		host: "localhost",
+		random: true
+	});
+}
+function commandExistsSync(execName) {
+	return (process.env.PATH ?? "").split(path.delimiter).some((directory) => {
+		const filePath = path.join(directory, execName);
+		return fs.existsSync(filePath) && fs.statSync(filePath).isFile();
+	});
+}
+const encoder = new TextEncoder();
+function byteLength(str) {
+	return encoder.encode(str).byteLength;
+}
+async function waitForReady(child, expectedResponse, signal) {
+	return new Promise((resolve, reject) => {
+		const readlineStdout = readline.createInterface({ input: child.stdout });
+		const readlineStderr = readline.createInterface({ input: child.stderr });
+		let recentOutput = "";
+		function recordOutput(lineOutput) {
+			const safeLine = byteLength(lineOutput) > MAX_ERROR_BUFFER_BYTES / 2 ? `${lineOutput.slice(0, MAX_ERROR_BUFFER_BYTES / 2)}…[truncated]` : lineOutput;
+			recentOutput = `${recentOutput} ${safeLine}\n`;
+			while (byteLength(recentOutput) > MAX_ERROR_BUFFER_BYTES) {
+				const newline = recentOutput.indexOf("\n");
+				if (newline === -1) {
+					recentOutput = "";
+					break;
+				}
+				recentOutput = recentOutput.slice(newline + 1);
+			}
+		}
+		let onLine = void 0;
+		let onErrLine = void 0;
+		let onError = void 0;
+		let onClose = void 0;
+		let onAbort = void 0;
+		function cleanup() {
+			if (onLine) readlineStdout.removeListener("line", onLine);
+			if (onErrLine) readlineStderr.removeListener("line", onErrLine);
+			if (onError) child.removeListener("error", onError);
+			if (onClose) child.removeListener("close", onClose);
+			if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+		}
+		function becomeReady() {
+			cleanup();
+			readlineStdout.on("line", (line) => {
+				console.log(`[${child.name}] ${line}`);
+			});
+			readlineStderr.on("line", (line) => {
+				console.log(`[${child.name}] ${line}`);
+			});
+			child.once("close", (code) => {
+				console.log(`[${child.name}] exited with code ${code}`);
+			});
+			resolve(child);
+		}
+		onLine = (lineOutput) => {
+			console.log(`[${child.name}] ${lineOutput}`);
+			recordOutput(lineOutput);
+			if (lineOutput.includes(expectedResponse)) becomeReady();
+		};
+		onErrLine = (line) => {
+			console.log(`[${child.name}] ${line}`);
+			recordOutput(line);
+			if (line.includes(expectedResponse)) becomeReady();
+		};
+		onError = (err) => {
+			cleanup();
+			reject(err);
+		};
+		onClose = (code) => {
+			console.log(`[${child.name}] exited with code ${code}`);
+			cleanup();
+			reject(/* @__PURE__ */ new Error(`[${child.name}] exited with code ${code} before becoming ready.${recentOutput ? `\nRecent output:\n${recentOutput}` : ""}`));
+		};
+		onAbort = () => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error(`[${child.name}] timed out waiting for "${expectedResponse}"`));
+		};
+		readlineStdout.on("line", onLine);
+		readlineStderr.on("line", onErrLine);
+		child.once("error", onError);
+		child.once("close", onClose);
+		if (signal) signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+async function waitNuxt(nuxtProcess) {
+	nuxtProcess.stderr.on("data", (data) => {
+		console.log("Nuxt STDERR:", data.toString().trim());
+	});
+	nuxtProcess.on("close", (code) => {
+		console.log(`Nuxt process closed with code ${code}`);
+	});
+	for await (const [data] of on(nuxtProcess.stdout, "data")) {
+		const output = String(data);
+		console.log("Nuxt STDOUT:", output.trim());
+		const port = /Listening on http:\/\/\[::\]:(?<port>\d+)/u.exec(output)?.groups?.port;
+		if (port !== void 0) {
+			console.log("Nuxt listening on port", port);
+			nuxtProcess.stdout.on("data", (newData) => {
+				console.log("Nuxt STDOUT:", newData.toString().trim());
+			});
+			return port;
+		}
+	}
+	throw new Error("Nuxt process closed");
+}
+async function runBrowser(scriptName) {
+	process.env.MODE = appMode.BROWSER;
+	const port = await getAvailablePort();
+	await waitNuxt(child_process.spawn("npm", ["run", scriptName], {
+		shell: true,
+		env: {
+			...process.env,
+			PORT: String(port)
+		}
+	}));
+	await setAppBaseUrl(`http://localhost:${port}`);
+	return port;
+}
+//#endregion
+export { commandExistsSync, getAvailablePort, runBrowser, waitForReady };

package/.build/server/utils/server.js

@@ -0,0 +1,44 @@
+import path from "node:path";
+import fs from "node:fs";
+import JSZip from "jszip";
+import { extract } from "tar";
+//#region server/utils/server.ts
+const TAR_ARCHIVE_PATTERN = /\.(?<ext>tar\.gz|tgz|tar)$/u;
+async function extractZipArchive(zipFilePath, outputDir) {
+	const data = await fs.promises.readFile(zipFilePath);
+	const zip = await JSZip.loadAsync(data);
+	const promises = [];
+	for (const [relativePath, zipEntry] of Object.entries(zip.files)) {
+		const outputPath = path.join(outputDir, relativePath);
+		if (zipEntry.dir) promises.push((async () => {
+			await fs.promises.mkdir(outputPath, { recursive: true });
+		})());
+		else promises.push((async () => {
+			const content = await zipEntry.async("nodebuffer");
+			await fs.promises.mkdir(path.dirname(outputPath), { recursive: true });
+			await fs.promises.writeFile(outputPath, content);
+		})());
+	}
+	await Promise.all(promises);
+}
+async function extractTarArchive(archivePath, outputDir) {
+	await extract({
+		file: archivePath,
+		cwd: outputDir
+	});
+}
+async function unzipFile(zipFilePath, outputDir = zipFilePath.replace(/\.[^/.]+$/u, "")) {
+	console.log("Unzipping file...", zipFilePath, outputDir);
+	try {
+		await fs.promises.mkdir(outputDir, { recursive: true });
+		if (TAR_ARCHIVE_PATTERN.test(zipFilePath)) await extractTarArchive(zipFilePath, outputDir);
+		else await extractZipArchive(zipFilePath, outputDir);
+		console.log("Extraction complete!");
+		return outputDir;
+	} catch (error) {
+		console.error("Error unzipping file:", error);
+		throw error;
+	}
+}
+//#endregion
+export { unzipFile };

package/.build/server/utils/server_config.js

@@ -0,0 +1,51 @@
+import { createServerWsRpcClient } from "./ws_client.js";
+//#region server/utils/server_config.ts
+const stringStorage = /* @__PURE__ */ new Map();
+const booleanStorage = /* @__PURE__ */ new Map();
+const clientStorage = /* @__PURE__ */ new Map();
+function getAppBaseUrl() {
+	const value = stringStorage.get("APP_BASE_URL");
+	if (value === void 0) throw new Error("APP_BASE_URL is not set");
+	return value;
+}
+function setAppBaseUrl(baseUrl) {
+	stringStorage.set("APP_BASE_URL", baseUrl);
+}
+function getBackBaseUrl() {
+	const value = stringStorage.get("BACK_BASE_URL");
+	if (value === void 0) throw new Error("BACK_BASE_URL is not set");
+	return value;
+}
+function setBackBaseUrl(baseUrl) {
+	stringStorage.set("BACK_BASE_URL", baseUrl);
+}
+function getViewerBaseUrl() {
+	const value = stringStorage.get("VIEWER_BASE_URL");
+	if (value === void 0) throw new Error("VIEWER_BASE_URL is not set");
+	return value;
+}
+function setViewerBaseUrl(baseUrl) {
+	stringStorage.set("VIEWER_BASE_URL", baseUrl);
+}
+function getIsAppReady() {
+	return booleanStorage.get("IS_APP_READY") ?? false;
+}
+function setIsAppReady(isAppReady) {
+	booleanStorage.set("IS_APP_READY", isAppReady);
+}
+async function setViewerWebSocketClient(baseUrl) {
+	const client = createServerWsRpcClient(baseUrl);
+	client.onConnectionClose(() => {
+		if (clientStorage.get("VIEWER_CLIENT") === client) clientStorage.delete("VIEWER_CLIENT");
+	});
+	await client.ready;
+	clientStorage.set("VIEWER_CLIENT", client);
+	return client;
+}
+async function getViewerWebSocketClient() {
+	const viewerClient = clientStorage.get("VIEWER_CLIENT");
+	if (viewerClient !== void 0 && viewerClient.isOpen()) return viewerClient;
+	return await setViewerWebSocketClient(getViewerBaseUrl());
+}
+//#endregion
+export { getAppBaseUrl, getBackBaseUrl, getIsAppReady, getViewerBaseUrl, getViewerWebSocketClient, setAppBaseUrl, setBackBaseUrl, setIsAppReady, setViewerBaseUrl, setViewerWebSocketClient };

package/.build/server/utils/stream.js

@@ -0,0 +1,6 @@
+//#region server/utils/stream.ts
+function toNodeWebStream(stream) {
+	return stream;
+}
+//#endregion
+export { toNodeWebStream };

package/.build/server/utils/ws_client.js

@@ -0,0 +1,100 @@
+import { WebSocket } from "ws";
+import { v4 } from "uuid";
+//#region server/utils/ws_client.ts
+const HELLO_ID = "system:hello";
+const HELLO_SECRET = "wslink-secret";
+function isWsRpcMessage(value) {
+	return typeof value === "object" && value !== null;
+}
+function rawDataToString(raw) {
+	if (Buffer.isBuffer(raw)) return raw.toString();
+	if (Array.isArray(raw)) return Buffer.concat(raw).toString();
+	return Buffer.from(raw).toString();
+}
+function createServerWsRpcClient(baseUrl) {
+	const socket = new WebSocket(baseUrl);
+	const pending = /* @__PURE__ */ new Map();
+	let onCloseCallback = void 0;
+	let onErrorCallback = void 0;
+	const ready = new Promise((resolve, reject) => {
+		socket.on("open", () => {
+			socket.send(JSON.stringify({
+				id: HELLO_ID,
+				method: "wslink.hello",
+				args: [{ secret: HELLO_SECRET }]
+			}));
+		});
+		socket.on("message", (raw) => {
+			let message = void 0;
+			try {
+				const parsed = JSON.parse(rawDataToString(raw));
+				if (!isWsRpcMessage(parsed)) return;
+				message = parsed;
+			} catch {
+				return;
+			}
+			if (message.id === HELLO_ID) {
+				resolve();
+				return;
+			}
+			if (typeof message.id === "string" && message.id.startsWith("publish:")) return;
+			const entry = message.id === void 0 ? void 0 : pending.get(message.id);
+			if (!entry || message.id === void 0) return;
+			pending.delete(message.id);
+			if (message.error) entry.reject(new Error(message.error.message ?? "wslink RPC error"));
+			else entry.resolve(message.result);
+		});
+		socket.on("error", (error) => {
+			onErrorCallback?.(error);
+			reject(error);
+		});
+		socket.on("close", () => {
+			onCloseCallback?.();
+			for (const { reject: rejectPending } of pending.values()) rejectPending(/* @__PURE__ */ new Error("WebSocket closed"));
+			pending.clear();
+		});
+	});
+	async function call(rpc, params = {}) {
+		await ready;
+		const id = v4();
+		return new Promise((resolve, reject) => {
+			pending.set(id, {
+				resolve,
+				reject
+			});
+			socket.send(JSON.stringify({
+				wslink: "1.0",
+				id,
+				method: rpc,
+				args: [params],
+				kwargs: { stream: true }
+			}));
+		});
+	}
+	function close() {
+		socket.close();
+	}
+	function getConnection() {
+		return { getSession: () => ({ call: (rpc, [params]) => call(rpc, params) }) };
+	}
+	function isOpen() {
+		return socket.readyState === WebSocket.OPEN;
+	}
+	function onConnectionClose(callback) {
+		onCloseCallback = callback;
+	}
+	function onConnectionError(callback) {
+		onErrorCallback = callback;
+	}
+	return {
+		call,
+		close,
+		getConnection,
+		isOpen,
+		onConnectionClose,
+		onConnectionError,
+		ready
+	};
+}
+//#endregion
+export { createServerWsRpcClient };

package/.build/shared/app_mode.js

@@ -0,0 +1,8 @@
+//#region shared/app_mode.ts
+const appMode = {
+	DESKTOP: "DESKTOP",
+	BROWSER: "BROWSER",
+	CLOUD: "CLOUD"
+};
+//#endregion
+export { appMode };

package/.build/shared/scripts.js

@@ -0,0 +1,49 @@
+import { fetchSchema } from "./utils/fetch_schema.js";
+import { api } from "../opengeodeweb_front_schemas.js";
+//#region shared/scripts.ts
+async function setAppBaseUrl(appBaseUrl) {
+	console.log("[API] setAppBaseUrl", appBaseUrl);
+	const schema = api.microservice.app.set_app_base_url;
+	return await fetchSchema({
+		schema,
+		params: { baseUrl: appBaseUrl },
+		baseURL: appBaseUrl
+	});
+}
+async function setBackBaseUrl(appBaseUrl, backBaseUrl) {
+	console.log("[API] setBackBaseUrl", appBaseUrl, backBaseUrl);
+	const schema = api.microservice.app.set_back_base_url;
+	return await fetchSchema({
+		schema,
+		params: { baseUrl: backBaseUrl },
+		baseURL: appBaseUrl
+	});
+}
+async function setViewerBaseUrl(appBaseUrl, viewerBaseUrl) {
+	console.log("[API] setViewerBaseUrl", appBaseUrl, viewerBaseUrl);
+	const schema = api.microservice.app.set_viewer_base_url;
+	return await fetchSchema({
+		schema,
+		params: { baseUrl: viewerBaseUrl },
+		baseURL: appBaseUrl
+	});
+}
+async function setIsAppReady(appBaseUrl, isReady) {
+	console.log("[API] setIsAppReady", isReady);
+	const schema = api.microservice.app.set_is_app_ready;
+	return await fetchSchema({
+		schema,
+		params: { isReady },
+		baseURL: appBaseUrl
+	});
+}
+async function getIsAppReady(appBaseUrl) {
+	console.log("[API] getIsAppReady");
+	const schema = api.microservice.app.get_is_app_ready;
+	return await fetchSchema({
+		schema,
+		baseURL: appBaseUrl
+	});
+}
+//#endregion
+export { getIsAppReady, setAppBaseUrl, setBackBaseUrl, setIsAppReady, setViewerBaseUrl };

package/.build/shared/utils/call_raw.js

@@ -0,0 +1,31 @@
+import pTimeout from "p-timeout";
+import "lodash";
+//#region shared/utils/call_raw.ts
+async function callClient({ rpc, params = {}, client }) {
+	if (globalThis.window !== void 0) return await client.getConnection().getSession().call(rpc, [params]);
+	return await client.call(rpc, params);
+}
+async function callRaw({ rpc, params = {}, client, timeout }, { request_error_function, response_function, response_error_function } = {}) {
+	async function performCall() {
+		try {
+			const response = await callClient({
+				rpc,
+				params,
+				client
+			});
+			if (response_function) await response_function(response);
+			return response;
+		} catch (error) {
+			if (request_error_function) request_error_function(error);
+			if (response_error_function) response_error_function(error);
+			throw error;
+		}
+	}
+	if (timeout !== void 0 && timeout > 0) return await pTimeout(performCall(), {
+		milliseconds: timeout,
+		message: `${rpc}: Timed out after ${timeout}ms`
+	});
+	return await performCall();
+}
+//#endregion
+export { callRaw };

package/.build/shared/utils/call_schema.js

@@ -0,0 +1,28 @@
+import { validateSchema } from "./validate_schema.js";
+import { callRaw } from "./call_raw.js";
+//#region shared/utils/call_schema.ts
+const ERROR_400 = 400;
+async function callSchema({ schema, params = {}, client, timeout }, { request_error_function, response_function, response_error_function, validation_error_function } = {}) {
+	const { valid, error: schema_error } = validateSchema(schema, params);
+	if (!valid) {
+		if (process.env.NODE_ENV !== "production") console.log("Bad request", schema_error, schema, params);
+		if (validation_error_function) validation_error_function({
+			code: ERROR_400,
+			name: "Bad request",
+			error: schema_error
+		});
+		throw new Error(`${schema.$id}: ${schema_error}`);
+	}
+	return await callRaw({
+		rpc: schema.$id,
+		params,
+		client,
+		timeout
+	}, {
+		request_error_function,
+		response_function,
+		response_error_function
+	});
+}
+//#endregion
+export { callSchema };

package/.build/shared/utils/fetch_raw.js

@@ -0,0 +1,52 @@
+import { hasBody } from "./file.js";
+import pTimeout from "p-timeout";
+import { $fetch } from "ofetch";
+import _ from "lodash";
+//#region shared/utils/fetch_raw.ts
+function resolveHeaders(headers, expectEvent) {
+	const resolvedHeaders = { ...headers };
+	if (expectEvent) {
+		const value = "text/event-stream";
+		if (_.isEmpty(resolvedHeaders)) resolvedHeaders.Accept = value;
+		else resolvedHeaders.Accept = `${resolvedHeaders.Accept}, ${value}`;
+	}
+	return resolvedHeaders;
+}
+async function performFetch({ route, method, params, baseURL, headers, max_retry, request_error_function, response_function, response_error_function }) {
+	return await $fetch(route, {
+		baseURL,
+		method,
+		headers,
+		...hasBody(params) ? { body: params } : {},
+		...max_retry === void 0 ? {} : { retry: max_retry },
+		async onRequestError({ error }) {
+			if (request_error_function) await request_error_function(error);
+		},
+		async onResponse({ response }) {
+			if (response.ok && response_function) await response_function(response._data);
+		},
+		async onResponseError({ response }) {
+			if (response_error_function) await response_error_function(response);
+		}
+	});
+}
+async function fetchRaw({ route, method, params = {}, baseURL, headers = {}, max_retry, timeout, expectEvent = false }, { request_error_function, response_function, response_error_function } = {}) {
+	const fetchOptions = {
+		route,
+		method,
+		params,
+		baseURL,
+		headers: resolveHeaders(headers, expectEvent),
+		max_retry,
+		request_error_function,
+		response_function,
+		response_error_function
+	};
+	if (timeout !== void 0 && timeout > 0) return await pTimeout(performFetch(fetchOptions), {
+		milliseconds: timeout,
+		message: `${route}: Timed out after ${timeout}ms`
+	});
+	return await performFetch(fetchOptions);
+}
+//#endregion
+export { fetchRaw };

package/.build/shared/utils/fetch_schema.js

@@ -0,0 +1,32 @@
+import { fetchRaw } from "./fetch_raw.js";
+import { validateSchema } from "./validate_schema.js";
+//#region shared/utils/fetch_schema.ts
+const ERROR_400 = 400;
+async function fetchSchema({ schema, params = {}, baseURL, headers, timeout, expectEvent = false }, { request_error_function, response_function, response_error_function, validation_error_function } = {}) {
+	const { valid, error: schema_error } = validateSchema(schema, params);
+	if (!valid) {
+		if (process.env.NODE_ENV !== "production") console.log("Bad request", schema_error, schema, params);
+		if (validation_error_function) validation_error_function({
+			code: ERROR_400,
+			name: "Bad request",
+			error: schema_error
+		});
+		throw new Error(`${schema.$id}: ${schema_error}`);
+	}
+	return await fetchRaw({
+		route: schema.$id,
+		method: schema.methods.find((method) => method !== "OPTIONS"),
+		params,
+		baseURL,
+		headers,
+		max_retry: schema.max_retry,
+		timeout,
+		expectEvent
+	}, {
+		request_error_function,
+		response_function,
+		response_error_function
+	});
+}
+//#endregion
+export { fetchSchema };

package/.build/shared/utils/file.js

@@ -0,0 +1,14 @@
+import _ from "lodash";
+//#region shared/utils/file.ts
+const BYTES_PER_KIBIBYTE = 1024;
+const CHUNK_SIZE_BYTES = 8192 * BYTES_PER_KIBIBYTE;
+function assertFile(file) {
+	console.log("[ASSERT_FILE] Asserting file", { file });
+	if (!(file instanceof File)) throw new Error("file must be an instance of File");
+}
+function hasBody(params) {
+	if (params instanceof FormData || params instanceof Blob) return true;
+	return !_.isEmpty(params);
+}
+//#endregion
+export { BYTES_PER_KIBIBYTE, CHUNK_SIZE_BYTES, assertFile, hasBody };