@angular-wave/angular.ts 0.0.1

package/test/ng/controller-provider.spec.js

@@ -0,0 +1,227 @@
+import { publishExternalAPI } from "../../src/public";
+import { createInjector } from "../../src/injector";
+
+describe("$controller", () => {
+  let $controllerProvider;
+  let $controller;
+
+  beforeEach(() => {
+    publishExternalAPI();
+    createInjector([
+      "ng",
+      function (_$controllerProvider_) {
+        $controllerProvider = _$controllerProvider_;
+      },
+    ]).invoke((_$controller_) => {
+      $controller = _$controller_;
+    });
+  });
+
+  describe("provider", () => {
+    it("should allow registration of controllers", () => {
+      const FooCtrl = function ($scope) {
+        $scope.foo = "bar";
+      };
+      const scope = {};
+      let ctrl;
+
+      $controllerProvider.register("FooCtrl", FooCtrl);
+      ctrl = $controller("FooCtrl", { $scope: scope });
+
+      expect(scope.foo).toBe("bar");
+      expect(ctrl instanceof FooCtrl).toBe(true);
+    });
+
+    it("should allow registration of bound controller functions", () => {
+      const FooCtrl = function ($scope) {
+        $scope.foo = "bar";
+      };
+      const scope = {};
+      let ctrl;
+
+      const BoundFooCtrl = FooCtrl.bind(null);
+
+      $controllerProvider.register("FooCtrl", ["$scope", BoundFooCtrl]);
+      ctrl = $controller("FooCtrl", { $scope: scope });
+
+      expect(scope.foo).toBe("bar");
+    });
+
+    it("should allow registration of map of controllers", () => {
+      const FooCtrl = function ($scope) {
+        $scope.foo = "foo";
+      };
+      const BarCtrl = function ($scope) {
+        $scope.bar = "bar";
+      };
+      const scope = {};
+      let ctrl;
+
+      $controllerProvider.register({ FooCtrl, BarCtrl });
+
+      ctrl = $controller("FooCtrl", { $scope: scope });
+      expect(scope.foo).toBe("foo");
+      expect(ctrl instanceof FooCtrl).toBe(true);
+
+      ctrl = $controller("BarCtrl", { $scope: scope });
+      expect(scope.bar).toBe("bar");
+      expect(ctrl instanceof BarCtrl).toBe(true);
+    });
+
+    it("should allow registration of controllers annotated with arrays", () => {
+      const FooCtrl = function ($scope) {
+        $scope.foo = "bar";
+      };
+      const scope = {};
+      let ctrl;
+
+      $controllerProvider.register("FooCtrl", ["$scope", FooCtrl]);
+      ctrl = $controller("FooCtrl", { $scope: scope });
+
+      expect(scope.foo).toBe("bar");
+      expect(ctrl instanceof FooCtrl).toBe(true);
+    });
+
+    it('should throw an exception if a controller is called "hasOwnProperty"', () => {
+      expect(() => {
+        $controllerProvider.register("hasOwnProperty", ($scope) => {});
+      }).toThrowError(/badname/);
+    });
+
+    it("should allow checking the availability of a controller", () => {
+      $controllerProvider.register("FooCtrl", () => {});
+      $controllerProvider.register("BarCtrl", ["dep1", "dep2", () => {}]);
+      $controllerProvider.register({
+        BazCtrl: () => {},
+        QuxCtrl: ["dep1", "dep2", () => {}],
+      });
+
+      expect($controllerProvider.has("FooCtrl")).toBe(true);
+      expect($controllerProvider.has("BarCtrl")).toBe(true);
+      expect($controllerProvider.has("BazCtrl")).toBe(true);
+      expect($controllerProvider.has("QuxCtrl")).toBe(true);
+
+      expect($controllerProvider.has("UnknownCtrl")).toBe(false);
+    });
+
+    it("should throw ctrlfmt if name contains spaces", () => {
+      expect(() => {
+        $controller("ctrl doom");
+      }).toThrow();
+    });
+  });
+
+  it("should return instance of given controller class", () => {
+    const MyClass = function () {};
+    const ctrl = $controller(MyClass);
+
+    expect(ctrl).toBeDefined();
+    expect(ctrl instanceof MyClass).toBe(true);
+  });
+
+  it("should inject arguments", () => {
+    const MyClass = function ($http) {
+      this.$http = $http;
+    };
+
+    const ctrl = $controller(MyClass);
+    expect(ctrl.$http).toBeTruthy();
+  });
+
+  it("should inject given scope", () => {
+    const MyClass = function ($scope) {
+      this.$scope = $scope;
+    };
+
+    const scope = {};
+    const ctrl = $controller(MyClass, { $scope: scope });
+
+    expect(ctrl.$scope).toBe(scope);
+  });
+
+  it("should not instantiate a controller defined on window", () => {
+    const scope = {};
+    const Foo = function () {};
+
+    window.a = { Foo };
+
+    expect(() => {
+      $controller("a.Foo", { $scope: scope });
+    }).toThrow();
+  });
+
+  it("should throw ctrlreg when the controller name does not match a registered controller", () => {
+    expect(() => {
+      $controller("IDoNotExist", { $scope: {} });
+    }).toThrowError(/ctrlreg/);
+  });
+
+  describe("ctrl as syntax", () => {
+    it("should publish controller instance into scope", () => {
+      const scope = {};
+
+      $controllerProvider.register("FooCtrl", function () {
+        this.mark = "foo";
+      });
+
+      const foo = $controller("FooCtrl as foo", { $scope: scope });
+      expect(scope.foo).toBe(foo);
+      expect(scope.foo.mark).toBe("foo");
+    });
+
+    it("should allow controllers with dots", () => {
+      const scope = {};
+
+      $controllerProvider.register("a.b.FooCtrl", function () {
+        this.mark = "foo";
+      });
+
+      const foo = $controller("a.b.FooCtrl as foo", { $scope: scope });
+      expect(scope.foo).toBe(foo);
+      expect(scope.foo.mark).toBe("foo");
+    });
+
+    it("should throw an error if $scope is not provided", () => {
+      $controllerProvider.register("a.b.FooCtrl", function () {
+        this.mark = "foo";
+      });
+
+      expect(() => {
+        $controller("a.b.FooCtrl as foo");
+      }).toThrowError(/noscp/);
+    });
+
+    it("should throw ctrlfmt if identifier contains non-ident characters", () => {
+      expect(() => {
+        $controller("ctrl as foo<bar");
+      }).toThrowError(/ctrlfmt/);
+    });
+
+    it("should throw ctrlfmt if identifier contains spaces", () => {
+      expect(() => {
+        $controller("ctrl as foo bar");
+      }).toThrowError(/ctrlfmt/);
+    });
+
+    it('should throw ctrlfmt if identifier missing after " as "', () => {
+      expect(() => {
+        $controller("ctrl as ");
+      }).toThrowError(/ctrlfmt/);
+      expect(() => {
+        $controller("ctrl as");
+      }).toThrowError(/ctrlfmt/);
+    });
+
+    it("should allow identifiers containing `$`", () => {
+      const scope = {};
+
+      $controllerProvider.register("FooCtrl", function () {
+        this.mark = "foo";
+      });
+
+      const foo = $controller("FooCtrl as $foo", { $scope: scope });
+      expect(scope.$foo).toBe(foo);
+      expect(scope.$foo.mark).toBe("foo");
+    });
+  });
+});

