@angular-wave/angular.ts 0.9.3 → 0.9.5

package/src/services/template-cache/template-cache.spec.js

@@ -1,134 +0,0 @@
-import { Angular } from "../../angular.js";
-import { dealoc } from "../../shared/dom.js";
-import { wait } from "../../shared/test-utils.js";
-
-describe("$templateCache", () => {
-  let templateCache, templateCacheProvider, el, $compile, $scope;
-
-  beforeEach(() => {
-    el = document.getElementById("app");
-    el.innerHTML = "";
-    let angular = new Angular();
-    angular.module("default", []).config(($templateCacheProvider) => {
-      templateCacheProvider = $templateCacheProvider;
-      templateCacheProvider.cache.set("test", "hello");
-    });
-    angular
-      .bootstrap(el, ["default"])
-      .invoke((_$templateCache_, _$compile_, _$rootScope_) => {
-        templateCache = _$templateCache_;
-        $compile = _$compile_;
-        $scope = _$rootScope_;
-      });
-  });
-
-  afterEach(() => {
-    dealoc(el);
-  });
-
-  it("should be available as provider", () => {
-    expect(templateCacheProvider).toBeDefined();
-  });
-
-  it("should be available as a service", () => {
-    expect(templateCache).toBeDefined();
-    expect(templateCache).toEqual(templateCacheProvider.cache);
-    expect(templateCache instanceof Map).toBeTrue();
-    expect(templateCache.get("test")).toEqual("hello");
-  });
-
-  it("should can be accessed via `ng-include`", async () => {
-    el.innerHTML = `
-        <div ng-include="'test'">test</div>
-    `;
-    expect(el.innerText).toEqual("test");
-    $compile(el)($scope);
-    await wait();
-    expect(el.innerText).toEqual("hello");
-  });
-
-  it("can be leader via `text/ng-template`", async () => {
-    el.innerHTML = `
-      <script type="text/ng-template" id="templateId.html">
-        <p>This is the content of the template</p>
-      </script>
-    `;
-    $compile(el)($scope);
-    await wait();
-    expect(templateCache.get("templateId.html").trim()).toEqual(
-      "<p>This is the content of the template</p>",
-    );
-  });
-
-  it("can be swapped for localStorage", async () => {
-    dealoc(el);
-    angular = new Angular();
-    angular.module("customStorage", []).config(($templateCacheProvider) => {
-      templateCacheProvider = $templateCacheProvider;
-      templateCacheProvider.cache = new LocalStorageMap();
-      templateCacheProvider.cache.set("test", "hello");
-    });
-    angular
-      .bootstrap(el, ["customStorage"])
-      .invoke((_$templateCache_, _$compile_, _$rootScope_) => {
-        templateCache = _$templateCache_;
-        $compile = _$compile_;
-        $scope = _$rootScope_;
-      });
-
-    expect(templateCache instanceof LocalStorageMap).toBeTrue();
-    el.innerHTML = `
-        <div ng-include="'test'">test</div>
-      `;
-    expect(el.innerText).toEqual("test");
-    $compile(el)($scope);
-    await wait();
-    expect(el.innerText).toEqual("hello");
-    expect(window.localStorage.getItem("test")).toEqual("hello");
-  });
-});
-
-class LocalStorageMap {
-  constructor(prefix = "") {
-    this.prefix = prefix;
-  }
-
-  _key(key) {
-    return `${this.prefix}${key}`;
-  }
-
-  get(key) {
-    const raw = localStorage.getItem(this._key(key));
-    if (raw === null) return undefined;
-    try {
-      return JSON.parse(raw);
-    } catch {
-      return raw;
-    }
-  }
-
-  set(key, value) {
-    localStorage.setItem(this._key(key), value);
-    return this;
-  }
-
-  has(key) {
-    return localStorage.getItem(this._key(key)) !== null;
-  }
-
-  delete(key) {
-    localStorage.removeItem(this._key(key));
-    return true;
-  }
-
-  clear() {
-    const toRemove = [];
-    for (let i = 0; i < localStorage.length; i++) {
-      const k = localStorage.key(i);
-      if (k && k.startsWith(this.prefix)) {
-        toRemove.push(k);
-      }
-    }
-    toRemove.forEach((k) => localStorage.removeItem(k));
-  }
-}

package/src/services/template-cache/template-cache.test.js

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

package/src/services/template-request.js

