vitrify 0.1.0 → 0.1.1

package/dist/index.js

@@ -0,0 +1,288 @@
+import vuePlugin from '@vitejs/plugin-vue';
+import { mergeConfig } from 'vite';
+import { readFileSync } from 'fs';
+import builtinModules from 'builtin-modules';
+import { resolve } from 'import-meta-resolve';
+import { getPkgJsonDir } from './app-urls.js';
+const serverModules = ['fastify', 'middie'];
+const configPluginMap = {
+    quasar: () => import('./plugins/quasar.js').then((module) => module.QuasarPlugin)
+};
+export const VIRTUAL_MODULES = [
+    'virtual:fastify-setup',
+    'virtual:boot-functions',
+    'virtual:ssr-functions',
+    'virtual:on-mounted-hooks',
+    'virtual:global-css',
+    'virtual:static-imports'
+];
+export const baseConfig = async ({ ssr, appDir, publicDir, command = 'build', mode = 'production', framework = 'vue', pwa = false }) => {
+    const { appDir: tempAppDir, cliDir, cliViteDir, srcDir } = await import('./app-urls.js');
+    const cwd = appDir || tempAppDir;
+    const frameworkDir = new URL(`${framework}/`, cliViteDir);
+    if (!appDir)
+        appDir = tempAppDir;
+    // const localPackages = ['vue', 'vue-router', 'quasar']
+    const localPackages = ['vue', 'vue-router'];
+    const cliPackages = ['vitest'];
+    const packageUrls = {};
+    await (async () => {
+        for (const val of localPackages)
+            packageUrls[val] = getPkgJsonDir(new URL(await resolve(val, appDir.href)));
+    })();
+    await (async () => {
+        for (const val of cliPackages)
+            packageUrls[val] = getPkgJsonDir(new URL(await resolve(val, cliDir.href)));
+    })();
+    // if (appDir) {
+    //   srcDir = new URL('src/', appDir);
+    //   quasarDir = new URL(await resolve('quasar/', appDir.href));
+    //   ({ appDir: cwd, cliDir } = await import('./app-urls.js'))
+    // } else {
+    //   ({ appDir, cliDir, srcDir, quasarDir } = await import('./app-urls.js'))
+    //   cwd = appDir
+    // }
+    // vueDir = new URL('./', await resolve('vue', appDir.href));
+    // vueRouterDir = new URL('../', await resolve('vue-router', appDir.href));
+    // vitestDir = new URL('../', await resolve('vitest', cliDir.href));
+    if (!publicDir)
+        publicDir = new URL('public/', appDir);
+    /**
+     * TODO:Perform some manual check if command is run inside a Quasar Project
+     */
+    let vitrifyConfig;
+    try {
+        vitrifyConfig = (await import(new URL('vitrify.config.js', appDir).pathname)).default;
+        if (typeof vitrifyConfig === 'function')
+            vitrifyConfig = vitrifyConfig({ mode, command });
+    }
+    catch (e) {
+        console.error(e);
+        console.log('No vitrify.config.js file found, using defaults');
+        vitrifyConfig = {};
+    }
+    const { productName = 'Product name' } = JSON.parse(readFileSync(new URL('package.json', appDir).pathname, {
+        encoding: 'utf-8'
+    }));
+    const fastifySetup = vitrifyConfig.vitrify?.fastify?.setup || ((fastify) => { });
+    const sass = [];
+    const sassVariables = vitrifyConfig.vitrify?.sassVariables;
+    if (sassVariables) {
+        for (const variable in sassVariables) {
+            sass.push(`${variable}: ${sassVariables[variable]}`);
+        }
+    }
+    const ssrTransformCustomDir = () => {
+        return {
+            props: [],
+            needRuntime: true
+        };
+    };
+    const frameworkPlugins = [];
+    for (const framework of Object.keys(configPluginMap)) {
+        if (Object.keys(vitrifyConfig).includes(framework)) {
+            const plugin = await configPluginMap[framework]();
+            frameworkPlugins.push(await plugin({
+                ssr,
+                pwa
+            }));
+        }
+    }
+    let bootFunctions;
+    let ssrFunctions;
+    let onMountedHooks;
+    let globalCss;
+    let staticImports;
+    const plugins = [
+        vuePlugin({
+            template: {
+                ssr: !!ssr,
+                compilerOptions: {
+                    directiveTransforms: {
+                        'close-popup': ssrTransformCustomDir,
+                        intersection: ssrTransformCustomDir,
+                        ripple: ssrTransformCustomDir,
+                        mutation: ssrTransformCustomDir,
+                        morph: ssrTransformCustomDir,
+                        scroll: ssrTransformCustomDir,
+                        'scroll-fire': ssrTransformCustomDir,
+                        'touch-hold': ssrTransformCustomDir,
+                        'touch-pan': ssrTransformCustomDir,
+                        'touch-repeat': ssrTransformCustomDir,
+                        'touch-swipe': ssrTransformCustomDir
+                    }
+                }
+            }
+        }),
+        ...frameworkPlugins,
+        // await QuasarPlugin({
+        //   ssr: ssr,
+        //   pwa: pwa
+        //   // quasarDir: packageUrls.quasar
+        // }),
+        {
+            name: 'vitrify-virtual-modules',
+            enforce: 'post',
+            config: async (config, env) => {
+                bootFunctions = config.vitrify?.bootFunctions || [];
+                ssrFunctions = config.vitrify?.ssrFunctions || [];
+                onMountedHooks = config.vitrify?.hooks?.onMounted || [];
+                globalCss = config.vitrify?.globalCss || [];
+                staticImports = config.vitrify?.staticImports || {};
+            },
+            resolveId(id) {
+                if (VIRTUAL_MODULES.includes(id))
+                    return id;
+                return;
+            },
+            load(id) {
+                if (id === 'virtual:fastify-setup') {
+                    return `export const setup = ${String(fastifySetup)}`;
+                }
+                else if (id === 'virtual:boot-functions') {
+                    return `export default [${bootFunctions
+                        .map((fn) => `${String(fn)}`)
+                        .join(', ')}]`;
+                }
+                else if (id === 'virtual:ssr-functions') {
+                    return `export default [${ssrFunctions
+                        .map((fn) => `${String(fn)}`)
+                        .join(', ')}]`;
+                }
+                else if (id === 'virtual:on-mounted-hooks') {
+                    return `export default [${onMountedHooks
+                        .map((fn) => `${String(fn)}`)
+                        .join(', ')}]`;
+                }
+                else if (id === 'virtual:global-css') {
+                    return `${globalCss.map((css) => `import '${css}'`).join('\n')}`;
+                }
+                else if (id === 'virtual:static-imports') {
+                    return `${Object.entries(staticImports)
+                        .map(([key, value]) => `export { ${value.join(',')} } from '${key}';`)
+                        .join('\n')}`;
+                }
+                return null;
+            }
+        }
+    ];
+    if (command !== 'test') {
+        plugins.unshift({
+            name: 'html-transform',
+            enforce: 'pre',
+            transformIndexHtml: {
+                enforce: 'pre',
+                transform: (html) => {
+                    let entry;
+                    switch (ssr) {
+                        case 'ssg':
+                        case 'server':
+                        case 'client':
+                            entry = new URL('ssr/entry-client.ts', frameworkDir).pathname;
+                            break;
+                        default:
+                            entry = new URL('csr/entry.ts', frameworkDir).pathname;
+                    }
+                    const entryScript = `<script type="module" src="${entry}"></script>`;
+                    html = html
+                        .replace('<!--entry-script-->', entryScript)
+                        .replace('<!--product-name-->', productName);
+                    return html;
+                }
+            }
+        });
+    }
+    const alias = [
+        { find: 'src', replacement: srcDir.pathname },
+        { find: 'app', replacement: appDir.pathname },
+        { find: 'cwd', replacement: cwd.pathname },
+        { find: 'boot', replacement: new URL('boot/', srcDir).pathname },
+        { find: 'assets', replacement: new URL('assets/', srcDir).pathname },
+        // ...Object.entries(packageUrls).map(([key, value]) => ({
+        //   find: key, replacement: value.pathname
+        // })),
+        { find: 'vue', replacement: packageUrls['vue'].pathname },
+        { find: 'vue-router', replacement: packageUrls['vue-router'].pathname },
+        { find: 'vitrify', replacement: cliDir.pathname }
+    ];
+    if (command === 'test')
+        alias.push({
+            find: 'vitest',
+            replacement: packageUrls.vitest.pathname
+        });
+    const config = {
+        root: frameworkDir.pathname,
+        publicDir: publicDir.pathname,
+        vitrify: {
+            productName,
+            urls: {
+                // @ts-ignore
+                app: appDir,
+                cli: cliDir,
+                src: srcDir,
+                cwd,
+                packages: packageUrls
+            }
+        },
+        plugins,
+        optimizeDeps: {
+            exclude: ['vue']
+        },
+        resolve: {
+            // Dedupe uses require which breaks ESM SSR builds
+            // dedupe: [
+            //   'vue',
+            //   'vue-router'
+            // ],
+            alias
+        },
+        build: {
+            target: ssr === 'server' ? 'esnext' : 'modules',
+            ssr: ssr === 'server' ? true : false,
+            ssrManifest: ssr === 'client' || ssr === 'ssg',
+            rollupOptions: ssr === 'server'
+                ? {
+                    input: [
+                        new URL('ssr/entry-server.ts', frameworkDir).pathname,
+                        new URL('ssr/server.ts', frameworkDir).pathname
+                    ],
+                    output: {
+                        minifyInternalExports: false,
+                        entryFileNames: '[name].mjs',
+                        chunkFileNames: '[name].mjs',
+                        format: 'es',
+                        manualChunks: (id) => {
+                            if (id.includes('fastify-ssr-plugin')) {
+                                return 'fastify-ssr-plugin';
+                            }
+                            else if (id.includes('node_modules')) {
+                                return 'vendor';
+                            }
+                        }
+                    }
+                }
+                : {
+                    output: {
+                        format: 'es'
+                    }
+                }
+        },
+        css: {
+            preprocessorOptions: {
+                sass: {
+                    additionalData: [...sass].join('\n') + '\n'
+                }
+            }
+        },
+        ssr: {
+            // Create a SSR bundle
+            noExternal: [
+                new RegExp(`^(?!.*(${[...builtinModules, ...serverModules].join('|')}))`)
+            ]
+        },
+        define: {
+            __BASE_URL__: `'/'`
+        }
+    };
+    return mergeConfig(config, vitrifyConfig);
+};

