@angular-wave/angular.ts 0.9.4 → 0.9.6

package/src/core/root-element.spec.js

@@ -1,14 +0,0 @@
-import { createElementFromHTML, dealoc } from "../shared/dom.js";
-import { Angular } from "../angular.js";
-
-describe("$rootElement", () => {
-  let angular = new Angular();
-
-  it("should publish the bootstrap element into $rootElement", () => {
-    const element = createElementFromHTML("<div></div>");
-    const injector = angular.bootstrap(element, []);
-
-    expect(injector.get("$rootElement")).toBe(element);
-    dealoc(element);
-  });
-});

package/src/core/sanitize/interface.ts

@@ -1,10 +0,0 @@
-/**
- * Sanitizer function that processes a URI string and optionally
- * treats it as a media URL.
- */
-export interface SanitizerFn {
-  (
-    uri: string | null | undefined,
-    isMediaUrl?: boolean,
-  ): string | null | undefined;
-}

package/src/core/sanitize/sanitize-uri.js

@@ -1,75 +0,0 @@
-import { isDefined } from "../../shared/utils.js";
-import { urlResolve } from "../../shared/url-utils/url-utils.js";
-
-/** @typedef {import('../../interface.ts').ServiceProvider} ServiceProvider */
-
-/**
- * Private service to sanitize uris for links and images. Used by $compile.
- * @implements {ServiceProvider}
- */
-export class SanitizeUriProvider {
-  constructor() {
-    /**
-     * @private
-     * @type {RegExp}
-     */
-    this._aHrefSanitizationTrustedUrlList =
-      /^\s*(https?|s?ftp|mailto|tel|file):/;
-
-    /**
-     * @private
-     * @type {RegExp}
-     */
-    this._imgSrcSanitizationTrustedUrlList =
-      /^\s*((https?|ftp|file|blob):|data:image\/)/;
-  }
-
-  /**
-   * Retrieves or overrides the regexp used to trust URLs for a[href] sanitization.
-   *
-   * @param {RegExp=} regexp New regexp to trust URLs with.
-   * @returns {RegExp|SanitizeUriProvider} Current regexp if no param, or self for chaining.
-   */
-  aHrefSanitizationTrustedUrlList(regexp) {
-    if (isDefined(regexp)) {
-      this._aHrefSanitizationTrustedUrlList = regexp;
-      return this;
-    }
-    return this._aHrefSanitizationTrustedUrlList;
-  }
-
-  /**
-   * Retrieves or overrides the regexp used to trust URLs for img[src] sanitization.
-   *
-   * @param {RegExp=} regexp New regexp to trust URLs with.
-   * @returns {RegExp|SanitizeUriProvider} Current regexp if no param, or self for chaining.
-   */
-  imgSrcSanitizationTrustedUrlList(regexp) {
-    if (isDefined(regexp)) {
-      this._imgSrcSanitizationTrustedUrlList = regexp;
-      return this;
-    }
-    return this._imgSrcSanitizationTrustedUrlList;
-  }
-
-  /**
-   * @returns {import("./interface").SanitizerFn}
-   */
-  $get() {
-    return (uri, isMediaUrl) => {
-      if (!uri) return uri;
-
-      /** @type {RegExp} */
-      const regex = isMediaUrl
-        ? this._imgSrcSanitizationTrustedUrlList
-        : this._aHrefSanitizationTrustedUrlList;
-
-      const normalizedVal = urlResolve(uri.trim()).href;
-
-      if (normalizedVal !== "" && !normalizedVal.match(regex)) {
-        return `unsafe:${normalizedVal}`;
-      }
-      return uri;
-    };
-  }
-}

package/src/core/sanitize/sanitize-uri.spec.js

