@angular-wave/angular.ts 0.0.34 → 0.0.36

package/src/core/{root-scope.js → scope/scope.js}

@@ -10,7 +10,7 @@ import {
   isNumberNaN,
   arrayRemove,
   equals,
-} from "../shared/utils";
+} from "../../shared/utils";
 
 /**
  * @enum {number}
@@ -21,6 +21,13 @@ export const ScopePhase = {
   DIGEST: 2,
 };
 
+/**
+ * @typedef {Object} AsyncQueueTask
+ * @property {Scope} scope
+ * @property {Function} fn
+ * @property {Object} locals
+ */
+
 /**
  *
  * The default number of `$digest` iterations the scope should attempt to execute before giving up and
@@ -34,9 +41,11 @@ export const ScopePhase = {
 export const TTL = 10;
 
 const $rootScopeMinErr = minErr("$rootScope");
-const $$asyncQueue = [];
-const $$postDigestQueue = [];
-const $$applyAsyncQueue = [];
+
+/** @type {AsyncQueueTask[]} */
+export const $$asyncQueue = [];
+export const $$postDigestQueue = [];
+export const $$applyAsyncQueue = [];
 let postDigestQueuePosition = 0;
 let lastDirtyWatch = null;
 let applyAsyncId = null;
@@ -114,16 +123,8 @@ export class $RootScopeProvider {
  * to construct.
  */
 
-export function getQueues() {
-  return {
-    asyncQueue: $$asyncQueue,
-    postDigestQueue: $$postDigestQueue,
-    applyAsyncQueue: $$applyAsyncQueue,
-  };
-}
-
 /**
- * @type {angular.IScope}
+ * @type {angular.Scope}
  */
 class Scope {
   constructor() {
@@ -136,35 +137,70 @@ class Scope {
     this.$$phase = ScopePhase.NONE;
 
     /**
-     * @type {?angular.IScope} Reference to the parent scope.
+     * @type {?Scope} Reference to the parent scope.
      */
     this.$parent = null;
 
     /**
-     * @type {?angular.IScope}
+     * @type {?angular.Scope}
      */
     this.$root = this;
 
-    this.$$watchers = null;
+    /**
+     * @type {[]}
+     */
+    this.$$watchers = [];
+
+    /**
+     * @type {number}
+     */
+    this.$$digestWatchIndex = -1;
+
+    /**
+     * @type {?Scope}
+     */
     this.$$nextSibling = null;
+
+    /**
+     * @type {?Scope}
+     */
     this.$$prevSibling = null;
+
+    /**
+     * @type {?Scope}
+     */
     this.$$childHead = null;
+
+    /**
+     * @type {?Scope}
+     */
     this.$$childTail = null;
+
+    /** @type {boolean} */
     this.$$destroyed = false;
+
+    // TODO use maps
+    /** @type {boolean} */
     this.$$suspended = false;
+
+    // TODO use maps
+    /** @type {object} */
     this.$$listeners = {};
+
+    /** @type {object} */
     this.$$listenerCount = {};
+
+    /** @type {number} */
     this.$$watchersCount = 0;
     this.$$isolateBindings = null;
 
     /**
-     * @type {Scope}
+     * @type {?Scope}
      */
     this.$$ChildScope = null;
   }
 
   /**
-   * @description
    * Creates a new child {@link Scope}.
    *
    * The parent scope will propagate the {@link ng.$rootScope.Scope#$digest $digest()} event.
@@ -179,24 +215,25 @@ class Scope {
    *         When creating widgets, it is useful for the widget to not accidentally read parent
    *         state.
    *
-   * @param {?angular.IScope} [parent=this] The {@link ng.$rootScope.Scope `Scope`} that will be the `$parent`
+   * @param {?Scope} [parent=this] The {@link ng.$rootScope.Scope `Scope`} that will be the `$parent`
    *                              of the newly created scope. Defaults to `this` scope if not provided.
    *                              This is used when creating a transclude scope to correctly place it
    *                              in the scope hierarchy while maintaining the correct prototypical
    *                              inheritance.
    *
-   * @returns {angular.IScope} The newly created child scope.
+   * @returns {Scope} The newly created child scope.
    *
    */
   $new(isolate, parent) {
+    /** @type {Scope} */
     let child;
     if (isolate) {
       child = new Scope();
-      child.$root = this.$root;
+      child.$root = rootScope;
     } else {
       child = Object.create(this);
       child.$id = nextUid();
-      child.$$watchers = null;
+      child.$$watchers = [];
       child.$$nextSibling = null;
       child.$$childHead = null;
       child.$$childTail = null;
@@ -206,6 +243,7 @@ class Scope {
       child.$$ChildScope = null;
       child.$$suspended = false;
     }
+
     child.$parent = parent || this;
     child.$$prevSibling = child.$parent.$$childTail;
     if (child.$parent.$$childHead) {
@@ -222,9 +260,13 @@ class Scope {
     // when the parent scope is destroyed.
     // The listener needs to be added after the parent is set
     if (isolate || parent !== this) {
-      child.$on("$destroy", ($event) => {
-        $event.currentScope.$$destroyed = true;
-      });
+      child.$on(
+        "$destroy",
+        /** @param {angular.IAngularEvent} $event */
+        ($event) => {
+          $event.currentScope.$$destroyed = true;
+        },
+      );
     }
     return child;
   }
@@ -329,13 +371,13 @@ class Scope {
  *
  *
  *
- * @param {(function()|string)} watchExpression Expression that is evaluated on each
+ * @param {string | ((scope: Scope) => any)} watchExp Expression that is evaluated on each
  *    {@link ng.$rootScope.Scope#$digest $digest} cycle. A change in the return value triggers
  *    a call to the `listener`.
  *
  *    - `string`: Evaluated as {@link guide/expression expression}
  *    - `function(scope)`: called with current `scope` as a parameter.
- * @param {function(newVal, oldVal, scope)} listener Callback called whenever the value
+ * @param {(newVal: any, oldVal: any, scope: angular.Scope) => any} listener Callback called whenever the value
  *    of `watchExpression` changes.
  *
  *    - `newVal` contains the current value of the `watchExpression`
@@ -352,8 +394,7 @@ class Scope {
     if (get.$$watchDelegate) {
       return get.$$watchDelegate(this, fn, objectEquality, get, watchExp);
     }
-    const scope = this;
-    let array = scope.$$watchers;
+
     const watcher = {
       fn,
       last: initWatchVal,
@@ -364,23 +405,21 @@ class Scope {
 
     lastDirtyWatch = null;
 
-    if (!array) {
-      array = scope.$$watchers = [];
-      array.$$digestWatchIndex = -1;
+    if (this.$$watchers.length == 0) {
+      this.$$digestWatchIndex = -1;
     }
     // we use unshift since we use a while loop in $digest for speed.
     // the while loop reads in reverse order.
-    array.unshift(watcher);
-    array.$$digestWatchIndex++;
+    this.$$watchers.unshift(watcher);
+    this.$$digestWatchIndex++;
     this.incrementWatchersCount(1);
-    const self = this;
 
-    return function deregisterWatch() {
-      const index = arrayRemove(array, watcher);
+    return () => {
+      const index = arrayRemove(this.$$watchers, watcher);
       if (index >= 0) {
-        self.incrementWatchersCount(-1);
-        if (index < array.$$digestWatchIndex) {
-          array.$$digestWatchIndex--;
+        this.incrementWatchersCount(-1);
+        if (index < this.$$digestWatchIndex) {
+          this.$$digestWatchIndex--;
         }
       }
       lastDirtyWatch = null;
@@ -715,7 +754,7 @@ class Scope {
     let ttl = TTL;
     let next;
     /**
-     * @type {angular.IScope}
+     * @type {Scope}
      */
     let current;
     const target = $$asyncQueue.length ? this.$root : this;
@@ -731,7 +770,7 @@ class Scope {
     if (this === this.$root && applyAsyncId !== null) {
       // If this is the root scope, and $applyAsync has scheduled a deferred $apply(), then
       // cancel the scheduled $apply and flush the queue of expressions to be evaluated.
-      $browser.defer.cancel(applyAsyncId);
+      $browser.cancel(applyAsyncId);
       flushApplyAsync();
       applyAsyncId = null;
     }
@@ -765,10 +804,10 @@ class Scope {
         // "traverse the scopes" loop
         if ((watchers = !current.$$suspended && current.$$watchers)) {
           // process our watches
-          watchers.$$digestWatchIndex = watchers.length;
-          while (watchers.$$digestWatchIndex--) {
+          current.$$digestWatchIndex = watchers.length;
+          while (current.$$digestWatchIndex--) {
             try {
-              watch = watchers[watchers.$$digestWatchIndex];
+              watch = watchers[current.$$digestWatchIndex];
               // Most common watches are on primitives, in which case we can short
               // circuit it with === operator, only when === fails do we use .equals
               if (watch) {
@@ -858,7 +897,7 @@ class Scope {
   }
 
   /**
-   *
+   * @private
    * @param {ScopePhase} phase
    */
   beginPhase(phase) {
@@ -971,7 +1010,7 @@ class Scope {
    * @description
    * Broadcasted when a scope and its children are being destroyed.
    *
-   * Note that, in AngularJS, there is also a `$destroy` jQuery event, which can be used to
+   * Note that, in AngularTS, there is also a `$destroy` jQuery event, which can be used to
    * clean up DOM bindings before an element is removed from the DOM.
    */
 
@@ -994,13 +1033,12 @@ class Scope {
    * Application code can register a `$destroy` event handler that will give it a chance to
    * perform any necessary cleanup.
    *
-   * Note that, in AngularJS, there is also a `$destroy` event, which can be used to
+   * Note that, in AngularTS, there is also a `$destroy` event, which can be used to
    * clean up DOM bindings before an element is removed from the DOM.
    */
   $destroy() {
     // We can't destroy a scope that has been already destroyed.
     if (this.$$destroyed) return;
-    const parent = this.$parent;
 
     this.$broadcast("$destroy");
     this.$$destroyed = true;
@@ -1017,10 +1055,12 @@ class Scope {
 
     // sever all the references to parent scopes (after this cleanup, the current scope should
     // not be retained by any of our references and should be eligible for garbage collection)
-    if (parent && parent.$$childHead === this)
-      parent.$$childHead = this.$$nextSibling;
-    if (parent && parent.$$childTail === this)
-      parent.$$childTail = this.$$prevSibling;
+    if (this.$parent) {
+      if (this.$parent.$$childHead === this)
+        this.$parent.$$childHead = this.$$nextSibling;
+      if (this.$parent.$$childTail === this)
+        this.$parent.$$childTail = this.$$prevSibling;
+    }
     if (this.$$prevSibling)
       this.$$prevSibling.$$nextSibling = this.$$nextSibling;
     if (this.$$nextSibling)
@@ -1059,12 +1099,12 @@ class Scope {
  *
  * @description
  * Executes the `expression` on the current scope and returns the result. Any exceptions in
- * the expression are propagated (uncaught). This is useful when evaluating AngularJS
+ * the expression are propagated (uncaught). This is useful when evaluating AngularTS
  * expressions.
  *
  * @example
  * ```js
-     let scope = ng.$rootScope.Scope();
+     let scope = new Scope();
      scope.a = 1;
      scope.b = 2;
 
@@ -1072,7 +1112,7 @@ class Scope {
      expect(scope.$eval(function(scope){ return scope.a + scope.b; })).toEqual(3);
  * ```
  *
- * @param {(string|function())=} expr An AngularJS expression to be executed.
+ * @param {string|function(Scope): any} [expr] An AngularTS expression to be executed.
  *
  *    - `string`: execute using the rules as defined in  {@link guide/expression expression}.
  *    - `function(scope)`: execute the function with the current `scope` parameter.
@@ -1107,7 +1147,7 @@ class Scope {
    * will be scheduled. However, it is encouraged to always call code that changes the model
    * from within an `$apply` call. That includes code evaluated via `$evalAsync`.
    *
-   * @param {(string|function())=} expr An AngularJS expression to be executed.
+   * @param {(string|function())=} expr An AngularTS expression to be executed.
    *
    *    - `string`: execute using the rules as defined in {@link guide/expression expression}.
    *    - `function(scope)`: execute the function with the current `scope` parameter.
@@ -1139,6 +1179,9 @@ class Scope {
     return id;
   }
 
+  /**
+   * @private
+   */
   $$postDigest(fn) {
     $$postDigestQueue.push(fn);
   }
@@ -1149,9 +1192,9 @@ class Scope {
  * @kind function
  *
  * @description
- * `$apply()` is used to execute an expression in AngularJS from outside of the AngularJS
+ * `$apply()` is used to execute an expression in AngularTS from outside of the AngularTS
  * framework. (For example from browser DOM events, setTimeout, XHR or third party libraries).
- * Because we are calling into the AngularJS framework we need to perform proper scope life
+ * Because we are calling into the AngularTS framework we need to perform proper scope life
  * cycle of {@link ng.$exceptionHandler exception handling},
  * {@link ng.$rootScope.Scope#$digest executing watches}.
  *
@@ -1180,7 +1223,7 @@ class Scope {
  *    expression was executed using the {@link ng.$rootScope.Scope#$digest $digest()} method.
  *
  *
- * @param {(string|function())=} expr An AngularJS expression to be executed.
+ * @param {string|function(Scope): any} [expr] An AngularTS expression to be executed.
  *
  *    - `string`: execute using the rules as defined in {@link guide/expression expression}.
  *    - `function(scope)`: execute the function with current `scope` parameter.
@@ -1224,7 +1267,7 @@ class Scope {
    * This can be used to queue up multiple expressions which need to be evaluated in the same
    * digest.
    *
-   * @param {(string|function())=} expr An AngularJS expression to be executed.
+   * @param {(string|function())=} expr An AngularTS expression to be executed.
    *
    *    - `string`: execute using the rules as defined in {@link guide/expression expression}.
    *    - `function(scope)`: execute the function with current `scope` parameter.
@@ -1261,7 +1304,7 @@ class Scope {
    *   - `defaultPrevented` - `{boolean}`: true if `preventDefault` was called.
    *
    * @param {string} name Event name to listen on.
-   * @param {function(event, ...args)} listener Function to call when the event is emitted.
+   * @param {function(angular.IAngularEvent): any} listener Function to call when the event is emitted.
    * @returns {function()} Returns a deregistration function for this listener.
    */
   $on(name, listener) {

package/{test/core → src/core/scope}/scope.spec.js

@@ -1,7 +1,7 @@
-import { getQueues } from "../../src/core/root-scope";
-import { extend, sliceArgs } from "../../src/shared/utils";
-import { publishExternalAPI } from "../../src/public";
-import { createInjector } from "../../src/injector";
+import { $$asyncQueue } from "../../core/root-scope";
+import { extend, sliceArgs } from "../../shared/utils";
+import { publishExternalAPI } from "../../public";
+import { createInjector } from "../../injector";
 
 describe("Scope", function () {
   let $rootScope;
@@ -2380,7 +2380,7 @@ describe("Scope", function () {
       $rootScope.$evalAsync("rootExpression");
       childScope.$evalAsync("childExpression");
       isolateScope.$evalAsync("isolateExpression");
-      expect(getQueues().asyncQueue).toEqual([
+      expect($$asyncQueue).toEqual([
         {
           scope: $rootScope,
           fn: $parse("rootExpression"),
@@ -2630,7 +2630,7 @@ describe("Scope", function () {
       const scope = $rootScope.$new();
       let id = scope.$applyAsync('x = "CODE ORANGE"');
 
-      $browser.defer.cancel(id);
+      $browser.cancel(id);
       setTimeout(() => {
         expect(scope.x).toBe("CODE ORANGE");
         expect($rootScope.x).toBeUndefined();
@@ -2644,8 +2644,8 @@ describe("Scope", function () {
       let id1 = $rootScope.$applyAsync('x.push("expr1")');
       let id2 = $rootScope.$applyAsync('x.push("expr2")');
 
-      $browser.defer.cancel(id1);
-      $browser.defer.cancel(id2);
+      $browser.cancel(id1);
+      $browser.cancel(id2);
       setTimeout(() => {
         expect($rootScope.x).toEqual(["expr1", "expr2"]);
       });
@@ -2660,7 +2660,7 @@ describe("Scope", function () {
         expect($browser.deferredFns.length).toBe(0);
       });
 
-      $browser.defer.cancel(id);
+      $browser.cancel(id);
       setTimeout(() => {
         expect($rootScope.x).toEqual(["expr1", "expr2"]);
       });
@@ -2672,7 +2672,7 @@ describe("Scope", function () {
         throw "OOPS";
       });
 
-      $browser.defer.cancel(id);
+      $browser.cancel(id);
       expect(logs).toEqual([]);
       setTimeout(() => expect(logs[0]).toEqual("OOPS"));
     });
@@ -2683,14 +2683,14 @@ describe("Scope", function () {
       });
       let id2 = $rootScope.$applyAsync('x = "All good!"');
 
-      $browser.defer.cancel(id);
-      $browser.defer.cancel(id2);
+      $browser.cancel(id);
+      $browser.cancel(id2);
       setTimeout(() => expect($rootScope.x).toBe("All good!"));
       expect($rootScope.x).toBeUndefined();
     });
 
     it("should be cancelled if a $rootScope digest occurs before the next tick", () => {
-      const cancel = spyOn($browser.defer, "cancel").and.callThrough();
+      const cancel = spyOn($browser, "cancel").and.callThrough();
       const expression = jasmine.createSpy("expr");
 
       $rootScope.$applyAsync(expression);

package/src/core/{timeout.js → timeout/timeout.js}

@@ -1,5 +1,5 @@
-import { markQExceptionHandled } from "./q";
-import { isDefined, isFunction, minErr, sliceArgs } from "../shared/utils";
+import { markQExceptionHandled } from "../q/q";
+import { isDefined, isFunction, minErr, sliceArgs } from "../../shared/utils";
 
 const $timeoutMinErr = minErr("$timeout");
 
@@ -103,7 +103,7 @@ export function $timeout($rootScope, $browser, $q, $$q, $exceptionHandler) {
     deferred.reject("canceled");
     delete deferreds[id];
 
-    return $browser.defer.cancel(id);
+    return $browser.cancel(id);
   };
 
   return timeout;

package/{test/core → src/core/timeout}/timeout.spec.js

@@ -1,5 +1,5 @@
-import { publishExternalAPI } from "../../src/public";
-import { createInjector } from "../../src/injector";
+import { publishExternalAPI } from "../../public";
+import { createInjector } from "../../injector";
 import { wait } from "../test-utils";
 
 describe("$timeout", () => {
@@ -325,7 +325,7 @@ describe("$timeout", () => {
     });
 
     it("should forget references to relevant deferred", () => {
-      // $browser.defer.cancel is only called on cancel if the deferred object is still referenced
+      // $browser.cancel is only called on cancel if the deferred object is still referenced
       const cancelSpy = spyOn($browser.defer, "cancel").and.callThrough();
 
       const promise = $timeout(() => {}, 0, false);

package/src/core/{urlUtils.js → url-utils/url-utils.js}

@@ -1,6 +1,6 @@
 /* eslint-disable no-use-before-define */
 
-import { isString } from "../shared/utils";
+import { isString } from "../../shared/utils";
 
 // service.
 const urlParsingNode = window.document.createElement("a");

package/{test/core → src/core/url-utils}/url-utils.spec.js

@@ -3,7 +3,7 @@ import {
   urlIsSameOrigin,
   urlIsSameOriginAsBaseUrl,
   urlIsAllowedOriginFactory,
-} from "../../src/core/urlUtils";
+} from "../../core/urlUtils";
 
 let $document = window.document;
 

package/src/directive/attrs/attrs.html

@@ -0,0 +1,18 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>AngularTS Test Runner</title>
+
+    <link rel="shortcut icon" type="image/png" href="/images/favicon.ico" />
+    <link rel="stylesheet" href="/jasmine/jasmine-5.1.2/jasmine.css" />
+    <script src="/jasmine/jasmine-5.1.2/jasmine.js"></script>
+    <script src="/jasmine/jasmine-5.1.2/jasmine-html.js"></script>
+    <script src="/jasmine/jasmine-5.1.2/boot0.js"></script>
+    <script src="/jasmine/jasmine-5.1.2/boot1.js"></script>
+    <script type="module" src="/src/directive/attrs/attrs.spec.js"></script>
+  </head>
+  <body>
+    <div id="dummy"></div>
+  </body>
+</html>

package/src/directive/{attrs.js → attrs/attrs.js}

@@ -1,6 +1,6 @@
-import { BOOLEAN_ATTR } from "../jqLite";
-import { forEach, directiveNormalize } from "../shared/utils";
-import { ALIASED_ATTR } from "../constants";
+import { BOOLEAN_ATTR } from "../../jqLite";
+import { forEach, directiveNormalize } from "../../shared/utils";
+import { ALIASED_ATTR } from "../../shared/constants";
 
 /**
  * @ngdoc directive

package/{test/directive/scrset.spec.js → src/directive/attrs/attrs.spec.js}

@@ -1,6 +1,6 @@
-import { publishExternalAPI } from "../../src/public";
-import { createInjector } from "../../src/injector";
-import { dealoc, jqLite } from "../../src/jqLite";
+import { publishExternalAPI } from "../../public";
+import { createInjector } from "../../injector";
+import { dealoc, jqLite } from "../../jqLite";
 
 describe("ngSrcset", () => {
   let $scope;

package/{test/directive → src/directive/attrs}/boolean.spec.js

@@ -1,6 +1,6 @@
-import { publishExternalAPI } from "../../src/public";
-import { createInjector } from "../../src/injector";
-import { dealoc, jqLite } from "../../src/jqLite";
+import { publishExternalAPI } from "../../public";
+import { createInjector } from "../../injector";
+import { dealoc, jqLite } from "../../jqLite";
 
 describe("boolean attr directives", () => {
   let element, $rootScope, $compile, $rootElement;

package/{test/directive → src/directive/attrs}/element-style.spec.js

@@ -1,6 +1,6 @@
-import { publishExternalAPI } from "../../src/public";
-import { createInjector } from "../../src/injector";
-import { dealoc, jqLite } from "../../src/jqLite";
+import { publishExternalAPI } from "../../public";
+import { createInjector } from "../../injector";
+import { dealoc, jqLite } from "../../jqLite";
 
 describe("style", () => {
   let $rootScope;

package/{test/directive → src/directive/attrs}/src.spec.js

@@ -1,6 +1,6 @@
-import { publishExternalAPI } from "../../src/public";
-import { createInjector } from "../../src/injector";
-import { dealoc, jqLite } from "../../src/jqLite";
+import { publishExternalAPI } from "../../public";
+import { createInjector } from "../../injector";
+import { dealoc, jqLite } from "../../jqLite";
 
 describe("ngSrc", () => {
   let $scope;

package/src/directive/attrs/srcset.test.js

@@ -0,0 +1,11 @@
+import { test, expect } from "@playwright/test";
+
+const TEST_URL = "src/directive/srcset/srcset.html";
+
+test("unit tests contain no errors", async ({ page }) => {
+  await page.goto(TEST_URL);
+  await page.content();
+  await expect(page.locator(".jasmine-overall-result")).toHaveText(
+    /0 failures/,
+  );
+});

package/src/directive/bind/bind.html

@@ -0,0 +1,18 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>AngularTS Test Runner</title>
+
+    <link rel="shortcut icon" type="image/png" href="/images/favicon.ico" />
+    <link rel="stylesheet" href="/jasmine/jasmine-5.1.2/jasmine.css" />
+    <script src="/jasmine/jasmine-5.1.2/jasmine.js"></script>
+    <script src="/jasmine/jasmine-5.1.2/jasmine-html.js"></script>
+    <script src="/jasmine/jasmine-5.1.2/boot0.js"></script>
+    <script src="/jasmine/jasmine-5.1.2/boot1.js"></script>
+    <script type="module" src="/src/directive/bind/bind.spec.js"></script>
+  </head>
+  <body>
+    <div id="dummy"></div>
+  </body>
+</html>

package/src/directive/{bind.js → bind/bind.js}

@@ -1,4 +1,4 @@
-import { isUndefined, stringify } from "../shared/utils";
+import { isUndefined, stringify } from "../../shared/utils";
 
 /**
  * @returns {angular.IDirective}

package/{test/directive → src/directive/bind}/bind.spec.js

@@ -1,6 +1,6 @@
-import { publishExternalAPI } from "../../src/public";
-import { createInjector } from "../../src/injector";
-import { dealoc, jqLite } from "../../src/jqLite";
+import { publishExternalAPI } from "../../public";
+import { createInjector } from "../../injector";
+import { dealoc, jqLite } from "../../jqLite";
 
 describe("ng-bind", () => {
   let $rootScope;

package/src/directive/bind/bind.test.js

@@ -0,0 +1,11 @@
+import { test, expect } from "@playwright/test";
+
+const TEST_URL = "src/directive/bind/bind.html";
+
+test("unit tests contain no errors", async ({ page }) => {
+  await page.goto(TEST_URL);
+  await page.content();
+  await expect(page.locator(".jasmine-overall-result")).toHaveText(
+    /0 failures/,
+  );
+});