package/test/ng/cookie-reader.spec.js

@@ -0,0 +1,98 @@
+import { publishExternalAPI } from "../../src/public";
+import { createInjector } from "../../src/injector";
+
+describe("$$cookieReader", () => {
+  let $$cookieReader;
+  let document;
+
+  describe("with access to `document.cookie`", () => {
+    function deleteAllCookies() {
+      const cookies = document.cookie.split(";");
+      const path = window.location.pathname;
+
+      for (let i = 0; i < cookies.length; i++) {
+        const cookie = cookies[i];
+        const eqPos = cookie.indexOf("=");
+        const name = eqPos > -1 ? cookie.substr(0, eqPos) : cookie;
+        const parts = path.split("/");
+        while (parts.length) {
+          document.cookie = `${name}=;path=${parts.join("/") || "/"};expires=Thu, 01 Jan 1970 00:00:00 GMT`;
+          parts.pop();
+        }
+      }
+    }
+
+    beforeEach(() => {
+      document = window.document;
+      deleteAllCookies();
+      expect(document.cookie).toEqual("");
+
+      publishExternalAPI();
+      var injector = createInjector(["ng"]);
+      $$cookieReader = injector.get("$$cookieReader");
+    });
+
+    afterEach(() => {
+      deleteAllCookies();
+      expect(document.cookie).toEqual("");
+    });
+
+    describe("get via $$cookieReader()[cookieName]", () => {
+      it("should return undefined for nonexistent cookie", () => {
+        expect($$cookieReader().nonexistent).not.toBeDefined();
+      });
+
+      it("should return a value for an existing cookie", () => {
+        document.cookie = "foo=bar=baz;path=/";
+        expect($$cookieReader().foo).toEqual("bar=baz");
+      });
+
+      it("should return the the first value provided for a cookie", () => {
+        // For a cookie that has different values that differ by path, the
+        // value for the most specific path appears first.  $$cookieReader()
+        // should provide that value for the cookie.
+        document.cookie = 'foo="first"; foo="second"';
+        expect($$cookieReader().foo).toBe('"first"');
+      });
+
+      it("should decode cookie values that were encoded by puts", () => {
+        document.cookie = "cookie2%3Dbar%3Bbaz=val%3Due;path=/";
+        expect($$cookieReader()["cookie2=bar;baz"]).toEqual("val=ue");
+      });
+
+      it("should preserve leading & trailing spaces in names and values", () => {
+        document.cookie = "%20cookie%20name%20=%20cookie%20value%20";
+        expect($$cookieReader()[" cookie name "]).toEqual(" cookie value ");
+        expect($$cookieReader()["cookie name"]).not.toBeDefined();
+      });
+
+      it("should decode special characters in cookie values", () => {
+        document.cookie = "cookie_name=cookie_value_%E2%82%AC";
+        expect($$cookieReader().cookie_name).toEqual("cookie_value_€");
+      });
+
+      it("should not decode cookie values that do not appear to be encoded", () => {
+        // see #9211 - sometimes cookies contain a value that causes decodeURIComponent to throw
+        document.cookie = "cookie_name=cookie_value_%XX";
+        expect($$cookieReader().cookie_name).toEqual("cookie_value_%XX");
+      });
+    });
+
+    describe("getAll via $$cookieReader()", () => {
+      it("should return cookies as hash", () => {
+        document.cookie = "foo1=bar1;path=/";
+        document.cookie = "foo2=bar2;path=/";
+        expect($$cookieReader()).toEqual({ foo1: "bar1", foo2: "bar2" });
+      });
+
+      it("should return empty hash if no cookies exist", () => {
+        expect($$cookieReader()).toEqual({});
+      });
+    });
+
+    it("should initialize cookie cache with existing cookies", () => {
+      document.cookie = "existingCookie=existingValue;path=/";
+      expect($$cookieReader()).toEqual({ existingCookie: "existingValue" });
+    });
+  });
+});

