@primate/vue 0.15.0 → 0.16.1

package/lib/app.d.ts

@@ -0,0 +1,5 @@
+declare module "app:vue" {
+  import type { RequestPublic } from "@primate/core";
+  import type { Ref } from "vue";
+  export function useRequest(): Ref<RequestPublic>;
+}

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+import "./app.d.ts";
+export { default } from "./public/default";

package/lib/private/client/Data.d.ts

@@ -0,0 +1,5 @@
+import type { Data as CoreData } from "@primate/core/client";
+import type Payload from "#client/Payload";
+type Data = CoreData<Payload>;
+export default Data;
+//# sourceMappingURL=Data.d.ts.map

package/lib/private/client/Data.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Data.js.map

package/lib/private/client/Payload.d.ts

@@ -0,0 +1,7 @@
+import type { Dict } from "@rcompat/type";
+type Payload = {
+    views: string[];
+    props: Dict[];
+};
+export default Payload;
+//# sourceMappingURL=Payload.d.ts.map

package/lib/private/client/Payload.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Payload.js.map

package/lib/private/client/app.d.ts

@@ -1,11 +1,5 @@
-import type ClientData from "@primate/core/client/Data";
-import type { Dict } from "@rcompat/type";
-type Data = ClientData<{
-    views: string[];
-    props: Dict[];
-}>;
+import type Data from "#client/Data";
 export default class VueApp {
-    static mount(_view: string, data: ClientData<Data>): void;
+    static mount(_view: string, data: Data): void;
 }
-export {};
 //# sourceMappingURL=app.d.ts.map

package/lib/private/client/app.js

@@ -1,31 +1,22 @@
-import spa from "@primate/core/client/spa";
-import { createApp, createSSRApp } from "vue";
-import root from "vue:root";
-import * as views from "vue:views";
-function resolve(names) {
-    return names.map(n => views[n]);
-}
-const make_app = (ssr, data, update) => {
-    const create = ssr ? createSSRApp : createApp;
-    return create(root, {
-        p: {
-            views: resolve(data.views),
-            props: data.props,
-            request: data.request,
-            update,
-        },
-    });
-};
+import root from "#client/root";
+import client from "@primate/core/client";
 export default class VueApp {
     static mount(_view, data) {
-        let app = make_app(data.ssr, data);
+        let app = root[data.ssr ? "ssr" : "csr"](root.toProps(data));
         app.mount("#app");
         if (data.spa) {
-            window.addEventListener("DOMContentLoaded", () => spa((next, update) => {
+            const start = () => client.boot((next, update) => {
                 app.unmount();
-                app = make_app(false, next, update);
+                app = root.csr(root.toProps(next, update));
                 app.mount("#app");
-            }));
+                update?.();
+            });
+            if (document.readyState === "loading") {
+                window.addEventListener("DOMContentLoaded", start, { once: true });
+            }
+            else {
+                start();
+            }
         }
     }
 }

package/lib/private/client/form.d.ts

