@modern-js/plugin-ssg 1.0.0-rc.9 → 1.1.1

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('loose').useSSG).toBe('loose');
-    expect(parsedSSGConfig('loose').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,55 +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
-  };
-}
-
-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/loader/index.js

@@ -1,105 +0,0 @@
-import { isDev } from '@modern-js/utils';
-import { LoaderManifest, MODE } from "../manifest-op";
-const FUNCTION_CREATE_CONTAINER_NAME = 'createContainer';
-const FUNCTION_USE_LOADER_NAME = 'useLoader';
-const FUNCTION_USE_STATIC_LOADER_NAME = 'useStaticLoader';
-const CONTAINER_LOADER_NAME = 'loader';
-const CONTAINER_STATIC_LOADER_NAME = 'staticLoader';
-
-const noop = function noop() {
-  return {
-    name: 'babel-plugin-ssg-static-loader'
-  };
-}; // develoment not need to static analysis
-
-
-const loader = isDev() ? noop : function () {
-  const loaderManifest = new LoaderManifest();
-  let useSSG = 0;
-  let createContainer = null;
-  let useStaticLoader = null;
-  let useLoader = null;
-  return {
-    name: 'babel-plugin-ssg-static-loader',
-
-    // reset settings whenever a new file passes through loader
-    pre() {
-      useSSG = 0;
-      createContainer = null;
-      useStaticLoader = null;
-      useLoader = null;
-    },
-
-    visitor: {
-      ImportSpecifier(path) {
-        const importName = path.get('imported.name').node;
-        const localName = path.get('local.name').node;
-
-        if (importName === FUNCTION_CREATE_CONTAINER_NAME) {
-          createContainer = localName;
-        }
-
-        if (importName === FUNCTION_USE_STATIC_LOADER_NAME) {
-          useStaticLoader = localName;
-        }
-
-        if (importName === FUNCTION_USE_LOADER_NAME) {
-          useLoader = localName;
-        }
-      },
-
-      Identifier(path) {
-        var _closestPath$node, _closestPath$node$cal;
-
-        // If the current file uses useLoader, the page can use SSG in MIXIN mode
-        // Todo: Mixin Mode is not support
-        const nodeName = path.node.name;
-
-        if (nodeName === useLoader && path.key === 'callee') {
-          useSSG = Math.max(useSSG, MODE.MIXIN);
-          return;
-        } // If the current file uses useStaticLoader, the page can use SSG in STRICT mode
-
-
-        if (nodeName === useStaticLoader && path.key === 'callee') {
-          useSSG = Math.max(useSSG, MODE.STRICT);
-          return;
-        } // after testing the Hook API, skip detection if the current nodeName is not 'container.(loader | staticLoader)'
-
-
-        if (nodeName !== CONTAINER_LOADER_NAME && nodeName !== CONTAINER_STATIC_LOADER_NAME) {
-          return;
-        } // if the current nodeName is 'container.(loader | staticLoader)', check whether the calling node is 'createContainer'
-
-
-        const closestPath = path.find(p => p.isCallExpression());
-
-        if ((closestPath === null || closestPath === void 0 ? void 0 : (_closestPath$node = closestPath.node) === null || _closestPath$node === void 0 ? void 0 : (_closestPath$node$cal = _closestPath$node.callee) === null || _closestPath$node$cal === void 0 ? void 0 : _closestPath$node$cal.name) === createContainer) {
-          if (nodeName === CONTAINER_LOADER_NAME) {
-            useSSG = Math.max(useSSG, MODE.MIXIN);
-            return;
-          }
-
-          if (nodeName === CONTAINER_STATIC_LOADER_NAME) {
-            useSSG = Math.max(useSSG, MODE.STRICT);
-          }
-        }
-      }
-
-    },
-
-    post(file) {
-      const {
-        filename
-      } = file.opts; // if the current usage mode is not determined, that is, no runtime API is used, the default is LOOSE
-
-      if (!useSSG) {
-        useSSG = MODE.LOOSE;
-      }
-
-      loaderManifest.add(filename, useSSG);
-    }
-
-  };
-};
-export default loader;

package/dist/js/modern/manifest-op.js

@@ -1,101 +0,0 @@
-import path from 'path';
-import { fs } from '@modern-js/utils';
-const CACHE_DIRECTORY = './node_modules/.cache';
-const cacheDir = path.join(process.cwd(), CACHE_DIRECTORY);
-const manifest = path.join(cacheDir, 'loaderManifest.json');
-fs.mkdirp(cacheDir);
-export const MODE = {
-  STRICT: 1,
-  LOOSE: 2,
-  MIXIN: 3
-};
-export function toKey(level) {
-  return `file_${level}`;
-}
-export class LoaderManifest {
-  constructor() {
-    this.content = void 0;
-    this.content = {};
-    this.load();
-  }
-
-  get(root, targetLevel) {
-    return Object.values(MODE).reduce((total, level) => {
-      if (level > targetLevel) {
-        return total;
-      }
-
-      const key = toKey(level);
-      const allow = this.content[key].filter(file => file.includes(root));
-      return total.concat(allow);
-    }, []);
-  }
-
-  add(filename, level) {
-    const key = toKey(level);
-    this.load();
-
-    if (this.includes(filename, key)) {
-      return;
-    }
-
-    this.cleanExist(filename);
-    this.content[key].push(filename);
-    this.dump();
-  }
-
-  initContent() {
-    return Object.values(MODE).reduce((total, level) => {
-      const key = toKey(level);
-      total[key] = [];
-      return total;
-    }, {});
-  }
-
-  dump() {
-    fs.writeFileSync(manifest, JSON.stringify(this.content, null, 4));
-  }
-
-  load() {
-    const exist = fs.existsSync(manifest);
-
-    if (exist) {
-      try {
-        const contentStr = fs.readFileSync(manifest, 'utf-8');
-        this.content = JSON.parse(contentStr);
-      } catch (e) {
-        throw new Error(`解析 loader mainfest 失败：${manifest}`);
-      }
-    } else {
-      this.content = this.initContent();
-    }
-  }
-
-  includes(filename, key) {
-    return this.content[key].includes(filename);
-  }
-
-  index(filename, key) {
-    return this.content[key].indexOf(filename);
-  }
-
-  del(index, key) {
-    this.content[key].splice(index, 1);
-  }
-
-  cleanExist(filename) {
-    Object.values(MODE).some(level => {
-      const key = toKey(level);
-
-      if (this.includes(filename, key)) {
-        const index = this.index(filename, key);
-        this.del(index, key);
-        return true;
-      }
-
-      return false;
-    });
-  }
-
-}
-export { manifest };