ream/dist/prepare-files.js

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.prepareFiles = void 0;
const fast_glob_1 = __importDefault(require("fast-glob"));
const fs_extra_1 = require("fs-extra");
const store_1 = require("./store");
const path_1 = __importDefault(require("path"));
const load_routes_1 = require("./utils/load-routes");
const normalize_path_1 = require("./utils/normalize-path");
const isAbsolutPath = (p) => /^\/|[a-zA-Z]:/.test(p);
async function prepareFiles(api) {
    const pagesDir = api.resolveSrcDir('pages');
    const routesFilePattern = '**/*.{vue,ts,tsx,js,jsx}';
    if (!(await fs_extra_1.pathExists(pagesDir))) {
        throw new Error(`${pagesDir} doesn't exist`);
    }
    const files = await fast_glob_1.default(routesFilePattern, {
        cwd: pagesDir,
        onlyFiles: true,
        ignore: ['node_modules', 'dist'],
    });
    const writeRoutes = async () => {
        const routesInfo = load_routes_1.filesToRoutes(files, pagesDir);
        const getRelativePathToTemplatesDir = (p) => {
            if (!isAbsolutPath(p)) {
                return p;
            }
            return normalize_path_1.normalizePath(path_1.default.relative(api.resolveDotReam('templates'), p));
        };
        const stringifyClientRoutes = (routes) => {
            const clientRoutes = routes.filter((route) => !route.isServerRoute);
            return `[
        ${clientRoutes
                .map((route) => {
                return `{
            path: "${route.path}",
            ${route.routeName ? `name: "${route.routeName}",` : ``}
            component: function() {
              return import("${getRelativePathToTemplatesDir(route.file)}")
                .then(wrapPage)
            },
            ${route.children
                    ? `children: ${stringifyClientRoutes(route.children)}`
                    : ``}
          }`;
            })
                .join(',')}${clientRoutes.length === 0 ? '' : ','}
          // Adding a 404 route to suppress vue-router warning
          {
            name: '404',
            path: '/:404(.*)',
            component: import.meta.env.DEV ? {
              render() {
                return h('h1','error: this component should not be rendered')
              }
            } : {}
          }
      ]`;
        };
        const stringifyServerRoutes = (routes) => {
            const serverRoutes = routes.filter((route) => route.isServerRoute);
            return `[
        ${serverRoutes
                .map((route) => {
                return `{
            path: "${route.path}",
            meta: {load: () => import("${getRelativePathToTemplatesDir(route.file)}")},
            component: {}
          }`;
            })
                .join(',')}${serverRoutes.length === 0 ? '' : ','}
          {
            name: '404',
            path: '/:404(.*)',
            component: {}
          }
      ]`;
        };
        // Exports that will be used in both server and client code
        const sharedExportsContent = `
    import { h, defineAsyncComponent } from 'vue'

    var ErrorComponent = defineAsyncComponent(function() {
      return import("${getRelativePathToTemplatesDir(routesInfo.errorFile)}")
    })

    var AppComponent = defineAsyncComponent(function() {
      return import("${getRelativePathToTemplatesDir(routesInfo.appFile)}")
    })

    var NotFoundComponent = defineAsyncComponent(function() {
      return import("${getRelativePathToTemplatesDir(routesInfo.notFoundFile)}")
    })

    var wrapPage = function(page) {
      return {
        name: 'PageWrapper',
        $$preload: page.preload,
        $$staticPreload: page.staticPreload,
        $$getStaticPaths: page.getStaticPaths,
        setup: function () {
          return function() {
            var Component = page.default
            return h(Component)
          }
        }
      }
    }

    var clientRoutes = ${stringifyClientRoutes(routesInfo.routes)}

    export {
      clientRoutes,
      ErrorComponent,
      AppComponent,
      NotFoundComponent
    }
    `;
        await fs_extra_1.outputFile(api.resolveDotReam('templates/shared-exports.js'), sharedExportsContent, 'utf8');
        const serverExportsContent = `
   export const serverRoutes = ${stringifyServerRoutes(routesInfo.routes)}

   export const _document = () => import("${routesInfo.documentFile}")
    `;
        await fs_extra_1.outputFile(api.resolveDotReam('templates/server-exports.js'), serverExportsContent, 'utf8');
        await fs_extra_1.outputFile(api.resolveDotReam('templates/global-imports.js'), `
      ${api.config.imports
            .map((file) => `import ${JSON.stringify(file)}`)
            .join('\n')}
      `, 'utf8');
        const enhanceAppFiles = [...store_1.store.state.pluginsFiles['enhance-app']];
        await fs_extra_1.outputFile(api.resolveDotReam('templates/enhance-app.js'), `
      ${enhanceAppFiles
            .map((file, index) => {
            return `import * as enhanceApp_${index} from "${file}"`;
        })
            .join('\n')}

    var files = [
      ${enhanceAppFiles.map((_, i) => `enhanceApp_${i}`).join(',')}
    ]

    var exec = function(name, context) {
      for (var i = 0; i < files.length; i++) {
        var mod = files[i]
        if (mod[name]) {
          mod[name](context)
        }
      }
    }

    export function onCreatedApp(context) {
      exec('onCreatedApp', context)
    }
    `, 'utf8');
    };
    await writeRoutes();
    if (!api.isDev) {
        const writeConfig = async () => {
            const config = {
                port: api.config.server.port,
            };
            await fs_extra_1.outputFile(api.resolveDotReam('meta/config.json'), JSON.stringify(config), 'utf8');
        };
        await writeConfig();
    }
    if (api.isDev) {
        const { watch } = await Promise.resolve().then(() => __importStar(require('chokidar')));
        watch(routesFilePattern, {
            cwd: pagesDir,
            ignoreInitial: true,
        })
            .on('add', async (file) => {
            files.push(file);
            await writeRoutes();
        })
            .on('unlink', async (file) => {
            files.splice(files.indexOf(file), 1);
            await writeRoutes();
        });
    }
}
exports.prepareFiles = prepareFiles;