@@ -1,8 +1,9 @@
-import { type FormInit } from "@primate/core/client";
+import type { FormInit } from "@primate/core/client";
 import type { Dict } from "@rcompat/type";
 type FormView<Values extends Dict> = {
     id: string;
     submitting: boolean;
+    submitted: boolean;
     submit: (event?: Event) => Promise<void>;
     errors: readonly string[];
     field: <K extends keyof Values & string>(name: K) => {

package/lib/private/client/form.js

@@ -1,31 +1,38 @@
 import core from "@primate/core/client";
 import { onUnmounted, shallowRef } from "vue";
 function form(init) {
-    const { initial, ...form_init } = init ?? {};
+    const { initial, ...form_init } = (init ?? {});
     const controller = core.createForm(form_init);
-    const values = initial ?? {};
+    const values = (initial ?? {});
     const snapshot = shallowRef(controller.read());
-    const unsub = controller.subscribe(next => {
+    const unsub = controller.subscribe((next) => {
         snapshot.value = next;
     });
     onUnmounted(unsub);
     return {
-        id: controller.id,
+        get id() {
+            return snapshot.value.id;
+        },
         get submitting() {
             return snapshot.value.submitting;
         },
-        submit: (event) => controller.submit(event),
+        get submitted() {
+            return snapshot.value.submitted;
+        },
+        submit(event) {
+            return controller.submit(event);
+        },
         get errors() {
             return snapshot.value.errors.form;
         },
         field(name) {
             const key = name;
-            const errs = snapshot.value.errors.fields[key] ?? [];
+            const errors = snapshot.value.errors.fields[key] ?? [];
             return {
                 name: key,
                 value: values[name],
-                error: errs[0] ?? null,
-                errors: errs,
+                error: errors[0] ?? null,
+                errors,
             };
         },
     };

package/lib/private/client/index.d.ts

@@ -0,0 +1,48 @@
+import form from "#client/form";
+declare const client: {
+    form: typeof form;
+    field: <T>(initial: T) => {
+        delete: (url: string, options?: {
+            headers?: import("@rcompat/type").Dict<string>;
+            map?: ((v: T) => import("@rcompat/type").JSONValue) | undefined;
+            path?: import("@rcompat/type").JSONPointer;
+        } | undefined) => {
+            error: import("vue").Ref<null | import("@primate/core/client").ValidationError>;
+            loading: import("vue").Ref<boolean>;
+            update: (updater: import("@primate/core/client").ValidateUpdater<T>) => Promise<void>;
+            value: import("vue").Ref<T, T>;
+        };
+        patch: (url: string, options?: {
+            headers?: import("@rcompat/type").Dict<string>;
+            map?: ((v: T) => import("@rcompat/type").JSONValue) | undefined;
+            path?: import("@rcompat/type").JSONPointer;
+        } | undefined) => {
+            error: import("vue").Ref<null | import("@primate/core/client").ValidationError>;
+            loading: import("vue").Ref<boolean>;
+            update: (updater: import("@primate/core/client").ValidateUpdater<T>) => Promise<void>;
+            value: import("vue").Ref<T, T>;
+        };
+        post: (url: string, options?: {
+            headers?: import("@rcompat/type").Dict<string>;
+            map?: ((v: T) => import("@rcompat/type").JSONValue) | undefined;
+            path?: import("@rcompat/type").JSONPointer;
+        } | undefined) => {
+            error: import("vue").Ref<null | import("@primate/core/client").ValidationError>;
+            loading: import("vue").Ref<boolean>;
+            update: (updater: import("@primate/core/client").ValidateUpdater<T>) => Promise<void>;
+            value: import("vue").Ref<T, T>;
+        };
+        put: (url: string, options?: {
+            headers?: import("@rcompat/type").Dict<string>;
+            map?: ((v: T) => import("@rcompat/type").JSONValue) | undefined;
+            path?: import("@rcompat/type").JSONPointer;
+        } | undefined) => {
+            error: import("vue").Ref<null | import("@primate/core/client").ValidationError>;
+            loading: import("vue").Ref<boolean>;
+            update: (updater: import("@primate/core/client").ValidateUpdater<T>) => Promise<void>;
+            value: import("vue").Ref<T, T>;
+        };
+    };
+};
+export default client;
+//# sourceMappingURL=index.d.ts.map

package/lib/private/client/index.js

@@ -0,0 +1,5 @@
+import field from "#client/field";
+import form from "#client/form";
+const client = { form, field };
+export default client;
+//# sourceMappingURL=index.js.map

package/lib/private/client/root.d.ts

@@ -0,0 +1,21 @@
+import type Data from "#client/Data";
+import type { Dict } from "@rcompat/type";
+import type { App, Component } from "vue";
+export type RootProps = {
+    views: Component[];
+    props: Dict[];
+    request: Data["request"] & {
+        url: URL;
+    };
+    update?: () => void;
+};
+declare function toProps(data: Data, update?: () => void): RootProps;
+declare function csr(props: RootProps): App;
+declare function ssr(props: RootProps): App;
+declare const root: {
+    toProps: typeof toProps;
+    csr: typeof csr;
+    ssr: typeof ssr;
+};
+export default root;
+//# sourceMappingURL=root.d.ts.map

package/lib/private/client/root.js

@@ -0,0 +1,27 @@
+import { createApp, createSSRApp } from "vue";
+import RootView from "vue:root";
+import * as Views from "vue:views";
+function toProps(data, update) {
+    return {
+        views: data.views.map((name) => Views[name]),
+        props: data.props,
+        request: {
+            ...data.request,
+            url: new URL(data.request.url),
+        },
+        update,
+    };
+}
+function csr(props) {
+    return createApp(RootView, { p: props });
+}
+function ssr(props) {
+    return createSSRApp(RootView, { p: props });
+}
+const root = {
+    toProps,
+    csr,
+    ssr,
+};
+export default root;
+//# sourceMappingURL=root.js.map

package/lib/private/compile.d.ts

@@ -1,4 +1,8 @@
 declare const _default: {
+    client(text: string): {
+        js: string;
+        css: string;
+    };
     server(text: string): string;
 };
 export default _default;

package/lib/private/compile.js

@@ -1,51 +1,61 @@
 import presets from "@primate/core/build/presets";
 import transform from "@primate/core/build/transform";
-import { compileScript, compileTemplate, parse, } from "vue/compiler-sfc";
+import { compileScript, compileStyle, compileTemplate, parse, } from "vue/compiler-sfc";
 const genDefaultAs = "__SCRIPT__";
 const id_size = 8;
 const analyze = ({ script, scriptSetup }) => {
     return {
         has_script: script !== null || scriptSetup !== null,
         inline: scriptSetup !== null,
-        is_typescript: script?.lang === "ts" || scriptSetup?.lang === "ts",
+        is_ts: script?.lang === "ts" || scriptSetup?.lang === "ts",
     };
 };
+const compile_sfc = (text) => {
+    const id = crypto.randomUUID().slice(0, id_size);
+    const { descriptor } = parse(text);
+    const { has_script, inline, is_ts } = analyze(descriptor);
+    let module;
+    if (inline) {
+        const script = compileScript(descriptor, {
+            genDefaultAs,
+            id,
+            inlineTemplate: true,
+        });
+        module = `
+      ${script.content}
+      export default { ...__SCRIPT__ };
+    `;
+    }
+    else {
+        const template = compileTemplate({
+            filename: "",
+            id,
+            source: descriptor.template?.content ?? "",
+        });
+        const script = has_script
+            ? compileScript(descriptor, { genDefaultAs, id, inlineTemplate: false })
+            : { content: `const ${genDefaultAs} = {}` };
+        module = `
+      ${template.code}
+      ${script.content}
+      export default { ...__SCRIPT__, render };
+    `;
+    }
+    const js = is_ts ? transform(module, presets.typescript).code : module;
+    const css = descriptor.styles.map(style => compileStyle({
+        filename: "",
+        id,
+        source: style.content,
+        scoped: style.scoped ?? false,
+    }).code).join("\n");
+    return { js, css };
+};
 export default {
+    client(text) {
+        return compile_sfc(text);
+    },
     server(text) {
-        const id = crypto.randomUUID().slice(0, id_size);
-        const { descriptor } = parse(text);
-        const { has_script, inline, is_typescript } = analyze(descriptor);
-        let module;
-        if (inline) {
-            // for <script setup>, compile with inlineTemplate to get both script and
-            // render
-            const script = compileScript(descriptor, {
-                genDefaultAs,
-                id,
-                inlineTemplate: true,
-            });
-            module = `
-        ${script.content}
-        export default { ...__SCRIPT__ };
-      `;
-        }
-        else {
-            // For regular components, compile template and script separately
-            const template = compileTemplate({
-                filename: "",
-                id,
-                source: descriptor.template?.content ?? "",
-            });
-            const script = has_script
-                ? compileScript(descriptor, { genDefaultAs, id, inlineTemplate: false })
-                : { content: `const ${genDefaultAs} = {}` };
-            module = `
-        ${template.code}
-        ${script.content}
-        export default { ...__SCRIPT__, render };
-      `;
-        }
-        return is_typescript ? transform(module, presets.typescript).code : module;
+        return compile_sfc(text).js;
     },
 };
 //# sourceMappingURL=compile.js.map

package/lib/private/create-root.js

@@ -11,9 +11,12 @@ export default (depth, i18n_active) => {
         }
     };
     const body = depth > 0 ? build_view(0) : "h(\"div\")";
-    const vueImports = `import {
-    defineComponent, h${i18n_active ? ", ref, onMounted, onUnmounted" : ""}
-    } from "vue";`;
+    const vueImports = `
+    import {
+      defineComponent, h${i18n_active ? ", ref, onMounted, onUnmounted" : ""}
+    } from "vue";
+    import { setRequest } from "@primate/vue/app";
+    `;
     const i18nImports = i18n_active
         ? `
 import t from "#i18n";
@@ -45,6 +48,7 @@ export default defineComponent({
     ${i18nSetup}
     return () => {
       const p = props.p;
+      setRequest(props.p.request);
       return ${body};
     };
   },

package/lib/private/default.d.ts

@@ -0,0 +1,7 @@
+declare const _default: (input?: {
+    extensions?: string[] | undefined;
+    spa?: boolean | undefined;
+    ssr?: boolean | undefined;
+} | undefined) => import("@primate/core/frontend").Module;
+export default _default;
+//# sourceMappingURL=default.d.ts.map

package/lib/private/default.js

@@ -0,0 +1,18 @@
+import compile from "#compile";
+import create_root from "#create-root";
+import init from "#init";
+import frontend from "@primate/core/frontend";
+export default frontend({
+    ...init,
+    root: {
+        create: create_root,
+    },
+    css: {
+        filter: /\.vuecss$/,
+    },
+    compile: {
+        client: (text, _, root) => root ? { js: text, css: "" } : compile.client(text),
+        server: (text, file) => file.path.startsWith("root:") ? text : compile.server(text),
+    },
+});
+//# sourceMappingURL=default.js.map

package/lib/private/init.d.ts

@@ -0,0 +1,5 @@
+import type { Init } from "@primate/core/frontend";
+import { type Renderer } from "vue";
+declare const module: Init<Renderer>;
+export default module;
+//# sourceMappingURL=init.d.ts.map

package/lib/private/init.js

@@ -0,0 +1,15 @@
+import { createSSRApp } from "vue";
+import { renderToString } from "vue/server-renderer";
+const module = {
+    name: "vue",
+    extensions: [".vue"],
+    layouts: true,
+    client: true,
+    async render(view, props) {
+        const app = createSSRApp(view, { p: { ...props } });
+        const html = await renderToString(app);
+        return { body: `<div id="app">${html}</div>` };
+    },
+};
+export default module;
+//# sourceMappingURL=init.js.map

package/lib/private/request/store.d.ts

@@ -0,0 +1,74 @@
+import type { RequestPublic } from "@primate/core";
+declare const store: import("vue").Ref<{
+    cookies: import("@rcompat/type").Dict<string>;
+    headers: import("@rcompat/type").Dict<string>;
+    query: import("@rcompat/type").Dict<string>;
+    url: {
+        hash: string;
+        host: string;
+        hostname: string;
+        href: string;
+        toString: () => string;
+        readonly origin: string;
+        password: string;
+        pathname: string;
+        port: string;
+        protocol: string;
+        search: string;
+        readonly searchParams: {
+            readonly size: number;
+            append: (name: string, value: string) => void;
+            delete: (name: string, value?: string) => void;
+            get: (name: string) => string | null;
+            getAll: (name: string) => string[];
+            has: (name: string, value?: string) => boolean;
+            set: (name: string, value: string) => void;
+            sort: () => void;
+            toString: () => string;
+            forEach: (callbackfn: (value: string, key: string, parent: URLSearchParams) => void, thisArg?: any) => void;
+            entries: () => URLSearchParamsIterator<[string, string]>;
+            keys: () => URLSearchParamsIterator<string>;
+            values: () => URLSearchParamsIterator<string>;
+            [Symbol.iterator]: () => URLSearchParamsIterator<[string, string]>;
+        };
+        username: string;
+        toJSON: () => string;
+    };
+}, RequestPublic | {
+    cookies: import("@rcompat/type").Dict<string>;
+    headers: import("@rcompat/type").Dict<string>;
+    query: import("@rcompat/type").Dict<string>;
+    url: {
+        hash: string;
+        host: string;
+        hostname: string;
+        href: string;
+        toString: () => string;
+        readonly origin: string;
+        password: string;
+        pathname: string;
+        port: string;
+        protocol: string;
+        search: string;
+        readonly searchParams: {
+            readonly size: number;
+            append: (name: string, value: string) => void;
+            delete: (name: string, value?: string) => void;
+            get: (name: string) => string | null;
+            getAll: (name: string) => string[];
+            has: (name: string, value?: string) => boolean;
+            set: (name: string, value: string) => void;
+            sort: () => void;
+            toString: () => string;
+            forEach: (callbackfn: (value: string, key: string, parent: URLSearchParams) => void, thisArg?: any) => void;
+            entries: () => URLSearchParamsIterator<[string, string]>;
+            keys: () => URLSearchParamsIterator<string>;
+            values: () => URLSearchParamsIterator<string>;
+            [Symbol.iterator]: () => URLSearchParamsIterator<[string, string]>;
+        };
+        username: string;
+        toJSON: () => string;
+    };
+}>;
+export default store;
+//# sourceMappingURL=store.d.ts.map

package/lib/private/request/store.js

@@ -0,0 +1,4 @@
+import { ref } from "vue";
+const store = ref(undefined);
+export default store;
+//# sourceMappingURL=store.js.map

package/lib/private/runtime.d.ts

@@ -0,0 +1,7 @@
+declare const _default: (input?: {
+    extensions?: string[] | undefined;
+    spa?: boolean | undefined;
+    ssr?: boolean | undefined;
+} | undefined) => import("@primate/core/frontend").Module;
+export default _default;
+//# sourceMappingURL=runtime.d.ts.map

package/lib/private/runtime.js

@@ -0,0 +1,4 @@
+import init from "#init";
+import frontend from "@primate/core/frontend";
+export default frontend(init);
+//# sourceMappingURL=runtime.js.map

package/lib/public/app.d.ts

@@ -0,0 +1,73 @@
+export declare function useRequest(): import("vue").Ref<{
+    cookies: import("@rcompat/type").Dict<string>;
+    headers: import("@rcompat/type").Dict<string>;
+    query: import("@rcompat/type").Dict<string>;
+    url: {
+        hash: string;
+        host: string;
+        hostname: string;
+        href: string;
+        toString: () => string;
+        readonly origin: string;
+        password: string;
+        pathname: string;
+        port: string;
+        protocol: string;
+        search: string;
+        readonly searchParams: {
+            readonly size: number;
+            append: (name: string, value: string) => void;
+            delete: (name: string, value?: string) => void;
+            get: (name: string) => string | null;
+            getAll: (name: string) => string[];
+            has: (name: string, value?: string) => boolean;
+            set: (name: string, value: string) => void;
+            sort: () => void;
+            toString: () => string;
+            forEach: (callbackfn: (value: string, key: string, parent: URLSearchParams) => void, thisArg?: any) => void;
+            entries: () => URLSearchParamsIterator<[string, string]>;
+            keys: () => URLSearchParamsIterator<string>;
+            values: () => URLSearchParamsIterator<string>;
+            [Symbol.iterator]: () => URLSearchParamsIterator<[string, string]>;
+        };
+        username: string;
+        toJSON: () => string;
+    };
+}, import("@primate/core/index").RequestPublic | {
+    cookies: import("@rcompat/type").Dict<string>;
+    headers: import("@rcompat/type").Dict<string>;
+    query: import("@rcompat/type").Dict<string>;
+    url: {
+        hash: string;
+        host: string;
+        hostname: string;
+        href: string;
+        toString: () => string;
+        readonly origin: string;
+        password: string;
+        pathname: string;
+        port: string;
+        protocol: string;
+        search: string;
+        readonly searchParams: {
+            readonly size: number;
+            append: (name: string, value: string) => void;
+            delete: (name: string, value?: string) => void;
+            get: (name: string) => string | null;
+            getAll: (name: string) => string[];
+            has: (name: string, value?: string) => boolean;
+            set: (name: string, value: string) => void;
+            sort: () => void;
+            toString: () => string;
+            forEach: (callbackfn: (value: string, key: string, parent: URLSearchParams) => void, thisArg?: any) => void;
+            entries: () => URLSearchParamsIterator<[string, string]>;
+            keys: () => URLSearchParamsIterator<string>;
+            values: () => URLSearchParamsIterator<string>;
+            [Symbol.iterator]: () => URLSearchParamsIterator<[string, string]>;
+        };
+        username: string;
+        toJSON: () => string;
+    };
+}>;
+export declare const setRequest: (value: any) => void;
+//# sourceMappingURL=app.d.ts.map

package/lib/public/app.js

@@ -0,0 +1,4 @@
+import store from "#request/store";
+export function useRequest() { return store; }
+export const setRequest = (value) => { store.value = value; };
+//# sourceMappingURL=app.js.map

package/lib/public/client.d.ts

@@ -1,48 +1,2 @@
-import form from "#client/form";
-declare const client: {
-    form: typeof form;
-    field: <T>(initial: T) => {
-        delete: (url: string, options?: {
-            headers?: import("@rcompat/type").Dict<string>;
-            map?: ((v: T) => import("@rcompat/type").JSONValue) | undefined;
-            path?: import("@rcompat/type").JSONPointer;
-        } | undefined) => {
-            error: import("vue").Ref<null | import("@primate/core/client").ValidationError>;
-            loading: import("vue").Ref<boolean>;
-            update: (updater: import("@primate/core/client").ValidateUpdater<T>) => Promise<void>;
-            value: import("vue").Ref<T, T>;
-        };
-        patch: (url: string, options?: {
-            headers?: import("@rcompat/type").Dict<string>;
-            map?: ((v: T) => import("@rcompat/type").JSONValue) | undefined;
-            path?: import("@rcompat/type").JSONPointer;
-        } | undefined) => {
-            error: import("vue").Ref<null | import("@primate/core/client").ValidationError>;
-            loading: import("vue").Ref<boolean>;
-            update: (updater: import("@primate/core/client").ValidateUpdater<T>) => Promise<void>;
-            value: import("vue").Ref<T, T>;
-        };
-        post: (url: string, options?: {
-            headers?: import("@rcompat/type").Dict<string>;
-            map?: ((v: T) => import("@rcompat/type").JSONValue) | undefined;
-            path?: import("@rcompat/type").JSONPointer;
-        } | undefined) => {
-            error: import("vue").Ref<null | import("@primate/core/client").ValidationError>;
-            loading: import("vue").Ref<boolean>;
-            update: (updater: import("@primate/core/client").ValidateUpdater<T>) => Promise<void>;
-            value: import("vue").Ref<T, T>;
-        };
-        put: (url: string, options?: {
-            headers?: import("@rcompat/type").Dict<string>;
-            map?: ((v: T) => import("@rcompat/type").JSONValue) | undefined;
-            path?: import("@rcompat/type").JSONPointer;
-        } | undefined) => {
-            error: import("vue").Ref<null | import("@primate/core/client").ValidationError>;
-            loading: import("vue").Ref<boolean>;
-            update: (updater: import("@primate/core/client").ValidateUpdater<T>) => Promise<void>;
-            value: import("vue").Ref<T, T>;
-        };
-    };
-};
-export default client;
+export { default } from "#client/index";
 //# sourceMappingURL=client.d.ts.map

package/lib/public/client.js

@@ -1,5 +1,2 @@
-import field from "#client/field";
-import form from "#client/form";
-const client = { form, field };
-export default client;
+export { default } from "#client/index";
 //# sourceMappingURL=client.js.map

package/lib/public/default.d.ts

@@ -1,4 +1,2 @@
-import Default from "#Default";
-declare const _default: (options?: typeof Default.input) => Default;
-export default _default;
+export { default } from "#default";
 //# sourceMappingURL=default.d.ts.map

package/lib/public/default.js

@@ -1,3 +1,2 @@
-import Default from "#Default";
-export default (options) => new Default(options);
+export { default } from "#default";
 //# sourceMappingURL=default.js.map

package/lib/public/runtime.d.ts

@@ -1,4 +1,2 @@
-import Runtime from "#Runtime";
-declare const _default: (options?: typeof Runtime.input) => Runtime;
-export default _default;
+export { default } from "#runtime";
 //# sourceMappingURL=runtime.d.ts.map

package/lib/public/runtime.js

@@ -1,3 +1,2 @@
-import Runtime from "#Runtime";
-export default (options) => new Runtime(options);
+export { default } from "#runtime";
 //# sourceMappingURL=runtime.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primate/vue",
-  "version": "0.15.0",
+  "version": "0.16.1",
   "description": "Vue for Primate",
   "homepage": "https://primate.run/docs/frontend/vue",
   "bugs": "https://github.com/primate-run/primate/issues",
@@ -16,36 +16,41 @@
     "/lib/**/*.d.ts",
     "!/**/*.spec.*"
   ],
+  "types": "lib/index.d.ts",
   "dependencies": {
-    "@primate/core": "^0.5.0"
+    "@primate/core": "^0.6.0"
   },
   "devDependencies": {
-    "@rcompat/type": "^0.9.0"
+    "@rcompat/type": "^0.11.1",
+    "@primate/test": "^0.0.0"
   },
   "peerDependencies": {
     "vue": "3",
-    "primate": "^0.36.0"
+    "primate": "^0.37.0"
   },
   "imports": {
     "#*": {
-      "apekit": "./src/private/*.ts",
+      "@primate/source": "./src/private/*.ts",
       "default": "./lib/private/*.js"
     }
   },
   "exports": {
     ".": {
+      "types": "./lib/index.d.ts",
+      "@primate/source": "./src/public/default.ts",
       "browser": "./lib/public/browser.js",
       "runtime": "./lib/public/runtime.js",
       "default": "./lib/public/default.js"
     },
     "./*": {
-      "apekit": "./src/public/*.ts",
+      "@primate/source": "./src/public/*.ts",
       "default": "./lib/public/*.js"
     }
   },
   "scripts": {
-    "build": "npm run clean && tsc",
+    "build": "npm run clean && tsc && cp src/types/{app,index}.d.ts lib",
     "clean": "rm -rf ./lib",
-    "lint": "eslint ."
+    "lint": "eslint .",
+    "test": "npx proby"
   }
 }

package/lib/private/Default.d.ts

@@ -1,16 +0,0 @@
-import Runtime from "#Runtime";
-import type BuildApp from "@primate/core/BuildApp";
-import type NextBuild from "@primate/core/NextBuild";
-export default class Default extends Runtime {
-    compile: {
-        client: (text: string, _: unknown, root: boolean) => {
-            js: string;
-        };
-        server: (text: string) => string;
-    };
-    root: {
-        create: (depth: number, i18n_active: boolean) => string;
-    };
-    build(app: BuildApp, next: NextBuild): Promise<BuildApp>;
-}
-//# sourceMappingURL=Default.d.ts.map

package/lib/private/Default.js

@@ -1,20 +0,0 @@
-import compile from "#compile";
-import create_root from "#create-root";
-import Runtime from "#Runtime";
-export default class Default extends Runtime {
-    compile = {
-        client: (text, _, root) => ({ js: root ? text : compile.server(text) }),
-        server: (text) => compile.server(text),
-    };
-    root = {
-        create: create_root,
-    };
-    async build(app, next) {
-        this.prebuild(app);
-        const source = this.root.create(app.depth(), app.i18n_active);
-        app.addRoot(this.rootname, source);
-        this.publish(app);
-        return next(app);
-    }
-}
-//# sourceMappingURL=Default.js.map

package/lib/private/Runtime.d.ts

@@ -1,11 +0,0 @@
-import FrontendModule from "@primate/core/frontend/Module";
-import type Render from "@primate/core/frontend/Render";
-import { type Renderer } from "vue";
-export default class Runtime extends FrontendModule<Renderer> {
-    name: string;
-    defaultExtensions: string[];
-    layouts: boolean;
-    client: boolean;
-    render: Render<Renderer>;
-}
-//# sourceMappingURL=Runtime.d.ts.map

package/lib/private/Runtime.js

@@ -1,16 +0,0 @@
-import FrontendModule from "@primate/core/frontend/Module";
-import { createSSRApp } from "vue";
-import { renderToString } from "vue/server-renderer";
-export default class Runtime extends FrontendModule {
-    name = "vue";
-    defaultExtensions = [".vue"];
-    layouts = true;
-    client = true;
-    render = async (view, props) => {
-        const app = createSSRApp(view, { p: { ...props } });
-        const html = await renderToString(app);
-        return { body: `<div id="app">${html}</div>` };
-    };
-}
-;
-//# sourceMappingURL=Runtime.js.map