@angular-wave/angular.ts 0.0.1

package/test/ng/url-utils.spec.js

@@ -0,0 +1,156 @@
+import {
+  urlResolve,
+  urlIsSameOrigin,
+  urlIsSameOriginAsBaseUrl,
+  urlIsAllowedOriginFactory,
+} from "../../src/core/urlUtils";
+
+let $document = window.document;
+
+describe("urlUtils", () => {
+  describe("urlResolve", () => {
+    it("should returned already parsed URLs unchanged", () => {
+      const urlObj = urlResolve("/foo?bar=baz#qux");
+      expect(urlResolve(urlObj)).toBe(urlObj);
+      expect(urlResolve(true)).toBe(true);
+      expect(urlResolve(null)).toBeNull();
+      expect(urlResolve(undefined)).toBeUndefined();
+    });
+
+    it("should normalize a relative url", () => {
+      expect(urlResolve("foo").href).toMatch(/^https?:\/\/[^/]+\/foo$/);
+    });
+
+    it("should parse relative URL into component pieces", () => {
+      const parsed = urlResolve("foo");
+      expect(parsed.href).toMatch(/https?:\/\//);
+      expect(parsed.protocol).toMatch(/^https?/);
+      expect(parsed.host).not.toBe("");
+      expect(parsed.hostname).not.toBe("");
+      expect(parsed.pathname).not.toBe("");
+    });
+
+    it("should return pathname as / if empty path provided", () => {
+      // IE (all versions) counts / as empty, necessary to use / so that pathname is not context.html
+      const parsed = urlResolve("/");
+      expect(parsed.pathname).toBe("/");
+    });
+
+    it("should return an IPv6 hostname wrapped in brackets", () => {
+      // Support: IE 9-11 only, Edge 16-17 only (fixed in 18 Preview)
+      // IE/Edge don't wrap IPv6 addresses' hostnames in square brackets
+      // when parsed out of an anchor element.
+      const parsed = urlResolve("http://[::1]/");
+      expect(parsed.hostname).toBe("[::1]");
+    });
+
+    it("should not put the domain in brackets for the hostname field", () => {
+      const parsed = urlResolve("https://google.com/");
+      expect(parsed.hostname).toBe("google.com");
+    });
+  });
+
+  describe("urlIsSameOrigin and urlIsSameOriginAsBaseUrl", () => {
+    it("should support various combinations of urls - both string and parsed", () => {
+      function expectIsSameOrigin(url, expectedValue) {
+        expect(urlIsSameOrigin(url)).toBe(expectedValue);
+        expect(urlIsSameOrigin(urlResolve(url))).toBe(expectedValue);
+
+        // urlIsSameOriginAsBaseUrl() should behave the same as urlIsSameOrigin() by default.
+        // Behavior when there is a non-default base URL or when the base URL changes dynamically
+        // is tested in the end-to-end tests in e2e/tests/base-tag.spec.js.
+        expect(urlIsSameOriginAsBaseUrl(url)).toBe(expectedValue);
+        expect(urlIsSameOriginAsBaseUrl(urlResolve(url))).toBe(expectedValue);
+      }
+
+      expectIsSameOrigin("path", true);
+
+      const origin = urlResolve($document.location.href);
+      expectIsSameOrigin(`//${origin.host}/path`, true);
+
+      // Different domain.
+      expectIsSameOrigin("http://example.com/path", false);
+
+      // Auto fill protocol.
+      expectIsSameOrigin("//example.com/path", false);
+
+      // Should not match when the ports are different.
+      // This assumes that the test is *not* running on port 22 (very unlikely).
+      expectIsSameOrigin(`//${origin.hostname}:22/path`, false);
+    });
+  });
+
+  describe("urlIsAllowedOriginFactory", () => {
+    const origin = urlResolve(window.location.href);
+    let urlIsAllowedOrigin;
+
+    beforeEach(() => {
+      urlIsAllowedOrigin = urlIsAllowedOriginFactory([
+        "https://foo.com/",
+        `${origin.protocol}://bar.com:1337/`,
+      ]);
+    });
+
+    it("should implicitly allow the current origin", () => {
+      expect(urlIsAllowedOrigin("path")).toBe(true);
+    });
+
+    it("should check against the list of trusted origins", () => {
+      expect(urlIsAllowedOrigin("https://foo.com/path")).toBe(true);
+      expect(urlIsAllowedOrigin(`${origin.protocol}://bar.com:1337/path`)).toBe(
+        true,
+      );
+      expect(urlIsAllowedOrigin("https://baz.com:1337/path")).toBe(false);
+      expect(urlIsAllowedOrigin("https://qux.com/path")).toBe(false);
+    });
+
+    it("should support both strings and parsed URL objects", () => {
+      expect(urlIsAllowedOrigin("path")).toBe(true);
+      expect(urlIsAllowedOrigin(urlResolve("path"))).toBe(true);
+      expect(urlIsAllowedOrigin("https://foo.com/path")).toBe(true);
+      expect(urlIsAllowedOrigin(urlResolve("https://foo.com/path"))).toBe(true);
+    });
+
+    it("should return true only if the origins (protocol, hostname, post) match", () => {
+      const differentProtocol = origin.protocol !== "http" ? "http" : "https";
+      const differentPort = (parseInt(origin.port, 10) || 0) + 1;
+      let url;
+
+      // Relative path
+      url = "path";
+      expect(urlIsAllowedOrigin(url)).toBe(true);
+
+      // Same origin
+      url = `${origin.protocol}://${origin.host}/path`;
+      expect(urlIsAllowedOrigin(url)).toBe(true);
+
+      // Same origin - implicit protocol
+      url = `//${origin.host}/path`;
+      expect(urlIsAllowedOrigin(url)).toBe(true);
+
+      // Same origin - different protocol
+      url = `${differentProtocol}://${origin.host}/path`;
+      expect(urlIsAllowedOrigin(url)).toBe(false);
+
+      // Same origin - different port
+      url = `${origin.protocol}://${origin.hostname}:${differentPort}/path`;
+      expect(urlIsAllowedOrigin(url)).toBe(false);
+
+      // Allowed origin
+      url = `${origin.protocol}://bar.com:1337/path`;
+      expect(urlIsAllowedOrigin(url)).toBe(true);
+
+      // Allowed origin - implicit protocol
+      url = "//bar.com:1337/path";
+      expect(urlIsAllowedOrigin(url)).toBe(true);
+
+      // Allowed origin - different protocol
+      url = `${differentProtocol}://bar.com:1337/path`;
+      expect(urlIsAllowedOrigin(url)).toBe(false);
+
+      // Allowed origin - different port
+      url = `${origin.protocol}://bar.com:1338/path`;
+      expect(urlIsAllowedOrigin(url)).toBe(false);
+    });
+  });
+});

package/test/ng/utils.spec.js

@@ -0,0 +1,144 @@
+import { hashKey } from "../../src/core/utils";
+
+describe("api", () => {
+  describe("hashKey()", () => {
+    it("should use an existing `$$hashKey`", () => {
+      const obj = { $$hashKey: "foo" };
+      expect(hashKey(obj)).toBe("foo");
+    });
+
+    it("should support a function as `$$hashKey` (and call it)", () => {
+      const obj = { $$hashKey: () => "foo" };
+      expect(hashKey(obj)).toBe("foo");
+    });
+
+    it("should create a new `$$hashKey` if none exists (and return it)", () => {
+      const obj = {};
+      expect(hashKey(obj)).toBe(obj.$$hashKey);
+      expect(obj.$$hashKey).toBeDefined();
+    });
+
+    it("should create appropriate `$$hashKey`s for primitive values", () => {
+      expect(hashKey(undefined)).toBe(hashKey(undefined));
+      expect(hashKey(null)).toBe(hashKey(null));
+      expect(hashKey(null)).not.toBe(hashKey(undefined));
+      expect(hashKey(true)).toBe(hashKey(true));
+      expect(hashKey(false)).toBe(hashKey(false));
+      expect(hashKey(false)).not.toBe(hashKey(true));
+      expect(hashKey(42)).toBe(hashKey(42));
+      expect(hashKey(1337)).toBe(hashKey(1337));
+      expect(hashKey(1337)).not.toBe(hashKey(42));
+      expect(hashKey("foo")).toBe(hashKey("foo"));
+      expect(hashKey("foo")).not.toBe(hashKey("bar"));
+    });
+
+    it("should create appropriate `$$hashKey`s for non-primitive values", () => {
+      const fn = function () {};
+      const arr = [];
+      const obj = {};
+      const date = new Date();
+
+      expect(hashKey(fn)).toBe(hashKey(fn));
+      expect(hashKey(fn)).not.toBe(hashKey(() => {}));
+      expect(hashKey(arr)).toBe(hashKey(arr));
+      expect(hashKey(arr)).not.toBe(hashKey([]));
+      expect(hashKey(obj)).toBe(hashKey(obj));
+      expect(hashKey(obj)).not.toBe(hashKey({}));
+      expect(hashKey(date)).toBe(hashKey(date));
+      expect(hashKey(date)).not.toBe(hashKey(new Date()));
+    });
+
+    it("is undefined:undefined for undefined", () => {
+      expect(hashKey(undefined)).toEqual("undefined:undefined");
+    });
+
+    it("is object:null for null", () => {
+      expect(hashKey(null)).toEqual("object:null");
+    });
+
+    it("is boolean:true for true", () => {
+      expect(hashKey(true)).toEqual("boolean:true");
+    });
+    it("is boolean:false for false", () => {
+      expect(hashKey(false)).toEqual("boolean:false");
+    });
+
+    it("is number:42 for 42", () => {
+      expect(hashKey(42)).toEqual("number:42");
+    });
+
+    it('is string:42 for "42"', () => {
+      expect(hashKey("42")).toEqual("string:42");
+    });
+
+    it("is object:[unique id] for objects", () => {
+      expect(hashKey({})).toMatch(/^object:\S+$/);
+    });
+
+    it("is the same key when asked for the same object many times", () => {
+      const obj = {};
+      expect(hashKey(obj)).toEqual(hashKey(obj));
+    });
+
+    it("does not change when object value changes", () => {
+      const obj = { a: 42 };
+      const hash1 = hashKey(obj);
+      obj.a = 43;
+      const hash2 = hashKey(obj);
+      expect(hash1).toEqual(hash2);
+    });
+
+    it("is not the same for different objects even with the same value", () => {
+      const obj1 = { a: 42 };
+      const obj2 = { a: 42 };
+      expect(hashKey(obj1)).not.toEqual(hashKey(obj2));
+    });
+
+    it("is function:[unique id] for functions", () => {
+      const fn = function (a) {
+        return a;
+      };
+      expect(hashKey(fn)).toMatch(/^function:\S+$/);
+    });
+
+    it("is the same key when asked for the same function many times", () => {
+      const fn = () => {};
+      expect(hashKey(fn)).toEqual(hashKey(fn));
+    });
+
+    it("is not the same for different identical functions", () => {
+      const fn1 = () => {
+        return 42;
+      };
+      const fn2 = () => {
+        return 42;
+      };
+      expect(hashKey(fn1)).not.toEqual(hashKey(fn2));
+    });
+
+    it("stores the hash key in the $$hashKey attribute", () => {
+      const obj = { a: 42 };
+      const hash = hashKey(obj);
+      expect(obj.$$hashKey).toEqual(hash.match(/^object:(\S+)$/)[0]);
+    });
+
+    it("uses preassigned $$hashKey", () => {
+      expect(hashKey({ $$hashKey: 42 })).toEqual(42);
+    });
+
+    it("supports a function $$hashKey", function () {
+      expect(hashKey({ $$hashKey: () => 42 })).toEqual(42);
+    });
+
+    it("calls the function $$hashKey as a method with the correct this", () => {
+      expect(
+        hashKey({
+          myKey: 42,
+          $$hashKey: function () {
+            return this.myKey;
+          },
+        }),
+      ).toEqual(42);
+    });
+  });
+});

package/test/original-test.html

@@ -0,0 +1,21 @@
+<!doctype html>
+<html>
+  <head>
+    <script src="../dist/build/angular.js"></script>
+  </head>
+  <body>
+    Test:
+    <my-component></my-component>
+    {{ 2 + 2 }}
+  </body>
+
+  <script>
+    document.addEventListener("DOMContentLoaded", () => {
+      window.angular.module("myModule", []).component("myComponent", {
+        template: "<div>ME</div>",
+      });
+      window.angular.bootstrap(document, ["myModule"]);
+      //angularInit(document, window.angular.bootstrap);
+    });
+  </script>
+</html>

package/test/public.spec.js

@@ -0,0 +1,34 @@
+import { publishExternalAPI } from "../src/public";
+import { createInjector } from "../src/injector";
+
+describe("public", () => {
+  beforeEach(() => {
+    publishExternalAPI();
+  });
+
+  it("sets up the angular object and the module loader", () => {
+    expect(window.angular).toBeDefined();
+    expect(window.angular.module).toBeDefined();
+  });
+
+  it("sets up the ng module", () => {
+    expect(createInjector(["ng"])).toBeDefined();
+  });
+
+  it("sets up the $filter service", () => {
+    const injector = createInjector(["ng"]);
+    expect(injector.has("$filter")).toBe(true);
+  });
+
+  it("sets up the $parse service", () => {
+    publishExternalAPI();
+    const injector = createInjector(["ng"]);
+    expect(injector.has("$parse")).toBe(true);
+  });
+
+  it("sets up the $rootScope", () => {
+    publishExternalAPI();
+    const injector = createInjector(["ng"]);
+    expect(injector.has("$rootScope")).toBe(true);
+  });
+});

package/test/sanitize/bing-html.spec.js

@@ -0,0 +1,36 @@
+import { createInjector } from "../../src/injector";
+import { forEach } from "../../src/core/utils";
+import { publishExternalAPI } from "../../src/public";
+
+describe("ngBindHtml", () => {
+  let $rootScope, $compile;
+
+  beforeEach(() => {
+    publishExternalAPI();
+    createInjector(["ng"]).invoke((_$rootScope_, _$compile_) => {
+      $rootScope = _$rootScope_;
+      $compile = _$compile_;
+    });
+  });
+
+  it("should set html", () => {
+    const element = $compile('<div ng-bind-html="html"></div>')($rootScope);
+    $rootScope.html = "<div>hello</div>";
+    $rootScope.$digest();
+    expect(element.html()).toEqual("<div>hello</div>");
+  });
+
+  it("should reset html when value is null or undefined", () => {
+    const element = $compile('<div ng-bind-html="html"></div>')($rootScope);
+
+    forEach([null, undefined, ""], (val) => {
+      $rootScope.html = "some val";
+      $rootScope.$digest();
+      expect(element.html()).toEqual("some val");
+
+      $rootScope.html = val;
+      $rootScope.$digest();
+      expect(element.html()).toEqual("");
+    });
+  });
+});

package/test/server/express.js

@@ -0,0 +1,158 @@
+import express from "express";
+const app = express();
+const port = 3000;
+
+app.use("/post", express.json());
+app.use("/nocontent", express.json());
+app.use((req, res, next) => {
+  res.header("Access-Control-Allow-Origin", "*"); // Change * to your desired origin if needed
+  res.header(
+    "Access-Control-Allow-Headers",
+    "Origin, X-Requested-With, Content-Type, Accept, Authorization",
+  );
+  // Additional headers you may need to allow
+
+  // Set the allowed methods
+  if (req.method === "OPTIONS") {
+    res.header("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE");
+    return res.status(200).json({});
+  }
+
+  next();
+});
+
+app.post("/post", (req, res) => {
+  console.log(req.body);
+  res.json(req.body);
+});
+
+app.post("/invalidarray", (req, res) => {
+  res.json("{1, 2, 3]");
+});
+
+app.post("/nocontent", (req, res) => {
+  console.log(req.body);
+  res.removeHeader("Content-type");
+  res.json(req.body);
+});
+
+app.post("/form", (req, res) => {
+  res.send(req.body);
+});
+
+app.post("/blob", (req, res) => {
+  res.send(req.body);
+});
+
+app.head("/head", (req, res) => {
+  res.send(req.body);
+});
+
+app.delete("/delete", (req, res) => {
+  res.send(req.body);
+});
+
+app.put("/put", (req, res) => {
+  res.json("Hello");
+});
+
+app.patch("/patch", (req, res) => {
+  res.json("Hello");
+});
+
+app.post("/hello", (req, res) => {
+  res.json("Hello");
+});
+
+app.get("/interpolation", (req, res) => {
+  res.send("{{expr}}");
+});
+
+app.get("/jsoninterpolation", (req, res) => {
+  res.json("{{expr}}");
+});
+
+app.get("/scopeinit", (req, res) => {
+  res.send('<div ng-init="name=1"></div>');
+});
+
+app.get("/directive", (req, res) => {
+  res.send("<div><div test></div></div>");
+});
+
+app.get("/empty", (req, res) => {
+  res.send(" ");
+});
+
+app.get("/hello", (req, res) => {
+  res.send("Hello");
+});
+
+app.get("/div", (req, res) => {
+  res.send("<div>Hello</div>");
+});
+
+app.get("/divexpr", (req, res) => {
+  res.send("<div>{{expr}}</div>");
+});
+
+app.get("/divctrlexpr", (req, res) => {
+  res.send("<div>{{$ctrl.expr}}</div>");
+});
+
+app.get("/template.html", (req, res) => {
+  res.send("<p>template.html</p>");
+});
+
+app.get("/circle-svg", (req, res) => {
+  res.send("<circle></circle>");
+});
+
+app.get("/hello2", (req, res) => {
+  res.send("Hello2");
+});
+
+app.get("/third", (req, res) => {
+  res.send("<div third>{{1+2}}</div>");
+});
+
+app.get("/script", (req, res) => {
+  res.send("<div><script>window.SCRIPT_RAN = true;</script></div>");
+});
+
+app.get("/401", (req, res) => {
+  res.sendStatus(401);
+});
+
+app.get("/404", (req, res) => {
+  res.sendStatus(404);
+});
+
+app.get("/never", (req, res) => {
+  setTimeout(() => {}, 500);
+});
+
+app.get("/my-rect.html", (req, res) => {
+  res.send("<g ng-include=\"'/mock/include.svg'\"></g>");
+});
+
+app.get("/my-rect2.html", (req, res) => {
+  res.send("<g ng-include=\"'/mock/include.svg'\"><a></a></g>");
+});
+
+app.get("/include.svg", (req, res) => {
+  res.send("<rect></rect><rect></rect>");
+});
+
+app.get("/", (req, res) => {
+  res.send("Hello");
+});
+
+app.listen(port, () => {
+  console.log(`Example app listening on port ${port}`);
+});
+
+// messageSpec.js
+app.get("/my-messages", (req, res) => {
+  res.send('<div ng-message="required">You did not enter a value</div>');
+});

package/test/test-utils.js

@@ -0,0 +1,11 @@
+import { jqLite } from "../src/jqLite";
+
+export function browserTrigger(element, event) {
+  jqLite(element)[0].dispatchEvent(
+    new Event(event, { bubbles: true, cancelable: true }),
+  );
+}
+
+export function wait(t) {
+  return new Promise((resolve, _) => setTimeout(resolve, t));
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "checkJs": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "lib": ["ES2018", "DOM"],
+    "target": "ES5",
+    "sourceMap": false,
+    "declaration": false,
+    "incremental": true,
+    "typeRoots": ["types/global.d.ts", "node_modules/@types"]
+  },
+  "include": ["./src/*.js", "./**/*.ts"],
+  "exclude": []
+}