@revojs/vue 0.1.56 → 0.2.0

package/dist/client/index.d.ts

@@ -1,35 +1 @@
-import { Component, MaybeRefOrGetter, Ref, ShallowRef } from "vue";
-import * as _$revojs from "revojs";
-import { RouterContext, Scope } from "revojs";
-
-//#region src/client/index.d.ts
-interface AsyncOptions<T> {
-  catch?: (error: T) => void | Promise<void>;
-}
-declare function useScope(): Scope;
-declare function useError(scope?: Scope): ShallowRef<Error>;
-declare function useRouter(): {
-  context: ShallowRef<RouterContext<Component>>;
-  navigate: (path: string) => void;
-  anchorNavigate: (event: Event) => void;
-};
-declare function useState<T>(name: MaybeRefOrGetter<string>): Ref<T | undefined>;
-declare function useState<T>(name: MaybeRefOrGetter<string>, value: T): Ref<T>;
-declare function useAsync<T, TError = Error>(name: MaybeRefOrGetter<string>, invoke: () => Promise<T>, defaultOptions?: AsyncOptions<TError>): Promise<{
-  state: Ref<T | undefined, T | undefined>;
-  isLoading: Ref<boolean, boolean>;
-  refresh: (options?: AsyncOptions<TError>) => Promise<T | undefined>;
-}>;
-declare function useFetch<T, TError = Error>(input: MaybeRefOrGetter<string>, options?: RequestInit & AsyncOptions<TError>): Promise<{
-  state: Ref<T | undefined, T | undefined>;
-  isLoading: Ref<boolean, boolean>;
-  refresh: (options?: AsyncOptions<TError> | undefined) => Promise<T | undefined>;
-}>;
-declare function refreshAsync(input?: string | Array<string>): Promise<void[] | undefined>;
-declare const isServerSideRendering: any;
-declare const NAVIGATE_HOOK: _$revojs.Descriptor<_$revojs.Invoke>;
-declare const REFRESH_ASYNC_HOOK: _$revojs.Descriptor<(names?: Array<string>) => Promise<void>>;
-declare const CLIENT_ERROR_CONTEXT: _$revojs.Descriptor<ShallowRef<Error>>;
-declare const CLIENT_ROUTER_CONTEXT: _$revojs.Descriptor<ShallowRef<RouterContext<Component>>>;
-//#endregion
-export { AsyncOptions, CLIENT_ERROR_CONTEXT, CLIENT_ROUTER_CONTEXT, NAVIGATE_HOOK, REFRESH_ASYNC_HOOK, isServerSideRendering, refreshAsync, useAsync, useError, useFetch, useRouter, useScope, useState };
+export {};

package/dist/client/index.js

@@ -1,98 +1,6 @@
-import { customRef, getCurrentScope, inject, isRef, onScopeDispose, ref, toValue, watch } from "vue";
-import { defineContext, defineHook, fetch, getState, isClient, isServer, sendRedirect, setState } from "revojs";
+import { createVueApp } from "../index.js";
+import { createScope } from "revojs";
 //#region src/client/index.ts
