@angular-wave/angular.ts 0.7.0-beta.0 → 0.7.1

package/src/core/exception-handler.js

@@ -1,5 +1,5 @@
 /**
- * Handles uncaught exceptions thrown in AngularJS expressions.
+ * Handles uncaught exceptions thrown in AngularTS expressions.
  *
  * By default, this service delegates to `$log.error()`, logging the exception to the browser console.
  * You can override this behavior to provide custom exception handling—such as reporting errors
@@ -7,7 +7,7 @@
  *
  * ## Default Behavior
  *
- * Uncaught exceptions within AngularJS expressions are intercepted and passed to this service.
+ * Uncaught exceptions within AngularTS expressions are intercepted and passed to this service.
  * The default implementation logs the error using `$log.error(exception, cause)`.
  *
  * ## Custom Implementation
@@ -39,17 +39,12 @@
  * }
  * ```
  *
- * @see {@link angular.ErrorHandler AngularJS ErrorHandler}
+ * @see {@link angular.ErrorHandler AngularTS ErrorHandler}
  */
 
 /** @typedef {import('../services/log').LogService} LogService */
 
-/**
- * @callback ErrorHandler
- * @param {Error} exception - Exception associated with the error.
- * @param {string} [cause] - Optional information about the context in which the error was thrown.
- * @returns {void}
- */
+/** @typedef {import("./error-handler.ts").ErrorHandler}  ErrorHandler */
 
 /**
  * Provider for `$exceptionHandler` service. Delegates uncaught exceptions to `$log.error()` by default.

package/src/core/filter/filter.js

@@ -6,29 +6,37 @@ import { orderByFilter } from "../../filters/order-by.js";
 import {
   $IncludedByStateFilter,
   $IsStateFilter,
-} from "../../router/state-filters";
+} from "../../router/state-filters.js";
 
 FilterProvider.$inject = ["$provide"];
+
+/**
+ * @param {import('../../interface.ts').Provider} $provide
+ */
 export function FilterProvider($provide) {
   const suffix = "Filter";
 
+  /**
+   * @param {string|Record<string, import('../../interface.ts').FilterFactory>} name
+   * @param {import('../../interface.ts').FilterFactory} factory
+   * @return {import('../../interface.ts').ServiceProvider}
+   */
   function register(name, factory) {
     if (isObject(name)) {
       const filters = {};
       Object.entries(name).forEach(([key, filter]) => {
         filters[key] = register(key, filter);
       });
-      return filters;
     }
     return $provide.factory(name + suffix, factory);
   }
+
   this.register = register;
 
   this.$get = [
     "$injector",
     /**
-     *
-     * @param {import("../../core/di/internal-injector").InjectorService} $injector
+     * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
      * @returns
      */
     function ($injector) {

package/src/core/filter/filter.md

@@ -9,7 +9,7 @@
 - annotated with dependencies and is responsible for creating a filter function.
 -
 - <div class="alert alert-warning">
-- **Note:** Filter names must be valid AngularJS {@link expression} identifiers, such as `uppercase` or `orderBy`.
+- **Note:** Filter names must be valid AngularTS {@link expression} identifiers, such as `uppercase` or `orderBy`.
 - Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace
 - your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores
 - (`myapp_subsection_filterx`).
@@ -64,8 +64,8 @@
 
 -
 -
-- For more information about how AngularJS filters work, and how to create your own filters, see
-- {@link guide/filter Filters} in the AngularJS Developer Guide.
+- For more information about how AngularTS filters work, and how to create your own filters, see
+- {@link guide/filter Filters} in the AngularTS Developer Guide.
   \*/
 
 /\*\*
@@ -76,7 +76,7 @@
 - @description
 - Filters are used for formatting data displayed to the user.
 -
-- They can be used in view templates, controllers or services. AngularJS comes
+- They can be used in view templates, controllers or services. AngularTS comes
 - with a collection of [built-in filters](api/ng/filter), but it is easy to
 - define your own as well.
 -
@@ -121,7 +121,7 @@
 - the keys are the filter names and the values are the filter factories.
 -
 - <div class="alert alert-warning">
-- **Note:** Filter names must be valid AngularJS {@link expression} identifiers, such as `uppercase` or `orderBy`.
+- **Note:** Filter names must be valid AngularTS {@link expression} identifiers, such as `uppercase` or `orderBy`.
 - Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace
 - your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores
 - (`myapp_subsection_filterx`).

package/src/core/interpolate/interpolate.js

@@ -32,9 +32,9 @@ function interr(text, err) {
  * Used for configuring the interpolation markup. Defaults to `{{` and `}}`.
  *
  * <div class="alert alert-danger">
- * This feature is sometimes used to mix different markup languages, e.g. to wrap an AngularJS
+ * This feature is sometimes used to mix different markup languages, e.g. to wrap an AngularTS
  * template within a Python Jinja template (or any other template language). Mixing templating
- * languages is **very dangerous**. The embedding template language will not safely escape AngularJS
+ * languages is **very dangerous**. The embedding template language will not safely escape AngularTS
  * expressions, so any user-controlled values in the template will cause Cross Site Scripting (XSS)
  * security bugs!
  * </div>
@@ -57,7 +57,7 @@ export class InterpolateProvider {
     "$sce",
     /**
      *
-     * @param {import("../parse/parse.js").ParseService} $parse
+     * @param {import("../parse/interface.ts").ParseService} $parse
      * @param {*} $sce
      * @returns
      */
@@ -97,7 +97,7 @@ export class InterpolateProvider {
        * ```js
        *   let $interpolate = ...; // injected
        *   let exp = $interpolate('Hello {{name | uppercase}}!');
-       *   expect(exp({name:'AngularJS'})).toEqual('Hello ANGULARJS!');
+       *   expect(exp({name:'AngularTS'})).toEqual('Hello ANGULARJS!');
        * ```
        *
        * `$interpolate` takes an optional fourth argument, `allOrNothing`. If `allOrNothing` is
@@ -115,8 +115,8 @@ export class InterpolateProvider {
        *   // "allOrNothing" mode
        *   exp = $interpolate('{{greeting}} {{name}}!', false, null, true);
        *   expect(exp(context)).toBeUndefined();
-       *   context.name = 'AngularJS';
-       *   expect(exp(context)).toEqual('Hello AngularJS!');
+       *   context.name = 'AngularTS';
+       *   expect(exp(context)).toEqual('Hello AngularTS!');
        * ```
        *
        * `allOrNothing` is useful for interpolating URLs. `ngSrc` and `ngSrcset` use this behavior.

package/src/core/interpolate/interpolate.spec.js

@@ -289,7 +289,7 @@ describe("$interpolate", () => {
 
     // This test demonstrates that the web-server is responsible for escaping every single instance
     // of interpolation start/end markers in an expression which they do not wish to evaluate,
-    // because AngularJS will not protect them from being evaluated (due to the added compleity
+    // because AngularTS will not protect them from being evaluated (due to the added compleity
     // and maintenance burden of context-sensitive escaping)
     it("should evaluate expressions between escaped start/end symbols", () => {
       expect($interpolate("\\{\\{Hello, {{bar}}!\\}\\}")(obj)).toBe(

package/src/core/location/location.js

@@ -156,7 +156,7 @@ export class Location {
    *
    * Return host of current URL.
    *
-   * Note: compared to the non-AngularJS version `location.host` which returns `hostname:port`, this returns the `hostname` portion only.
+   * Note: compared to the non-AngularTS version `location.host` which returns `hostname:port`, this returns the `hostname` portion only.
    *
    *
    * @return {string} host of current URL.
@@ -507,7 +507,7 @@ export class LocationHashbangUrl extends Location {
      *  * a.setAttribute('href', '/foo')
      *   * a.pathname === '/C:/foo' //true
      *
-     * Inside of AngularJS, we're always using pathnames that
+     * Inside of AngularTS, we're always using pathnames that
      * do not include drive names for routing.
      */
     function removeWindowsDriveName(path, url, base) {
@@ -747,7 +747,7 @@ export class LocationProvider {
             !event.defaultPrevented
           ) {
             if ($location.$$parseLinkUrl(absHref, relHref)) {
-              // We do a preventDefault for all urls that are part of the AngularJS application,
+              // We do a preventDefault for all urls that are part of the AngularTS application,
               // in html5mode and also without, so that we are able to abort navigation without
               // getting double entries in the location history.
               event.preventDefault();

package/src/core/parse/ast/ast.js

@@ -1,6 +1,6 @@
 import { isAssignable } from "../interpreter.js";
 import { ASTType } from "../ast-type.js";
-import { minErr } from "../../../shared/utils.js";
+import { hasOwn, minErr } from "../../../shared/utils.js";
 
 /**
  * @typedef {import("./ast-node.ts").ASTNode} ASTNode
@@ -269,7 +269,7 @@ export class AST {
     } else if (this.expect("{")) {
       primary = this.object();
     } else if (
-      Object.prototype.hasOwnProperty.call(
+      hasOwn(
         this.selfReferential,
         /** @type {import("../lexer/lexer.js").Token} */ (this.peek()).text,
       )

package/src/core/parse/ast/ast.spec.js

@@ -29,15 +29,7 @@ describe("ast", () => {
   beforeEach(() => {
     createAst = function () {
       const lexer = new Lexer({});
-      const ast = new AST(lexer, {
-        csp: false,
-        literals: {
-          true: true,
-          false: false,
-          undefined: undefined,
-          null: null,
-        },
-      });
+      const ast = new AST(lexer);
       return ast.ast.apply(ast, arguments);
     };
   });

package/src/core/parse/interface.ts

@@ -0,0 +1,84 @@
+import type { DecoratedASTNode } from "./interpreter.js";
+import type { Scope } from "../scope/scope.js";
+
+/**
+ * Describes metadata and behavior for a compiled AngularTS expression.
+ */
+export interface CompiledExpressionProps {
+  /** Indicates if the expression is a literal. */
+  literal: boolean;
+  /** Indicates if the expression is constant. */
+  constant: boolean;
+  /** Optional flag for pure expressions. */
+  isPure?: boolean;
+  /** Indicates if the expression should be evaluated only once. */
+  oneTime: boolean;
+  /** AST node decorated with metadata. */
+  decoratedNode: DecoratedASTNode;
+  /**
+   * Optional custom watch delegate function for the expression.
+   * @param scope - The current scope.
+   * @param listener - A listener function.
+   * @param equalityCheck - Whether to use deep equality.
+   * @param expression - The compiled expression or string.
+   */
+  $$watchDelegate?: (
+    scope: Scope,
+    listener: Function,
+    equalityCheck: boolean,
+    expression: CompiledExpression | string | ((scope: Scope) => any),
+  ) => any;
+  /** Expression inputs; may be an array or a function. */
+  inputs: any[] | Function;
+  /**
+   * Optional assign function for two-way binding.
+   * Assigns a value to a context.
+   * If value is not provided, may return the getter.
+   */
+  assign?: (context: any, value: any) => any;
+}
+
+/**
+ * Expression function with context and optional locals/assign.
+ * Evaluates the compiled expression.
+ */
+export type CompiledExpressionFunction = (
+  context?: Scope,
+  locals?: object,
+  assign?: any,
+) => any;
+
+/**
+ * A compiled expression that is both a function and includes expression metadata.
+ */
+export type CompiledExpression = CompiledExpressionFunction &
+  CompiledExpressionProps;
+
+/**
+ * Map used for expressions that watch specific object keys.
+ */
+export interface CompiledExpressionHandlerMap {
+  /** Indicates if the expression is a literal. */
+  literal: boolean;
+  /** Indicates if the expression is constant. */
+  constant: boolean;
+  /** Optional flag for pure expressions. */
+  isPure?: boolean;
+  /** Indicates if the expression should be evaluated only once. */
+  oneTime: boolean;
+  /** A map of property keys to observe. */
+  keyMap: Map<string, Function>;
+}
+
+/**
+ * Parses a string or expression function into a compiled expression.
+ * @param expression - The input expression (string or function).
+ * @param interceptorFn - Optional value transformer.
+ * @param expensiveChecks - Whether to enable expensive change detection.
+ * @returns A compiled expression.
+ */
+export type ParseService = (
+  expression?: CompiledExpression | string | ((scope: Scope) => any),
+  interceptorFn?: (value: any, scope: Scope, locals: any) => any,
+  expensiveChecks?: boolean,
+) => CompiledExpression;

package/src/core/parse/interpreter.js

@@ -15,16 +15,16 @@ export class ASTInterpreter {
   /**
    * Compiles the AST into a function.
    * @param {import("./ast/ast").ASTNode} ast - The AST to compile.
-   * @returns {import("./parse").CompiledExpression}
+   * @returns {import("./interface.ts").CompiledExpression}
    */
   compile(ast) {
     let decoratedNode = findConstantAndWatchExpressions(ast, this.$filter);
     /** @type {import("./ast/ast").ASTNode} */
     let assignable;
-    /** @type {import("./parse").CompiledExpression} */
+    /** @type {import("./interface.ts").CompiledExpression} */
     let assign;
     if ((assignable = assignableAST(decoratedNode))) {
-      assign = /** @type {import("./parse").CompiledExpression} */ (
+      assign = /** @type {import("./interface.ts").CompiledExpression} */ (
         this.recurse(assignable)
       );
     }
@@ -33,9 +33,10 @@ export class ASTInterpreter {
     if (toWatch) {
       inputs = [];
       for (const [key, watch] of Object.entries(toWatch)) {
-        const input = /** @type {import("./parse").CompiledExpression} */ (
-          this.recurse(watch)
-        );
+        const input =
+          /** @type {import("./interface.ts").CompiledExpression} */ (
+            this.recurse(watch)
+          );
         input.isPure = watch.isPure;
         watch.input = input;
         inputs.push(input);
@@ -47,7 +48,7 @@ export class ASTInterpreter {
       expressions.push(this.recurse(expression.expression));
     });
 
-    /** @type {import("./parse").CompiledExpression} */
+    /** @type {import("./interface.ts").CompiledExpression} */
     const fn =
       decoratedNode.body.length === 0
         ? () => {}
@@ -75,7 +76,7 @@ export class ASTInterpreter {
    * @param {import("./ast/ast").ASTNode} ast - The AST node.
    * @param {Object} [context] - The context.
    * @param {boolean|1} [create] - The create flag.
-   * @returns {import("./parse").CompiledExpressionFunction} The recursive function.
+   * @returns {import("./interface.ts").CompiledExpressionFunction} The recursive function.
    */
   recurse(ast, context, create) {
     let left;
@@ -97,11 +98,13 @@ export class ASTInterpreter {
         right = this.recurse(ast.right);
         return this[`binary${ast.operator}`](left, right, context);
       case ASTType.ConditionalExpression:
-        return this["ternary?:"](
-          this.recurse(ast.test),
-          this.recurse(ast.alternate),
-          this.recurse(ast.consequent),
-          context,
+        return /** @type {import("./interface.ts").CompiledExpressionFunction} */ (
+          this["ternary?:"](
+            this.recurse(ast.test),
+            this.recurse(ast.alternate),
+            this.recurse(ast.consequent),
+            context,
+          )
         );
       case ASTType.Identifier:
         return self.identifier(ast.name, context, create);
@@ -111,19 +114,21 @@ export class ASTInterpreter {
           right = ast.property.name;
         }
         if (ast.computed) right = this.recurse(ast.property);
-        return ast.computed
-          ? this.computedMember(
-              left,
-              /** @type {function } */ (right),
-              context,
-              create,
-            )
-          : this.nonComputedMember(
-              left,
-              /** @type {string } */ (right),
-              context,
-              create,
-            );
+        return /** @type {import("./interface.ts").CompiledExpressionFunction} */ (
+          ast.computed
+            ? this.computedMember(
+                left,
+                /** @type {function } */ (right),
+                context,
+                create,
+              )
+            : this.nonComputedMember(
+                left,
+                /** @type {string } */ (right),
+                context,
+                create,
+              )
+        );
       case ASTType.CallExpression:
         args = [];
         ast.arguments.forEach((expr) => {
@@ -505,7 +510,7 @@ export class ASTInterpreter {
    * Returns the value of a literal.
    * @param {*} value - The literal value.
    * @param {Object} [context] - The context.
-   * @returns {function} The function returning the literal value.
+   * @returns {import("./interface.ts").CompiledExpressionFunction} The function returning the literal value.
    */
   value(value, context) {
     return function () {
@@ -518,7 +523,7 @@ export class ASTInterpreter {
    * @param {string} name - The identifier name.
    * @param {Object} [context] - The context.
    * @param {boolean|1} [create] - Whether to create the identifier if it does not exist.
-   * @returns {function} The function returning the identifier value.
+   * @returns {import("./interface.ts").CompiledExpressionFunction} The function returning the identifier value.
    */
   identifier(name, context, create) {
     return function (scope, locals) {

package/src/core/parse/parse.js

@@ -3,57 +3,17 @@ import { PURITY_RELATIVE } from "./interpreter.js";
 import { Lexer } from "./lexer/lexer.js";
 import { Parser } from "./parser/parser.js";
 
-/**
- * @typedef {Object} CompiledExpressionProps
- * @property {boolean} literal - Indicates if the expression is a literal.
- * @property {boolean} constant - Indicates if the expression is constant.
- * @property {boolean} [isPure]
- * @property {boolean} oneTime
- * @property {import("./interpreter.js").DecoratedASTNode} decoratedNode
- * @property {function(import('../scope/scope.js').Scope, Function, boolean, CompiledExpression, string | ((scope:  import('../scope/scope.js').Scope) => any) | CompiledExpression): any} [$$watchDelegate]
- * @property {any[]|Function} inputs
- * @property {function(any, any): any} [assign] - Assigns a value to a context. If value is not provided,
- */
-
-/**
- * @typedef {Object} CompiledExpressionHandlerMap
- * @property {boolean} literal - Indicates if the expression is a literal.
- * @property {boolean} constant - Indicates if the expression is constant.
- * @property {boolean} [isPure]
- * @property {boolean} oneTime
- * @property {Map<string, Function>} keyMap - property keys to observe
- */
-
-/**
- * @typedef {Function} CompiledExpressionFunction
- * @param {import('../scope/scope.js').Scope} context - An object against which any expressions embedded in the strings are evaluated against (typically a scope object).
- * @param {object} [locals] - local variables context object, useful for overriding values in `context`.
- * @param {any} [assign]
- * @returns {any}
- * undefined is gonna be used since the implementation
- * does not check the parameter. Let's force a value for consistency. If consumer
- * wants to undefine it, pass the undefined value explicitly.
- */
-
-/**
- * @typedef {CompiledExpressionFunction & CompiledExpressionProps} CompiledExpression
- */
-
-/**
- * @typedef {function(CompiledExpression|string|function(import('../scope/scope.js').Scope):any, function(any, import('../scope/scope.js').Scope, any):any=, boolean=): CompiledExpression} ParseService
- */
-
 export function ParseProvider() {
   const cache = Object.create(null);
 
   /** @type {function(any):boolean?} */
-  var identStart;
+  let identStart;
 
   /** @type {function(any):boolean?} */
-  var identContinue;
+  let identContinue;
 
   /**
-   * Allows defining the set of characters that are allowed in AngularJS expressions. The function
+   * Allows defining the set of characters that are allowed in AngularTS expressions. The function
    * `identifierStart` will get called to know if a given character is a valid character to be the
    * first character for an identifier. The function `identifierContinue` will get called to know if
    * a given character is a valid character to be a follow-up identifier character. The functions
@@ -83,11 +43,11 @@ export function ParseProvider() {
     /**
      *
      * @param {(any) => any} $filter
-     * @returns {ParseService}
+     * @returns {import('./interface').ParseService}
      */
     function ($filter) {
       /** @type {import("./lexer/lexer.js").LexerOptions} */
-      var $lexerOptions = {
+      const $lexerOptions = {
         isIdentifierStart: isFunction(identStart) && identStart,
         isIdentifierContinue: isFunction(identContinue) && identContinue,
       };
@@ -99,7 +59,7 @@ export function ParseProvider() {
        * @returns any
        */
       function $parse(exp, interceptorFn) {
-        var parsedExpression, cacheKey;
+        let parsedExpression, cacheKey;
 
         switch (typeof exp) {
           case "string":
@@ -109,8 +69,8 @@ export function ParseProvider() {
             parsedExpression = cache[cacheKey];
 
             if (!parsedExpression) {
-              var lexer = new Lexer($lexerOptions);
-              var parser = new Parser(lexer, $filter);
+              const lexer = new Lexer($lexerOptions);
+              const parser = new Parser(lexer, $filter);
               parsedExpression = parser.parse(exp);
 
               cache[cacheKey] = addWatchDelegate(parsedExpression);
@@ -128,7 +88,7 @@ export function ParseProvider() {
       /**
        * @param {Function} parsedExpression
        * @param interceptorFn
-       * @returns {CompiledExpression|*}
+       * @returns {import('./interface').CompiledExpression|*}
        */
       function addInterceptor(parsedExpression, interceptorFn) {
         if (!interceptorFn) return parsedExpression;
@@ -231,8 +191,8 @@ export function constantWatchDelegate(
 
 /**
  *
- * @param {CompiledExpression} parsedExpression
- * @returns {CompiledExpression}
+ * @param {import('./interface.ts').CompiledExpression} parsedExpression
+ * @returns {import('./interface.ts').CompiledExpression}
  */
 function addWatchDelegate(parsedExpression) {
   if (parsedExpression.constant) {
@@ -249,7 +209,7 @@ function addWatchDelegate(parsedExpression) {
  * @param {import('../scope/scope.js').Scope} scope
  * @param {Function} listener
  * @param {*} objectEquality
- * @param {CompiledExpression} parsedExpression
+ * @param {import('./interface').CompiledExpression} parsedExpression
  * @returns
  */
 function inputsWatchDelegate(
@@ -276,9 +236,7 @@ function inputsWatchDelegate(
             inputExpression.isPure,
           )
         ) {
-          lastResult = parsedExpression($scope, undefined, undefined, [
-            newInputValue,
-          ]);
+          lastResult = parsedExpression($scope, undefined, [newInputValue]);
           oldInputValueOf = newInputValue && getValueOf(newInputValue);
         }
         return lastResult;
@@ -315,12 +273,7 @@ function inputsWatchDelegate(
         }
 
         if (changed) {
-          lastResult = parsedExpression(
-            scope,
-            undefined,
-            undefined,
-            oldInputValues,
-          );
+          lastResult = parsedExpression(scope, undefined, oldInputValues);
         }
 
         return lastResult;

package/src/core/parse/parse.md

@@ -1,9 +1,9 @@
-// Sandboxing AngularJS Expressions
+// Sandboxing AngularTS Expressions
 // ------------------------------
-// AngularJS expressions are no longer sandboxed. So it is now even easier to access arbitrary JS code by
+// AngularTS expressions are no longer sandboxed. So it is now even easier to access arbitrary JS code by
 // various means such as obtaining a reference to native JS functions like the Function constructor.
 //
-// As an example, consider the following AngularJS expression:
+// As an example, consider the following AngularTS expression:
 //
 // {}.toString.constructor('alert("evil JS code")')
 //
@@ -20,14 +20,14 @@
 -
 - @description
 -
-- Converts AngularJS {@link guide/expression expression} into a function.
+- Converts AngularTS {@link guide/expression expression} into a function.
 -
 - let getter = $parse('user.name');
 - let setter = getter.assign;
-- let context = {user:{name:'AngularJS'}};
+- let context = {user:{name:'AngularTS'}};
 - let locals = {user:{name:'local'}};
 -
-- expect(getter(context)).toEqual('AngularJS');
+- expect(getter(context)).toEqual('AngularTS');
 - setter(context, 'newValue');
 - expect(context.user.name).toEqual('newValue');
 - expect(getter(context, locals)).toEqual('local');

package/src/core/parse/parser/parser.js

@@ -27,7 +27,7 @@ export class Parser {
   /**
    *
    * @param {string} exp - Expression to be parsed
-   * @returns {import("../parse.js").CompiledExpression}
+   * @returns {import("../interface.ts").CompiledExpression}
    */
   parse(exp) {
     const { ast } = this.getAst(exp);

package/src/core/pubsub/pubsub.js

@@ -1,3 +1,23 @@
+/** @typedef {import('../../interface.js').ServiceProvider} ServiceProvider
+
+/**
+ * Configurable provider for an injectable event bus
+ * @implements {ServiceProvider}
+ */
+export class PubSubProvider {
+  constructor() {
+    /**
+     * @type {PubSub}
+     */
+    this.eventBus = EventBus;
+  }
+
+  /**
+   * @returns {PubSub}
+   */
+  $get = () => this.eventBus;
+}
+
 export class PubSub {
   /**
    * Topic-based publish/subscribe channel.  Maintains a map of topics to

package/src/core/pubsub/pubsub.spec.js

@@ -1,4 +1,17 @@
-import { PubSub } from "./pubsub";
+import { PubSub } from "./pubsub.js";
+import { createInjector } from "../di/injector.js";
+import { Angular } from "../../loader.js";
+
+describe("PubSubProvider", () => {
+  it("should be injectable", () => {
+    let angular = new Angular();
+    angular.module("test", ["ng"]);
+    let $injector = createInjector(["test"]);
+    expect($injector.has("$eventBus")).toBeTrue();
+    expect($injector.get("$eventBus") instanceof PubSub).toBeTrue();
+    expect($injector.get("$eventBus").async_).toBeTrue();
+  });
+});
 
 describe("PubSub", function () {
   let pubsub;