@void/vue 0.0.0

package/README.md

@@ -0,0 +1,113 @@
+# @void/vue
+
+Vue adapter for Void Pages mode.
+
+## Setup
+
+```ts
+import { defineConfig } from 'vite';
+import { voidPlugin } from 'void';
+import { voidVue } from '@void/vue/plugin';
+
+export default defineConfig({
+  plugins: [voidPlugin(), voidVue()],
+});
+```
+
+## Plugin
+
+`voidVue(options?)` returns:
+
+- `@vitejs/plugin-vue`
+- the Vue pages plugin
+- the Vue islands plugin
+
+Options:
+
+- `vue?` — forwarded to `@vitejs/plugin-vue`
+- `viewTransitions?` — enable View Transitions for SPA navigation
+
+## Runtime
+
+Main runtime APIs live at `@void/vue`:
+
+- `Link`
+- `useRouter()`
+- `useNavigation()`
+- `useShared()`
+- `useForm()`
+- `useIslandForm()`
+- `action()`
+
+Deferred helpers are exported from `@void/vue/deferred`.
+
+### Link
+
+`Link` renders an `<a>` for GET navigation and a `<button>` for mutation methods:
+
+```vue
+<Link href="/users" :data="{ page: 2, tag: ['active', 'new'] }">Filtered users</Link>
+<Link href="/users" replace>Users</Link>
+<Link href="/logout" reload-document>Sign out</Link>
+```
+
+GET `data` is merged into the rendered `href` query string. Primitive values are serialized with `String(value)`, arrays become repeated keys, `null` and `undefined` are omitted, and nested objects throw.
+
+`prefetch` and `reloadDocument` are GET-only and throw for mutation links. `onNavigate` can cancel client-side navigation by calling `event.preventDefault()`.
+
+### Forms
+
+`useForm()` tracks form state for Pages actions. Use `pending` for in-flight
+state, `errors` for field validation, and `error` for non-validation call-site
+failures. The submit helpers return promises so boundary-class failures can
+propagate through Vue async error handling or explicit `catch` handlers.
+
+```vue
+<script setup lang="ts">
+import { useForm } from '@void/vue';
+
+const form = useForm('/users', { name: '', email: '' });
+</script>
+
+<template>
+  <form @submit.prevent="form.post()">
+    <input v-model="form.data.name" name="name" />
+    <p v-if="form.errors.name">{{ form.errors.name }}</p>
+    <p v-if="form.error">{{ form.error.message }}</p>
+    <button :disabled="form.pending">Save</button>
+  </form>
+</template>
+```
+
+Use `action()` for the awaitable imperative escape hatch. It returns
+`{ ok: true, pageData }` or `{ ok: false, error }` for call-site action errors,
+while boundary-class failures are thrown. `action()` uses `POST` by default and
+accepts `{ method: "PUT" | "PATCH" | "DELETE" }`.
+
+## Pages
+
+Pages are `.vue` files in `pages/` with companion `.server.ts` files:
+
+```vue
+<script setup lang="ts">
+defineProps<{ title: string }>();
+</script>
+
+<template>
+  <h1>{{ title }}</h1>
+</template>
+```
+
+```ts
+import { defineHandler } from 'void';
+
+export const loader = defineHandler(() => ({ title: 'Home' }));
+```
+
+## Tests
+
+- `test/unit/use-form.test.ts`
+- `test/unit/prefetch.test.ts`
+- `test/integration/vue-pages-client.test.ts`
+
+Cross-package SSR/protocol coverage for Vue pages mode also lives in `framework/packages/void/test/integration/*`.

package/dist/index-C0fE29Kv.d.mts

