@void/vue 0.0.0

package/dist/runtime/index.d.mts

@@ -0,0 +1,2 @@
+import { a as useIslandForm, c as useShared, i as setActionRouter, l as useRouter, n as InferProps, o as useNavigation, r as action, s as useForm, t as Deferred, u as Link } from "../index-C0fE29Kv.mjs";
+export { Deferred, InferProps, Link, action, setActionRouter, useForm, useIslandForm, useNavigation, useRouter, useShared };

package/dist/runtime/index.mjs

@@ -0,0 +1,2 @@
+import { a as useForm, c as Link, i as useNavigation, n as setActionRouter, o as useShared, r as useIslandForm, s as useRouter, t as action } from "../runtime-DL_B0L_H.mjs";
+export { Link, action, setActionRouter, useForm, useIslandForm, useNavigation, useRouter, useShared };

package/dist/runtime/prefetch.d.mts

@@ -0,0 +1,2 @@
+import { CacheEntry, CacheForInput, CacheForResult, PrefetchCache, parseCacheFor } from "void/pages-prefetch";
+export { type CacheEntry, type CacheForInput, type CacheForResult, PrefetchCache, parseCacheFor };

package/dist/runtime/prefetch.mjs

@@ -0,0 +1,2 @@
+import { PrefetchCache, parseCacheFor } from "void/pages-prefetch";
+export { PrefetchCache, parseCacheFor };

package/dist/runtime/use-deferred.d.mts

@@ -0,0 +1,19 @@
+//#region src/runtime/use-deferred.d.ts
+type DeferredRef<T = unknown> = {
+  value: null;
+  loading: true;
+  error: null;
+} | {
+  value: T;
+  loading: false;
+  error: null;
+} | {
+  value: null;
+  loading: false;
+  error: Error;
+};
+declare function createDeferred<T = unknown>(): DeferredRef<T>;
+declare function resolveDeferred(ref: DeferredRef, data: unknown): void;
+declare function rejectDeferred(ref: DeferredRef, error: string): void;
+//#endregion
+export { DeferredRef, createDeferred, rejectDeferred, resolveDeferred };

package/dist/runtime/use-deferred.mjs

@@ -0,0 +1,21 @@
+import { reactive } from "vue";
+//#region src/runtime/use-deferred.ts
+function createDeferred() {
+	return reactive({
+		value: null,
+		loading: true,
+		error: null
+	});
+}
+function resolveDeferred(ref, data) {
+	const r = ref;
+	r.value = data;
+	r.loading = false;
+}
+function rejectDeferred(ref, error) {
+	const r = ref;
+	r.error = new Error(error);
+	r.loading = false;
+}
+//#endregion
+export { createDeferred, rejectDeferred, resolveDeferred };

package/dist/runtime-DL_B0L_H.mjs

