@modern-js/plugin-ssg 1.0.1 → 1.1.2

package/src/libs/replace.ts

@@ -2,7 +2,7 @@ import normalize from 'normalize-path';
 import { ModernRoute } from '@modern-js/server';
 import { SsgRoute } from '../types';
 
-export function exist(route: SsgRoute, pageRoutes: ModernRoute[]): number {
+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;
@@ -16,12 +16,15 @@ export function exist(route: SsgRoute, pageRoutes: ModernRoute[]): number {
 export function replaceRoute(ssgRoutes: SsgRoute[], pageRoutes: ModernRoute[]) {
   // remove redundant fields and replace rendered entryPath
   const cleanSsgRoutes = ssgRoutes.map(ssgRoute => {
-    const { output, ...cleanSsgRoute } = ssgRoute;
-    return Object.assign(cleanSsgRoute, output ? { entryPath: output } : {});
+    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: SsgRoute[] = [];
+  const freshRoutes: ModernRoute[] = [];
   cleanSsgRoutes.forEach(ssgRoute => {
     const index = exist(ssgRoute, pageRoutes);
 

package/src/libs/util.ts

@@ -1,13 +1,13 @@
 import path from 'path';
-import { ROUTE_SPEC_FILE, fs } from '@modern-js/utils';
+import { ROUTE_SPEC_FILE, fs, isSingleEntry } from '@modern-js/utils';
 import { ModernRoute } from '@modern-js/server';
-import { SSGConfig, SsgRoute } from '../types';
-import { MODE } from '@/manifest-op';
+import { EntryPoint, MultiEntryOptions, SSG, SsgRoute } from '../types';
 
-export function formatOutput(base: string, filename: string) {
-  const file = path.extname(filename) ? filename : `${filename}/index.html`;
-  const dirname = path.dirname(base);
-  return path.join(dirname, file);
+export function formatOutput(filename: string) {
+  const outputPath = path.extname(filename)
+    ? filename
+    : `${filename}/index.html`;
+  return outputPath;
 }
 
 export function formatPath(str: string) {
@@ -89,27 +89,39 @@ export const writeJSONSpec = (dir: string, routes: ModernRoute[]) => {
   fs.writeJSONSync(routeJSONPath, { routes }, { spaces: 2 });
 };
 
-export const getSSGRenderLevel = (key: boolean | string) => {
-  const level = typeof key === 'boolean' ? MODE.LOOSE : MODE[key.toUpperCase()];
-  // currently only MODE.STRICT and MODE.LOOSE are supported
-  if (!level || level > 2 || level < 1) {
-    throw new Error(
-      `[SSG Render Fail] SSG 不支持当前 Mode，useSSG: ${key.toString()}, Level: ${level}`,
-    );
-  }
-
-  return level;
-};
-
-export const parsedSSGConfig = (ssg: SSGConfig) => {
-  const useSSG = Boolean(ssg);
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
-  const userHook = typeof ssg === 'function' ? ssg : () => {};
-  return { useSSG, userHook };
-};
-
 export const replaceWithAlias = (
   base: string,
   filePath: string,
   alias: string,
-) => path.join(alias, path.relative(base, filePath));
+) => 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/index.ts

@@ -15,7 +15,7 @@ export const createServer = (
   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 = ssgRoutes.map(ssgRoute => ({
+    const backup: ModernRoute[] = ssgRoutes.map(ssgRoute => ({
       ...ssgRoute,
       isSSR: true,
       bundle: `${SERVER_BUNDLE_DIRECTORY}/${ssgRoute.entryName}.js`,

package/src/server/process.ts

@@ -2,9 +2,10 @@ import Server, { ModernRoute } from '@modern-js/server';
 import portfinder from 'portfinder';
 import { NormalizedConfig } from '@modern-js/core';
 import { compatRequire } from '@modern-js/utils';
-import { makeRender } from '../libs/render';
+import { makeRender } from '../libs/make';
 import { compile as createRender } from './prerender';
 import { CLOSE_SIGN } from './consts';
+import { SsgRoute } from '@/types';
 
 type Then<T> = T extends PromiseLike<infer U> ? U : T;
 
@@ -67,7 +68,7 @@ process.on('message', async (chunk: string) => {
       // get server handler, render to ssr
       const render = createRender(modernServer!.getRequestHandler());
       const renderPromiseAry = makeRender(
-        routes.filter(route => !route.isApi),
+        routes.filter(route => !route.isApi) as SsgRoute[],
         render,
         port,
       );

package/src/types.ts

@@ -16,30 +16,36 @@ export type AgreedRouteMap = {
   [propNames: string]: AgreedRoute[];
 };
 
-export type FreshPageConfig = {
-  url?: string;
-  output?: string;
-  params?: Record<string, string | number>;
+export type SsgRoute = ModernRoute & {
+  output: string;
   headers?: Record<string, string>;
 };
-export type UserInterfaceRoute = ModernRoute & {
-  path: string;
-  agreed?: boolean;
-};
 
-export type CreatePageParam = FreshPageConfig | FreshPageConfig[];
-export type CreatePageListener = (route: SsgRoute, agreed?: boolean) => void;
+export type RouteOptions =
+  | string
+  | {
+      url: string;
+      output?: string;
+      params?: Record<string, any>[];
+      headers?: Record<string, any>;
+    };
 
-export type SsgRoute = ModernRoute & {
-  output?: string;
-  headers?: Record<string, string>;
-};
-export type HookContext = {
-  createPage: (config?: CreatePageParam) => any;
-  route: UserInterfaceRoute;
-};
+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 SSGConfig = boolean | ((context: any) => void);
 export type ExtendOutputConfig = {
-  ssg: SSGConfig;
+  ssg: SSG;
 };

package/tests/lib.test.ts

@@ -1,178 +1,10 @@
 import fs from 'fs';
 import path from 'path';
-// import { createInvoker } from '../libs/invoker';
 import { ModernRoute } from '@modern-js/server';
 import { exist, replaceRoute } from '@/libs/replace';
-import {
-  AgreedRoute,
-  CreatePageListener,
-  HookContext,
-  SsgRoute,
-} from '@/types';
-import { createPageFactory } from '@/libs/createPage';
-import { invoker } from '@/libs/invoker';
-
-const noop = () => {
-  //
-};
+import { makeRoute } from '@/libs/make';
 
 describe('test functional function', () => {
-  it('should listener get arguments correctly', () => {
-    const route = { path: '/foo', agreed: false };
-    const listener: CreatePageListener = (r: SsgRoute, agreed?: boolean) => {
-      expect(r.urlPath).toBe('/foo');
-      expect(agreed).toBeFalsy();
-    };
-    const createPage = createPageFactory(route as any, listener);
-    createPage();
-  });
-
-  it('should listener get url correctly', () => {
-    const route = { path: '/foo', agreed: false };
-    const listener: CreatePageListener = (r: SsgRoute, agreed?: boolean) => {
-      expect(r.urlPath).toBe('/bar');
-      expect(agreed).toBeFalsy();
-    };
-    const createPage = createPageFactory(route as any, listener);
-    createPage({ url: '/bar' });
-  });
-
-  it('should listener get output correctly', () => {
-    const route = { path: '/foo', agreed: false };
-    const listener: CreatePageListener = (r: SsgRoute, agreed?: boolean) => {
-      expect(r.output).toBe('./bar');
-      expect(agreed).toBeFalsy();
-    };
-    const createPage = createPageFactory(route as any, listener);
-    createPage({ output: './bar' });
-  });
-
-  it('should listener get dynamic route correctly', () => {
-    const route = { path: '/:foo', agreed: true };
-    const listener: CreatePageListener = (r: SsgRoute, agreed?: boolean) => {
-      expect(r.urlPath).toBe('/bar');
-      expect(agreed).toBeTruthy();
-    };
-    const createPage = createPageFactory(route as any, listener);
-    createPage({ params: { foo: 'bar' } });
-  });
-
-  it('should listener get multi route correctly', () => {
-    const route = { path: '/foo', agreed: false };
-    const urls = ['/a', '/b', '/c'];
-    const listener: CreatePageListener = (r: SsgRoute) => {
-      expect(urls.includes(r.urlPath)).toBe(true);
-    };
-    const createPage = createPageFactory(route as any, listener);
-    createPage(urls.map(url => ({ url })));
-  });
-
-  it('should hook get context correctly', () => {
-    const pageRoutes = [
-      {
-        urlPath: '/foo',
-        entryName: 'foo',
-      },
-      {
-        urlPath: '/bar',
-        entryName: 'bar',
-      },
-    ];
-    let i = 0;
-    const hook = (context: HookContext) => {
-      expect(typeof context.createPage).toBe('function');
-      expect(context.route.path).toEqual(pageRoutes[i].urlPath);
-      i++;
-    };
-
-    invoker(pageRoutes as any, {}, hook, () => false, noop);
-  });
-
-  it('should hook get context correctly while use appoint', () => {
-    const pageRoutes = [
-      {
-        urlPath: '/foo',
-        entryName: 'foo',
-      },
-    ];
-    const appointRouteMap: Record<string, AgreedRoute[]> = {
-      foo: [
-        {
-          path: '/a',
-          component: 'a',
-          _component: 'a',
-          exact: true,
-        },
-        {
-          path: '/b',
-          component: 'b',
-          _component: 'b',
-          exact: true,
-        },
-      ],
-    };
-
-    let i = 0;
-    const hook = (context: HookContext) => {
-      expect(typeof context.createPage).toBe('function');
-      expect(context.route.path).toEqual(`/foo${appointRouteMap.foo[i].path}`);
-      i++;
-    };
-
-    invoker(
-      pageRoutes as any,
-      appointRouteMap,
-      hook,
-      context => {
-        expect(['a', 'b'].includes(context.component)).toBeTruthy();
-        return true;
-      },
-      noop,
-    );
-  });
-
-  it('only static route invoke checker', () => {
-    const pageRoutes = [
-      {
-        urlPath: '/foo',
-        entryName: 'foo',
-      },
-      {
-        urlPath: '/:bar',
-        entryName: 'bar',
-      },
-    ];
-    const appointRouteMap: Record<string, AgreedRoute[]> = {
-      foo: [
-        {
-          path: '/a',
-          component: 'a',
-          _component: 'a',
-          exact: true,
-        },
-      ],
-      bar: [
-        {
-          path: '/b',
-          component: 'b',
-          _component: 'b',
-          exact: true,
-        },
-      ],
-    };
-
-    invoker(
-      pageRoutes as any,
-      appointRouteMap,
-      noop,
-      context => {
-        expect(context.component).toBe('a');
-        return true;
-      },
-      noop,
-    );
-  });
-
   it('should check route exist correctly', () => {
     const pageRoutes: ModernRoute[] = JSON.parse(
       fs.readFileSync(path.join(__dirname, 'material/lib.route.json'), 'utf-8'),
@@ -222,4 +54,51 @@ describe('test functional function', () => {
 
     expect(result).toEqual(final);
   });
+
+  it('shoule generate route correctly', () => {
+    const baseRoute: ModernRoute = {
+      urlPath: '/foo',
+      isSPA: true,
+      isSSR: false,
+      entryName: 'foo',
+      isApi: false,
+      bundle: '',
+      entryPath: 'html/foo/index.html',
+    };
+
+    const route1 = makeRoute(baseRoute, '/baz');
+    expect(route1.urlPath).toBe('/foo/baz');
+    expect(route1.urlPath).toBe('/foo/baz');
+
+    const route2 = makeRoute(baseRoute, { url: '/baz' });
+    expect(route2.urlPath).toBe('/foo/baz');
+    expect(route2.output).toBe(path.normalize('html/foo/baz'));
+
+    const route3 = makeRoute(baseRoute, {
+      url: '/baz',
+      output: 'html/baz.html',
+    });
+    expect(route3.output).toBe(path.normalize('html/baz.html'));
+
+    const route4 = makeRoute(
+      baseRoute,
+      {
+        url: '/baz',
+      },
+      { ua: 'mobile' },
+    );
+    expect(route4.headers).toEqual({ ua: 'mobile' });
+
+    const route5 = makeRoute(
+      baseRoute,
+      {
+        url: '/baz',
+        headers: {
+          ua: 'pc',
+        },
+      },
+      { ua: 'mobile' },
+    );
+    expect(route5.headers).toEqual({ ua: 'pc' });
+  });
 });

package/tests/util.test.ts

@@ -4,11 +4,9 @@ import {
   isDynamicUrl,
   getUrlPrefix,
   getOutput,
-  getSSGRenderLevel,
-  parsedSSGConfig,
   replaceWithAlias,
+  standardOptions,
 } from '@/libs/util';
-import { MODE } from '@/manifest-op';
 
 describe('test ssg util function', () => {
   it('should return format path correctly', () => {
@@ -64,42 +62,83 @@ describe('test ssg util function', () => {
   });
 
   it('should return format output correctly', () => {
-    const entryPath = '/base/home/index.html';
-    const onlyBase = formatOutput(entryPath, '');
-    expect(onlyBase).toBe(entryPath);
+    const entryPath1 = '/base/home/index.html';
+    expect(formatOutput(entryPath1)).toBe(entryPath1);
 
-    const noExtention = formatOutput(entryPath, './a');
-    expect(noExtention).toBe('/base/home/a/index.html');
+    const entryPath2 = '/base/home';
+    expect(formatOutput(entryPath2)).toBe(entryPath1);
+  });
 
-    const extention = formatOutput(entryPath, 'a.html');
-    expect(extention).toBe('/base/home/a.html');
+  it('should replace alias correctly', () => {
+    expect(replaceWithAlias('/src', '/src/app.js', '@src')).toBe('@src/app.js');
+  });
 
-    const relate_1 = formatOutput(entryPath, '../a.html');
-    expect(relate_1).toBe('/base/a.html');
+  it('should starndar user config correctly', () => {
+    const opt0 = standardOptions(false, []);
+    expect(opt0).toBeFalsy();
 
-    const relate_2 = formatOutput(entryPath, '../../a.html');
-    expect(relate_2).toBe('/a.html');
-  });
+    const opt1 = standardOptions(true, [{ entryName: 'main', entry: '' }]);
+    expect(opt1).toEqual({ main: true });
 
-  it('should get ssg level correctly', () => {
-    expect(getSSGRenderLevel(true)).toBe(MODE.LOOSE);
-    expect(getSSGRenderLevel('loose')).toBe(MODE.LOOSE);
-    expect(getSSGRenderLevel('LOOSE')).toBe(MODE.LOOSE);
-  });
+    const opt2 = standardOptions(true, [
+      { entryName: 'main', entry: '' },
+      { entryName: 'home', entry: '' },
+    ]);
+    expect(opt2).toEqual({ main: true, home: true });
+
+    const opt3 = standardOptions(true, [
+      { entryName: 'main', entry: '' },
+      { entryName: 'home', entry: '' },
+    ]);
+    expect(opt3).toEqual({ main: true, home: true });
 
-  it('should parse ssg config correctly', () => {
-    const empty = () => {
-      // empty test
+    // single entry, object config
+    const ssg1 = {
+      routes: ['/foo', { url: '/baz' }],
     };
-    expect(parsedSSGConfig(true).useSSG).toBe(true);
-    expect(parsedSSGConfig(true).userHook).toBeInstanceOf(Function);
-    expect(parsedSSGConfig(true as any).useSSG).toBe(true);
-    expect(parsedSSGConfig(true as any).userHook).toBeInstanceOf(Function);
-    expect(parsedSSGConfig(empty).useSSG).toBe(true);
-    expect(parsedSSGConfig(empty).userHook).toBe(empty);
+    const opt4 = standardOptions(ssg1, [{ entryName: 'main', entry: '' }]);
+    expect(opt4).toEqual({ main: ssg1 });
   });
 
-  it('should replace alias correctly', () => {
-    expect(replaceWithAlias('/src', '/src/app.js', '@src')).toBe('@src/app.js');
-  });
+  // error usage, just test
+  const ssg2 = {
+    routes: ['/foo', { url: '/baz' }],
+  };
+  const opt5 = standardOptions(ssg2, [
+    { entryName: 'main', entry: '' },
+    { entryName: 'home', entry: '' },
+  ]);
+  expect(opt5).toEqual(ssg2);
+
+  const ssg3 = {
+    main: { routes: ['/foo', { url: '/baz' }] },
+    home: false,
+  };
+  const opt6 = standardOptions(ssg3, [
+    { entryName: 'main', entry: '' },
+    { entryName: 'home', entry: '' },
+  ]);
+  expect(opt6).toEqual(ssg3);
+
+  const ssg4 = () => true;
+  const opt7 = standardOptions(ssg4, [
+    { entryName: 'main', entry: '' },
+    { entryName: 'home', entry: '' },
+  ]);
+  expect(opt7).toEqual({ main: true, home: true });
+
+  const ssg5 = (entryName: string) => {
+    if (entryName === 'main') {
+      return true;
+    } else {
+      return {
+        routes: ['/foo'],
+      };
+    }
+  };
+  const opt8 = standardOptions(ssg5, [
+    { entryName: 'main', entry: '' },
+    { entryName: 'home', entry: '' },
+  ]);
+  expect(opt8).toEqual({ main: true, home: { routes: ['/foo'] } });
 });

package/dist/js/modern/libs/createPage.js

@@ -1,46 +0,0 @@
-const _excluded = ["path", "agreed"];
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
-
-function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
-
-import { generatePath } from 'react-router-dom';
-import { formatPath, isDynamicUrl } from "./util";
-export const createPageFactory = (route, listener) => config => {
-  if (Array.isArray(config)) {
-    config.forEach(cfg => {
-      listener(createPage(route, cfg), route.agreed);
-    });
-  } else {
-    listener(createPage(route, config), route.agreed);
-  }
-};
-
-function createPage(route, config = {}) {
-  const {
-    path,
-    agreed
-  } = route,
-        filterRoute = _objectWithoutProperties(route, _excluded);
-
-  const urlPath = formatPath(config.url || path);
-
-  const ssgRoute = _objectSpread(_objectSpread({}, filterRoute), {}, {
-    urlPath
-  }); // using params completion dynamic routing
-
-
-  if (agreed && isDynamicUrl(urlPath) && config.params) {
-    ssgRoute.urlPath = generatePath(urlPath, config.params);
-  }
-
-  ssgRoute.output = config.output;
-  ssgRoute.headers = config.headers;
-  return ssgRoute;
-}

package/dist/js/modern/libs/invoker.js

@@ -1,56 +0,0 @@
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-import normalize from 'normalize-path';
-import { isDynamicUrl } from "./util";
-import { createPageFactory } from "./createPage";
-
-function createContext(route, listener) {
-  return {
-    createPage: createPageFactory(route, listener),
-    route
-  };
-} // eslint-disable-next-line max-params
-
-
-export async function invoker(pageRoutes, agreedRouteMap, hook, autoAddAgreed, listener) {
-  for (const pageRoute of pageRoutes) {
-    const {
-      urlPath,
-      entryName
-    } = pageRoute;
-    const agreedRoutes = agreedRouteMap[entryName];
-
-    if (agreedRoutes) {
-      for (const agreedRoute of agreedRoutes) {
-        const fullpath = normalize(`${urlPath}${agreedRoute.path}`) || '/';
-
-        const route = _objectSpread(_objectSpread({}, pageRoute), {}, {
-          path: fullpath,
-          agreed: true
-        });
-
-        const context = createContext(route, listener); // The hook function can return false to prevent the automatic addition of agreed routes
-
-        const isStaticPage = await hook(context);
-
-        if (!isDynamicUrl(fullpath) && isStaticPage !== false) {
-          const autoAdd = autoAddAgreed(_objectSpread(_objectSpread({}, context), {}, {
-            component: agreedRoute._component
-          }));
-          autoAdd && context.createPage();
-        }
-      }
-    } else {
-      const route = _objectSpread(_objectSpread({}, pageRoute), {}, {
-        path: urlPath
-      });
-
-      const context = createContext(route, listener);
-      await hook(context);
-    }
-  }
-}

package/dist/js/modern/libs/render.js

@@ -1,15 +0,0 @@
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-export function makeRender(ssgRoutes, render, port) {
-  return ssgRoutes.map(ssgRoute => render({
-    url: ssgRoute.urlPath,
-    headers: _objectSpread({
-      host: `localhost:${port}`
-    }, ssgRoute.headers),
-    connection: {}
-  }));
-}