-function useScope() {
-	const scope = inject("REVOJS_SCOPE");
-	if (scope) return scope;
-	throw new Error();
-}
-function useError(scope = useScope()) {
-	return scope.getContext(CLIENT_ERROR_CONTEXT);
-}
-function useRouter() {
-	const scope = useScope();
-	const context = scope.getContext(CLIENT_ROUTER_CONTEXT);
-	const navigate = (path) => {
-		if (isClient) {
-			if (window.location.pathname != path) window.history.pushState(window.history.state, "", path);
-			scope.dispatchHook(NAVIGATE_HOOK);
-		}
-		if (isServer) throw sendRedirect(scope, path);
-	};
-	const anchorNavigate = (event) => {
-		event.preventDefault();
-		navigate(event.currentTarget?.getAttribute("href") ?? "/");
-	};
-	return {
-		context,
-		navigate,
-		anchorNavigate
-	};
-}
-function useState(name, value) {
-	const scope = useScope();
-	return customRef((track, trigger) => ({
-		get() {
-			track();
-			return getState(scope, toValue(name)) ?? value;
-		},
-		set(update) {
-			setState(scope, toValue(name), update);
-			trigger();
-		}
-	}));
-}
-async function useAsync(name, invoke, defaultOptions) {
-	const scope = useScope();
-	const state = useState(name);
-	const isLoading = ref(false);
-	const refresh = async (options) => {
-		const onCatch = options?.catch ?? defaultOptions?.catch;
-		isLoading.value = true;
-		try {
-			state.value = await invoke();
-		} catch (error) {
-			state.value = void 0;
-			onCatch?.(error);
-		} finally {
-			isLoading.value = false;
-		}
-		return state.value;
-	};
-	const task = refresh();
-	if (isServer) await task;
-	if (isClient) onScopeDispose(scope.registerHook(REFRESH_ASYNC_HOOK, async (names) => {
-		if (names === void 0 || names?.includes(toValue(name))) await refresh();
-	}));
-	return {
-		state,
-		isLoading,
-		refresh
-	};
-}
-async function useFetch(input, options) {
-	const scope = useScope();
-	const effectScope = getCurrentScope();
-	const { state, isLoading, refresh } = await useAsync(input, () => fetch(scope, toValue(input), options), options);
-	if (isClient && (isRef(input) || typeof input === "function")) effectScope?.run(() => {
-		watch(input, async (next, previous) => {
-			if (next !== previous) await refresh();
-		}, { flush: "post" });
-	});
-	return {
-		state,
-		isLoading,
-		refresh
-	};
-}
-async function refreshAsync(input) {
-	const scope = useScope();
-	if (isClient) return await scope.dispatchHook(REFRESH_ASYNC_HOOK, input === void 0 ? void 0 : Array.isArray(input) ? input : [input]);
-}
-const isServerSideRendering = import.meta.SERVER_SIDE_RENDERING ?? globalThis?.import?.meta?.SERVER_SIDE_RENDERING;
-const NAVIGATE_HOOK = defineHook("NAVIGATE_HOOK");
-const REFRESH_ASYNC_HOOK = defineHook("REFRESH_ASYNC_HOOK");
-const CLIENT_ERROR_CONTEXT = defineContext("CLIENT_ERROR_CONTEXT");
-const CLIENT_ROUTER_CONTEXT = defineContext("CLIENT_ROUTER_CONTEXT");
+await createVueApp(await createScope()).then((app) => app.mount("#app"));
 //#endregion
-export { CLIENT_ERROR_CONTEXT, CLIENT_ROUTER_CONTEXT, NAVIGATE_HOOK, REFRESH_ASYNC_HOOK, isServerSideRendering, refreshAsync, useAsync, useError, useFetch, useRouter, useScope, useState };
+export {};

package/dist/index.d.ts

