vitrify 0.21.0 → 0.22.0

package/dist/bin/dev.js

@@ -1,4 +1,3 @@
-import { searchForWorkspaceRoot } from 'vite';
 import { baseConfig } from '../index.js';
 import fastify from 'fastify';
 import { fastifySsrPlugin } from '../frameworks/vue/fastify-ssr-plugin.js';
@@ -15,7 +14,6 @@ export async function createVitrifyDevServer({ port = 3000, logLevel = 'info',
 // mode = 'csr',
 ssr, framework = 'vue', host, appDir, publicDir, base }) {
     const { getAppDir, getCliDir, getCliViteDir, getCwd } = await import('../app-urls.js');
-    const cliDir = getCliDir();
     if (!appDir)
         appDir = getAppDir();
     let config = {};
@@ -33,46 +31,27 @@ ssr, framework = 'vue', host, appDir, publicDir, base }) {
         publicDir,
         base
     });
-    config.logLevel = logLevel;
-    config.define = {
-        ...config.define,
-        __HOST__: `'${host}'`
-    };
     const wsPort = await getFirstOpenPort(24678);
     if (config.server?.https) {
         exitLogs.push(`[warning] HTTPS mode enabled. Visit https://{hostname}:${wsPort} to enable a security exception for HMR.`);
     }
-    config.server = {
-        https: config.server?.https,
-        hmr: {
-            protocol: config.server?.https ? 'wss' : 'ws',
-            port: wsPort
-        },
-        port,
-        // middlewareMode: mode === 'ssr' ? 'ssr' : undefined,
-        middlewareMode: ssr ? true : false,
-        fs: {
-            strict: false, // https://github.com/vitejs/vite/issues/8175
-            allow: [
-                searchForWorkspaceRoot(process.cwd()),
-                searchForWorkspaceRoot(fileURLToPath(appDir)),
-                searchForWorkspaceRoot(fileURLToPath(cliDir)),
-                fileURLToPath(appDir)
-            ]
-        },
-        watch: {
-            // During tests we edit the files too fast and sometimes chokidar
-            // misses change events, so enforce polling for consistency
-            usePolling: true,
-            interval: 100
-        },
-        host
-    };
-    if (ssr)
-        config.appType = 'custom';
     const vitrifyDevServer = await (await import('vite')).createServer({
         configFile: false,
-        ...config
+        ...config,
+        logLevel,
+        define: {
+            ...config.define,
+            __HOST__: `'${host}'`
+        },
+        server: {
+            ...config.server,
+            host,
+            port,
+            hmr: {
+                protocol: config.server?.https ? 'wss' : 'ws',
+                port: wsPort
+            }
+        }
     });
     return vitrifyDevServer;
 }
