vitrify 0.1.0 → 0.2.1

package/dist/plugins/quasar.js

@@ -0,0 +1,299 @@
+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/src/directives.js');
+                        app.use(staticImports.Quasar, {
+                            plugins: quasarPlugins,
+                            directives
+                        }, ssrContext);
+                    }
+                ];
+                return {
+                    vitrify: {
+                        urls,
+                        bootFunctions,
+                        ssrFunctions: [injectSsrContext],
+                        globalCss,
+                        staticImports: {
+                            quasar: ['Quasar']
+                        },
+                        hooks: {
+                            onMounted: onMountedHooks
+                        },
+                        sass: {
+                            additionalData: [`@import 'quasar/src/css/index.sass'`]
+                        }
+                    }
+                };
+            }
+        },
+        {
+            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: `@import 'quasar/src/css/index.sass'`
+                    //       // [
+                    //       //   // ...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')
+                    //     }
+                    //   }
+                    // },
+                    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 * from 'quasar/src/utils.js';
+          export { default as Quasar } from 'quasar/src/install-quasar.js'`;
+                }
+                return null;
+            }
+        }
+    ];
+};
+export default QuasarPlugin;

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

@@ -0,0 +1,12 @@
+export declare const getPkgJsonDir: (dir: URL) => URL;
+export declare const getAppDir: () => URL;
+export declare const getCliDir: () => URL;
+export declare const getCliViteDir: (cliDir: URL) => URL;
+export declare const getSrcDir: (appDir: URL) => URL;
+export declare const getCwd: () => URL;
+export declare const parsePath: (path: string, basePath: URL) => URL | undefined;
+export declare const getProjectURLs: (appDir: URL, cliDir: URL) => {
+    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 { getProjectURLs } from '../app-urls.js';
+export interface VitrifyContext {
+    vitrify: {
+        version: string;
+    };
+    projectURLs: ReturnType<typeof getProjectURLs>;
+}
+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/frameworks/vue/fastify-ssr-plugin.d.ts

@@ -0,0 +1,14 @@
+import type { FastifyPluginCallback, FastifyRequest, FastifyReply } from 'fastify';
+import type { ViteDevServer } from 'vite';
+import type { SsrFunction } from '../../vitrify-config.js';
+export interface FastifySsrOptions {
+    baseUrl?: string;
+    provide?: (req: FastifyRequest, res: FastifyReply) => Promise<Record<string, unknown>>;
+    vite?: ViteDevServer;
+    cliDir?: URL;
+    appDir?: URL;
+    productName?: string;
+    ssrFunctions?: SsrFunction[];
+}
+declare const fastifySsrPlugin: FastifyPluginCallback<FastifySsrOptions>;
+export { fastifySsrPlugin };

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

@@ -0,0 +1,8 @@
+import type { SsrFunction } from '../../vitrify-config.js';
+export declare const prerender: ({ outDir, templatePath, manifestPath, entryServerPath, ssrFunctions }: {
+    outDir: string;
+    templatePath: string;
+    manifestPath: string;
+    entryServerPath: string;
+    ssrFunctions: SsrFunction[];
+}) => Promise<void[]>;

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

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import type { FastifyInstance } from 'fastify';
+import type { SsrFunction } from '../../vitrify-config.js';
+export declare const createApp: ({ setup, appDir, baseUrl, ssrFunctions }: {
+    setup: (fastify: FastifyInstance) => any;
+    appDir: URL;
+    baseUrl?: string | undefined;
+    ssrFunctions?: SsrFunction[] | undefined;
+}) => FastifyInstance<import("http").Server, import("http").IncomingMessage, import("http").ServerResponse, import("fastify").FastifyLoggerInstance> & PromiseLike<FastifyInstance<import("http").Server, import("http").IncomingMessage, import("http").ServerResponse, import("fastify").FastifyLoggerInstance>>;

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;

package/dist/types/index.d.ts

@@ -0,0 +1,15 @@
+import type { InlineConfig } from 'vite';
+import type { BootFunction, VitrifyConfig } from './vitrify-config.js';
+import type { VitrifyContext } from './bin/run.js';
+import type { VitrifyPlugin } from './plugins/index.js';
+export declare const VIRTUAL_MODULES: string[];
+export declare const baseConfig: ({ ssr, appDir, publicDir, command, mode, framework, pwa }: {
+    ssr?: "server" | "client" | "ssg" | undefined;
+    appDir?: URL | undefined;
+    publicDir?: URL | undefined;
+    command?: "build" | "dev" | "test" | undefined;
+    mode?: "production" | "development" | undefined;
+    framework?: "vue" | undefined;
+    pwa?: boolean | undefined;
+}) => Promise<InlineConfig>;
+export type { VitrifyConfig, VitrifyPlugin, VitrifyContext, BootFunction };

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

@@ -0,0 +1,7 @@
+import type { Plugin } from 'vite';
+export declare type VitrifyPlugin = ({ ssr, mode, command }: {
+    ssr?: 'server' | 'client' | 'ssg' | false;
+    pwa?: boolean;
+    mode?: 'production' | 'development';
+    command?: 'build' | 'dev' | 'test';
+}) => Promise<Plugin | Plugin[]> | Plugin | Plugin[];

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

@@ -0,0 +1,16 @@
+import type { VitrifyPlugin } from './index.js';
+export interface QuasarConf {
+    ctx: Record<string, any>;
+    css: string[];
+    boot: string[];
+    framework: {
+        components?: string[];
+        directives?: string[];
+        plugins?: string[];
+    };
+    animations: string[];
+    extras: string[];
+}
+export declare const injectSsrContext: (html: string, ssrContext: Record<string, any>) => string;
+export declare const QuasarPlugin: VitrifyPlugin;
+export default QuasarPlugin;

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

@@ -0,0 +1,67 @@
+import type { FastifyInstance } from 'fastify';
+import type { UserConfig } from 'vite';
+import type { QuasarConf } from './plugins/quasar.js';
+import type { ComponentInternalInstance } from '@vue/runtime-core';
+export declare type BootFunction = ({ app, ssrContext, staticImports }: {
+    app: any;
+    ssrContext: Record<string, unknown>;
+    staticImports: Record<string, any>;
+}) => Promise<void> | void;
+export declare type OnMountedHook = (instance: ComponentInternalInstance) => Promise<void> | void;
+export declare type StaticImports = Record<string, string[]>;
+export declare type SsrFunction = (html: string, ssrContext: Record<string, any>) => string;
+export interface VitrifyConfig extends UserConfig {
+    vitrify?: {
+        /**
+         * Global CSS imports
+         */
+        globalCss?: string[];
+        /**
+         * Functions which run after initializing the app
+         */
+        bootFunctions?: BootFunction[];
+        /**
+         * Functions which run on the server after rendering the app
+         */
+        ssrFunctions?: SsrFunction[];
+        /**
+         * Static imports in the app: packageName: [imports]
+         */
+        staticImports?: StaticImports;
+        hooks?: {
+            /**
+             * Functions which run in the onMounted hook of the app
+             */
+            onMounted: OnMountedHook[];
+        };
+        /**
+         * Global SASS variables
+         */
+        sass?: {
+            variables?: Record<string, string>;
+            additionalData?: string[];
+        };
+        fastify?: {
+            /**
+             * setup() is called directly after instantiating fastify. Use it to register your own plugins, routes etc.
+             */
+            setup: (fastify: FastifyInstance) => any;
+        };
+        /**
+         * Product name of the application. Will be used for the HTML title tag
+         */
+        productName?: string;
+        /**
+         * URL's for common dev paths and packages, automatically generated
+         */
+        urls?: {
+            app?: URL;
+            cli?: URL;
+            src?: URL;
+            cwd?: URL;
+            packages?: Record<string, URL>;
+        };
+    };
+    quasar?: QuasarConf;
+}
+export declare const defineConfig: (config: VitrifyConfig) => VitrifyConfig;

package/dist/vitrify-config.js

@@ -0,0 +1 @@
+export const defineConfig = (config) => config;