@modern-js/plugin-ssg 1.0.1 → 1.1.2

package/src/libs/invoker.ts

@@ -1,56 +0,0 @@
-import normalize from 'normalize-path';
-import { ModernRoute } from '@modern-js/server';
-import {
-  CreatePageListener,
-  HookContext,
-  UserInterfaceRoute,
-  AgreedRouteMap,
-} from '../types';
-import { isDynamicUrl } from './util';
-import { createPageFactory } from './createPage';
-
-function createContext(
-  route: UserInterfaceRoute,
-  listener: CreatePageListener,
-) {
-  return {
-    createPage: createPageFactory(route, listener),
-    route,
-  };
-}
-
-// eslint-disable-next-line max-params
-export async function invoker(
-  pageRoutes: ModernRoute[],
-  agreedRouteMap: AgreedRouteMap,
-  hook: (context: HookContext) => any,
-  autoAddAgreed: (context: HookContext & { component: string }) => boolean,
-  listener: CreatePageListener,
-) {
-  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 = { ...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({
-            ...context,
-            component: agreedRoute._component,
-          });
-          autoAdd && context.createPage();
-        }
-      }
-    } else {
-      const route = { ...pageRoute, path: urlPath };
-      const context = createContext(route, listener);
-      await hook(context);
-    }
-  }
-}

package/src/libs/render.ts

@@ -1,16 +0,0 @@
-import { compile } from '../server/prerender';
-import { 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: {},
-    }),
-  );
-}

package/src/loader/index.ts

@@ -1,99 +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 () {
-  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: string | null = null;
-      let useStaticLoader: string | null = null;
-      let useLoader: string | null = 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: any) {
-            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: any) {
-            // 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: any) => p.isCallExpression());
-            if (closestPath?.node?.callee?.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: any) {
-          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/src/manifest-op.ts

@@ -1,111 +0,0 @@
-import path from 'path';
-import { fs } from '@modern-js/utils';
-
-type ManifestContent = Record<string, string[]>;
-
-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: Record<string, number> = {
-  STRICT: 1,
-  LOOSE: 2,
-  MIXIN: 3,
-};
-
-export function toKey(level: number): string {
-  return `file_${level}`;
-}
-export class LoaderManifest {
-  content: ManifestContent;
-
-  constructor() {
-    this.content = {};
-    this.load();
-  }
-
-  public get(root: string, targetLevel: number): string[] {
-    return Object.values(MODE).reduce((total: string[], level: number) => {
-      if (level > targetLevel) {
-        return total;
-      }
-
-      const key = toKey(level);
-      const allow = this.content[key].filter((file: string) =>
-        file.includes(root),
-      );
-      return total.concat(allow);
-    }, []);
-  }
-
-  public add(filename: string, level: number) {
-    const key = toKey(level);
-    this.load();
-    if (this.includes(filename, key)) {
-      return;
-    }
-
-    this.cleanExist(filename);
-    this.content[key].push(filename);
-    this.dump();
-  }
-
-  private initContent() {
-    return Object.values(MODE).reduce(
-      (total: ManifestContent, level: number) => {
-        const key = toKey(level);
-        total[key] = [];
-        return total;
-      },
-      {},
-    );
-  }
-
-  private dump() {
-    fs.writeFileSync(manifest, JSON.stringify(this.content, null, 4));
-  }
-
-  private 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();
-    }
-  }
-
-  private includes(filename: string, key: string) {
-    return this.content[key].includes(filename);
-  }
-
-  private index(filename: string, key: string) {
-    return this.content[key].indexOf(filename);
-  }
-
-  private del(index: number, key: string) {
-    this.content[key].splice(index, 1);
-  }
-
-  private cleanExist(filename: string) {
-    Object.values(MODE).some((level: number) => {
-      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 };

package/tests/operate.test.ts

@@ -1,39 +0,0 @@
-import { fs } from '@modern-js/utils';
-import { LoaderManifest, manifest } from '@/manifest-op';
-
-describe('test ssg manifest operate', () => {
-  beforeAll(() => {
-    if (fs.existsSync(manifest)) {
-      fs.unlinkSync(manifest);
-    }
-  });
-
-  test('should get correctly initial data', () => {
-    const loaderManifest = new LoaderManifest();
-    expect(loaderManifest.content).toEqual({
-      file_1: [],
-      file_2: [],
-      file_3: [],
-    });
-  });
-
-  test('should add file correctly', () => {
-    const loaderManifest = new LoaderManifest();
-    loaderManifest.add('/foo.js', 1);
-    loaderManifest.add('/bar.js', 2);
-    loaderManifest.add('/dir/baz.js', 2);
-    loaderManifest.add('/dir/foo.js', 3);
-    expect(loaderManifest.content).toEqual({
-      file_1: ['/foo.js'],
-      file_2: ['/bar.js', '/dir/baz.js'],
-      file_3: ['/dir/foo.js'],
-    });
-  });
-
-  test('should get file correctly', () => {
-    const loaderManifest = new LoaderManifest();
-    expect(loaderManifest.get('/', 1)).toEqual(['/foo.js']);
-    expect(loaderManifest.get('/dir', 2)).toEqual(['/dir/baz.js']);
-    expect(loaderManifest.get('/unknow', 3)).toEqual([]);
-  });
-});