vitrify 0.22.0 → 0.23.0

package/dist/bin/cli.js

@@ -20,7 +20,6 @@ cli
     const { build } = await import('./build.js');
     let appDir;
     let prerender;
-    let onRendered;
     if (options.appDir) {
         if (options.appDir.slice(-1) !== '/')
             options.appDir += '/';
@@ -75,7 +74,7 @@ cli
                 outDir: fileURLToPath(new URL('ssr/server/', baseOutDir))
             });
             ({ prerender } = await import(new URL('ssr/server/prerender.mjs', baseOutDir).pathname));
-            const { template, manifest, render, getRoutes, onRendered } = await loadSSRAssets({
+            const { template, manifest, render, getRoutes, onRendered, onTemplateRendered } = await loadSSRAssets({
                 mode: 'ssg',
                 distDir: baseOutDir
             });
@@ -86,7 +85,8 @@ cli
                 manifest,
                 render,
                 routes,
-                onRendered
+                onRendered,
+                onTemplateRendered
             });
             break;
         default:

package/dist/bin/dev.js

@@ -75,7 +75,7 @@ ssr, framework = 'vue', host, appDir, publicDir, vite }) {
     let setup;
     let app;
     let server;
-    let onRendered;
+    let onTemplateRendered;
     let vitrifyConfig;
     console.log(`Development mode: ${ssr ? ssr : 'csr'}`);
     if (ssr) {
@@ -83,7 +83,7 @@ ssr, framework = 'vue', host, appDir, publicDir, vite }) {
             ? fileURLToPath(new URL('src/vite/fastify/entry.ts', cliDir))
             : fileURLToPath(new URL(`src/vite/${framework}/ssr/app.ts`, cliDir));
         const environment = vite.environments.ssr;
-        ({ setup, onRendered, vitrifyConfig } =
+        ({ setup, onTemplateRendered, vitrifyConfig } =
             // @ts-expect-error missing types
             await environment.runner.import(entryUrl));
         // console.log(module)
@@ -112,7 +112,7 @@ ssr, framework = 'vue', host, appDir, publicDir, vite }) {
             await app.register(fastifySsrPlugin, {
                 appDir,
                 mode: 'development',
-                onRendered,
+                onTemplateRendered,
                 host
             });
         }

package/dist/frameworks/vue/fastify-ssr-plugin.js

@@ -3,6 +3,8 @@ import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { addOrReplaceAppDiv, appendToBody, appendToHead } from '../../helpers/utils.js';
 import { getAppDir } from '../../app-urls.js';