@@ -1,142 +0,0 @@
-import { defaultHttpResponseTransform } from "./http/http.js";
-import { extend, isString, minErr } from "../shared/utils.js";
-
-const $templateRequestMinErr = minErr("$templateRequest");
-
-/**
- * Used to configure the options passed to the {@link $http} service when making a template request.
- *
- * For example, it can be used for specifying the "Accept" header that is sent to the server, when
- * requesting a template.
- */
-export function TemplateRequestProvider() {
-  let httpOptions;
-
-  /**
-   * The options to be passed to the {@link $http} service when making the request.
-   * You can use this to override options such as the "Accept" header for template requests.
-   * The {@link $templateRequest} will set the `cache` and the `transformResponse` properties of the
-   * options if not overridden here.
-   *
-   * @param {string=} val new value for the {@link $http} options.
-   * @returns {string|TemplateRequestProvider} Returns the {@link $http} options when used as getter and self if used as setter.
-   */
-  this.httpOptions = function (val) {
-    if (val) {
-      httpOptions = val;
-      return this;
-    }
-    return httpOptions;
-  };
-
-  /**
-   * The `$templateRequest` service runs security checks then downloads the provided template using
-   * `$http` and, upon success, stores the contents inside of `$templateCache`. If the HTTP request
-   * fails or the response data of the HTTP request is empty, a `$compile` error will be thrown (the
-   * exception can be thwarted by setting the 2nd parameter of the function to true). Note that the
-   * contents of `$templateCache` are trusted, so the call to `$sce.getTrustedUrl(tpl)` is omitted
-   * when `tpl` is of type string and `$templateCache` has the matching entry.
-   *
-   * If you want to pass custom options to the `$http` service, such as setting the Accept header you
-   * can configure this via {@link $templateRequestProvider#httpOptions}.
-   *
-   * `$templateRequest` is used internally by {@link $compile}, {@link ngRoute.$route}, and directives such
-   * as {@link ngInclude} to download and cache templates.
-   *
-   * 3rd party modules should use `$templateRequest` if their services or directives are loading
-   * templates.
-   *
-   * @param {string} tpl The HTTP request template URL
-   * @param {boolean=} ignoreRequestError Whether or not to ignore the exception when the request fails or the template is empty
-   *
-   * @return {Promise} a promise for the HTTP response data of the given URL.
-   *
-   * @property {number} totalPendingRequests total amount of pending template requests being downloaded.
-   */
-  this.$get = [
-    "$exceptionHandler",
-    "$templateCache",
-    "$http",
-    "$sce",
-    /**
-     *
-     * @param {import('./exception/exception-handler.js').ErrorHandler} $exceptionHandler
-     * @param {import('../services/template-cache/interface.ts').TemplateCache} $templateCache
-     * @param {import("interface.ts").HttpService} $http
-     * @param {*} $sce
-     * @returns
-     */
-    function ($exceptionHandler, $templateCache, $http, $sce) {
-      function handleRequestFn(tpl, ignoreRequestError) {
-        handleRequestFn.totalPendingRequests++;
-
-        // We consider the template cache holds only trusted templates, so
-        // there's no need to go through adding the template again to the trusted
-        // resources for keys that already are included in there. This also makes
-        // AngularTS accept any script directive, no matter its name. However, we
-        // still need to unwrap trusted types.
-
-        if (!isString(tpl) || !$templateCache.has(tpl)) {
-          try {
-            tpl = $sce.getTrustedResourceUrl(tpl);
-            if (!tpl) {
-              return Promise.reject("Template not found");
-            }
-          } catch (e) {
-            return Promise.reject(e.message);
-          }
-        }
-
-        let transformResponse =
-          $http.defaults && $http.defaults.transformResponse;
-
-        if (Array.isArray(transformResponse)) {
-          transformResponse = transformResponse.filter(function (transformer) {
-            return transformer !== defaultHttpResponseTransform;
-          });
-        } else if (transformResponse === defaultHttpResponseTransform) {
-          transformResponse = null;
-        }
-
-        return $http
-          .get(
-            tpl,
-            extend(
-              {
-                cache: $templateCache,
-                transformResponse: transformResponse,
-              },
-              httpOptions,
-            ),
-          )
-          .finally(function () {
-            handleRequestFn.totalPendingRequests--;
-          })
-          .then(function (response) {
-            $templateCache.set(tpl, response.data);
-            return response.data;
-          }, handleError);
-
-        function handleError(resp) {
-          if (!ignoreRequestError) {
-            resp = $templateRequestMinErr(
-              "tpload",
-              "Failed to load template: {0} (HTTP status: {1} {2})",
-              tpl,
-              resp.status,
-              resp.statusText,
-            );
-
-            $exceptionHandler(resp);
-          }
-
-          return Promise.reject(resp);
-        }
-      }
-
-      handleRequestFn.totalPendingRequests = 0;
-
-      return handleRequestFn;
-    },
-  ];
-}

package/src/shared/cache.js

@@ -1,7 +0,0 @@
-/**
- * Expando cache for adding properties to DOM nodes with JavaScript.
- * This used to be an Object in JQLite decorator, but swapped out for a Map
- *
- * @type {Map<number, import('../interface.ts').ExpandoStore>}
- */
-export const Cache = new Map();