@@ -0,0 +1,79 @@
+import { Component } from "vue";
+import { ActionResult, NavigationState, VisitOptions, VoidActionError, VoidRouter } from "void/pages-client";
+import { CloudContextVariables, DeferredState as Deferred, InferProps } from "void";
+import { ActionFormOptions, ActionUrl, ResolveActionBody, ResolveActionParams } from "void/routes";
+
+//#region src/runtime/link.d.ts
+declare const Link: Component;
+//#endregion
+//#region src/runtime/use-router.d.ts
+declare function useRouter(): VoidRouter;
+//#endregion
+//#region src/runtime/use-shared.d.ts
+declare function useShared<T = CloudContextVariables["shared"]>(): T;
+//#endregion
+//#region src/runtime/use-form.d.ts
+type FormSubmitOptions = Omit<VisitOptions, "method" | "data"> & {
+  data?: Record<string, unknown>;
+};
+declare function useForm<U extends ActionUrl & string>(url: U, defaults: ResolveActionBody<U>, options?: ActionFormOptions<U>): {
+  data: ResolveActionBody<U>;
+  errors: Partial<Record<keyof ResolveActionBody<U> & string, string>>;
+  error: VoidActionError | null;
+  pending: boolean;
+  hasChanges: boolean;
+  wasSuccessful: boolean;
+  recentlySuccessful: boolean;
+  post(opts?: FormSubmitOptions): Promise<void>;
+  put(opts?: FormSubmitOptions): Promise<void>;
+  patch(opts?: FormSubmitOptions): Promise<void>;
+  delete(opts?: FormSubmitOptions): Promise<void>;
+  reset(...fields: Array<keyof ResolveActionBody<U> & string>): void;
+  clearErrors(...fields: Array<keyof ResolveActionBody<U> & string>): void;
+  clearError(): void;
+};
+//#endregion
+//#region src/runtime/use-navigation.d.ts
+declare function useNavigation(): NavigationState;
+//#endregion
+//#region src/runtime/use-island-form.d.ts
+interface IslandFormReturn<T extends Record<string, unknown>> {
+  data: T;
+  errors: Record<string, string>;
+  error: VoidActionError | null;
+  pending: boolean;
+  hasChanges: boolean;
+  wasSuccessful: boolean;
+  recentlySuccessful: boolean;
+  submit(url: string, method: string): Promise<void>;
+  post(url: string): Promise<void>;
+  put(url: string): Promise<void>;
+  patch(url: string): Promise<void>;
+  delete(url: string): Promise<void>;
+  reset(...fields: Array<keyof T & string>): void;
+  clearErrors(...fields: Array<string>): void;
+  clearError(): void;
+}
+/**
+* Form composable for island pages. Uses fetch + page reload instead of the
+* Void Router (which is not available in island mode).
+*/
+declare function useIslandForm<T extends Record<string, unknown>>(defaults: T): IslandFormReturn<T>;
+//#endregion
+//#region src/runtime/action.d.ts
+type ActionMethod = "POST" | "PUT" | "PATCH" | "DELETE";
+type HasParams<U extends string> = [ResolveActionParams<U>] extends [never] ? false : true;
+type ActionOptions<U extends string> = {
+  data?: ResolveActionBody<U>;
+  method?: ActionMethod;
+} & (HasParams<U> extends true ? {
+  params: ResolveActionParams<U>;
+} : {
+  params?: never;
+});
+/** Called during app initialization to store the router instance */
+declare function setActionRouter(router: VoidRouter): void;
+/** Programmatic one-shot page action call with Inertia page update */
+declare function action<U extends ActionUrl & string>(url: U, ...args: HasParams<U> extends true ? [options: ActionOptions<U>] : [options?: ActionOptions<U>]): Promise<ActionResult>;
+//#endregion
+export { useIslandForm as a, useShared as c, setActionRouter as i, useRouter as l, InferProps as n, useNavigation as o, action as r, useForm as s, Deferred as t, Link as u };

package/dist/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/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/plugin.d.mts

@@ -0,0 +1,11 @@
+import vue from "@vitejs/plugin-vue";
+import { Plugin } from "vite";
+
+//#region src/plugin.d.ts
+interface VoidVueOptions {
+  vue?: Parameters<typeof vue>[0];
+  viewTransitions?: boolean;
+}
+declare function voidVue(options?: VoidVueOptions): Array<Plugin>;
+//#endregion
+export { VoidVueOptions, voidVue };