package/dist/plugins/index.js

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

package/dist/plugins/quasar.js

@@ -0,0 +1,294 @@
+import { readFileSync } from 'fs';
+import Components from 'unplugin-vue-components/vite';
+// import { quasarDir as defaultQuasarDir } from '../app-urls.js'
+// import { QuasarResolver } from '../resolver.js';
+import { QuasarResolver } from 'unplugin-vue-components/resolvers';
+import { getPkgJsonDir } from '../app-urls.js';
+import { resolve } from 'import-meta-resolve';
+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 interface Configuration {
+//   ssr?: 'server' | 'client' | 'ssg' | false
+// }
+export const QuasarPlugin = async ({ ssr = false, pwa = false }) => {
+    // const extraPlugins: Plugin[] = []
+    // const ctx = {
+    //   prod: process.env.MODE === 'production',
+    //   dev: process.env.MODE === 'development',
+    //   mode: {
+    //     ssr: !!ssr,
+    //     pwa: !!pwa
+    //   }
+    // }
+    // let bootFilePaths: Record<string, any> = {}
+    // let components: string[] = []
+    let plugins = [];
+    // let css: string[] = []
+    let extras = [];
+    return [
+        // {
+        //   name: 'legacy-support',
+        //   enforce: 'pre',
+        //   transform (code, id) {
+        //     /**
+        //      * ESM does not resolve an import to .default when there are multiple exports. The following is required to make the VuePlugin import of QCalendar work.
+        //      */
+        //     if (code.includes('app.use(VuePlugin)')) {
+        //       code = code.replace(/app\.use\(VuePlugin\)/g, `app.use(VuePlugin.install ? VuePlugin : VuePlugin.default)`)
+        //     }
+        //     return code
+        //   }
+        // },
+        Components({
+            resolvers: [QuasarResolver()]
+        }),
+        {
+            name: 'vite-plugin-quasar-setup',
+            enforce: 'pre',
+            config: async (config, env) => {
+                const { vitrify: { urls } = {}, quasar } = config;
+                const globalCss = quasar?.extras.map((extra) => `@quasar/extras/${extra}/${extra}.css`);
+                const localPackages = ['@quasar/extras', 'quasar'];
+                await (async () => {
+                    for (const val of localPackages)
+                        urls.packages[val] = getPkgJsonDir(new URL(await resolve(val, urls.app.href)));
+                })();
+                const onMountedHooks = [
+                    async (instance) => {
+                        // @ts-ignore
+                        const { proxy: { $q } } = instance;
+                        $q.onSSRHydrated !== void 0 && $q.onSSRHydrated();
+                    }
+                ];
+                const bootFunctions = [
+                    async ({ app, ssrContext, staticImports }) => {
+                        // @ts-ignore
+                        // const quasarVuePlugin = (await import('quasar/vue-plugin')).default
+                        // @ts-ignore
+                        const quasarPlugins = await import('virtual:quasar-plugins');
+                        // @ts-ignore
+                        const directives = await import('quasar/directives');
+                        app.use(staticImports.Quasar, {
+                            plugins: quasarPlugins,
+                            directives
+                        }, ssrContext);
+                    }
+                ];
+                return {
+                    vitrify: {
+                        urls,
+                        bootFunctions,
+                        ssrFunctions: [injectSsrContext],
+                        globalCss,
+                        staticImports: {
+                            quasar: ['Quasar']
+                        },
+                        hooks: {
+                            onMounted: onMountedHooks
+                        }
+                    }
+                };
+            }
+        },
+        {
+            name: 'vite-plugin-quasar',
+            enforce: 'post',
+            // transformIndexHtml: {
+            //   enforce: 'post',
+            //   transform: (html) => {
+            //     return html.replace(
+            //       '<!--product-name-->',
+            //       productName
+            //     )
+            //   }
+            // },
+            config: async (config, env) => {
+                // let appDir: URL
+                // let cliDir: URL
+                // let cwd: URL
+                // let quasarDir: URL
+                // let quasarConf: QuasarConf | undefined
+                const { quasar: quasarConf, vitrify: { urls } = {} } = config;
+                const quasarPkgJsonPath = new URL('package.json', urls?.packages?.quasar).pathname;
+                const { version } = JSON.parse(readFileSync(quasarPkgJsonPath, { encoding: 'utf-8' }));
+                // if (quasarConf?.boot) {
+                //   bootFilePaths = (quasarConf.boot as (Record<string, any> | string)[])
+                //     .filter(entry => {
+                //       if (typeof entry === 'object') return (entry.server && (ssr === 'server'))
+                //       else if (entry !== '') return true
+                //     })
+                //     .map(entry => {
+                //       if (typeof entry === 'string') return entry
+                //       else if (typeof entry === 'object') return entry.path
+                //     })
+                //     .reduce((acc, entry) => {
+                //       if (entry[0] === '~') {
+                //         const split = entry.substring(1).split('/')
+                //         const name = split[0].replace(/[|&;$%@"<>()+,]/g, "");
+                //         acc[name] = {
+                //           path: new URL(`node_modules/${entry.substring(1)}`, urls?.app).pathname
+                //         }
+                //       } else {
+                //         const name = entry.split('.')[0]
+                //         acc[name] = {
+                //           path: `src/boot/${entry}`
+                //         }
+                //       }
+                //       return acc
+                //     }, {})
+                // }
+                /**
+                 * 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;
+                }
+                // css = (quasarConf?.css || []).map((v => {
+                //   if (v[0] === '~') {
+                //     return v.slice(1)
+                //   }
+                //   return v
+                // })).map((v) => `@import '${v}'`)
+                extras = quasarConf?.extras || [];
+                return {
+                    resolve: {
+                        alias: [
+                            {
+                                find: 'quasar/wrappers',
+                                replacement: new URL('quasar-wrappers.ts', urls?.cli).pathname
+                            },
+                            {
+                                find: 'quasar/vue-plugin',
+                                replacement: new URL('src/vue-plugin.js', urls?.packages?.quasar).pathname
+                            },
+                            {
+                                find: 'quasar/plugins',
+                                replacement: new URL('src/plugins.js', urls?.packages?.quasar)
+                                    .pathname
+                            },
+                            {
+                                find: 'quasar/components',
+                                replacement: new URL('src/components.js', urls?.packages?.quasar).pathname
+                            },
+                            {
+                                find: 'quasar/composables',
+                                replacement: new URL('src/composables.js', urls?.packages?.quasar).pathname
+                            },
+                            {
+                                find: 'quasar/directives',
+                                replacement: new URL('src/directives.js', urls?.packages?.quasar).pathname
+                            },
+                            {
+                                find: 'quasar/src',
+                                replacement: new URL('src/', urls?.packages?.quasar).pathname
+                            },
+                            // ...extras.map(extra => ({
+                            //   find: `@quasar/extras/${extra}/${extra}.css`,
+                            //   replacement: new URL(`${extra}/${extra}.css`, urls?.packages?.['@quasar/extras']).pathname
+                            // })
+                            // ),
+                            {
+                                find: 'quasar',
+                                replacement: new URL('src/', urls?.packages?.quasar).pathname
+                            },
+                            {
+                                find: `@quasar/extras`,
+                                replacement: new URL('.', urls?.packages?.['@quasar/extras'])
+                                    .pathname
+                            }
+                            // { find: new RegExp('^quasar$'), replacement: new URL('src/index.all.js', urls?.packages?.quasar).pathname },
+                            // { find: new RegExp('^quasar$'), replacement: 'virtual:quasar' },
+                        ]
+                    },
+                    define: {
+                        __DEV__: process.env.NODE_ENV !== 'production' || true,
+                        __QUASAR_VERSION__: `'${version}'`,
+                        __QUASAR_SSR__: !!ssr,
+                        __QUASAR_SSR_SERVER__: ssr === 'server',
+                        __QUASAR_SSR_CLIENT__: ssr === 'client',
+                        __QUASAR_SSR_PWA__: ssr === 'client' && pwa
+                    },
+                    css: {
+                        preprocessorOptions: {
+                            sass: {
+                                additionalData: [
+                                    // ...extras.map(extra => `@import "@quasar/extras/${extra}/${extra}.css"`),
+                                    // ...extras.map(extra => `@import ${new URL(`${extra}/${extra}.css`, urls?.packages?.['@quasar/extras']).pathname}`) || [],
+                                    config.css?.preprocessorOptions?.sass?.additionalData,
+                                    `@import 'quasar/src/css/index.sass'`
+                                ].join('\n') + '\n'
+                            }
+                        }
+                    },
+                    ssr: {
+                        noExternal: ['quasar']
+                    }
+                };
+            }
+        },
+        {
+            name: 'quasar-virtual-modules',
+            enforce: 'post',
+            config: async (config, env) => ({
+                resolve: {
+                    alias: [
+                        { find: new RegExp('^quasar$'), replacement: 'virtual:quasar' }
+                    ]
+                }
+            }),
+            resolveId(id) {
+                switch (id) {
+                    case 'virtual:quasar-plugins':
+                        return 'virtual:quasar-plugins';
+                    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') {
+                    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 { default as Quasar } from 'quasar/src/vue-plugin.js'`;
+                }
+                return null;
+            }
+        }
+    ];
+};
+export default QuasarPlugin;

package/dist/types/app-urls.d.ts

@@ -0,0 +1,11 @@
+export declare const getPkgJsonDir: (dir: URL) => URL;
+export declare const appDir: URL;
+export declare const cliDir: URL;
+export declare const cliViteDir: URL;
+export declare const srcDir: URL;
+export declare const parsePath: (path: string) => URL | undefined;
+export declare const projectURLs: {
+    src: (path: string) => URL;
+    app: (path: string) => URL;
+    cli: (path: string) => URL;
+};

package/dist/types/bin/build.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/node --experimental-specifier-resolution=node
+export declare function build(opts: {
+    ssr?: 'client' | 'server' | 'ssg';
+    base?: string;
+    outDir?: string;
+    appDir?: URL;
+    publicDir?: URL;
+}): Promise<import("rollup").RollupOutput | import("rollup").RollupOutput[] | import("rollup").RollupWatcher>;

package/dist/types/bin/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/types/bin/dev.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import type { ViteDevServer, LogLevel } from 'vite';
+import type { Server } from 'net';
+export declare function createServer({ port, logLevel, mode, framework, host, appDir, publicDir }: {
+    port?: number;
+    logLevel?: LogLevel;
+    mode?: 'csr' | 'ssr';
+    framework?: 'vue';
+    host?: string;
+    appDir?: URL;
+    publicDir?: URL;
+}): Promise<{
+    server: Server;
+    vite: ViteDevServer;
+}>;

package/dist/types/bin/run.d.ts

@@ -0,0 +1,8 @@
+import { projectURLs } from '../app-urls.js';
+export interface VitrifyContext {
+    vitrify: {
+        version: string;
+    };
+    projectURLs: typeof projectURLs;
+}
+export declare function run(filePath: string): Promise<void>;

package/dist/types/bin/test.d.ts

@@ -0,0 +1,3 @@
+export declare function test(opts: {
+    appDir: URL;
+}): Promise<void>;

package/dist/types/helpers/logger.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import type { Server } from 'net';
+import type { ResolvedConfig } from 'vite';
+export declare const clearConsole: () => void;
+export declare const log: (msg?: string | undefined) => void;
+export declare const warn: (msg?: string | undefined, pill?: string | undefined) => void;
+export declare const fatal: (msg?: string | undefined, pill?: string | undefined) => never;
+/**
+ * Extended approach - Compilation status & pills
+ */
+export declare const successPill: (msg?: string | undefined) => string;
+export declare const infoPill: (msg?: string | undefined) => string;
+export declare const errorPill: (msg?: string | undefined) => string;
+export declare const warningPill: (msg?: string | undefined) => string;
+export declare const success: (msg?: string | undefined, title?: string) => void;
+export declare const getSuccess: (msg?: string | undefined, title?: string | undefined) => string;
+export declare const info: (msg?: string | undefined, title?: string) => void;
+export declare const getInfo: (msg?: string | undefined, title?: string | undefined) => string;
+export declare const error: (msg?: string | undefined, title?: string) => void;
+export declare const getError: (msg?: string | undefined, title?: string) => string;
+export declare const warning: (msg?: string | undefined, title?: string) => void;
+export declare const getWarning: (msg?: string | undefined, title?: string) => string;
+export declare function printHttpServerUrls(server: Server, config: ResolvedConfig): void;

package/dist/types/helpers/routes.d.ts

@@ -0,0 +1,2 @@
+import type { RouteRecordRaw } from 'vue-router';
+export declare const routesToPaths: (routes?: RouteRecordRaw[] | undefined) => string[];

package/dist/types/helpers/utils.d.ts

@@ -0,0 +1,5 @@
+export interface Hostname {
+    host: string | undefined;
+    name: string;
+}
+export declare function resolveHostname(optionsHost: string | boolean | undefined): Hostname;