feat: add code

Author: imtaotao

packages/runtime/core/src/garfish.ts

@@ -33,11 +33,11 @@ export class Garfish implements interfaces.Garfish {
   public channel = new EventEmitter();
   public options = createDefaultOptions();
   public externals: Record<string, any> = {};
+  public appInfos: Record<string, interfaces.AppInfo> = {};
   public activeApps: Array<interfaces.App> = [];
   public cacheApps: Record<string, interfaces.App> = {};
-  public appInfos: Record<string, interfaces.AppInfo> = {};
 
-  private allApps: WeakSet<interfaces.App> = new WeakSet();
+  private registeredPlugins = new WeakSet();
   private loading: Record<string, Promise<any> | null> = {};
 
   get props(): Record<string, any> {
@@ -110,14 +110,24 @@ export class Garfish implements interfaces.Garfish {
     ...args: Array<any>
   ) {
     assert(typeof plugin === 'function', 'Plugin must be a function.');
-    if ((plugin as any)._registered) {
+    if (this.registeredPlugins.has(plugin)) {
       __DEV__ && warn('Please do not register the plugin repeatedly.');
       return this;
     }
-    (plugin as any)._registered = true;
-    const allHooks = plugin.apply(this, [this, ...args]);
-    // Distinguish between xx and xxx, in order to be compatible with the old api
-    return this.hooks.usePlugin(allHooks);
+    this.registeredPlugins.add(plugin);
+    const pluginConfig = plugin.apply(this, [this, ...args]);
+
+    // Register app hooks, Compatible with the old api
+    this.activeApps.forEach((app) => app.hooks.usePlugin(pluginConfig));
+    for (const key in this.cacheApps) {
+      const app = this.cacheApps[key];
+      if (!this.activeApps.includes(app)) {
+        app.hooks.usePlugin(pluginConfig);
+      }
+    }
+    // Register global hooks
+    this.hooks.usePlugin(pluginConfig);
+    return this;
   }
 
   run(options?: interfaces.Options) {
@@ -204,6 +214,7 @@ export class Garfish implements interfaces.Garfish {
     } else {
       this.externals[nameOrExtObj] = value;
     }
+    return this;
   }
 
   async loadApp(
@@ -270,8 +281,9 @@ export class Garfish implements interfaces.Garfish {
             this.options.customLoader,
           );
 
-          this.allApps.add(appInstance);
-          this.cacheApps[appName] = appInstance;
+          if (appInfo.cache) {
+            this.cacheApps[appName] = appInstance;
+          }
         } catch (e) {
           __DEV__ && error(e);
           this.hooks.lifecycle.errorLoadApp.emit(e, appInfo);

packages/runtime/core/src/hooks/hooksSystem.ts

@@ -1,18 +1,16 @@
-import { assert, isObject } from '@garfish/utils';
 import { SyncHook, AsyncHook } from '@garfish/hooks';
+import { assert, isPlainObject } from '@garfish/utils';
 
 type Plugin<T> = Partial<Record<keyof T, (...args: Array<any>) => void>> & {
   name: string;
 };
 
 export class HooksSystem<T extends Record<string, SyncHook | AsyncHook>> {
-  type: string;
   lifecycle: T;
   lifecycleKeys: Array<keyof T>;
   private registerPlugins = new WeakSet<Plugin<T>>();
 
-  constructor(type: string, lifecycle: T) {
-    this.type = type;
+  constructor(lifecycle: T) {
     this.lifecycle = lifecycle;
     this.lifecycleKeys = Object.keys(lifecycle);
   }
@@ -21,7 +19,7 @@ export class HooksSystem<T extends Record<string, SyncHook | AsyncHook>> {
     // Plugin name is required and unique
     const pluginName = plugin.name;
     assert(pluginName, 'Plugin must provide a name');
-    assert(isObject(plugin), 'Plugin must return object type.');
+    assert(isPlainObject(plugin), 'Plugin must return object type.');
 
     if (!this.registerPlugins.has(plugin)) {
       this.registerPlugins.add(plugin);
@@ -30,17 +28,16 @@ export class HooksSystem<T extends Record<string, SyncHook | AsyncHook>> {
         const pluginLife = plugin[key as string];
         if (pluginLife) {
           // Differentiate different types of hooks and adopt different registration strategies
-          this.lifecycle[key].on(pluginName, pluginLife);
+          this.lifecycle[key].on(pluginLife);
         }
       }
     }
   }
 
   removePlugin(plugin: Plugin<T>) {
-    const pluginName = plugin.name;
-    assert(pluginName, 'Plugin must provide a name');
-    for (const key in this.lifecycle) {
-      this.lifecycle[key].remove(pluginName, plugin[key as string]);
+    assert(isPlainObject(plugin), 'Invalid plugin configuration');
+    for (const key in plugin) {
+      this.lifecycle[key].remove(plugin[key as string]);
     }
   }
 }

packages/runtime/core/src/hooks/lifecycle.ts

@@ -2,20 +2,19 @@ import { HooksSystem } from './hooksSystem';
 import { SyncHook, AsyncHook } from '@garfish/hooks';
 
 export function globalLifecycle() {
-  const hooks = {
+  return new HooksSystem({
     beforeBootstrap: new SyncHook(),
     bootstrap: new SyncHook(),
     beforeRegisterApp: new SyncHook(),
     registerApp: new SyncHook(),
     beforeLoad: new AsyncHook(),
     afterLoad: new SyncHook(),
     errorLoadApp: new SyncHook(),
-  };
-  return new HooksSystem('global', hooks);
+  });
 }
 
 export function appLifecycle() {
-  const hooks = {
+  return new HooksSystem({
     beforeEval: new SyncHook(),
     afterEval: new SyncHook(),
     beforeMount: new SyncHook(),
@@ -25,6 +24,5 @@ export function appLifecycle() {
     errorMountApp: new SyncHook(),
     errorUnmountApp: new SyncHook(),
     errorExecCode: new SyncHook(),
-  };
-  return new HooksSystem('app', hooks);
+  });
 }

packages/runtime/hooks/src/asyncHook.ts

@@ -2,12 +2,12 @@ import { SyncHook } from './syncHook';
 
 export class AsyncHook extends SyncHook {
   emit(...data: Array<any>) {
-    const hs = this.hooks;
-    if (hs.length > 0) {
+    const ls = Array.from(this.listeners);
+    if (ls.length > 0) {
       let i = 0;
       const call = (stop?: any) => {
-        if (stop !== false && i < hs.length) {
-          const result = hs[i++].fn.apply(null, data);
+        if (stop !== false && i < ls.length) {
+          const result = ls[i++].apply(null, data);
           return Promise.resolve(result).then(call);
         }
       };

packages/runtime/hooks/src/channel.ts

@@ -1,4 +1,3 @@
-export { Channel } from './channel';
 export { SyncHook } from './syncHook';
 export { AsyncHook } from './asyncHook';
 export { LoaderPlugin } from './loaderPlugin';

packages/runtime/hooks/src/index.ts

@@ -3,49 +3,40 @@ import { warn } from '@garfish/utils';
 type Callback = (...args: Array<any>) => void;
 
 export class SyncHook {
-  public type: string = '';
-  public hooks: Array<{ name: string; fn: Callback }> = [];
+  type: string = '';
+  listeners = new Set<Callback>();
 
   constructor(type?: string) {
     if (type) this.type = type;
   }
 
-  on(name: string, fn: Callback) {
-    if (typeof name === 'string' && typeof fn === 'function') {
-      this.hooks.push({ name, fn });
+  on(fn: Callback) {
+    if (typeof fn === 'function') {
+      this.listeners.add(fn);
     } else if (__DEV__) {
       warn('Invalid parameter');
     }
   }
 
-  once(name: string, fn: Callback) {
+  once(fn: Function) {
     const self = this;
-    this.on(name, function wrapper(...args: Array<any>) {
-      self.remove(name, wrapper);
+    this.on(function wrapper(...args: Array<any>) {
+      self.remove(wrapper);
       fn(...args);
     });
   }
 
   emit(...data: Array<any>) {
-    if (this.hooks.length > 0) {
-      this.hooks.forEach((hook) => hook.fn.apply(null, data));
+    if (this.listeners.size > 0) {
+      this.listeners.forEach((fn) => fn.apply(null, data));
     }
   }
 
-  remove(name: string, fn: Callback) {
-    for (let i = 0; i < this.hooks.length; i++) {
-      const hook = this.hooks[i];
-      if (name === hook.name) {
-        if (fn && fn !== hook.fn) {
-          continue;
-        }
-        this.hooks.splice(i, 1);
-        i--;
-      }
-    }
+  remove(fn: Callback) {
+    return this.listeners.delete(fn);
   }
 
   removeAll() {
-    this.hooks.length = 0;
+    this.listeners.clear();
   }
 }

packages/runtime/hooks/src/syncHook.ts

@@ -114,21 +114,19 @@ function allExternal() {
 }
 
 function extractTsDeclare() {
-  let outputoptions;
   let pkgDir = '';
   let pkgName = '';
   return {
     name: 'garfish-extractTsDeclare',
     options(op) {
-      outputoptions = op;
       pkgDir = op.input.replace('/src/index.ts', '');
-      let splitPkg = pkgDir.split('/');
+      const splitPkg = pkgDir.split('/');
       pkgName = splitPkg[splitPkg.length - 1];
     },
     writeBundle() {
       if (!pkgName) return;
 
-      let tsTypeDir = path.resolve(
+      const tsTypeDir = path.resolve(
         pkgDir,
         `dist/packages/runtime/${pkgName}/src`,
       );
@@ -137,21 +135,12 @@ function extractTsDeclare() {
         if (!fs.existsSync(tsTypeDir)) return;
         fs.copySync(
           path.resolve(pkgDir, tsTypeDir),
-          path.resolve(pkgDir, `dist/`),
+          path.resolve(pkgDir, 'dist/'),
           {
             overwrite: true,
           },
         );
       }, 1000);
-      // setTimeout(() => {
-      //   const args = require('minimist')(process.argv.slice(2));
-      //   const watch = args.watch || args.w;
-      //   // if (!watch) {
-      //   fs.remove(path.resolve(pkgDir, `dist/packages`));
-      //   fs.remove(path.resolve(pkgDir, `dist/dist`));
-      //   fs.remove(path.resolve(pkgDir, `temp`));
-      //   // }
-      // }, 3000);
     },
   };
 }

rollup.config.js

@@ -31,8 +31,6 @@ run();
 async function run() {
   const buildAll = async (targets) => {
     for (const target of targets) {
-      // watch mode can't await
-      if (target.indexOf('hooks') !== -1) continue;
       if (watch) {
         build(target);
       } else {

scripts/build.js

@@ -1,5 +1,3 @@
-const path = require('path');
-const os = require('os');
 const lernaPublish = require('@lerna/publish');
 
 const opts = {
@@ -17,8 +15,7 @@ const opts = {
 };
 
 function publish(canary) {
-  // eslint-disable-next-line no-console
-  console.log(`publish ${canary ? `测试版本` : `正式版本`}\n`);
+  console.log(`publish ${canary ? '测试版本' : '正式版本'}\n`);
 
   return lernaPublish({
     ...opts,