@@ -1,249 +0,0 @@
-import { SanitizeUriProvider } from "./sanitize-uri.js";
-
-describe("sanitizeUri", () => {
-  let sanitizeHref;
-  let sanitizeImg;
-  let sanitizeUriProvider;
-  let testUrl;
-  let $$sanitizeUri;
-  beforeEach(() => {
-    sanitizeUriProvider = new SanitizeUriProvider();
-    $$sanitizeUri = sanitizeUriProvider.$get();
-
-    sanitizeHref = function (uri) {
-      return $$sanitizeUri(uri, false);
-    };
-    sanitizeImg = function (uri) {
-      return $$sanitizeUri(uri, true);
-    };
-  });
-
-  function isEvilInCurrentBrowser(uri) {
-    const a = document.createElement("a");
-    a.setAttribute("href", uri);
-    return a.href.substring(0, 4) !== "http";
-  }
-
-  describe("img[src] sanitization", () => {
-    it("should sanitize javascript: urls", () => {
-      testUrl = "javascript:doEvilStuff()";
-      expect(sanitizeImg(testUrl)).toBe("unsafe:javascript:doEvilStuff()");
-    });
-
-    it("should sanitize javascript: urls with comments", () => {
-      testUrl = "javascript:alert(1)//data:image/";
-      expect(sanitizeImg(testUrl)).toBe(
-        "unsafe:javascript:alert(1)//data:image/",
-      );
-    });
-
-    it("should sanitize non-image data: urls", () => {
-      testUrl = "data:application/javascript;charset=US-ASCII,alert('evil!');";
-      expect(sanitizeImg(testUrl)).toBe(
-        "unsafe:data:application/javascript;charset=US-ASCII,alert('evil!');",
-      );
-
-      testUrl = "data:,foo";
-      expect(sanitizeImg(testUrl)).toBe("unsafe:data:,foo");
-    });
-
-    it("should sanitize mailto: urls", () => {
-      testUrl = "mailto:foo@bar.com";
-      expect(sanitizeImg(testUrl)).toBe("unsafe:mailto:foo@bar.com");
-    });
-
-    it("should sanitize obfuscated javascript: urls", () => {
-      // case-sensitive
-      testUrl = "JaVaScRiPt:doEvilStuff()";
-      expect(sanitizeImg(testUrl)).toBe("unsafe:javascript:doEvilStuff()");
-
-      // tab in protocol
-      testUrl = "java\u0009script:doEvilStuff()";
-      if (isEvilInCurrentBrowser(testUrl)) {
-        expect(sanitizeImg(testUrl)).toEqual("unsafe:javascript:doEvilStuff()");
-      }
-
-      // space before
-      testUrl = " javascript:doEvilStuff()";
-      expect(sanitizeImg(testUrl)).toBe("unsafe:javascript:doEvilStuff()");
-
-      // ws chars before
-      testUrl = " \u000e javascript:doEvilStuff()";
-      if (isEvilInCurrentBrowser(testUrl)) {
-        expect(sanitizeImg(testUrl)).toEqual("unsafe:javascript:doEvilStuff()");
-      }
-
-      // post-fixed with proper url
-      testUrl = "javascript:doEvilStuff(); http://make.me/look/good";
-      expect(sanitizeImg(testUrl)).toBe(
-        "unsafe:javascript:doEvilStuff(); http://make.me/look/good",
-      );
-    });
-
-    it("should sanitize ng-src bindings as well", () => {
-      testUrl = "javascript:doEvilStuff()";
-      expect(sanitizeImg(testUrl)).toBe("unsafe:javascript:doEvilStuff()");
-    });
-
-    it("should not sanitize valid urls", () => {
-      testUrl = "foo/bar";
-      expect(sanitizeImg(testUrl)).toBe("foo/bar");
-
-      testUrl = "/foo/bar";
-      expect(sanitizeImg(testUrl)).toBe("/foo/bar");
-
-      testUrl = "../foo/bar";
-      expect(sanitizeImg(testUrl)).toBe("../foo/bar");
-
-      testUrl = "#foo";
-      expect(sanitizeImg(testUrl)).toBe("#foo");
-
-      testUrl = "http://foo.com/bar";
-      expect(sanitizeImg(testUrl)).toBe("http://foo.com/bar");
-
-      testUrl = " http://foo.com/bar";
-      expect(sanitizeImg(testUrl)).toBe(" http://foo.com/bar");
-
-      testUrl = "https://foo.com/bar";
-      expect(sanitizeImg(testUrl)).toBe("https://foo.com/bar");
-
-      testUrl = "ftp://foo.com/bar";
-      expect(sanitizeImg(testUrl)).toBe("ftp://foo.com/bar");
-
-      testUrl = "file:///foo/bar.html";
-      expect(sanitizeImg(testUrl)).toBe("file:///foo/bar.html");
-    });
-
-    it("should not sanitize blob urls", () => {
-      testUrl = "blob:///foo/bar.html";
-      expect(sanitizeImg(testUrl)).toBe("blob:///foo/bar.html");
-    });
-
-    it("should not sanitize data: URIs for images", () => {
-      // image data uri
-      // ref: http://probablyprogramming.com/2009/03/15/the-tiniest-gif-ever
-      testUrl =
-        "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==";
-      expect(sanitizeImg(testUrl)).toBe(
-        "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==",
-      );
-    });
-
-    it("should allow reconfiguration of the src trusted URIs", () => {
-      let returnVal;
-      expect(
-        sanitizeUriProvider.imgSrcSanitizationTrustedUrlList() instanceof
-          RegExp,
-      ).toBe(true);
-      returnVal =
-        sanitizeUriProvider.imgSrcSanitizationTrustedUrlList(/javascript:/);
-      expect(returnVal).toBe(sanitizeUriProvider);
-
-      testUrl = "javascript:doEvilStuff()";
-      expect(sanitizeImg(testUrl)).toBe("javascript:doEvilStuff()");
-
-      testUrl = "http://recon/figured";
-      expect(sanitizeImg(testUrl)).toBe("unsafe:http://recon/figured");
-    });
-  });
-
-  describe("a[href] sanitization", () => {
-    it("should sanitize javascript: urls", () => {
-      testUrl = "javascript:doEvilStuff()";
-      expect(sanitizeHref(testUrl)).toBe("unsafe:javascript:doEvilStuff()");
-    });
-
-    it("should sanitize data: urls", () => {
-      testUrl = "data:evilPayload";
-      expect(sanitizeHref(testUrl)).toBe("unsafe:data:evilPayload");
-    });
-
-    it("should sanitize obfuscated javascript: urls", () => {
-      // case-sensitive
-      testUrl = "JaVaScRiPt:doEvilStuff()";
-      expect(sanitizeHref(testUrl)).toBe("unsafe:javascript:doEvilStuff()");
-
-      // tab in protocol
-      testUrl = "java\u0009script:doEvilStuff()";
-      if (isEvilInCurrentBrowser(testUrl)) {
-        expect(sanitizeHref(testUrl)).toEqual(
-          "unsafe:javascript:doEvilStuff()",
-        );
-      }
-
-      // space before
-      testUrl = " javascript:doEvilStuff()";
-      expect(sanitizeHref(testUrl)).toBe("unsafe:javascript:doEvilStuff()");
-
-      // ws chars before
-      testUrl = " \u000e javascript:doEvilStuff()";
-      if (isEvilInCurrentBrowser(testUrl)) {
-        expect(sanitizeHref(testUrl)).toEqual(
-          "unsafe:javascript:doEvilStuff()",
-        );
-      }
-
-      // post-fixed with proper url
-      testUrl = "javascript:doEvilStuff(); http://make.me/look/good";
-      expect(sanitizeHref(testUrl)).toBe(
-        "unsafe:javascript:doEvilStuff(); http://make.me/look/good",
-      );
-    });
-
-    it("should sanitize ngHref bindings as well", () => {
-      testUrl = "javascript:doEvilStuff()";
-      expect(sanitizeHref(testUrl)).toBe("unsafe:javascript:doEvilStuff()");
-    });
-
-    it("should not sanitize valid urls", () => {
-      testUrl = "foo/bar";
-      expect(sanitizeHref(testUrl)).toBe("foo/bar");
-
-      testUrl = "/foo/bar";
-      expect(sanitizeHref(testUrl)).toBe("/foo/bar");
-
-      testUrl = "../foo/bar";
-      expect(sanitizeHref(testUrl)).toBe("../foo/bar");
-
-      testUrl = "#foo";
-      expect(sanitizeHref(testUrl)).toBe("#foo");
-
-      testUrl = "http://foo/bar";
-      expect(sanitizeHref(testUrl)).toBe("http://foo/bar");
-
-      testUrl = " http://foo/bar";
-      expect(sanitizeHref(testUrl)).toBe(" http://foo/bar");
-
-      testUrl = "https://foo/bar";
-      expect(sanitizeHref(testUrl)).toBe("https://foo/bar");
-
-      testUrl = "ftp://foo/bar";
-      expect(sanitizeHref(testUrl)).toBe("ftp://foo/bar");
-
-      testUrl = "sftp://foo/bar";
-      expect(sanitizeHref(testUrl)).toBe("sftp://foo/bar");
-
-      testUrl = "mailto:foo@bar.com";
-      expect(sanitizeHref(testUrl)).toBe("mailto:foo@bar.com");
-
-      testUrl = "file:///foo/bar.html";
-      expect(sanitizeHref(testUrl)).toBe("file:///foo/bar.html");
-    });
-
-    it("should allow reconfiguration of the href trusted URIs", () => {
-      let returnVal;
-      expect(
-        sanitizeUriProvider.aHrefSanitizationTrustedUrlList() instanceof RegExp,
-      ).toBe(true);
-      returnVal =
-        sanitizeUriProvider.aHrefSanitizationTrustedUrlList(/javascript:/);
-      expect(returnVal).toBe(sanitizeUriProvider);
-
-      testUrl = "javascript:doEvilStuff()";
-      expect(sanitizeHref(testUrl)).toBe("javascript:doEvilStuff()");
-
-      testUrl = "http://recon/figured";
-      expect(sanitizeHref(testUrl)).toBe("unsafe:http://recon/figured");
-    });
-  });
-});

package/src/core/sanitize/sanitize-uri.test.js

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

package/src/core/sanitize/sanitize.html

@@ -1,22 +0,0 @@
-<!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.css" />
-    <link rel="stylesheet" href="/public/jasmine-helper.css" />
-    <script src="/jasmine/jasmine.js"></script>
-    <script src="/jasmine/jasmine-html.js"></script>
-    <script src="/jasmine/boot0.js"></script>
-    <script src="/jasmine/boot1.js"></script>
-    <script
-      type="module"
-      src="/src/core/sanitize/sanitize-uri.spec.js"
-    ></script>
-  </head>
-  <body>
-    <div id="app"></div>
-  </body>
-</html>

package/src/core/scope/scope.html

@@ -1,19 +0,0 @@
-<!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.css" />
-    <link rel="stylesheet" href="/public/jasmine-helper.css" />
-    <script src="/jasmine/jasmine.js"></script>
-    <script src="/jasmine/jasmine-html.js"></script>
-    <script src="/jasmine/boot0.js"></script>
-    <script src="/jasmine/boot1.js"></script>
-    <script type="module" src="/src/core/scope/scope.spec.js"></script>
-  </head>
-  <body>
-    <div id="app"></div>
-  </body>
-</html>