@@ -103,9 +82,17 @@ ssr, framework = 'vue', host, appDir, publicDir, vite }) {
         const entryUrl = ssr === 'fastify'
             ? fileURLToPath(new URL('src/vite/fastify/entry.ts', cliDir))
             : fileURLToPath(new URL(`src/vite/${framework}/ssr/app.ts`, cliDir));
-        ({ setup, onRendered, vitrifyConfig } = await vite.ssrLoadModule(entryUrl));
+        const environment = vite.environments.ssr;
+        ({ setup, onRendered, vitrifyConfig } =
+            // @ts-expect-error missing types
+            await environment.runner.import(entryUrl));
+        // console.log(module)
+        // ;({ setup, onRendered, vitrifyConfig } = await vite.ssrLoadModule(entryUrl))
         app = fastify({
             logger: {
+                transport: {
+                    target: '@fastify/one-line-logger'
+                },
                 level: process.env.DEBUG
                     ? 'debug'
                     : process.env.PINO_LOG_LEVEL || 'info'

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

@@ -36,7 +36,10 @@ const fastifySsrPlugin = async (fastify, options) => {
                 let template = readFileSync(new URL('index.html', frameworkDir)).toString();
                 template = await vite.transformIndexHtml(url, template);
                 const entryUrl = fileURLToPath(new URL('ssr/entry-server.ts', frameworkDir));
-                const render = (await vite.ssrLoadModule(entryUrl)).render;
+                const environment = vite.environments.ssr;
+                // @ts-expect-error missing type
+                const { render } = await environment.runner.import(entryUrl);
+                // const render = (await vite!.ssrLoadModule(entryUrl)).render
                 let manifest;
                 // TODO: https://github.com/vitejs/vite/issues/2282
                 try {

package/dist/frameworks/vue/server.js

@@ -2,6 +2,9 @@ import fastify from 'fastify';
 export const createApp = ({ onSetup, appDir, baseUrl, fastifyPlugin, onRendered, vitrifyDir, mode }) => {
     const app = fastify({
         logger: {
+            transport: {
+                target: '@fastify/one-line-logger'
+            },
             level: process.env.DEBUG ? 'debug' : process.env.PINO_LOG_LEVEL || 'info'
         }
     });

package/dist/index.js

@@ -14,6 +14,7 @@ import { addOrReplaceTitle, appendToBody } from './helpers/utils.js';
 import Components from 'unplugin-vue-components/vite';
 import { VitePWA } from 'vite-plugin-pwa';
 import UnoCSS from 'unocss/vite';
+import { searchForWorkspaceRoot } from 'vite';
 const internalServerModules = [
     'util',
     'vitrify',
@@ -29,12 +30,6 @@ const internalServerModules = [
     'ws',
     'abort-controller'
 ];
-const configPluginMap = {
-    quasar: () => import('./plugins/quasar.js').then((module) => module.QuasarPlugin)
-};
-const configResolverMap = {
-    quasar: () => import('unplugin-vue-components/resolvers').then((module) => module.QuasarResolver())
-};
 const manualChunkNames = [
     'prerender',
     'fastify-ssr-plugin',
@@ -68,30 +63,6 @@ const manualChunksFn = (manualChunkList) => {
         }
     };
 };
-// const manualChunks: ManualChunksOption = (
-//   id: string,
-//   manualChunkList?: string[]
-// ) => {
-//   const matchedModule = Object.entries(moduleChunks).find(
-//     ([chunkName, moduleNames]) =>
-//       moduleNames.some((moduleName) => id.includes(moduleName + '/'))
-//   )
-//   if (id.includes('vitrify/src/')) {
-//     const name = id.split('/').at(-1)?.split('.').at(0)
-//     if (name && manualChunkNames.includes(name)) return name
-//   } else if (
-//     VIRTUAL_MODULES.some((virtualModule) => id.includes(virtualModule))
-//   ) {
-//     return VIRTUAL_MODULES.find((name) => id.includes(name))
-//   } else if (manualChunkList?.some((file) => id.includes(file))) {
-//     return manualChunkList.find((file) => id.includes(file))
-//   } else if (id.includes('node_modules')) {
-//     if (matchedModule) {
-//       return matchedModule[0]
-//     }
-//     return 'vendor'
-//   }
-// }
 export const VIRTUAL_MODULES = [
     'virtual:vitrify-hooks',
     'virtual:static-imports',
@@ -168,7 +139,6 @@ export const baseConfig = async ({ ssr, appDir, publicDir, base = '/', command =
             const bundledConfig = await bundleConfigFile(fileURLToPath(new URL('vitrify.config.ts', appDir)));
             fs.writeFileSync(configPath + '.js', bundledConfig.code);
             rawVitrifyConfig = (await import('file://' + configPath + '.js')).default;
-            // vitrifyConfig = (await import(configPath + '.js')).default
             fs.unlinkSync(configPath + '.js');
         }
         else {
@@ -185,8 +155,9 @@ export const baseConfig = async ({ ssr, appDir, publicDir, base = '/', command =
         console.log('No valid vitrify.config.(ts|js) file found.');
         throw e;
     }
-    const localPackages = ['vue', 'vue-router', '@vue/server-renderer'];
-    // const localPackages: string[] = []
+    const localPackages = [];
+    if (framework === 'vue')
+        localPackages.push('vue', 'vue-router', '@vue/server-renderer');
     const cliPackages = [];
     const packageUrls = vitrifyConfig.vitrify?.urls?.packages || {};
     await (async () => {
@@ -196,12 +167,6 @@ export const baseConfig = async ({ ssr, appDir, publicDir, base = '/', command =
                 packageUrls[val] = new URL(`file://${pkgDir}`);
         }
     })();
-    // await (async () => {
-    //   for (const val of cliPackages)
-    //     packageUrls[val] = getPkgJsonDir(
-    //       new URL(await resolve(val, cliDir!.href))
-    //     )
-    // })()
     if (!productName) {
         try {
             ;
@@ -220,16 +185,26 @@ export const baseConfig = async ({ ssr, appDir, publicDir, base = '/', command =
     }
     const isPwa = !!vitrifyConfig.vitrify?.pwa || false;
     const frameworkPlugins = [];
-    const resolvers = [];
-    for (const framework of Object.keys(configPluginMap)) {
-        if (Object.keys(vitrifyConfig).includes(framework)) {
-            const plugin = await configPluginMap[framework]();
-            const resolver = await configResolverMap[framework]();
-            frameworkPlugins.push(await plugin({
+    if (framework === 'vue') {
+        frameworkPlugins.push(vuePlugin());
+    }
+    const vitrifyPlugins = [];
+    if (vitrifyConfig.vitrify?.plugins) {
+        for (const vitrifyPluginConfig of vitrifyConfig.vitrify.plugins) {
+            const vitrifyPlugin = await vitrifyPluginConfig.plugin({
                 ssr,
-                pwa: isPwa
-            }));
-            resolvers.push(resolver);
+                pwa: isPwa,
+                options: vitrifyPluginConfig.options
+            });
+            if ('plugin' in vitrifyPlugin) {
+                vitrifyPlugins.push(vitrifyPlugin.plugin);
+            }
+            else if ('plugins' in vitrifyPlugin) {
+                vitrifyPlugins.push(...vitrifyPlugin.plugins);
+            }
+            if (vitrifyPlugin.config) {
+                vitrifyConfig = mergeConfig(vitrifyConfig, vitrifyPlugin.config);
+            }
         }
     }
     let onBootHooks;
@@ -283,13 +258,12 @@ export const baseConfig = async ({ ssr, appDir, publicDir, base = '/', command =
                     code = code
                         .replace(/<style>(.*?)<\/style>/, '<style>' + css + '</style>')
                         .replace(/<style lang="sass">(.*?)<\/style>/, '<style lang="sass">' + sass + '</style>');
-                    // code = code.replace(/<\/style>/, sass + '</style>')
                 }
                 return code;
             }
         },
-        vuePlugin(),
         ...frameworkPlugins,
+        ...vitrifyPlugins,
         {
             name: 'vitrify-setup',
             enforce: 'post',
@@ -348,9 +322,6 @@ export const baseConfig = async ({ ssr, appDir, publicDir, base = '/', command =
                             .replaceAll('_', '')
                             .replaceAll('+', '');
                         return `import ${varName} from '${new URL(url, appDir).pathname}'; onSetup.push(${varName})`;
-                        // return `import ${varName} from '${fileURLToPath(
-                        //   url
-                        // )}'; onSetup.push(${varName})`
                     })
                         .join('\n')}`;
                 }
@@ -368,9 +339,6 @@ export const baseConfig = async ({ ssr, appDir, publicDir, base = '/', command =
                         ...globalSass.map((sass) => `@import '${sass}'`)
                     ].join('\n');
                 }
-                // else if (id === 'vitrify.css') {
-                //   return `${globalCss.map((css) => `@import '${css}'`).join('\n')}`
-                // }
                 else if (id === 'virtual:vitrify-config') {
                     return `export default ${JSON.stringify(vitrifyConfig)}`;
                 }
@@ -395,12 +363,12 @@ export const baseConfig = async ({ ssr, appDir, publicDir, base = '/', command =
             }
         },
         Components({
+            ...vitrifyConfig.vitrify?.unpluginVueComponents,
             exclude: [
                 new RegExp(`[\\/]node_modules[\\/].*[\\/]!(${serverModules.join('|')})`),
                 /[\\/]\.git[\\/]/,
                 /[\\/]\.nuxt[\\/]/
-            ],
-            resolvers
+            ]
         }),
         UnoCSS({
             ...vitrifyConfig.vitrify?.unocss,
@@ -448,31 +416,13 @@ export const baseConfig = async ({ ssr, appDir, publicDir, base = '/', command =
                     else {
                         entryScript = `<script type="module" src="${entry}"></script>`;
                     }
-                    // html = html.replace('<!--entry-script-->', entryScript)
                     html = appendToBody(entryScript, html);
                     if (productName)
                         html = addOrReplaceTitle(productName, html);
-                    // html = html.replace('<!--product-name-->', productName)
                     return html;
                 }
             }
         });
-        // plugins.unshift({
-        //   name: 'product-name',
-        //   enforce: 'post',
-        //   config: (config: VitrifyConfig, env) => {
-        //     if (config.vitrify?.productName)
-        //       productName = config.vitrify?.productName
-        //     return
-        //   },
-        //   transformIndexHtml: {
-        //     enforce: 'post',
-        //     transform: (html) => {
-        //       html = html.replace('<!--product-name-->', productName)
-        //       return html
-        //     }
-        //   }
-        // })
         if (debug)
             plugins.push(visualizer());
     }
@@ -486,31 +436,33 @@ export const baseConfig = async ({ ssr, appDir, publicDir, base = '/', command =
         '@vue/server-renderer'
     ];
     const vuePkgAliases = [];
-    for (const pkg of vueInternalPkgs) {
-        const specifier = pkg.split('/').at(-1);
-        const pkgJsonPath = await findDepPkgJsonPath(pkg, fileURLToPath(appDir));
-        if (pkgJsonPath)
+    if (packageUrls['vue']) {
+        for (const pkg of vueInternalPkgs) {
+            const specifier = pkg.split('/').at(-1);
+            const pkgJsonPath = await findDepPkgJsonPath(pkg, fileURLToPath(appDir));
+            if (pkgJsonPath)
+                vuePkgAliases.push({
+                    find: pkg,
+                    replacement: fileURLToPath(new URL(`./dist/${specifier}.esm-bundler.js`, `file://${pkgJsonPath}` || ''))
+                });
             vuePkgAliases.push({
-                find: pkg,
-                replacement: fileURLToPath(new URL(`./dist/${specifier}.esm-bundler.js`, `file://${pkgJsonPath}` || ''))
-            });
+                find: new RegExp('^vue$'),
+                replacement: fileURLToPath(new URL('./dist/vue.runtime.esm-bundler.js', packageUrls['vue']))
+            }, {
+                find: new RegExp('^vue-router$'),
+                replacement: fileURLToPath(new URL('./dist/vue-router.esm-bundler.js', packageUrls['vue-router']))
+            }, ...vuePkgAliases);
+        }
     }
     const alias = [
         { find: 'src', replacement: fileURLToPath(srcDir) },
         { find: 'app', replacement: fileURLToPath(appDir) },
         { find: 'cwd', replacement: fileURLToPath(cwd) },
         { find: 'boot', replacement: fileURLToPath(new URL('boot/', srcDir)) },
-        { find: 'assets', replacement: fileURLToPath(new URL('assets/', srcDir)) },
-        {
-            find: new RegExp('^vue$'),
-            replacement: fileURLToPath(new URL('./dist/vue.runtime.esm-bundler.js', packageUrls['vue']))
-        },
-        {
-            find: new RegExp('^vue-router$'),
-            replacement: fileURLToPath(new URL('./dist/vue-router.esm-bundler.js', packageUrls['vue-router']))
-        },
-        ...vuePkgAliases
+        { find: 'assets', replacement: fileURLToPath(new URL('assets/', srcDir)) }
     ];
+    if (framework === 'vue')
+        alias.push(...vuePkgAliases);
     if (mode === 'development' && vitrifyConfig.vitrify?.dev?.alias)
         alias.push(...vitrifyConfig.vitrify.dev.alias);
     if (command === 'test')
@@ -579,6 +531,7 @@ export const baseConfig = async ({ ssr, appDir, publicDir, base = '/', command =
     }
     const config = {
         root: fileURLToPath(appDir),
+        appType: ssr ? 'custom' : 'spa',
         publicDir: fileURLToPath(publicDir),
         base,
         envDir: fileURLToPath(appDir),
@@ -615,6 +568,28 @@ export const baseConfig = async ({ ssr, appDir, publicDir, base = '/', command =
             __HOST__: `'localhost'`,
             __BASE_URL__: `'${base}'`,
             __IS_PWA__: `${isPwa}`
+        },
+        // environments: {
+        // },
+        server: {
+            https: vitrifyConfig.server?.https,
+            // middlewareMode: mode === 'ssr' ? 'ssr' : undefined,
+            middlewareMode: ssr ? true : false,
+            fs: {
+                strict: false, // https://github.com/vitejs/vite/issues/8175
+                allow: [
+                    searchForWorkspaceRoot(process.cwd()),
+                    searchForWorkspaceRoot(fileURLToPath(appDir)),
+                    searchForWorkspaceRoot(fileURLToPath(cliDir)),
+                    fileURLToPath(appDir)
+                ]
+            },
+            watch: {
+                // During tests we edit the files too fast and sometimes chokidar
+                // misses change events, so enforce polling for consistency
+                usePolling: true,
+                interval: 100
+            }
         }
     };
     return mergeConfig(config, vitrifyConfig);

package/dist/plugins/index.js

@@ -1 +1 @@
-export {};
+export * from './quasar/index.js';

package/dist/plugins/quasar/index.js

@@ -0,0 +1,227 @@
+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,
+                                onRendered: [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()]
+                }
+            }
+        }
+    };
+};
+export default QuasarPlugin;

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

@@ -1,7 +1,17 @@
 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';

package/dist/types/plugins/{quasar.d.ts → quasar/index.d.ts}

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