@@ -0,0 +1,462 @@
+import { computed, defineComponent, h, inject, onMounted, onUnmounted, reactive, ref, watch } from "vue";
+import { VoidActionError, categorizeActionError, idleNavigationState, isAbortError, isEqualFormValue, ssrProxy, submitAction } from "void/pages-client";
+//#region src/runtime/link.ts
+function appendQueryValue(params, key, value) {
+	if (value === null || value === void 0) return false;
+	if (value instanceof Date) {
+		params.append(key, value.toISOString());
+		return true;
+	}
+	if (Array.isArray(value)) {
+		let appended = false;
+		for (const item of value) appended = appendQueryValue(params, key, item) || appended;
+		return appended;
+	}
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+		params.append(key, String(value));
+		return true;
+	}
+	throw new Error(`Link: GET data only supports primitive values and arrays. Remove nested data for '${key}'.`);
+}
+function mergeDataIntoHref(href, data) {
+	if (!data) return href;
+	const hashIndex = href.indexOf("#");
+	const beforeHash = hashIndex === -1 ? href : href.slice(0, hashIndex);
+	const hash = hashIndex === -1 ? "" : href.slice(hashIndex);
+	const searchIndex = beforeHash.indexOf("?");
+	const path = searchIndex === -1 ? beforeHash : beforeHash.slice(0, searchIndex);
+	const search = searchIndex === -1 ? "" : beforeHash.slice(searchIndex + 1);
+	const params = new URLSearchParams(search);
+	let appended = false;
+	for (const [key, value] of Object.entries(data)) appended = appendQueryValue(params, key, value) || appended;
+	if (!appended) return href;
+	const query = params.toString();
+	return `${path}${query ? `?${query}` : ""}${hash}`;
+}
+function hasPrefetch(prefetch) {
+	return prefetch !== false;
+}
+function isModifiedEvent(e) {
+	const target = e.currentTarget.getAttribute("target");
+	return target !== null && target !== "_self" || e.ctrlKey || e.metaKey || e.shiftKey || e.altKey || e.button !== 0;
+}
+function callHandler(handler, event) {
+	if (Array.isArray(handler)) {
+		for (const fn of handler) if (typeof fn === "function") fn(event);
+	} else if (typeof handler === "function") handler(event);
+}
+const Link = defineComponent({
+	name: "Link",
+	props: {
+		href: {
+			type: String,
+			required: true
+		},
+		method: {
+			type: String,
+			default: "GET"
+		},
+		data: {
+			type: Object,
+			default: void 0
+		},
+		preserveScroll: {
+			type: Boolean,
+			default: false
+		},
+		preserveState: {
+			type: Boolean,
+			default: false
+		},
+		replace: {
+			type: Boolean,
+			default: false
+		},
+		reloadDocument: {
+			type: Boolean,
+			default: false
+		},
+		viewTransition: {
+			type: Boolean,
+			default: void 0
+		},
+		onNavigate: {
+			type: Function,
+			default: void 0
+		},
+		prefetch: {
+			type: [
+				Boolean,
+				String,
+				Array
+			],
+			default: false
+		},
+		cacheFor: {
+			type: [
+				Number,
+				String,
+				Array
+			],
+			default: void 0
+		}
+	},
+	setup(props, { slots, attrs }) {
+		const router = inject("__void_router", null);
+		const elRef = ref(null);
+		const normalizedMethod = computed(() => props.method.toUpperCase());
+		const isGet = computed(() => normalizedMethod.value === "GET");
+		const hrefWithData = computed(() => isGet.value ? mergeDataIntoHref(props.href, props.data) : props.href);
+		const strategies = computed(() => {
+			if (props.prefetch === false || props.reloadDocument) return [];
+			if (props.prefetch === true) return ["hover"];
+			if (typeof props.prefetch === "string") return [props.prefetch];
+			return props.prefetch;
+		});
+		function doPrefetch() {
+			if (!router?.prefetch) return;
+			const current = window.location.pathname + window.location.search;
+			if (hrefWithData.value === current) return;
+			const options = {};
+			if (props.cacheFor !== void 0) options.cacheFor = props.cacheFor;
+			if (normalizedMethod.value) options.method = normalizedMethod.value;
+			router.prefetch(hrefWithData.value, options);
+		}
+		function onClick(e) {
+			callHandler(attrs.onClick, e);
+			if (props.reloadDocument || !router || e.defaultPrevented || isModifiedEvent(e)) return;
+			if (e.currentTarget.hasAttribute("download")) return;
+			if (new URL(hrefWithData.value, window.location.origin).origin !== window.location.origin) return;
+			let navigatePrevented = false;
+			props.onNavigate?.({ preventDefault() {
+				navigatePrevented = true;
+			} });
+			if (navigatePrevented) {
+				e.preventDefault();
+				return;
+			}
+			e.preventDefault();
+			router.visit(hrefWithData.value, {
+				method: normalizedMethod.value,
+				data: isGet.value ? void 0 : props.data,
+				preserveScroll: props.preserveScroll,
+				preserveState: props.preserveState,
+				replace: props.replace,
+				viewTransition: props.viewTransition
+			});
+		}
+		let hoverTimer = null;
+		let observer = null;
+		function onMouseEnter(e) {
+			callHandler(attrs.onMouseenter ?? attrs.onMouseEnter, e);
+			if (e.defaultPrevented) return;
+			hoverTimer = setTimeout(doPrefetch, router?._hoverDelay ?? 75);
+		}
+		function onMouseLeave(e) {
+			callHandler(attrs.onMouseleave ?? attrs.onMouseLeave, e);
+			if (hoverTimer) {
+				clearTimeout(hoverTimer);
+				hoverTimer = null;
+			}
+		}
+		function onFocus(e) {
+			callHandler(attrs.onFocus, e);
+			if (!e.defaultPrevented) doPrefetch();
+		}
+		function onMouseDown(e) {
+			callHandler(attrs.onMousedown ?? attrs.onMouseDown, e);
+			if (!e.defaultPrevented) doPrefetch();
+		}
+		function onTouchStart(e) {
+			callHandler(attrs.onTouchstart ?? attrs.onTouchStart, e);
+			if (!e.defaultPrevented) doPrefetch();
+		}
+		onMounted(() => {
+			if (strategies.value.includes("mount")) doPrefetch();
+			if (strategies.value.includes("visible") && elRef.value) {
+				observer = new IntersectionObserver((entries) => {
+					if (entries.some((e) => e.isIntersecting)) {
+						doPrefetch();
+						observer?.disconnect();
+						observer = null;
+					}
+				}, { rootMargin: "0px" });
+				observer.observe(elRef.value);
+			}
+		});
+		onUnmounted(() => {
+			if (hoverTimer) clearTimeout(hoverTimer);
+			if (observer) {
+				observer.disconnect();
+				observer = null;
+			}
+		});
+		return () => {
+			if (hasPrefetch(props.prefetch) && !isGet.value) throw new Error("Link: prefetch only supports GET links. Remove `prefetch` or use method=\"GET\".");
+			if (props.reloadDocument && !isGet.value) throw new Error("Link: reloadDocument only supports GET links.");
+			const tag = isGet.value ? "a" : "button";
+			const eventHandlers = { onClick };
+			if (strategies.value.includes("hover")) {
+				eventHandlers.onMouseenter = onMouseEnter;
+				eventHandlers.onMouseleave = onMouseLeave;
+				eventHandlers.onFocus = onFocus;
+				eventHandlers.onTouchstart = onTouchStart;
+			}
+			if (strategies.value.includes("click")) {
+				eventHandlers.onMousedown = onMouseDown;
+				eventHandlers.onTouchstart = onTouchStart;
+			}
+			return h(tag, {
+				...attrs,
+				ref: elRef,
+				...isGet.value ? { href: hrefWithData.value } : { type: "button" },
+				style: [{ touchAction: "manipulation" }, attrs.style],
+				...eventHandlers
+			}, slots.default?.());
+		};
+	}
+});
+//#endregion
+//#region src/runtime/use-router.ts
+function useRouter() {
+	return inject("__void_router", null) ?? ssrProxy;
+}
+//#endregion
+//#region src/runtime/use-shared.ts
+function useShared() {
+	const shared = inject("__void_shared");
+	if (!shared) throw new Error("useShared(): must be used inside a Void page.");
+	return shared;
+}
+//#endregion
+//#region src/runtime/use-form.ts
+function getValidationErrors$1(error) {
+	const body = error.body;
+	if (body && typeof body === "object" && "errors" in body && body.errors && typeof body.errors === "object" && !Array.isArray(body.errors)) return body.errors;
+	return null;
+}
+function useForm(url, defaults, options) {
+	let resolvedUrl = url;
+	const formDefaults = defaults;
+	let actionQuery = "";
+	const qIdx = resolvedUrl.indexOf("?");
+	if (qIdx !== -1) {
+		actionQuery = resolvedUrl.slice(qIdx);
+		resolvedUrl = resolvedUrl.slice(0, qIdx);
+	}
+	if (options?.params) for (const [key, value] of Object.entries(options.params)) resolvedUrl = resolvedUrl.replace(`:${key}`, encodeURIComponent(value));
+	resolvedUrl = resolvedUrl + actionQuery;
+	const router = inject("__void_router", null);
+	const data = reactive({ ...formDefaults });
+	const errors = reactive({});
+	const error = ref(null);
+	const pending = ref(false);
+	const wasSuccessful = ref(false);
+	const recentlySuccessful = ref(false);
+	let defaults_ = { ...formDefaults };
+	let successTimeout = null;
+	const hasChanges = ref(false);
+	watch(() => ({ ...data }), (val) => {
+		hasChanges.value = Object.keys(defaults_).some((key) => !isEqualFormValue(val[key], defaults_[key]));
+	}, { deep: true });
+	function reset(...fields) {
+		if (fields.length === 0) Object.assign(data, { ...defaults_ });
+		else for (const field of fields) data[field] = defaults_[field];
+	}
+	function clearErrors(...fields) {
+		if (fields.length === 0) for (const key of Object.keys(errors)) delete errors[key];
+		else for (const field of fields) delete errors[field];
+	}
+	function clearError() {
+		error.value = null;
+	}
+	async function submit(method, opts = {}) {
+		pending.value = true;
+		wasSuccessful.value = false;
+		recentlySuccessful.value = false;
+		if (successTimeout) clearTimeout(successTimeout);
+		clearErrors();
+		clearError();
+		try {
+			if (!router) throw new Error("useForm(): requires the Void Router.");
+			const result = await submitAction(router, resolvedUrl, {
+				method,
+				data: { ...data },
+				...opts
+			});
+			if (!result.ok) {
+				const validationErrors = getValidationErrors$1(result.error);
+				if (validationErrors) Object.assign(errors, validationErrors);
+				else error.value = result.error;
+				return;
+			}
+			wasSuccessful.value = true;
+			recentlySuccessful.value = true;
+			defaults_ = { ...data };
+			successTimeout = setTimeout(() => {
+				recentlySuccessful.value = false;
+			}, 2e3);
+		} catch (submitError) {
+			if (isAbortError(submitError)) return;
+			throw submitError;
+		} finally {
+			pending.value = false;
+		}
+	}
+	return reactive({
+		data,
+		errors,
+		error,
+		pending,
+		hasChanges,
+		wasSuccessful,
+		recentlySuccessful,
+		reset,
+		clearErrors,
+		clearError,
+		post: (opts) => submit("POST", opts),
+		put: (opts) => submit("PUT", opts),
+		patch: (opts) => submit("PATCH", opts),
+		delete: (opts) => submit("DELETE", opts)
+	});
+}
+//#endregion
+//#region src/runtime/use-navigation.ts
+function useNavigation() {
+	return inject("__void_navigation", null) ?? idleNavigationState();
+}
+//#endregion
+//#region src/runtime/use-island-form.ts
+function getValidationErrors(body) {
+	if (body && typeof body === "object" && "errors" in body && body.errors && typeof body.errors === "object" && !Array.isArray(body.errors)) return body.errors;
+	return null;
+}
+async function readActionErrorBody(response) {
+	const contentType = response.headers.get("content-type") || "";
+	try {
+		if (contentType.includes("application/json")) return await response.json();
+		return await response.text() || null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Form composable for island pages. Uses fetch + page reload instead of the
+* Void Router (which is not available in island mode).
+*/
+function useIslandForm(defaults) {
+	const data = reactive({ ...defaults });
+	const errors = reactive({});
+	const error = ref(null);
+	const pending = ref(false);
+	const wasSuccessful = ref(false);
+	const recentlySuccessful = ref(false);
+	let defaults_ = { ...defaults };
+	let successTimeout = null;
+	const hasChanges = ref(false);
+	watch(() => ({ ...data }), (val) => {
+		hasChanges.value = Object.keys(defaults_).some((key) => !isEqualFormValue(val[key], defaults_[key]));
+	}, { deep: true });
+	function reset(...fields) {
+		if (fields.length === 0) Object.assign(data, { ...defaults_ });
+		else for (const field of fields) data[field] = defaults_[field];
+	}
+	function clearErrors(...fields) {
+		if (fields.length === 0) for (const key of Object.keys(errors)) delete errors[key];
+		else for (const field of fields) delete errors[field];
+	}
+	function clearError() {
+		error.value = null;
+	}
+	async function submit(url, method) {
+		pending.value = true;
+		wasSuccessful.value = false;
+		recentlySuccessful.value = false;
+		if (successTimeout) clearTimeout(successTimeout);
+		clearErrors();
+		clearError();
+		try {
+			const response = await fetch(url, {
+				method,
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(data)
+			});
+			if (response.redirected) {
+				window.location.href = response.url;
+				return;
+			}
+			if (response.ok) {
+				wasSuccessful.value = true;
+				recentlySuccessful.value = true;
+				defaults_ = { ...data };
+				successTimeout = setTimeout(() => {
+					recentlySuccessful.value = false;
+				}, 2e3);
+				window.location.reload();
+			} else if (!response.ok) {
+				const body = await readActionErrorBody(response);
+				const actionError = new VoidActionError({
+					body,
+					status: response.status,
+					statusText: response.statusText,
+					url
+				});
+				const validationErrors = response.status === 422 ? getValidationErrors(body) : null;
+				if (validationErrors) {
+					Object.assign(errors, validationErrors);
+					return;
+				}
+				if (categorizeActionError(response.status) === "boundary") throw actionError;
+				error.value = actionError;
+			}
+		} finally {
+			pending.value = false;
+		}
+	}
+	return reactive({
+		data,
+		errors,
+		error,
+		pending,
+		hasChanges,
+		wasSuccessful,
+		recentlySuccessful,
+		submit,
+		reset,
+		clearErrors,
+		clearError,
+		post: (url) => submit(url, "POST"),
+		put: (url) => submit(url, "PUT"),
+		patch: (url) => submit(url, "PATCH"),
+		delete: (url) => submit(url, "DELETE")
+	});
+}
+//#endregion
+//#region src/runtime/action.ts
+let _router = null;
+/** Called during app initialization to store the router instance */
+function setActionRouter(router) {
+	_router = router;
+}
+/** Programmatic one-shot page action call with Inertia page update */
+async function action(url, ...args) {
+	if (!_router) throw new Error("action(): called before router initialization.");
+	const options = args[0];
+	const data = options?.data;
+	const method = options?.method || "POST";
+	let resolvedUrl = url;
+	let actionQuery = "";
+	const qIdx = resolvedUrl.indexOf("?");
+	if (qIdx !== -1) {
+		actionQuery = resolvedUrl.slice(qIdx);
+		resolvedUrl = resolvedUrl.slice(0, qIdx);
+	}
+	if (options?.params) for (const [key, value] of Object.entries(options.params)) resolvedUrl = resolvedUrl.replace(`:${key}`, encodeURIComponent(value));
+	resolvedUrl = resolvedUrl + actionQuery;
+	return submitAction(_router, resolvedUrl, {
+		method,
+		data
+	});
+}
+//#endregion
+export { useForm as a, Link as c, useNavigation as i, setActionRouter as n, useShared as o, useIslandForm as r, useRouter as s, action as t };

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@void/vue",
+  "version": "0.0.0",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./plugin": {
+      "types": "./dist/plugin.d.mts",
+      "import": "./dist/plugin.mjs"
+    },
+    "./runtime": {
+      "types": "./dist/runtime/index.d.mts",
+      "import": "./dist/runtime/index.mjs"
+    },
+    "./deferred": {
+      "types": "./dist/runtime/use-deferred.d.mts",
+      "import": "./dist/runtime/use-deferred.mjs"
+    },
+    "./prefetch": {
+      "types": "./dist/runtime/prefetch.d.mts",
+      "import": "./dist/runtime/prefetch.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsgo --noEmit"
+  },
+  "dependencies": {
+    "@vitejs/plugin-vue": "^6.0.6"
+  },
+  "devDependencies": {
+    "@types/node": "catalog:",
+    "pathe": "catalog:",
+    "tsdown": "catalog:",
+    "vite": "catalog:",
+    "void": "workspace:*",
+    "vue": "^3.5.33"
+  },
+  "peerDependencies": {
+    "vite": "catalog:",
+    "void": "workspace:*",
+    "vue": "^3.5.0"
+  }
+}