package/test/ng/directive/a.spec.js

@@ -0,0 +1,192 @@
+import { publishExternalAPI } from "../../../src/public";
+import { createInjector } from "../../../src/injector";
+import { dealoc, jqLite } from "../../../src/jqLite";
+import { valueFn, isDefined } from "../../../src/core/utils";
+
+describe("a", () => {
+  let element;
+  let $compile;
+  let $rootScope;
+
+  beforeEach(() => {
+    publishExternalAPI();
+    createInjector([
+      "ng",
+      function ($compileProvider) {
+        $compileProvider
+          .directive(
+            "linkTo",
+            valueFn({
+              restrict: "A",
+              template:
+                '<div class="my-link"><a href="{{destination}}">{{destination}}</a></div>',
+              replace: true,
+              scope: {
+                destination: "@linkTo",
+              },
+            }),
+          )
+          .directive(
+            "linkNot",
+            valueFn({
+              restrict: "A",
+              template:
+                '<div class="my-link"><a href>{{destination}}</a></div>',
+              replace: true,
+              scope: {
+                destination: "@linkNot",
+              },
+            }),
+          );
+      },
+    ]).invoke((_$compile_, _$rootScope_) => {
+      $compile = _$compile_;
+      $rootScope = _$rootScope_;
+    });
+  });
+
+  afterEach(() => {
+    dealoc(element);
+  });
+
+  it("should prevent default action to be executed when href is empty", () => {
+    const orgLocation = window.document.location.href;
+    let preventDefaultCalled = false;
+    let event;
+
+    element = $compile('<a href="">empty link</a>')($rootScope);
+
+    event = window.document.createEvent("MouseEvent");
+    event.initMouseEvent(
+      "click",
+      true,
+      true,
+      window,
+      0,
+      0,
+      0,
+      0,
+      0,
+      false,
+      false,
+      false,
+      false,
+      0,
+      null,
+    );
+
+    event.preventDefaultOrg = event.preventDefault;
+    event.preventDefault = function () {
+      preventDefaultCalled = true;
+      if (this.preventDefaultOrg) this.preventDefaultOrg();
+    };
+
+    element[0].dispatchEvent(event);
+
+    expect(preventDefaultCalled).toEqual(true);
+
+    expect(window.document.location.href).toEqual(orgLocation);
+  });
+
+  it("should not link and hookup an event if href is present at compile", () => {
+    const jq = jqLite;
+    element = jq('<a href="//a.com">hello@you</a>');
+    const linker = $compile(element);
+
+    spyOn(jq.prototype, "on");
+
+    linker($rootScope);
+
+    expect(jq.prototype.on).not.toHaveBeenCalled();
+  });
+
+  it("should not preventDefault if anchor element is replaced with href-containing element", () => {
+    spyOn(jqLite.prototype, "on").and.callThrough();
+    element = $compile('<a link-to="https://www.google.com">')($rootScope);
+    $rootScope.$digest();
+
+    const child = element.children("a");
+    const preventDefault = jasmine.createSpy("preventDefault");
+
+    child.triggerHandler({
+      type: "click",
+      preventDefault,
+    });
+
+    expect(preventDefault).not.toHaveBeenCalled();
+  });
+
+  it("should preventDefault if anchor element is replaced with element without href attribute", () => {
+    spyOn(jqLite.prototype, "on").and.callThrough();
+    element = $compile('<a link-not="https://www.google.com">')($rootScope);
+    $rootScope.$digest();
+
+    const child = element.children("a");
+    const preventDefault = jasmine.createSpy("preventDefault");
+
+    child.triggerHandler({
+      type: "click",
+      preventDefault,
+    });
+
+    expect(preventDefault).toHaveBeenCalled();
+  });
+
+  if (isDefined(window.SVGElement)) {
+    describe("SVGAElement", () => {
+      it("should prevent default action to be executed when href is empty", () => {
+        const orgLocation = window.document.location.href;
+        let preventDefaultCalled = false;
+        let event;
+        let child;
+
+        element = $compile('<svg><a xlink:href="">empty link</a></svg>')(
+          $rootScope,
+        );
+        child = element.children("a");
+
+        event = window.document.createEvent("MouseEvent");
+        event.initMouseEvent(
+          "click",
+          true,
+          true,
+          window,
+          0,
+          0,
+          0,
+          0,
+          0,
+          false,
+          false,
+          false,
+          false,
+          0,
+          null,
+        );
+
+        event.preventDefaultOrg = event.preventDefault;
+        event.preventDefault = function () {
+          preventDefaultCalled = true;
+          if (this.preventDefaultOrg) this.preventDefaultOrg();
+        };
+
+        child[0].dispatchEvent(event);
+
+        expect(preventDefaultCalled).toEqual(true);
+        expect(window.document.location.href).toEqual(orgLocation);
+      });
+
+      it("should not link and hookup an event if xlink:href is present at compile", () => {
+        const jq = jqLite;
+        element = jq('<svg><a xlink:href="bobby">hello@you</a></svg>');
+        const linker = $compile(element);
+
+        spyOn(jq.prototype, "on");
+
+        linker($rootScope);
+
+        expect(jq.prototype.on).not.toHaveBeenCalled();
+      });
+    });
+  }
+});