@modern-js/plugin-ssg 1.2.0 → 1.2.1

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @modern-js/plugin-ssg
 
+## 1.2.1
+
+### Patch Changes
+
+- 83166714: change .npmignore
+- Updated dependencies [83166714]
+- Updated dependencies [c3de9882]
+- Updated dependencies [33ff48af]
+  - @modern-js/core@1.3.2
+  - @modern-js/utils@1.2.2
+
 ## 1.2.0
 
 ### Minor Changes

package/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "1.2.0",
+  "version": "1.2.1",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/js/node/index.js",
@@ -37,15 +37,15 @@
   },
   "dependencies": {
     "@babel/runtime": "^7",
-    "@modern-js/utils": "^1.2.0",
+    "@modern-js/utils": "^1.2.2",
     "node-mocks-http": "^1.10.1",
     "normalize-path": "^3.0.0",
     "portfinder": "^1.0.28",
     "react-router-dom": "^5.2.1"
   },
   "devDependencies": {
-    "@modern-js/server": "^1.3.0",
-    "@modern-js/types": "^1.2.0",
+    "@modern-js/server": "^1.3.2",
+    "@modern-js/types": "^1.2.1",
     "@types/jest": "^26",
     "@types/node": "^14",
     "@types/react": "^17",
@@ -53,13 +53,13 @@
     "@types/react-router": "^5.1.16",
     "@types/react-router-dom": "^5.1.8",
     "typescript": "^4",
-    "@modern-js/core": "^1.3.0",
+    "@modern-js/core": "^1.3.2",
     "@scripts/build": "0.0.0",
     "jest": "^27",
     "@scripts/jest-config": "0.0.0"
   },
   "peerDependencies": {
-    "@modern-js/core": "^1.3.0"
+    "@modern-js/core": "^1.3.2"
   },
   "sideEffects": false,
   "modernConfig": {

package/src/global.d.ts

@@ -1 +0,0 @@
-declare module 'normalize-path';

package/src/index.ts

@@ -1,209 +0,0 @@
-import path from 'path';
-import { logger, PLUGIN_SCHEMAS } from '@modern-js/utils';
-import {
-  createPlugin,
-  useAppContext,
-  useResolvedConfigContext,
-} from '@modern-js/core';
-import { generatePath } from 'react-router-dom';
-import {
-  AgreedRoute,
-  AgreedRouteMap,
-  EntryPoint,
-  ExtendOutputConfig,
-  SSG,
-  SsgRoute,
-} from './types';
-import {
-  formatOutput,
-  isDynamicUrl,
-  readJSONSpec,
-  standardOptions,
-  writeJSONSpec,
-} from './libs/util';
-import { createServer } from './server';
-import { writeHtmlFile } from './libs/output';
-import { replaceRoute } from './libs/replace';
-import { makeRoute } from './libs/make';
-
-export default createPlugin(
-  (() => {
-    const agreedRouteMap: AgreedRouteMap = {};
-
-    return {
-      validateSchema() {
-        return PLUGIN_SCHEMAS['@modern-js/plugin-ssg'];
-      },
-      modifyFileSystemRoutes({
-        entrypoint,
-        routes,
-      }: {
-        entrypoint: EntryPoint;
-        routes: AgreedRoute[];
-      }) {
-        const { entryName } = entrypoint;
-        agreedRouteMap[entryName] = routes;
-
-        return { entrypoint, routes };
-      },
-      // eslint-disable-next-line max-statements
-      async afterBuild() {
-        // eslint-disable-next-line react-hooks/rules-of-hooks
-        const resolvedConfig = useResolvedConfigContext();
-        // eslint-disable-next-line react-hooks/rules-of-hooks
-        const appContext = useAppContext();
-
-        const { appDirectory, entrypoints } = appContext;
-        const { output } = resolvedConfig;
-        const { ssg, path: outputPath } = output as typeof output &
-          ExtendOutputConfig;
-
-        const ssgOptions: SSG = Array.isArray(ssg) ? ssg.pop() : ssg;
-        // no ssg configuration, skip ssg render.
-        if (!ssgOptions) {
-          return;
-        }
-
-        const buildDir = path.join(appDirectory, outputPath as string);
-        const routes = readJSONSpec(buildDir);
-
-        // filter all routes not web
-        const pageRoutes = routes.filter(route => !route.isApi);
-        const apiRoutes = routes.filter(route => route.isApi);
-
-        // if no web page route, skip ssg render
-        if (pageRoutes.length === 0) {
-          return;
-        }
-
-        const intermediateOptions = standardOptions(ssgOptions, entrypoints);
-
-        if (!intermediateOptions) {
-          return;
-        }
-
-        const ssgRoutes: SsgRoute[] = [];
-        // each route will try to match the configuration
-        pageRoutes.forEach(pageRoute => {
-          const { entryName, entryPath } = pageRoute;
-          const agreedRoutes = agreedRouteMap[entryName as string];
-          let entryOptions = intermediateOptions[entryName as string];
-
-          if (!agreedRoutes) {
-            // default behavior for non-agreed route
-            if (!entryOptions) {
-              return;
-            }
-
-            // only add entry route if entryOptions is true
-            if (entryOptions === true) {
-              ssgRoutes.push({ ...pageRoute, output: entryPath });
-            } else if (entryOptions.routes?.length > 0) {
-              // if entryOptions is object and has routes options
-              // add every route in options
-              const { routes: enrtyRoutes, headers } = entryOptions;
-              enrtyRoutes.forEach(route => {
-                ssgRoutes.push(makeRoute(pageRoute, route, headers));
-              });
-            }
-          } else {
-            // Unless entryOptions is set to false
-            // the default behavior is to add all file-based routes
-            if (entryOptions === false) {
-              return;
-            }
-
-            if (!entryOptions || entryOptions === true) {
-              entryOptions = { preventDefault: [], routes: [], headers: {} };
-            }
-
-            const {
-              preventDefault = [],
-              routes: userRoutes = [],
-              headers,
-            } = entryOptions;
-            // if the user sets the routes, then only add them
-            if (userRoutes.length > 0) {
-              userRoutes.forEach(route => {
-                if (typeof route === 'string') {
-                  ssgRoutes.push(makeRoute(pageRoute, route, headers));
-                } else if (Array.isArray(route.params)) {
-                  route.params.forEach(param => {
-                    ssgRoutes.push(
-                      makeRoute(
-                        pageRoute,
-                        { ...route, url: generatePath(route.url, param) },
-                        headers,
-                      ),
-                    );
-                  });
-                } else {
-                  ssgRoutes.push(makeRoute(pageRoute, route, headers));
-                }
-              });
-            } else {
-              // otherwith add all except dynamic routes
-              agreedRoutes
-                .filter(route => !preventDefault.includes(route.path))
-                .forEach(route => {
-                  if (!isDynamicUrl(route.path)) {
-                    ssgRoutes.push(makeRoute(pageRoute, route.path, headers));
-                  }
-                });
-            }
-          }
-        });
-
-        if (ssgRoutes.length === 0) {
-          return;
-        }
-
-        // currently SSG and SSR cannot be turned on at the same time、same route
-        ssgRoutes.forEach((ssgRoute: SsgRoute) => {
-          if (ssgRoute.isSSR) {
-            const isOriginRoute = pageRoutes.some(
-              pageRoute =>
-                pageRoute.urlPath === ssgRoute.urlPath &&
-                pageRoute.entryName === ssgRoute.entryName,
-            );
-
-            if (isOriginRoute) {
-              throw new Error(
-                `ssg can not using with ssr，url - ${
-                  ssgRoute.urlPath
-                }, entry - ${ssgRoute.entryName!} `,
-              );
-            }
-
-            logger.warn(
-              `new ssg route ${
-                ssgRoute.urlPath
-              } is using ssr now，maybe from parent route ${ssgRoute.entryName!}，close ssr`,
-            );
-          }
-          ssgRoute.isSSR = false;
-          ssgRoute.output = formatOutput(ssgRoute.output);
-        });
-
-        const htmlAry = await createServer(
-          ssgRoutes,
-          apiRoutes,
-          resolvedConfig,
-          appDirectory,
-        );
-
-        // write to dist file
-        writeHtmlFile(htmlAry, ssgRoutes, buildDir);
-
-        // format route info, side effect
-        replaceRoute(ssgRoutes, pageRoutes);
-
-        // write routes to spec file
-        writeJSONSpec(buildDir, pageRoutes.concat(apiRoutes));
-
-        logger.info('ssg Compiled successfully');
-      },
-    };
-  }) as any,
-  { name: '@modern-js/plugin-ssg' },
-) as any;

package/src/libs/make.ts

@@ -1,45 +0,0 @@
-import path from 'path';
-import { ServerRoute as ModernRoute } from '@modern-js/types';
-import normalize from 'normalize-path';
-import { compile } from '../server/prerender';
-import { RouteOptions, SsgRoute } from '../types';
-
-export function makeRender(
-  ssgRoutes: SsgRoute[],
-  render: ReturnType<typeof compile>,
-  port: number,
-): Promise<string>[] {
-  return ssgRoutes.map((ssgRoute: SsgRoute) =>
-    render({
-      url: ssgRoute.urlPath,
-      headers: { host: `localhost:${port}`, ...ssgRoute.headers },
-      connection: {},
-    }),
-  );
-}
-
-export function makeRoute(
-  baseRoute: ModernRoute,
-  route: string | RouteOptions,
-  headers: Record<string, any> = {},
-): SsgRoute {
-  const { urlPath, entryPath } = baseRoute;
-
-  if (typeof route === 'string') {
-    return {
-      ...baseRoute,
-      urlPath: normalize(`${urlPath}${route}`) || '/',
-      headers,
-      output: path.join(entryPath, `..${route}`),
-    };
-  } else {
-    return {
-      ...baseRoute,
-      urlPath: normalize(`${urlPath}${route.url}`) || '/',
-      headers: { ...headers, ...route.headers },
-      output: route.output
-        ? path.normalize(route.output)
-        : path.join(entryPath, `..${route.url}`),
-    };
-  }
-}

package/src/libs/output.ts

@@ -1,19 +0,0 @@
-import path from 'path';
-import { fs } from '@modern-js/utils';
-import { SsgRoute } from '../types';
-
-export function writeHtmlFile(
-  htmlAry: string[],
-  ssgRoutes: SsgRoute[],
-  baseDir: string,
-) {
-  htmlAry.forEach((html: any, index: number) => {
-    const ssgRoute = ssgRoutes[index];
-    const filepath = path.join(baseDir, ssgRoute.output);
-    if (!fs.existsSync(path.dirname(filepath))) {
-      fs.ensureDirSync(path.dirname(filepath));
-    }
-
-    fs.writeFileSync(filepath, html);
-  });
-}

package/src/libs/replace.ts

@@ -1,42 +0,0 @@
-import normalize from 'normalize-path';
-import { ServerRoute as ModernRoute } from '@modern-js/types';
-import { SsgRoute } from '../types';
-
-export function exist(route: ModernRoute, pageRoutes: ModernRoute[]): number {
-  return pageRoutes.slice().findIndex(pageRoute => {
-    const urlEqual = normalize(pageRoute.urlPath) === normalize(route.urlPath);
-    const entryEqual = pageRoute.entryName === route.entryName;
-    if (urlEqual && entryEqual) {
-      return true;
-    }
-    return false;
-  });
-}
-
-export function replaceRoute(ssgRoutes: SsgRoute[], pageRoutes: ModernRoute[]) {
-  // remove redundant fields and replace rendered entryPath
-  const cleanSsgRoutes = ssgRoutes.map(ssgRoute => {
-    const { output, headers, ...cleanSsgRoute } = ssgRoute;
-    return Object.assign(
-      cleanSsgRoute,
-      output ? { entryPath: output } : {},
-    ) as ModernRoute;
-  });
-
-  // all routes that need to be added and replaced
-  const freshRoutes: ModernRoute[] = [];
-  cleanSsgRoutes.forEach(ssgRoute => {
-    const index = exist(ssgRoute, pageRoutes);
-
-    if (index < 0) {
-      // new route
-      freshRoutes.push({ ...ssgRoute });
-    } else {
-      // overwrite original entry
-      pageRoutes[index].entryPath = ssgRoute.entryPath;
-    }
-  });
-
-  pageRoutes.push(...freshRoutes);
-  return pageRoutes;
-}

package/src/libs/util.ts

@@ -1,127 +0,0 @@
-import path from 'path';
-import { ROUTE_SPEC_FILE, fs, isSingleEntry } from '@modern-js/utils';
-import { ServerRoute as ModernRoute } from '@modern-js/types';
-import { EntryPoint, MultiEntryOptions, SSG, SsgRoute } from '../types';
-
-export function formatOutput(filename: string) {
-  const outputPath = path.extname(filename)
-    ? filename
-    : `${filename}/index.html`;
-  return outputPath;
-}
-
-export function formatPath(str: string) {
-  let addr = str;
-  if (!addr || typeof addr !== 'string') {
-    return addr;
-  }
-  if (addr.startsWith('.')) {
-    addr = addr.slice(1);
-  }
-  if (!addr.startsWith('/')) {
-    addr = `/${addr}`;
-  }
-  if (addr.endsWith('/') && addr !== '/') {
-    addr = addr.slice(0, addr.length - 1);
-  }
-
-  return addr;
-}
-
-export function isDynamicUrl(url: string): boolean {
-  return url.includes(':');
-}
-
-export function getUrlPrefix(route: SsgRoute, baseUrl: string | string[]) {
-  let base = '';
-  if (Array.isArray(baseUrl)) {
-    const filters = baseUrl.filter(url => route.urlPath.includes(url));
-    if (filters.length > 1) {
-      const matched = filters.sort((a, b) => a.length - b.length)[0];
-
-      // this should never happend
-      if (!matched) {
-        throw new Error('');
-      }
-      base = matched;
-    }
-  } else {
-    base = baseUrl;
-  }
-
-  base = base === '/' ? '' : base;
-  const entryName = route.entryName === 'main' ? '' : route.entryName;
-  const prefix = `${base}/${entryName as string}`;
-  return prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
-}
-
-// if no output, return default path for aggred-route(relative),
-// or thorw error for control-route
-export function getOutput(route: SsgRoute, base: string, agreed?: boolean) {
-  const { output } = route;
-  if (output) {
-    return output;
-  }
-
-  if (agreed) {
-    const urlWithoutBase = route.urlPath.replace(base, '');
-    return urlWithoutBase.startsWith('/')
-      ? urlWithoutBase.slice(1)
-      : urlWithoutBase;
-  }
-
-  throw new Error(
-    `routing must provide output when calling createPage(), check ${route.urlPath}`,
-  );
-}
-
-export const readJSONSpec = (dir: string) => {
-  const routeJSONPath = path.join(dir, ROUTE_SPEC_FILE);
-  const routeJSON: {
-    routes: ModernRoute[];
-  } = require(routeJSONPath);
-  const { routes } = routeJSON;
-  return routes;
-};
-
-export const writeJSONSpec = (dir: string, routes: ModernRoute[]) => {
-  const routeJSONPath = path.join(dir, ROUTE_SPEC_FILE);
-  fs.writeJSONSync(routeJSONPath, { routes }, { spaces: 2 });
-};
-
-export const replaceWithAlias = (
-  base: string,
-  filePath: string,
-  alias: string,
-) => path.posix.join(alias, path.posix.relative(base, filePath));
-
-export const standardOptions = (ssgOptions: SSG, entrypoints: EntryPoint[]) => {
-  if (ssgOptions === false) {
-    return false;
-  }
-
-  if (ssgOptions === true) {
-    return entrypoints.reduce((opt, entry) => {
-      opt[entry.entryName] = ssgOptions;
-      return opt;
-    }, {} as MultiEntryOptions);
-  } else if (typeof ssgOptions === 'object') {
-    const isSingle = isSingleEntry(entrypoints);
-
-    if (isSingle && typeof (ssgOptions as any).main === 'undefined') {
-      return { main: ssgOptions } as MultiEntryOptions;
-    } else {
-      return ssgOptions as MultiEntryOptions;
-    }
-  } else if (typeof ssgOptions === 'function') {
-    const intermediateOptions: MultiEntryOptions = {};
-    for (const entrypoint of entrypoints) {
-      const { entryName } = entrypoint;
-      // Todo may be async function
-      intermediateOptions[entryName] = ssgOptions(entryName);
-    }
-    return intermediateOptions;
-  }
-
-  return false;
-};

package/src/server/consts.ts

@@ -1 +0,0 @@
-export const CLOSE_SIGN = 'modern_close_server';

package/src/server/index.ts

@@ -1,85 +0,0 @@
-import childProcess from 'child_process';
-import path from 'path';
-import { logger, SERVER_BUNDLE_DIRECTORY } from '@modern-js/utils';
-import { NormalizedConfig, useAppContext } from '@modern-js/core';
-import { ServerRoute as ModernRoute } from '@modern-js/types';
-import { SsgRoute } from '../types';
-import { CLOSE_SIGN } from './consts';
-
-export const createServer = (
-  ssgRoutes: SsgRoute[],
-  apiRoutes: ModernRoute[],
-  options: NormalizedConfig,
-  appDirectory: string,
-): Promise<string[]> =>
-  new Promise((resolve, reject) => {
-    // this side of the shallow copy of a route for subsequent render processing, to prevent the modification of the current field
-    // manually enable the server-side rendering configuration for all routes that require SSG
-    const backup: ModernRoute[] = ssgRoutes.map(ssgRoute => ({
-      ...ssgRoute,
-      isSSR: true,
-      bundle: `${SERVER_BUNDLE_DIRECTORY}/${ssgRoute.entryName as string}.js`,
-    }));
-
-    const total = backup.concat(apiRoutes);
-
-    const cp = childProcess.fork(path.join(__dirname, 'process'), {
-      cwd: appDirectory,
-      silent: true,
-    });
-
-    const appContext = useAppContext();
-    const serverPlugins = appContext.plugins
-      .filter((p: any) => p.server)
-      .map((p: any) => p.server);
-    const plugins = serverPlugins.map((p: any) => p.name);
-
-    cp.send(
-      JSON.stringify({
-        options,
-        routes: total,
-        appDirectory,
-        plugins,
-      }),
-    );
-
-    const htmlChunks: string[] = [];
-    const htmlAry: string[] = [];
-
-    cp.on('message', (chunk: string) => {
-      if (chunk !== null) {
-        htmlChunks.push(chunk);
-      } else {
-        const html = htmlChunks.join('');
-        htmlAry.push(html);
-        htmlChunks.length = 0;
-      }
-
-      if (htmlAry.length === backup.length) {
-        cp.send(CLOSE_SIGN);
-        resolve(htmlAry);
-      }
-    });
-
-    cp.stderr!.on('data', chunk => {
-      const str = chunk.toString();
-      if (str.includes('Error')) {
-        logger.error(str);
-        reject(new Error('ssg render failed'));
-        cp.kill('SIGKILL');
-      } else {
-        logger.info(str.replace(/[^\S\n]+/g, ' '));
-      }
-    });
-
-    cp.stdout!.on('data', chunk => {
-      const str = chunk.toString();
-      if (str.includes('Error')) {
-        logger.error(str);
-        reject(new Error('ssg render failed'));
-        cp.kill('SIGKILL');
-      } else {
-        logger.info(str.replace(/[^\S\n]+/g, ' '));
-      }
-    });
-  });

package/src/server/prerender.ts

@@ -1,49 +0,0 @@
-import EventEmitter from 'events';
-import { IncomingMessage, ServerResponse } from 'http';
-import { Readable } from 'stream';
-import httpMocks from 'node-mocks-http';
-
-export type Options = {
-  url: string;
-  headers: {
-    host: string;
-    [key: string]: string;
-  };
-  [propName: string]: any;
-};
-
-export const compile =
-  (requestHandler: (req: IncomingMessage, res: ServerResponse) => void) =>
-  (options: Options, extend = {}): Promise<string> =>
-    new Promise((resolve, reject) => {
-      const req = httpMocks.createRequest({
-        ...options,
-        eventEmitter: Readable,
-      });
-      const res = httpMocks.createResponse({ eventEmitter: EventEmitter });
-
-      Object.assign(req, extend);
-      const proxyRes = new Proxy(res, {
-        get(obj: any, prop: any) {
-          if (typeof prop === 'symbol' && !obj[prop]) {
-            return null;
-          }
-          return obj[prop];
-        },
-      });
-
-      res.on('finish', () => {
-        if (res.statusCode !== 200) {
-          reject(new Error(res.statusMessage));
-        } else {
-          resolve(res._getData());
-        }
-      });
-
-      res.on('error', (e: Error) => reject(e));
-      try {
-        requestHandler(req, proxyRes);
-      } catch (e) {
-        reject(e);
-      }
-    });

package/src/server/process.ts

@@ -1,94 +0,0 @@
-import Server from '@modern-js/server';
-import { ServerRoute as ModernRoute } from '@modern-js/types';
-import portfinder from 'portfinder';
-import { NormalizedConfig } from '@modern-js/core';
-import { compatRequire } from '@modern-js/utils';
-import { makeRender } from '../libs/make';
-import { SsgRoute } from '../types';
-import { compile as createRender } from './prerender';
-import { CLOSE_SIGN } from './consts';
-
-type Then<T> = T extends PromiseLike<infer U> ? U : T;
-
-type ModernServer = Then<ReturnType<typeof Server>>;
-
-const safetyRequire = (filename: string, base: string) => {
-  try {
-    return compatRequire(
-      require.resolve(`${filename}/server`, { paths: [base] }),
-    );
-  } catch (e) {
-    return compatRequire(require.resolve(filename, { paths: [base] }));
-  }
-};
-
-process.on('message', async (chunk: string) => {
-  if (chunk === CLOSE_SIGN) {
-    // eslint-disable-next-line no-process-exit
-    process.exit();
-  }
-
-  const context = JSON.parse(chunk as any);
-  const {
-    routes,
-    options,
-    appDirectory,
-    plugins,
-  }: {
-    routes: ModernRoute[];
-    options: NormalizedConfig;
-    appDirectory: string;
-    plugins: string[];
-  } = context;
-
-  const instances = plugins.map(plugin => safetyRequire(plugin, appDirectory));
-
-  let modernServer: ModernServer | null = null;
-  try {
-    const { server } = options;
-
-    // start server in default port
-    const defaultPort = Number(process.env.PORT) || server.port;
-    portfinder.basePort = defaultPort!;
-    const port = await portfinder.getPortPromise();
-
-    modernServer = await Server({
-      pwd: appDirectory,
-      config: options,
-      routes,
-      staticGenerate: true,
-      plugins: instances,
-    });
-
-    // listen just for bff request in ssr page
-    modernServer.listen(port, async (err: Error) => {
-      if (err) {
-        throw err;
-      }
-
-      if (!modernServer) {
-        return;
-      }
-
-      // get server handler, render to ssr
-      const render = createRender(modernServer.getRequestHandler());
-      const renderPromiseAry = makeRender(
-        routes.filter(route => !route.isApi) as SsgRoute[],
-        render,
-        port,
-      );
-
-      // eslint-disable-next-line promise/no-promise-in-callback
-      const htmlAry = await Promise.all(renderPromiseAry);
-      htmlAry.forEach((html: string) => {
-        process.send!(html);
-        process.send!(null);
-      });
-
-      modernServer.close();
-    });
-  } catch (e) {
-    modernServer?.close();
-    throw e;
-  }
-});

package/src/types.ts

@@ -1,51 +0,0 @@
-import { ServerRoute as ModernRoute } from '@modern-js/types';
-
-export type AgreedRoute = {
-  path: string;
-  component: string;
-  _component: string;
-  exact: boolean;
-};
-
-export type EntryPoint = {
-  entryName: string;
-  entry: string;
-};
-
-export type AgreedRouteMap = {
-  [propNames: string]: AgreedRoute[];
-};
-
-export type SsgRoute = ModernRoute & {
-  output: string;
-  headers?: Record<string, string>;
-};
-
-export type RouteOptions =
-  | string
-  | {
-      url: string;
-      output?: string;
-      params?: Record<string, any>[];
-      headers?: Record<string, any>;
-    };
-
-export type SingleEntryOptions =
-  | boolean
-  | {
-      preventDefault?: string[];
-      headers?: Record<string, any>;
-      routes: RouteOptions[];
-    };
-
-export type MultiEntryOptions = Record<string, SingleEntryOptions>;
-
-export type SSG =
-  | boolean
-  | SingleEntryOptions
-  | MultiEntryOptions
-  | ((entryName: string) => SingleEntryOptions);
-
-export type ExtendOutputConfig = {
-  ssg: SSG;
-};