+import { stringify } from 'devalue';
+import stringifyObject from 'stringify-object';
 const fastifySsrPlugin = async (fastify, options) => {
     options.baseUrl = options.baseUrl || '/';
     options.mode = options.mode || process.env.MODE || import.meta.env.MODE;
@@ -49,11 +51,12 @@ const fastifySsrPlugin = async (fastify, options) => {
                     manifest = {};
                 }
                 const html = await renderHtml({
-                    request: req,
-                    reply: res,
+                    req,
+                    res,
                     url: url ?? '/',
                     provide,
                     onRendered: options.onRendered,
+                    onTemplateRendered: options.onTemplateRendered,
                     template,
                     manifest,
                     render
@@ -84,15 +87,16 @@ const fastifySsrPlugin = async (fastify, options) => {
         fastify.get(`${options.baseUrl}*`, async (req, res) => {
             const url = req.raw.url?.replace(options.baseUrl, '/');
             const provide = options.provide ? await options.provide(req, res) : {};
-            const { template, manifest, render, onRendered } = await loadSSRAssets({
+            const { template, manifest, render, onRendered, onTemplateRendered } = await loadSSRAssets({
                 distDir: new URL('./dist/', options.appDir)
             });
             const html = await renderHtml({
-                request: req,
-                reply: res,
+                req,
+                res,
                 url: url ?? '/',
                 provide,
                 onRendered,
+                onTemplateRendered,
                 template,
                 manifest,
                 render
@@ -107,19 +111,50 @@ const renderTemplate = ({ template, initialStateScript, appHtml, preloadLinks })
     return appendToHead(preloadLinks, appendToBody(initialStateScript, addOrReplaceAppDiv(appHtml, template)));
 };
 const renderHtml = async (options) => {
+    const ssrContextOnRendered = [];
     const ssrContext = {
-        req: options.request,
-        res: options.reply,
-        provide: options.provide
+        req: options.req,
+        res: options.res,
+        provide: options.provide,
+        initialState: {},
+        _modules: new Set(),
+        _meta: {},
+        __qMetaList: [],
+        onRenderedList: ssrContextOnRendered,
+        onRendered: (fn) => {
+            ssrContextOnRendered.push(fn);
+        }
     };
     const onRendered = options.onRendered ?? [];
-    const [appHtml, preloadLinks] = await options.render(options.url, options.manifest, ssrContext);
-    if (!ssrContext.initialState)
-        ssrContext.initialState = {};
+    const onTemplateRendered = options.onTemplateRendered ?? [];
+    const { html: appHtml, preloadLinks, app } = await options.render(options.url, options.manifest, ssrContext);
+    if (ssrContextOnRendered?.length) {
+        for (const ssrFunction of ssrContextOnRendered) {
+            await ssrFunction();
+        }
+    }
+    if (onRendered?.length) {
+        for (const ssrFunction of onRendered) {
+            await ssrFunction({ app, ssrContext });
+        }
+    }
+    // if (!ssrContext.initialState) ssrContext.initialState = {}
     ssrContext.initialState.provide = options.provide;
+    const ssrContextInitialStateStringified = {};
+    for (const key in ssrContext.initialState) {
+        if (key === 'provide') {
+            ssrContextInitialStateStringified[key] = JSON.stringify(ssrContext.initialState.provide);
+        }
+        else if (key === 'piniaColada') {
+            ssrContextInitialStateStringified[key] = JSON.stringify(ssrContext.initialState.piniaColada);
+        }
+        else {
+            ssrContextInitialStateStringified[key] = stringify(ssrContext.initialState[key]);
+        }
+    }
     const initialStateScript = `
   <script>
-  __INITIAL_STATE__ = '${JSON.stringify(ssrContext.initialState)}'
+  __INITIAL_STATE__ = ${stringifyObject(ssrContextInitialStateStringified)}
   </script>`;
     let html = renderTemplate({
         template: options.template,
@@ -127,9 +162,9 @@ const renderHtml = async (options) => {
         initialStateScript,
         preloadLinks
     });
-    if (onRendered?.length) {
-        for (const ssrFunction of onRendered) {
-            html = ssrFunction(html, ssrContext);
+    if (onTemplateRendered?.length) {
+        for (const ssrFunction of onTemplateRendered) {
+            html = await ssrFunction({ html, ssrContext });
         }
     }
     return html;
@@ -140,7 +175,7 @@ const loadSSRAssets = async ({ mode, distDir } = {
     const appDir = getAppDir(new URL(import.meta.url));
     const baseOutDir = distDir || new URL('dist/', appDir);
     let templatePath, manifestPath, entryServerPath;
-    const onRenderedPath = fileURLToPath(new URL('ssr/server/virtual_vitrify-hooks.mjs', baseOutDir));
+    const vitrifyHooksPath = fileURLToPath(new URL('ssr/server/virtual_vitrify-hooks.mjs', baseOutDir));
     if (mode === 'ssg') {
         templatePath = fileURLToPath(new URL('static/index.html', baseOutDir));
         manifestPath = fileURLToPath(new URL('static/.vite/ssr-manifest.json', baseOutDir));
@@ -156,13 +191,14 @@ const loadSSRAssets = async ({ mode, distDir } = {
         const manifest = JSON.parse(readFileSync(manifestPath).toString());
         const entryServer = await import(entryServerPath);
         const { render, getRoutes } = entryServer;
-        const onRendered = (await import(onRenderedPath)).onRendered;
+        const { onTemplateRendered, onRendered } = await import(vitrifyHooksPath);
         return {
             template,
             manifest,
             render,
             getRoutes,
-            onRendered
+            onRendered,
+            onTemplateRendered
         };
     }
     catch (e) {

package/dist/frameworks/vue/prerender.js

@@ -1,7 +1,7 @@
 import { existsSync, promises as fs, mkdirSync } from 'fs';
 import { routesToPaths } from '../../helpers/routes.js';
 import { renderHtml } from './fastify-ssr-plugin.js';
-export const prerender = async ({ outDir, template, manifest, render, routes, onRendered }) => {
+export const prerender = async ({ outDir, template, manifest, render, routes, onTemplateRendered }) => {
     const promises = [];
     const paths = routesToPaths(routes).filter((i) => !i.includes(':') && !i.includes('*'));
     const beasties = new (await import('beasties')).default({
@@ -23,10 +23,10 @@ export const prerender = async ({ outDir, template, manifest, render, routes, on
             manifest,
             provide: {},
             render,
-            request: { headers: {}, url },
-            reply: {},
+            req: { headers: {}, url },
+            res: {},
             template,
-            onRendered
+            onTemplateRendered
         });
         html = await beasties.process(html);
         promises.push(fs.writeFile(outDir + filename, html, 'utf-8'));

package/dist/frameworks/vue/server.js

@@ -1,5 +1,5 @@
 import fastify from 'fastify';
-export const createApp = ({ onSetup, appDir, baseUrl, fastifyPlugin, onRendered, vitrifyDir, mode }) => {
+export const createApp = ({ onSetup, appDir, baseUrl, fastifyPlugin, onRendered, onTemplateRendered, vitrifyDir, mode }) => {
     const app = fastify({
         logger: {
             transport: {
@@ -13,6 +13,7 @@ export const createApp = ({ onSetup, appDir, baseUrl, fastifyPlugin, onRendered,
         appDir,
         vitrifyDir,
         onRendered,
+        onTemplateRendered,
         mode
     });
     if (onSetup?.length) {

package/dist/hooks/index.js

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

package/dist/index.js

@@ -37,7 +37,7 @@ const manualChunkNames = [
     'server'
 ];
 const moduleChunks = {
-    vue: ['vue', '@vue', 'vue-router'],
+    vue: ['vue', '@vue', 'vue-router', 'pinia', '@pinia/colada', '@vue/devtools'],
     quasar: ['quasar'],
     atQuasar: ['@quasar']
 };
@@ -209,7 +209,9 @@ export const baseConfig = async ({ ssr, appDir, publicDir, base = '/', command =
     }
     let onBootHooks;
     let onRenderedHooks;
+    let onTemplateRenderedHooks;
     let onMountedHooks;
+    let onAppCreatedHooks;
     let onSetupFiles;
     let globalCss = [];
     let staticImports;
@@ -270,7 +272,10 @@ export const baseConfig = async ({ ssr, appDir, publicDir, base = '/', command =
             config: (config, env) => {
                 onBootHooks = config.vitrify?.hooks?.onBoot || [];
                 onRenderedHooks = config.vitrify?.hooks?.onRendered || [];
+                onTemplateRenderedHooks =
+                    config.vitrify?.hooks?.onTemplateRendered || [];
                 onMountedHooks = config.vitrify?.hooks?.onMounted || [];
+                onAppCreatedHooks = config.vitrify?.hooks?.onAppCreated || [];
                 onSetupFiles = config?.vitrify?.hooks?.onSetup || [];
                 globalCss = config.vitrify?.globalCss || [];
                 staticImports = config.vitrify?.staticImports || {};
@@ -310,6 +315,12 @@ export const baseConfig = async ({ ssr, appDir, publicDir, base = '/', command =
             export const onRendered = [${onRenderedHooks
                         .map((fn) => `${String(fn)}`)
                         .join(', ')}]
+            export const onTemplateRendered = [${onTemplateRenderedHooks
+                        .map((fn) => `${String(fn)}`)
+                        .join(', ')}]
+            export const onAppCreated = [${onAppCreatedHooks
+                        .map((fn) => `${String(fn)}`)
+                        .join(', ')}]
             export const onSetup = []
             ${onSetupFiles
                         .map((url, index) => {

package/dist/plugins/index.js

@@ -1 +1,2 @@
 export * from './quasar/index.js';
+export * from './pinia/index.js';

package/dist/plugins/pinia/index.js

@@ -0,0 +1,61 @@
+const piniaonAppCreated = async ({ app, ctx, initialState, ssrContext }) => {
+    const { createPinia } = await import('pinia');
+    const pinia = createPinia();
+    ctx.pinia = pinia;
+    app.use(pinia);
+    // SSR Client
+    if (initialState?.pinia)
+        pinia.state.value = initialState.pinia;
+    // SSR Server
+    if (ssrContext)
+        ssrContext.pinia = pinia;
+};
+const piniaOnRenderedHook = ({ app, ssrContext }) => {
+    // SSR Server
+    if (ssrContext?.initialState && ssrContext.pinia) {
+        ssrContext.initialState.pinia = ssrContext.pinia.state.value;
+    }
+};
+const piniaColadaonAppCreated = async ({ app, ctx, initialState }) => {
+    if (ctx?.pinia) {
+        const { PiniaColada, useQueryCache, hydrateQueryCache } = await import('@pinia/colada');
+        app.use(PiniaColada);
+        // SSR Client
+        if (initialState?.piniaColada) {
+            hydrateQueryCache(useQueryCache(ctx.pinia), initialState.piniaColada);
+        }
+    }
+};
+const piniaColadaOnRenderedHook = async ({ app, ssrContext }) => {
+    // SSR Server
+    if (ssrContext?.initialState && ssrContext.pinia) {
+        const { useQueryCache, serializeQueryCache } = await import('@pinia/colada');
+        // Delete to prevent Non-POJO error
+        if (ssrContext.initialState.pinia?._pc_query) {
+            delete ssrContext.initialState.pinia._pc_query;
+        }
+        ssrContext.initialState.piniaColada = serializeQueryCache(useQueryCache(ssrContext.pinia));
+    }
+};
+export const PiniaPlugin = async ({ ssr = false, pwa = false, options = {} }) => {
+    const onAppCreated = [piniaonAppCreated];
+    const onRendered = [piniaOnRenderedHook];
+    if (options.colada) {
+        onAppCreated.push(piniaColadaonAppCreated);
+        onRendered.push(piniaColadaOnRenderedHook);
+    }
+    return {
+        plugins: [],
+        config: {
+            vitrify: {
+                ssr: {
+                    serverModules: ['@pinia/colada']
+                },
+                hooks: {
+                    onAppCreated,
+                    onRendered
+                }
+            }
+        }
+    };
+};

package/dist/plugins/quasar/index.js

@@ -1,7 +1,7 @@
 import { fileURLToPath } from 'url';
 import { findDepPkgJsonPath } from 'vitefu';
 import { QuasarResolver } from 'unplugin-vue-components/resolvers';
-export const injectSsrContext = (html, ssrContext) => html
+export const injectSsrContext = ({ html, ssrContext }) => html
     .replace(/(<html[^>]*)(>)/i, (found, start, end) => {
     let matches;
     matches = found.match(/\sdir\s*=\s*['"]([^'"]*)['"]/i);
@@ -12,12 +12,12 @@ export const injectSsrContext = (html, ssrContext) => html
     if (matches) {
         start = start.replace(matches[0], '');
     }
-    return `${start} ${ssrContext._meta.htmlAttrs || ''} ${end}`;
+    return `${start} ${ssrContext?._meta.htmlAttrs || ''} ${end}`;
 })
-    .replace(/(<head[^>]*)(>)/i, (_, start, end) => `${start}${end}${ssrContext._meta.headTags || ''}`)
-    .replace(/(<\/head>)/i, (_, tag) => `${ssrContext._meta.resourceStyles || ''}${ssrContext._meta.endingHeadTags || ''}${tag}`)
+    .replace(/(<head[^>]*)(>)/i, (_, start, end) => `${start}${end}${ssrContext?._meta.headTags || ''}`)
+    .replace(/(<\/head>)/i, (_, tag) => `${ssrContext?._meta.resourceStyles || ''}${ssrContext?._meta.endingHeadTags || ''}${tag}`)
     .replace(/(<body[^>]*)(>)/i, (found, start, end) => {
-    let classes = ssrContext._meta.bodyClasses || '';
+    let classes = ssrContext?._meta.bodyClasses || '';
     const matches = found.match(/\sclass\s*=\s*['"]([^'"]*)['"]/i);
     if (matches) {
         if (matches[1].length > 0) {
@@ -25,7 +25,7 @@ export const injectSsrContext = (html, ssrContext) => html
         }
         start = start.replace(matches[0], '');
     }
-    return `${start} class="${classes.trim()}" ${ssrContext._meta.bodyAttrs || ''}${end}${ssrContext._meta.bodyTags || ''}`;
+    return `${start} class="${classes.trim()}" ${ssrContext?._meta.bodyAttrs || ''}${end}${ssrContext?._meta.bodyTags || ''}`;
 });
 export const QuasarPlugin = async ({ ssr = false, pwa = false, options }) => {
     let plugins = [];
@@ -119,7 +119,7 @@ export const QuasarPlugin = async ({ ssr = false, pwa = false, options }) => {
                             hooks: {
                                 onBoot: onBootHooks,
                                 onMounted: onMountedHooks,
-                                onRendered: [injectSsrContext]
+                                onTemplateRendered: [injectSsrContext]
                             },
                             sass: quasarConf.disableSass
                                 ? undefined
@@ -224,4 +224,3 @@ export const QuasarPlugin = async ({ ssr = false, pwa = false, options }) => {
         }
     };
 };
-export default QuasarPlugin;

package/dist/types/frameworks/vue/fastify-ssr-plugin.d.ts

@@ -1,6 +1,6 @@
 import type { FastifyPluginAsync, FastifyRequest, FastifyReply } from 'fastify';
 import type { ViteDevServer } from 'vite';
-import type { OnRenderedHook } from '../../vitrify-config.js';
+import type { OnRenderedHook, OnTemplateRenderedHook } from '../../vitrify-config.js';
 type ProvideFn = (req: FastifyRequest, res: FastifyReply) => Promise<Record<string, unknown | {
     value: unknown;
 }>>;
@@ -10,6 +10,7 @@ export interface FastifySsrOptions {
     vitrifyDir?: URL;
     vite?: ViteDevServer;
     onRendered?: OnRenderedHook[];
+    onTemplateRendered?: OnTemplateRenderedHook[];
     appDir?: URL;
     publicDir?: URL;
     mode?: string;
@@ -18,13 +19,14 @@ export interface FastifySsrOptions {
 declare const fastifySsrPlugin: FastifyPluginAsync<FastifySsrOptions>;
 declare const renderHtml: (options: {
     url: string;
-    request: FastifyRequest | {
+    req: FastifyRequest | {
         headers: Record<string, unknown>;
         url: string;
     };
-    reply: FastifyReply | Record<string, unknown>;
+    res: FastifyReply | Record<string, unknown>;
     provide: Record<string, unknown>;
     onRendered?: OnRenderedHook[];
+    onTemplateRendered?: OnTemplateRenderedHook[];
     template: string;
     manifest: Record<string, unknown>;
     render: any;
@@ -38,6 +40,7 @@ declare const loadSSRAssets: ({ mode, distDir }?: {
     render: any;
     getRoutes: any;
     onRendered: any;
+    onTemplateRendered: any;
 }>;
 export { fastifySsrPlugin, renderHtml, loadSSRAssets };
 export type FastifySsrPlugin = typeof fastifySsrPlugin;

package/dist/types/frameworks/vue/prerender.d.ts

@@ -1,10 +1,10 @@
-import type { OnRenderedHook } from 'src/node/vitrify-config.js';
+import type { OnTemplateRenderedHook } from 'src/node/vitrify-config.js';
 import { type RouteRecordRaw } from 'vue-router';
-export declare const prerender: ({ outDir, template, manifest, render, routes, onRendered }: {
+export declare const prerender: ({ outDir, template, manifest, render, routes, onTemplateRendered }: {
     outDir: string;
     template: string;
     manifest: Record<string, unknown>;
     render: unknown;
     routes: RouteRecordRaw[];
-    onRendered: OnRenderedHook[];
+    onTemplateRendered: OnTemplateRenderedHook[];
 }) => Promise<void[]>;

package/dist/types/frameworks/vue/server.d.ts

@@ -1,15 +1,15 @@
-import type { FastifyInstance } from 'fastify';
-import type { OnRenderedHook, OnSetupHook } from '../../vitrify-config.js';
+import type { OnTemplateRenderedHook, OnSetupHook, OnRenderedHook } from '../../vitrify-config.js';
 import type { FastifyCsrPlugin } from './fastify-csr-plugin.js';
 import type { FastifySsrPlugin } from './fastify-ssr-plugin.js';
-export declare const createApp: ({ onSetup, appDir, baseUrl, fastifyPlugin, onRendered, vitrifyDir, mode }: {
+export declare const createApp: ({ onSetup, appDir, baseUrl, fastifyPlugin, onRendered, onTemplateRendered, vitrifyDir, mode }: {
     onSetup: OnSetupHook[];
     appDir: URL;
     baseUrl?: string;
     fastifyPlugin: FastifySsrPlugin | FastifyCsrPlugin;
     onRendered?: OnRenderedHook[];
+    onTemplateRendered?: OnTemplateRenderedHook[];
     vitrifyDir?: URL;
     mode: string;
-}) => FastifyInstance<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault> & PromiseLike<FastifyInstance<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>> & {
+}) => import("fastify").FastifyInstance<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault> & PromiseLike<import("fastify").FastifyInstance<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>> & {
     __linterBrands: "SafePromiseLike";
 };

package/dist/types/hooks/index.d.ts

@@ -0,0 +1,2 @@
+import type { OnBootHook, onAppCreatedHook, OnMountedHook, OnRenderedHook, OnTemplateRenderedHook, OnSetupFile, OnSetupHook } from '../vitrify-config.js';
+export { OnBootHook, onAppCreatedHook, OnMountedHook, OnRenderedHook, OnTemplateRenderedHook, OnSetupFile, OnSetupHook };

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 import type { InlineConfig } from 'vite';
-import type { BootFunction, VitrifyConfig, VitrifyConfigAsync, VitrifyCommands, VitrifyModes, VitrifyUIFrameworks, VitrifySSRModes } from './vitrify-config.js';
+import type { VitrifyConfig, VitrifyConfigAsync, VitrifyCommands, VitrifyModes, VitrifyUIFrameworks, VitrifySSRModes, OnBootHook } from './vitrify-config.js';
 import type { VitrifyContext } from './bin/run.js';
 import type { VitrifyPlugin } from './plugins/index.js';
 export declare const VIRTUAL_MODULES: string[];
@@ -16,4 +16,4 @@ export declare const baseConfig: ({ ssr, appDir, publicDir, base, command, mode,
 }) => Promise<InlineConfig>;
 export declare const vitrifyDir: URL;
 export { prerender } from './frameworks/vue/prerender.js';
-export type { VitrifyConfig, VitrifyConfigAsync, VitrifyPlugin, VitrifyContext, BootFunction };
+export type { VitrifyConfig, VitrifyConfigAsync, VitrifyPlugin, VitrifyContext, OnBootHook };

package/dist/types/plugins/index.d.ts

@@ -15,3 +15,4 @@ export type VitrifyPlugin<Options> = ({ ssr, pwa, mode, command, options }: {
     options: Options;
 }) => Promise<VitrifyPluginReturnType> | VitrifyPluginReturnType;
 export * from './quasar/index.js';
+export * from './pinia/index.js';

package/dist/types/plugins/pinia/index.d.ts

@@ -0,0 +1,5 @@
+import type { VitrifyPlugin } from '../index.js';
+export type PiniaPluginOptions = {
+    colada?: boolean;
+};
+export declare const PiniaPlugin: VitrifyPlugin<PiniaPluginOptions>;

package/dist/types/plugins/quasar/index.d.ts

@@ -1,3 +1,4 @@
+import type { OnTemplateRenderedHook } from '../../vitrify-config.js';
 import type { VitrifyPlugin } from '../index.js';
 import { type QuasarFonts, type QuasarComponents, type QuasarDirectives, type QuasarIconSets, type QuasarPlugins, type GlobalQuasarIconMapFn, type QuasarIconSet } from 'quasar';
 export interface QuasarPluginOptions {
@@ -12,6 +13,5 @@ export interface QuasarPluginOptions {
     extras?: (QuasarIconSets | QuasarFonts)[];
     disableSass?: boolean;
 }
-export declare const injectSsrContext: (html: string, ssrContext: Record<string, any>) => string;
+export declare const injectSsrContext: OnTemplateRenderedHook;
 export declare const QuasarPlugin: VitrifyPlugin<QuasarPluginOptions>;
-export default QuasarPlugin;

package/dist/types/vitrify-config.d.ts

@@ -1,28 +1,82 @@
 import type { Alias, UserConfig as ViteUserConfig, ViteDevServer } from 'vite';
 import type { ComponentInternalInstance } from '@vue/runtime-core';
-import type { FastifyInstance, FastifyServerOptions } from 'fastify';
+import type { FastifyInstance, FastifyReply, FastifyRequest, FastifyServerOptions } from 'fastify';
 import type { VitePWAOptions } from 'vite-plugin-pwa';
 import type { Options as unpluginVueComponentsOptions } from 'unplugin-vue-components';
 import type { UserConfig as UnoCSSUserConfig } from '@unocss/core';
-import { VitrifyPlugin } from './plugins/index.js';
-export type BootFunction = ({ app, ssrContext, staticImports }: {
-    app: any;
-    ssrContext: Record<string, unknown>;
-    staticImports: Record<string, any>;
+import type { VitrifyPlugin } from './plugins/index.js';
+import type { Router } from 'vue-router';
+import type { App } from '@vue/runtime-core';
+import type { Pinia } from 'pinia';
+import type { _UseQueryEntryNodeValueSerialized } from '@pinia/colada/index.js';
+export type SSRContext = {
+    req: FastifyRequest | {
+        headers: Record<string, unknown>;
+        url: string;
+    };
+    res: FastifyReply | Record<string, unknown>;
+    provide: Record<string, unknown>;
+    initialState: {
+        provide?: Record<string, unknown>;
+        pinia?: Record<string, unknown>;
+        piniaColada?: Record<string, _UseQueryEntryNodeValueSerialized>;
+        [key: string]: unknown;
+    };
+    pinia?: Pinia;
+    _modules: Set<unknown>;
+    _meta: Record<string, any>;
+    __qMetaList: unknown[];
+    /**
+     * Required for Quasar
+     */
+    onRenderedList: (() => unknown)[];
+    onRendered: (fn: () => unknown) => void;
+    /**
+     * Vue internals
+     */
+    modules?: Map<unknown, unknown>;
+    transports?: Record<string, unknown>;
+    [key: string]: unknown;
+};
+export type onAppCreatedHook = ({ app, router, ctx, initialState, ssrContext }: {
+    app: App;
+    router: Router;
+    ctx: {
+        pinia?: Pinia;
+        [key: string]: unknown;
+    };
+    initialState: {
+        provide?: Record<string, unknown>;
+        pinia?: Record<string, unknown>;
+        piniaColada?: Record<string, _UseQueryEntryNodeValueSerialized>;
+        [key: string]: unknown;
+    };
+    ssrContext?: SSRContext;
 }) => Promise<void> | void;
 export type OnBootHook = ({ app, ssrContext, staticImports }: {
-    app: any;
-    ssrContext: Record<string, unknown>;
+    app: App;
+    ssrContext: SSRContext;
     staticImports?: Record<string, any>;
 }) => Promise<void> | void;
 export type OnMountedHook = (instance: ComponentInternalInstance) => Promise<void> | void;
 export type StaticImports = Record<string, string[]>;
-export type SsrFunction = (html: string, ssrContext: Record<string, any>) => string;
-export type OnRenderedHook = (html: string, ssrContext: Record<string, any>) => string;
+export type OnSetupFile = URL;
 export type OnSetupHook = (fastify: FastifyInstance, options?: {
     vite?: ViteDevServer;
 }) => any;
-export type OnSetupFile = URL;
+export type Render = (url: string, manifest: Record<string, unknown>, ssrContext: SSRContext, renderToString: (app: App, ctx?: Record<string, any>) => Promise<string>) => Promise<{
+    html: string;
+    preloadLinks: string;
+    app: App;
+}>;
+export type OnRenderedHook = ({ app, ssrContext }: {
+    app: App;
+    ssrContext?: SSRContext;
+}) => Promise<void> | void;
+export type OnTemplateRenderedHook = ({ html, ssrContext }: {
+    html: string;
+    ssrContext?: SSRContext;
+}) => Promise<string> | string;
 export interface VitrifyConfig extends ViteUserConfig {
     vitrify?: {
         lang?: string;
@@ -55,6 +109,14 @@ export interface VitrifyConfig extends ViteUserConfig {
              * Functions which run after rendering the app (SSR)
              */
             onRendered?: OnRenderedHook[];
+            /**
+             * Functions which run after rendering the template (SSR)
+             */
+            onTemplateRendered?: OnTemplateRenderedHook[];
+            /**
+             * Functions which run directly after initializing the application
+             */
+            onAppCreated?: onAppCreatedHook[];
         };
         /**
          * Global SASS variables