vitrify 0.21.0 → 0.23.0

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

@@ -0,0 +1,226 @@
+import { fileURLToPath } from 'url';
+import { findDepPkgJsonPath } from 'vitefu';
+import { QuasarResolver } from 'unplugin-vue-components/resolvers';
+export const injectSsrContext = ({ html, ssrContext }) => html
+    .replace(/(<html[^>]*)(>)/i, (found, start, end) => {
+    let matches;
+    matches = found.match(/\sdir\s*=\s*['"]([^'"]*)['"]/i);
+    if (matches) {
+        start = start.replace(matches[0], '');
+    }
+    matches = found.match(/\slang\s*=\s*['"]([^'"]*)['"]/i);
+    if (matches) {
+        start = start.replace(matches[0], '');
+    }
+    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(/(<body[^>]*)(>)/i, (found, start, end) => {
+    let classes = ssrContext?._meta.bodyClasses || '';
+    const matches = found.match(/\sclass\s*=\s*['"]([^'"]*)['"]/i);
+    if (matches) {
+        if (matches[1].length > 0) {
+            classes += ` ${matches[1]}`;
+        }
+        start = start.replace(matches[0], '');
+    }
+    return `${start} class="${classes.trim()}" ${ssrContext?._meta.bodyAttrs || ''}${end}${ssrContext?._meta.bodyTags || ''}`;
+});
+export const QuasarPlugin = async ({ ssr = false, pwa = false, options }) => {
+    let plugins = [];
+    const quasarConf = options;
+    return {
+        plugins: [
+            {
+                name: 'vite-plugin-quasar-transform',
+                enforce: 'pre',
+                transform: (code, id, options) => {
+                    code = code
+                        .replaceAll('__QUASAR_SSR__', ssr ? 'true' : 'false')
+                        .replaceAll('__QUASAR_SSR_SERVER__', ssr ? '(import.meta.env.SSR === true)' : 'false')
+                        .replaceAll('__QUASAR_SSR_CLIENT__', ssr ? '(import.meta.env.SSR === false)' : 'false')
+                        .replaceAll('__QUASAR_SSR_PWA__', ssr && pwa ? '(import.meta.env.SSR === false)' : 'false');
+                    return code;
+                }
+            },
+            {
+                name: 'vite-plugin-quasar-setup',
+                enforce: 'pre',
+                config: async (config, env) => {
+                    const { vitrify: { urls } = {} } = config;
+                    // if (quasar) quasarConf = quasar
+                    if (!quasarConf.framework.lang && config.vitrify?.lang)
+                        quasarConf.framework.lang = config.vitrify.lang;
+                    const globalCss = quasarConf?.extras?.map((extra) => `@quasar/extras/${extra}/${extra}.css`);
+                    const localPackages = ['@quasar/extras', 'quasar'];
+                    // const localPackages: string[] = []
+                    await (async () => {
+                        for (const val of localPackages) {
+                            const pkgDir = await findDepPkgJsonPath(val, fileURLToPath(config.vitrify.urls.app));
+                            if (pkgDir)
+                                urls.packages[val] = new URL(`file://${pkgDir}`);
+                        }
+                    })();
+                    const onMountedHooks = [
+                        async (instance) => {
+                            const { proxy: { $q } } = instance;
+                            if ($q.onSSRHydrated !== void 0)
+                                $q.onSSRHydrated();
+                        }
+                    ];
+                    const onBootHooks = [
+                        async ({ app, ssrContext, staticImports }) => {
+                            // @ts-expect-error undefined
+                            const quasarPlugins = await import('virtual:quasar-plugins');
+                            // @ts-expect-error undefined
+                            const directives = await import('virtual:quasar-directives');
+                            // @ts-expect-error undefined
+                            const { default: lang } = await import('virtual:quasar-lang');
+                            const { default: iconSet } = await import(
+                            // @ts-expect-error undefined
+                            'virtual:quasar-iconSet');
+                            const { default: iconMapFn } = await import(
+                            // @ts-expect-error undefined
+                            'virtual:quasar-iconMapFn');
+                            app.use(staticImports?.Quasar, {
+                                plugins: quasarPlugins,
+                                directives,
+                                lang,
+                                iconSet,
+                                config: {
+                                    iconMapFn
+                                }
+                            }, ssrContext);
+                        }
+                    ];
+                    /**
+                     * Importing package.json is problematic
+                     */
+                    const version = '?';
+                    /**
+                     * All components should have been auto-imported
+                     */
+                    if (quasarConf?.framework?.plugins) {
+                        if (!quasarConf.framework)
+                            quasarConf.framework = {};
+                        quasarConf.framework.plugins = [
+                            ...new Set(quasarConf.framework.plugins)
+                        ];
+                        plugins = quasarConf?.framework.plugins;
+                    }
+                    return {
+                        vitrify: {
+                            urls,
+                            globalCss,
+                            staticImports: {
+                                quasar: ['Quasar']
+                            },
+                            hooks: {
+                                onBoot: onBootHooks,
+                                onMounted: onMountedHooks,
+                                onTemplateRendered: [injectSsrContext]
+                            },
+                            sass: quasarConf.disableSass
+                                ? undefined
+                                : {
+                                    global: ['quasar/src/css/index.sass']
+                                }
+                        },
+                        resolve: {
+                            alias: [
+                                {
+                                    find: 'quasar/src/',
+                                    replacement: fileURLToPath(new URL('./src/', config.vitrify.urls.packages.quasar))
+                                }
+                            ]
+                        },
+                        optimizeDeps: {
+                            exclude: ['quasar']
+                        },
+                        define: {
+                            __DEV__: process.env.NODE_ENV !== 'production' || true,
+                            __QUASAR_VERSION__: `'${version}'`
+                        },
+                        ssr: {
+                            noExternal: ['quasar']
+                        }
+                    };
+                }
+            },
+            {
+                name: 'quasar-virtual-modules',
+                enforce: 'pre',
+                config: async (config, env) => ({
+                    resolve: {
+                        alias: [
+                            {
+                                find: new RegExp('^quasar$'),
+                                replacement: 'virtual:quasar'
+                            }
+                            // { find: new RegExp('^quasar$'), replacement: 'virtual:quasar' }
+                        ]
+                    }
+                }),
+                resolveId(id) {
+                    switch (id) {
+                        case 'virtual:quasar-plugins':
+                            return 'virtual:quasar-plugins';
+                        case 'virtual:quasar-directives':
+                            return 'virtual:quasar-directives';
+                        case 'virtual:quasar-lang':
+                            return 'virtual:quasar-lang';
+                        case 'virtual:quasar-iconSet':
+                            return 'virtual:quasar-iconSet';
+                        case 'virtual:quasar-iconMapFn':
+                            return 'virtual:quasar-iconMapFn';
+                        case 'virtual:quasar':
+                            return { id: 'virtual:quasar', moduleSideEffects: false };
+                        default:
+                            return;
+                    }
+                },
+                load(id) {
+                    if (id === 'virtual:quasar-plugins') {
+                        return `export { ${plugins.join(',')} } from 'quasar'`;
+                    }
+                    else if (id === 'virtual:quasar-directives') {
+                        return `export * from 'quasar/src/directives.js'`;
+                    }
+                    else if (id === 'virtual:quasar-lang') {
+                        return `import lang from 'quasar/lang/${quasarConf?.framework?.lang || 'en-US'}';
+          export default lang`;
+                    }
+                    else if (id === 'virtual:quasar-iconSet') {
+                        return `${typeof quasarConf.framework.iconSet === 'string'
+                            ? `import iconSet from 'quasar/icon-set/${quasarConf?.framework.iconSet || 'material-icons'}';
+          export default iconSet`
+                            : `export default ${quasarConf.framework.iconSet
+                                ? JSON.stringify(quasarConf.framework.iconSet)
+                                : null}`}`;
+                    }
+                    else if (id === 'virtual:quasar-iconMapFn') {
+                        return `export default ${quasarConf?.framework.iconMapFn?.toString() ?? null}`;
+                    }
+                    else if (id === 'virtual:quasar') {
+                        return `export * from 'quasar/src/plugins.js';
+          export * from 'quasar/src/components.js';
+          export * from 'quasar/src/composables.js';
+          export * from 'quasar/src/directives.js';
+          export * from 'quasar/src/utils.js';
+          export * from 'quasar/src/composables.js';
+          export { default as Quasar } from 'quasar/src/install-quasar.js'`;
+                    }
+                    return null;
+                }
+            }
+        ],
+        config: {
+            vitrify: {
+                unpluginVueComponents: {
+                    resolvers: [QuasarResolver()]
+                }
+            }
+        }
+    };
+};

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

@@ -1,7 +1,18 @@
 import type { Plugin } from 'vite';
-export type VitrifyPlugin = ({ ssr, mode, command }: {
+import { VitrifyConfig } from '../vitrify-config.js';
+type VitrifyPluginReturnType = {
+    plugin: Plugin;
+    config?: Partial<VitrifyConfig>;
+} | {
+    plugins: Plugin[];
+    config?: Partial<VitrifyConfig>;
+};
+export type VitrifyPlugin<Options> = ({ ssr, pwa, mode, command, options }: {
     ssr?: 'server' | 'client' | 'ssg' | 'fastify' | false;
     pwa?: boolean;
     mode?: 'production' | 'development';
     command?: 'build' | 'dev' | 'test';
-}) => Promise<Plugin | Plugin[]> | Plugin | Plugin[];
+    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.d.ts → quasar/index.d.ts}

@@ -1,6 +1,7 @@
-import type { VitrifyPlugin } from './index.js';
+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 QuasarConf {
+export interface QuasarPluginOptions {
     framework: {
         components?: (keyof QuasarComponents)[];
         directives?: (keyof QuasarDirectives)[];
@@ -12,6 +13,5 @@ export interface QuasarConf {
     extras?: (QuasarIconSets | QuasarFonts)[];
     disableSass?: boolean;
 }
-export declare const injectSsrContext: (html: string, ssrContext: Record<string, any>) => string;
-export declare const QuasarPlugin: VitrifyPlugin;
-export default QuasarPlugin;
+export declare const injectSsrContext: OnTemplateRenderedHook;
+export declare const QuasarPlugin: VitrifyPlugin<QuasarPluginOptions>;

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

@@ -1,30 +1,89 @@
 import type { Alias, UserConfig as ViteUserConfig, ViteDevServer } from 'vite';
-import type { QuasarConf } from './plugins/quasar.js';
 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';
-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;
+        /**
+         * Vitrify plugins
+         */
+        plugins?: VitrifyPluginConfig[];
         /**
          * Global CSS imports
          */
@@ -50,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
@@ -97,8 +164,11 @@ export interface VitrifyConfig extends ViteUserConfig {
          * UnoCSS Configuration
          */
         unocss?: UnoCSSUserConfig;
+        /**
+         * unplugin-vue-components configuration
+         */
+        unpluginVueComponents?: unpluginVueComponentsOptions;
     };
-    quasar?: QuasarConf;
 }
 export type VitrifyCommands = 'build' | 'dev' | 'test';
 export type VitrifyModes = 'production' | 'development';
@@ -108,4 +178,9 @@ export type VitrifyConfigAsync = ({ mode, command }: {
     mode: VitrifyModes;
     command: VitrifyCommands;
 }) => Promise<VitrifyConfig>;
+type VitrifyPluginConfig = {
+    plugin: VitrifyPlugin<any>;
+    options: any;
+};
 export declare const defineConfig: (config: VitrifyConfig) => VitrifyConfig;
+export {};