@@ -1,12 +1,31 @@
-import { Options } from "@vitejs/plugin-vue";
-import { App, Module } from "revojs";
-
-//#region src/index.d.ts
-interface VueOptions {
-  serverSideRendering?: boolean;
-  compilerOption?: Options;
+import { type RouterContext, type Scope } from "revojs";
+import type { Awaitable } from "revojs/shared";
+import { type Component, type MaybeRefOrGetter, type Ref, type ShallowRef } from "vue";
+export interface AsyncOptions<T> {
+    catch?: (error: T) => Awaitable<void>;
 }
-declare function addPages(app: App, path: string): void;
-declare function vue(options?: VueOptions): Module;
-//#endregion
-export { VueOptions, addPages, vue };
+export declare function useScope(): Scope;
+export declare function useError(scope?: Scope): ShallowRef<Error>;
+export declare function useRouter(): {
+    context: ShallowRef<RouterContext<Component>>;
+    navigate: <TRoute extends string>(route: TRoute) => void;
+    anchorNavigate: (event: Event) => void;
+};
+export declare function useState<T>(name: MaybeRefOrGetter<string>): Ref<T | undefined>;
+export declare function useState<T>(name: MaybeRefOrGetter<string>, value: T): Ref<T>;
+export declare function useAsync<T, TError = Error>(name: MaybeRefOrGetter<string>, invoke: () => Awaitable<T>, defaultOptions?: AsyncOptions<TError>): Promise<{
+    state: Ref<T | undefined, T | undefined>;
+    isLoading: Ref<boolean, boolean>;
+    refresh: (options?: AsyncOptions<TError>) => Promise<T | undefined>;
+}>;
+export declare function useFetch<T, TError = Error>(input: MaybeRefOrGetter<string>, options?: RequestInit & AsyncOptions<TError>): Promise<{
+    state: Ref<T | undefined, T | undefined>;
+    isLoading: Ref<boolean, boolean>;
+    refresh: (options?: AsyncOptions<TError> | undefined) => Promise<T | undefined>;
+}>;
+export declare function refreshAsync(input?: string | Array<string>): Promise<void[] | undefined>;
+export declare function createVueApp(scope: Scope): Promise<import("vue").App<Element>>;
+export declare const NAVIGATE_HOOK: import("revojs").Descriptor<import("revojs").Hook>;
+export declare const REFRESH_ASYNC_HOOK: import("revojs").Descriptor<(names?: Array<string>) => Promise<void>>;
+export declare const CLIENT_ERROR_CONTEXT: import("revojs").Descriptor<ShallowRef<Error>>;
+export declare const CLIENT_ROUTER_CONTEXT: import("revojs").Descriptor<ShallowRef<RouterContext<Component>>>;

package/dist/index.js

@@ -1,47 +1,154 @@
-import vueCompiler from "@vitejs/plugin-vue";
-import { addRoutes, addTypes, useKit } from "revojs/kit";
+import pages from "#pages";
+import { isClient, isServer, isServerSideRendering } from "#variables";
+import { fetch, getState, sendRedirect, setState, useUrl } from "@revojs/server";
+import { Router, defineContext, defineHook, dispatchHook, getContext, registerHook, setContext } from "revojs";
+import { Suspense, computed, createApp, createCommentVNode, createSSRApp, customRef, defineAsyncComponent, defineComponent, getCurrentScope, h, inject, isRef, onErrorCaptured, onScopeDispose, ref, shallowRef, toValue, warn, watch } from "vue";
 //#region src/index.ts
-function addPages(app, path) {
-	app.config.sources.pages?.entries.push(path);
-}
-function vue(options) {
-	return { setup(app) {
-		const { fromModule } = useKit(import.meta.url);
-		app.config.template.head.children.push({
-			tagName: "script",
-			attributes: { type: "module" },
-			children: [`import "${fromModule("./runtime/entry.js")}"`]
-		}, {
-			tagName: "script",
-			attributes: {
-				id: "states",
-				type: "application/json"
-			},
-			children: ["<!-- STATES -->"]
+function useScope() {
+	const scope = inject("REVOJS_SCOPE");
+	if (scope) return scope;
+	throw new Error("Vue scope is unavailable");
+}
+function useError(scope = useScope()) {
+	return getContext(scope, CLIENT_ERROR_CONTEXT);
+}
+function useRouter() {
+	const scope = useScope();
+	const context = getContext(scope, CLIENT_ROUTER_CONTEXT);
+	const navigate = (route) => {
+		if (isClient) {
+			if (globalThis.location.pathname !== route) globalThis.history.pushState(globalThis.history.state, "", route);
+			dispatchHook(scope, NAVIGATE_HOOK);
+		}
+		if (isServer) throw sendRedirect(scope, route);
+	};
+	const anchorNavigate = (event) => {
+		event.preventDefault();
+		navigate(event.currentTarget?.getAttribute("href") ?? "/");
+	};
+	return {
+		context,
+		navigate,
+		anchorNavigate
+	};
+}
+function useState(name, value) {
+	const scope = useScope();
+	return customRef((track, trigger) => ({
+		get() {
+			track();
+			return getState(scope, toValue(name)) ?? value;
+		},
+		set(update) {
+			setState(scope, toValue(name), update);
+			trigger();
+		}
+	}));
+}
+async function useAsync(name, invoke, defaultOptions) {
+	const scope = useScope();
+	const state = useState(name);
+	const isLoading = ref(false);
+	const refresh = async (options) => {
+		const onCatch = options?.catch ?? defaultOptions?.catch;
+		isLoading.value = true;
+		try {
+			state.value = await invoke();
+		} catch (error) {
+			state.value = void 0;
+			onCatch?.(error);
+		} finally {
+			isLoading.value = false;
+		}
+		return state.value;
+	};
+	const task = refresh();
+	if (isServer) await task;
+	if (isClient) onScopeDispose(registerHook(scope, REFRESH_ASYNC_HOOK, async (names) => {
+		if (names === void 0 || names?.includes(toValue(name))) await refresh();
+	}));
+	return {
+		state,
+		isLoading,
+		refresh
+	};
+}
+async function useFetch(input, options) {
+	const scope = useScope();
+	const effectScope = getCurrentScope();
+	const { state, isLoading, refresh } = await useAsync(input, () => fetch(scope, toValue(input), options), options);
+	if (isClient && (isRef(input) || typeof input === "function")) effectScope?.run(() => {
+		watch(input, async (next, previous) => {
+			if (next !== previous) await refresh();
+		}, { flush: "post" });
+	});
+	return {
+		state,
+		isLoading,
+		refresh
+	};
+}
+async function refreshAsync(input) {
+	const scope = useScope();
+	if (isClient) return await dispatchHook(scope, REFRESH_ASYNC_HOOK, input === void 0 ? void 0 : Array.isArray(input) ? input : [input]);
+}
+async function createVueApp(scope) {
+	const router = new Router();
+	const error = shallowRef();
+	const context = shallowRef();
+	for (const entries of Object.values(pages)) for (const [path, resolve] of Object.entries(entries)) {
+		const segments = path.split("/");
+		for (const attribute of segments.pop()?.split(".") ?? []) {
+			if (attribute === "page") continue;
+			segments.push(attribute);
+		}
+		router.use(segments, defineAsyncComponent(resolve));
+	}
+	const navigate = async () => {
+		const path = useUrl(scope).pathname.replace(/^\/+/, "").replace(/\/+$/, "");
+		const segments = path === "" ? [] : path.split("/");
+		context.value = await router.resolve(scope, segments);
+	};
+	registerHook(scope, NAVIGATE_HOOK, navigate);
+	setContext(scope, CLIENT_ERROR_CONTEXT, error);
+	setContext(scope, CLIENT_ROUTER_CONTEXT, context);
+	await navigate();
+	const app = (isServerSideRendering ? createSSRApp(h(Main, { navigate })) : createApp(h(Main, { navigate }))).provide("REVOJS_SCOPE", scope);
+	app.config.warnHandler = (message, instance, trace) => {
+		if (message.includes("Invalid vnode type when creating vnode") || message.includes("Component <Anonymous> is missing template or render function")) return;
+		warn(message, instance, trace);
+	};
+	app.config.throwUnhandledErrorInProduction = true;
+	return app;
+}
+var Main = defineComponent({
+	name: "Main",
+	props: { navigate: {
+		type: Function,
+		required: true
+	} },
+	setup({ navigate }) {
+		const scope = useScope();
+		const error = getContext(scope, CLIENT_ERROR_CONTEXT);
+		const context = getContext(scope, CLIENT_ROUTER_CONTEXT);
+		const match = computed(() => {
+			if (!context.value?.match) return;
+			return context.value.hooks.reduceRight((child, hook) => h(hook, null, { default: () => child }), h(context.value.match, { key: context.value.segments.join("/") }));
 		});
-		app.config.template.body.children.push({
-			tagName: "div",
-			attributes: { id: "app" },
-			children: ["<!-- APP -->"]
+		if (isClient) {
+			globalThis.addEventListener("popstate", navigate);
+			onScopeDispose(() => globalThis.removeEventListener("popstate", navigate));
+		}
+		onErrorCaptured((value) => {
+			error.value = value;
+			return false;
 		});
-		addRoutes(app, fromModule("./runtime/routes"));
-		addTypes(app, "revojs-vue", () => `import "@revojs/vue/types"`);
-		return {
-			variables: { SERVER_SIDE_RENDERING: options?.serverSideRendering ?? true },
-			sources: { pages: {
-				match: ["**/page.vue", "**/+layout.vue"],
-				entries: ["./routes"]
-			} },
-			vite: {
-				plugins: [vueCompiler(options?.compilerOption)],
-				resolve: { alias: {
-					"#vue/app": fromModule("./runtime/app.js"),
-					"#vue/main": fromModule("./runtime/main.vue")
-				} },
-				optimizeDeps: { exclude: ["vue"] }
-			}
-		};
-	} };
-}
+		return () => h(Suspense, void 0, { default: () => match.value ? h(match.value) : createCommentVNode() });
+	}
+});
+var NAVIGATE_HOOK = defineHook("NAVIGATE_HOOK");
+var REFRESH_ASYNC_HOOK = defineHook("REFRESH_ASYNC_HOOK");
+var CLIENT_ERROR_CONTEXT = defineContext("CLIENT_ERROR_CONTEXT");
+var CLIENT_ROUTER_CONTEXT = defineContext("CLIENT_ROUTER_CONTEXT");
 //#endregion
-export { addPages, vue };
+export { CLIENT_ERROR_CONTEXT, CLIENT_ROUTER_CONTEXT, NAVIGATE_HOOK, REFRESH_ASYNC_HOOK, createVueApp, refreshAsync, useAsync, useError, useFetch, useRouter, useScope, useState };

package/dist/module/index.d.ts

@@ -0,0 +1,7 @@
+import { type Options } from "@vitejs/plugin-vue";
+export interface VueConfig {
+    serverSideRendering?: boolean;
+    compilerOption?: Options;
+}
+declare const _default: import("revojs/module").Module<"vue", VueConfig, readonly [import("revojs/module").Module<"server", Record<string, never>, []>, import("revojs/module").Module<"client", import("@revojs/client/module").ClientConfig, []>]>;
+export default _default;

package/dist/module/index.js

@@ -0,0 +1,62 @@
+import client from "@revojs/client/module";
+import server from "@revojs/server/module";
+import vueCompiler from "@vitejs/plugin-vue";
+import { addTypes, defineModule, useModule } from "revojs/module";
+//#region src/module/index.ts
+var module_default = defineModule({
+	name: "vue",
+	modules: [server, client],
+	config: () => ({ serverSideRendering: true }),
+	setup(config) {
+		const { fromModule } = useModule(import.meta.url);
+		addTypes(config, "vue", () => `import "${fromModule("../types/index.d.ts")}"`);
+		return {
+			variables: {
+				client: { isServerSideRendering: {
+					type: "boolean",
+					default: config.vue.serverSideRendering ?? true
+				} },
+				server: { isServerSideRendering: {
+					type: "boolean",
+					default: config.vue.serverSideRendering ?? true
+				} }
+			},
+			sources: {
+				routes: { from: [fromModule("../routes")] },
+				pages: {
+					match: ["**/page.vue", "**/+layout.vue"],
+					from: ["./routes"]
+				}
+			},
+			client: { html: {
+				head: { children: [{
+					tagName: "script",
+					attributes: { type: "module" },
+					children: [`import "${fromModule("../client/index.js")}"`]
+				}, {
+					tagName: "script",
+					attributes: {
+						id: "states",
+						type: "application/json"
+					},
+					children: ["<!-- STATES -->"]
+				}] },
+				body: { children: [{
+					tagName: "div",
+					attributes: { id: "app" },
+					children: ["<!-- APP -->"]
+				}, {
+					tagName: "div",
+					attributes: { id: "teleports" },
+					children: ["<!-- TELEPORTS -->"]
+				}] }
+			} },
+			vite: {
+				plugins: [vueCompiler(config.vue.compilerOption)],
+				optimizeDeps: { exclude: ["vue"] }
+			}
+		};
+	}
+});
+//#endregion
+export { module_default as default };

package/dist/routes/[...]/get.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    fetch(scope: import("revojs").Scope): Promise<Response>;
+};
+export default _default;

package/dist/routes/[...]/get.js

@@ -0,0 +1,29 @@
+import { createVueApp, useError } from "../../index.js";
+import { isServerSideRendering } from "#variables";
+import { defineRoute, sendOk, useServer } from "@revojs/server";
+import client from "#client";
+import { renderToString } from "vue/server-renderer";
+//#region src/routes/[...]/get.ts
+var get_default = defineRoute({ async fetch(scope) {
+	const { states } = useServer(scope);
+	let content = client;
+	if (isServerSideRendering) {
+		const app = await createVueApp(scope);
+		const context = {};
+		try {
+			content = content.replace("<!-- APP -->", await renderToString(app, context));
+		} catch (error) {
+			throw useError(scope).value ?? error;
+		}
+		let body = "";
+		let container = "";
+		for (const [target, teleport] of Object.entries(context.teleports ?? {})) if (target.toLowerCase() === "body") body += teleport;
+		else container += teleport;
+		content = content.replace(/\s*<!-- TELEPORTS -->\s*/, () => container);
+		if (body) content = content.replace(/<body[^>]*>/i, (opening) => opening + body);
+	}
+	const value = JSON.stringify(states).replace(/</g, String.raw`\u003c`).replace(/>/g, String.raw`\u003e`).replace(/&/g, String.raw`\u0026`).replace(/\u2028/g, String.raw`\u2028`).replace(/\u2029/g, String.raw`\u2029`);
+	return sendOk(scope, content.replace(`<!-- STATES -->`, value));
+} });
+//#endregion
+export { get_default as default };

package/dist/{runtime/types → types}/index.d.ts

@@ -5,14 +5,6 @@ declare module "#vue/app" {
     export default function createApp(scope: Scope): Promise<App>;
 }
 
-declare module "#vue/main" {
-    import type { Component } from "vue";
-
-    const main: Component;
-
-    export default app;
-}
-
 declare module "*.vue" {
     import type { DefineComponent } from "vue";
 
@@ -20,6 +12,14 @@ declare module "*.vue" {
     export default component;
 }
 
-interface ImportMeta {
-    readonly SERVER_SIDE_RENDERING: boolean;
+declare module "#pages" {
+    import type { Source } from "revojs";
+    import type { Component } from "vue";
+
+    const entries: Source<Component>;
+    export default entries;
+}
+
+declare module "#variables" {
+    export const isServerSideRendering: boolean;
 }

package/package.json

@@ -1,8 +1,11 @@
 {
     "name": "@revojs/vue",
-    "version": "0.1.56",
+    "version": "0.2.0",
     "license": "MIT",
-    "repository": "tellua/revojs",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/tellua/revojs.git"
+    },
     "files": [
         "dist"
     ],
@@ -15,21 +18,24 @@
             "types": "./dist/index.d.ts",
             "import": "./dist/index.js"
         },
-        "./client": {
-            "types": "./dist/client/index.d.ts",
-            "import": "./dist/client/index.js"
+        "./module": {
+            "types": "./dist/module/index.d.ts",
+            "import": "./dist/module/index.js"
         },
         "./types": {
-            "types": "./dist/runtime/types/index.d.ts"
+            "types": "./dist/types/index.d.ts"
         }
     },
     "scripts": {
-        "build": "revojs module build"
+        "build": "vite build",
+        "watch": "vite build --watch"
     },
     "dependencies": {
-        "@vitejs/plugin-vue": "^6.0.6",
+        "@revojs/client": "*",
+        "@revojs/server": "*",
+        "@vitejs/plugin-vue": "^6.0.8",
         "revojs": "*",
-        "vue": "^3.5.32"
+        "vue": "^3.5.42"
     },
     "devDependencies": {
         "@revojs/tsconfig": "*"

package/dist/runtime/app.d.ts

@@ -1,7 +0,0 @@
-import * as _$vue from "vue";
-import { Scope } from "revojs";
-
-//#region src/runtime/app.d.ts
-declare const _default: (scope: Scope) => Promise<_$vue.App<Element>>;
-//#endregion
-export { _default as default };

package/dist/runtime/app.js

@@ -1,15 +0,0 @@
-import Main from "#vue/main";
-import { createApp, createSSRApp, warn } from "vue";
-import { isServerSideRendering } from "../client";
-//#region src/runtime/app.ts
-var app_default = async (scope) => {
-	const app = (isServerSideRendering ? createSSRApp(Main) : createApp(Main)).provide("REVOJS_SCOPE", scope);
-	app.config.warnHandler = (message, instance, trace) => {
-		if (message.includes("Invalid vnode type when creating vnode") || message.includes("Component <Anonymous> is missing template or render function")) return;
-		warn(message, instance, trace);
-	};
-	app.config.throwUnhandledErrorInProduction = true;
-	return app;
-};
-//#endregion
-export { app_default as default };

package/dist/runtime/entry.d.ts

@@ -1 +0,0 @@
-export { };

package/dist/runtime/entry.js

@@ -1,5 +0,0 @@
-import createApp from "#vue/app";
-import { Scope } from "revojs";
-//#region src/runtime/entry.ts
-await createApp(new Scope()).then((app) => app.mount("#app"));
-//#endregion

package/dist/runtime/main.vue

@@ -1,74 +0,0 @@
-<template>
-    <Suspense>
-        <component :is="route" v-if="route" />
-    </Suspense>
-</template>
-
-<script setup lang="ts">
-import pages from "#pages";
-import { isClient, Router, RouterContext, useUrl } from "revojs";
-import { computed, h, onErrorCaptured, onScopeDispose, shallowRef, type Component } from "vue";
-import { CLIENT_ERROR_CONTEXT, CLIENT_ROUTER_CONTEXT, NAVIGATE_HOOK, useScope } from "../client";
-
-const scope = useScope();
-
-const error = shallowRef<Error>();
-const context = shallowRef<RouterContext<Component>>();
-
-const router = new Router<Component>();
-
-for (const path in pages) {
-    const segments = path.split("/");
-
-    for (const attribute of segments.pop()?.split(".") ?? []) {
-        if (attribute === "page" || attribute === "vue") {
-            continue;
-        }
-
-        segments.push(attribute);
-    }
-
-    for (const page of pages[path]) {
-        router.use(segments, page);
-    }
-}
-
-const route = computed(() => {
-    if (context.value?.route) {
-        const route = h(context.value.route);
-
-        return context.value.hooks.reduceRight(
-            (previous, hook) =>
-                h(hook, null, {
-                    default: () => (error.value === undefined ? previous : undefined),
-                }),
-            route,
-        );
-    }
-});
-
-const fetch = () => {
-    const next = useUrl(scope);
-
-    const path = next.pathname.replace(/^\/+/, "").replace(/\/+$/, "");
-    const segments = path === "" ? [] : path.split("/");
-
-    context.value = router.match(segments);
-};
-
-scope.registerHook(NAVIGATE_HOOK, fetch);
-
-if (isClient) {
-    window.addEventListener("popstate", fetch);
-    onScopeDispose(() => window.removeEventListener("popstate", fetch));
-}
-
-fetch();
-
-scope.setContext(CLIENT_ERROR_CONTEXT, error);
-scope.setContext(CLIENT_ROUTER_CONTEXT, context);
-
-onErrorCaptured((value) => {
-    error.value ??= value;
-});
-</script>

package/dist/runtime/routes/[...]/get.d.ts

@@ -1,8 +0,0 @@
-import * as _$revojs from "revojs";
-
-//#region src/runtime/routes/[...]/get.d.ts
-declare const _default: {
-  fetch(scope: _$revojs.Scope): Promise<Response>;
-};
-//#endregion
-export { _default as default };

package/dist/runtime/routes/[...]/get.js

@@ -1,20 +0,0 @@
-import { isServerSideRendering, useError } from "../../../client";
-import createApp from "#vue/app";
-import { defineRoute, sendOk, useServer } from "revojs";
-import client from "#client";
-import { renderToString } from "vue/server-renderer";
-//#region src/runtime/routes/[...]/get.ts
-var get_default = defineRoute({ async fetch(scope) {
-	const { states } = useServer(scope);
-	let content = client;
-	if (isServerSideRendering) {
-		const app = await createApp(scope);
-		content = content.replace("<!-- APP -->", await renderToString(app));
-		const error = useError(scope);
-		if (error.value) throw error.value;
-	}
-	const value = JSON.stringify(states).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
-	return sendOk(scope, content.replace(`<!-- STATES -->`, value));
-} });
-//#endregion
-export { get_default as default };

package/dist/runtime/types/pages.d.ts

@@ -1,7 +0,0 @@
-declare module "#pages" {
-    import type { Component } from "vue";
-
-    const entries: Record<string, Array<Component>>;
-
-    export default entries;
-}