Decouple event bus from router. Make Event bus lazy

Author: tolyo

@types/namespace.d.ts

@@ -93,7 +93,7 @@ import {
 import { RestService as TRestService } from "./services/rest/rest.js";
 import { ServiceProvider as TServiceProvider } from "./interface.ts";
 import { NgModelController as TNgModelController } from "./directive/model/model.js";
-import { RouterProvider } from "./router/router.ts";
+import { RouterProvider as TRouterProvider } from "./router/router.ts";
 import { TransitionProvider as TTransitionProvider } from "./router/transition/transition-service.js";
 import { AnimateProvider as TAnimateProvider } from "./animations/animate.js";
 import { UrlService as TUrlService } from "./router/url/url-service.js";
@@ -142,6 +142,7 @@ declare global {
     type SceProvider = TSceProvider;
     type SceDelegateProvider = TSceDelegateProvider;
     type TransitionProvider = TTransitionProvider;
+    type RouterProvider = TRouterProvider;
     type AnchorScrollService = TAnchorScrollService;
     type AnimateService = TAnimateService;
     type CompileService = TCompileFn;
@@ -162,7 +163,7 @@ declare global {
     type PubSubService = TPubSub;
     type RootElementService = Element;
     type RootScopeService = TScope & Record<string, any>;
-    type RouterService = RouterProvider;
+    type RouterService = TRouterProvider;
     type StateService = TStateProvider;
     type StateRegistryService = TStateRegistryProvider;
     type SseService = TSseService;

@types/router/state/state-service.d.ts

@@ -7,10 +7,15 @@ export class StateProvider {
   static $inject: string[];
   /**
    *
-   * @param {ng.RouterService} globals
-   * @param {*} transitionService
+   * @param {ng.RouterProvider} globals
+   * @param {ng.TransitionProvider} transitionService
+   * @param {ng.ExceptionHandlerProvider} exceptionHandlerProvider
    */
-  constructor(globals: ng.RouterService, transitionService: any);
+  constructor(
+    globals: ng.RouterProvider,
+    transitionService: ng.TransitionProvider,
+    exceptionHandlerProvider: ng.ExceptionHandlerProvider,
+  );
   /**
    * The latest successful state parameters
    *
@@ -30,14 +35,15 @@ export class StateProvider {
    */
   get $current(): import("./state-object.js").StateObject;
   globals: import("../router.js").RouterProvider;
-  transitionService: any;
+  transitionService: import("../transition/transition-service.js").TransitionProvider;
   stateRegistry: any;
   /** @type {ng.UrlService} */
   urlService: ng.UrlService;
   /** @type {ng.InjectorService} */
   $injector: ng.InjectorService;
   invalidCallbacks: any[];
-  _defaultErrorHandler: ($error$: any) => never;
+  /** @type {ng.ExceptionHandlerService} */
+  _defaultErrorHandler: ng.ExceptionHandlerService;
   $get: (
     | string
     | (($injector: ng.InjectorService, $url: any) => StateProvider)

@types/router/transition/transition.d.ts

@@ -16,20 +16,20 @@ export class Transition implements HookRegistry {
    * @param {Array<import('../path/path-node.js').PathNode>} fromPath The path of [[PathNode]]s from which the transition is leaving.  The last node in the `fromPath`
    *        encapsulates the "from state".
    * @param {import('../state/target-state.js').TargetState} targetState The target state and parameters being transitioned to (also, the transition options)
-   * @param {ng.TransitionService} transitionService The [[TransitionService]] instance
+   * @param {ng.TransitionProvider} transitionService The [[TransitionService]] instance
    * @param {ng.RouterService} globals
    */
   constructor(
     fromPath: Array<import("../path/path-node.js").PathNode>,
     targetState: import("../state/target-state.js").TargetState,
-    transitionService: ng.TransitionService,
+    transitionService: ng.TransitionProvider,
     globals: ng.RouterService,
   );
   /**
    * @type {import('../router.js').RouterProvider}
    */
   _globals: import("../router.js").RouterProvider;
-  _transitionService: ng.TransitionService;
+  _transitionService: import("./transition-service.js").TransitionProvider;
   _deferred: any;
   /**
    * This promise is resolved or rejected based on the outcome of the Transition.

@types/services/pubsub/pubsub.d.ts

@@ -3,22 +3,32 @@
  * @implements {ng.ServiceProvider}
  */
 export class PubSubProvider implements ng.ServiceProvider {
+  static $inject: string[];
+  /**
+   * @param {ng.ExceptionHandlerProvider} $exceptionHandler
+   * @param {ng.ServiceProvider} angularProvider
+   */
+  constructor(
+    $exceptionHandler: ng.ExceptionHandlerProvider,
+    angularProvider: ng.ServiceProvider,
+  );
   /**
    * @type {PubSub}
    */
   eventBus: PubSub;
-  $get: (
-    | string
-    | (($exceptionHandler: ng.ExceptionHandlerService) => PubSub)
-  )[];
+  $get: () => PubSub;
 }
 export class PubSub {
+  /**
+   * @param {ng.ExceptionHandlerService} $exceptionHandler
+   */
+  constructor($exceptionHandler: ng.ExceptionHandlerService);
   /** @private {Object<string, Array<{fn: Function, context: any}>>} */
   private _topics;
   /** @private */
   private _disposed;
-  /** @public @type {ng.ExceptionHandlerService | undefined} */
-  public $exceptionHandler: ng.ExceptionHandlerService | undefined;
+  /** @public @type {ng.ExceptionHandlerService} */
+  public $exceptionHandler: ng.ExceptionHandlerService;
   /**
    * Set instance to initial state
    */
@@ -73,5 +83,3 @@ export class PubSub {
    */
   publish(topic: string, ...args: any[]): boolean;
 }
-/** @private */
-export const EventBus: PubSub;

src/angular.js

@@ -16,7 +16,6 @@ import { createInjector } from "./core/di/injector.js";
 import { NgModule } from "./core/di/ng-module/ng-module.js";
 import { registerNgModule } from "./ng.js";
 import { unnestR } from "./shared/common.js";
-import { EventBus } from "./services/pubsub/pubsub.js";
 import { $injectTokens as $t } from "./injection-tokens.js";
 import { annotate } from "./core/di/di.js";
 import { validateIsString } from "./shared/validate.js";
@@ -38,7 +37,7 @@ export class Angular {
     this._bootsrappedModules = [];
 
     /** @public @type {ng.PubSubService} */
-    this.$eventBus = EventBus;
+    this.$eventBus;
 
     /** @public @type {ng.InjectorService} */
     this.$injector;

src/namespace.ts

@@ -98,7 +98,7 @@ import {
 import { RestService as TRestService } from "./services/rest/rest.js";
 import { ServiceProvider as TServiceProvider } from "./interface.ts";
 import { NgModelController as TNgModelController } from "./directive/model/model.js";
-import { RouterProvider } from "./router/router.ts";
+import { RouterProvider as TRouterProvider } from "./router/router.ts";
 import { TransitionProvider as TTransitionProvider } from "./router/transition/transition-service.js";
 import { AnimateProvider as TAnimateProvider } from "./animations/animate.js";
 import { UrlService as TUrlService } from "./router/url/url-service.js";
@@ -154,6 +154,7 @@ declare global {
     export type SceProvider = TSceProvider;
     export type SceDelegateProvider = TSceDelegateProvider;
     export type TransitionProvider = TTransitionProvider;
+    export type RouterProvider = TRouterProvider;
 
     // Services
     export type AnchorScrollService = TAnchorScrollService;
@@ -176,7 +177,7 @@ declare global {
     export type PubSubService = TPubSub;
     export type RootElementService = Element;
     export type RootScopeService = TScope & Record<string, any>;
-    export type RouterService = RouterProvider;
+    export type RouterService = TRouterProvider;
     export type StateService = TStateProvider;
     export type StateRegistryService = TStateRegistryProvider;
     export type SseService = TSseService;

src/router/state/state-service.js

@@ -14,7 +14,6 @@ import { TargetState } from "./target-state.js";
 import { Param } from "../params/param.js";
 import { Glob } from "../glob/glob.js";
 import { lazyLoadState } from "../hooks/lazy-load.js";
-import { EventBus } from "../../services/pubsub/pubsub.js";
 import { $injectTokens, provider } from "../../injection-tokens.js";
 
 const stdErr = minErr("$stateProvider");
@@ -55,14 +54,16 @@ export class StateProvider {
   /* @ignore */ static $inject = provider([
     $injectTokens._router,
     $injectTokens._transitions,
+    $injectTokens._exceptionHandler,
   ]);
 
   /**
    *
-   * @param {ng.RouterService} globals
-   * @param {*} transitionService
+   * @param {ng.RouterProvider} globals
+   * @param {ng.TransitionProvider} transitionService
+   * @param {ng.ExceptionHandlerProvider} exceptionHandlerProvider
    */
-  constructor(globals, transitionService) {
+  constructor(globals, transitionService, exceptionHandlerProvider) {
     this.globals = globals;
     this.transitionService = transitionService;
     this.stateRegistry = undefined;
@@ -73,19 +74,8 @@ export class StateProvider {
     this.$injector = undefined;
     this.invalidCallbacks = [];
 
-    this._defaultErrorHandler = function $defaultErrorHandler($error$) {
-      if ($error$ instanceof Error && $error$.stack) {
-        throw $error$;
-      } else if ($error$ instanceof Rejection) {
-        throw new Error($error$.toString());
-      } else {
-        throw new Error($error$);
-      }
-    };
-
-    EventBus.subscribe("$stateService:defaultErrorHandler", (error) =>
-      this.defaultErrorHandler()(error),
-    );
+    /** @type {ng.ExceptionHandlerService} */
+    this._defaultErrorHandler = exceptionHandlerProvider.handler;
   }
 
   $get = [

src/router/transition/transition.js

@@ -47,7 +47,7 @@ export class Transition {
    * @param {Array<import('../path/path-node.js').PathNode>} fromPath The path of [[PathNode]]s from which the transition is leaving.  The last node in the `fromPath`
    *        encapsulates the "from state".
    * @param {import('../state/target-state.js').TargetState} targetState The target state and parameters being transitioned to (also, the transition options)
-   * @param {ng.TransitionService} transitionService The [[TransitionService]] instance
+   * @param {ng.TransitionProvider} transitionService The [[TransitionService]] instance
    * @param {ng.RouterService} globals
    */
   constructor(fromPath, targetState, transitionService, globals) {

src/services/log/log.js

@@ -32,8 +32,6 @@ export class LogProvider {
           arg.message && arg.stack.indexOf(arg.message) === -1
             ? `Error: ${arg.message}\n${arg.stack}`
             : arg.stack;
-      } else if (arg.sourceURL) {
-        arg = `${arg.message}\n${arg.sourceURL}:${arg.line}`;
       }
     }
 

src/services/pubsub/pubsub.js

@@ -1,41 +1,44 @@
-import { $injectTokens } from "../../injection-tokens.js";
+import { $injectTokens, provider } from "../../injection-tokens.js";
 
 /**
  * Configurable provider for an injectable event bus
  * @implements {ng.ServiceProvider}
  */
 export class PubSubProvider {
-  constructor() {
+  static $inject = provider([
+    $injectTokens._exceptionHandler,
+    $injectTokens._angular,
+  ]);
+
+  /**
+   * @param {ng.ExceptionHandlerProvider} $exceptionHandler
+   * @param {ng.ServiceProvider} angularProvider
+   */
+  constructor($exceptionHandler, angularProvider) {
     /**
      * @type {PubSub}
      */
-    this.eventBus = EventBus;
+    this.eventBus = new PubSub($exceptionHandler.handler);
+    /** @type {ng.Angular} */ (angularProvider.$get()).$eventBus =
+      this.eventBus;
   }
 
-  $get = [
-    $injectTokens._exceptionHandler,
-    /**
-     * @param {ng.ExceptionHandlerService} $exceptionHandler
-     * @returns {PubSub}
-     */
-    ($exceptionHandler) => {
-      this.eventBus.$exceptionHandler = $exceptionHandler;
-
-      return this.eventBus;
-    },
-  ];
+  $get = () => this.eventBus;
 }
 
 export class PubSub {
-  constructor() {
+  /**
+   * @param {ng.ExceptionHandlerService} $exceptionHandler
+   */
+  constructor($exceptionHandler) {
     /** @private {Object<string, Array<{fn: Function, context: any}>>} */
     this._topics = Object.create(null);
 
     /** @private */
     this._disposed = false;
 
-    /** @public @type {ng.ExceptionHandlerService | undefined} */
-    this.$exceptionHandler = undefined;
+    /** @public @type {ng.ExceptionHandlerService} */
+    this.$exceptionHandler = $exceptionHandler;
   }
 
   /**
@@ -183,6 +186,3 @@ export class PubSub {
     return true;
   }
 }
-
-/** @private */
-export const EventBus = new PubSub();