@angular-wave/angular.ts 0.9.4 → 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/interface.ts

@@ -1,23 +0,0 @@
-export interface TemplateRequestService {
-  /**
-   * Downloads a 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 then a $compile error will be thrown (unless
-   * {ignoreRequestError} is set to true).
-   *
-   * @param tpl                  The template URL.
-   * @param ignoreRequestError   Whether or not to ignore the exception
-   *                             when the request fails or the template is
-   *                             empty.
-   *
-   * @return   A promise whose value is the template content.
-   */
-  (tpl: string, ignoreRequestError?: boolean): Promise<string>;
-
-  /**
-   * total amount of pending template requests being downloaded.
-   */
-  totalPendingRequests: number;
-}

package/src/services/template-request/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 {ng.ExceptionHandlerService} $exceptionHandler
-     * @param {ng.TemplateCacheService} $templateCache
-     * @param {ng.HttpService} $http
-     * @param {*} $sce
-     * @returns {ng.TemplateRequestService}
-     */
-    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();

package/src/shared/common.js

@@ -1,365 +0,0 @@
-import { isDate, isFunction, isRegExp, isString } from "./utils.js";
-
-export function equals(o1, o2) {
-  if (o1 === o2) return true;
-  if (o1 === null || o2 === null) return false;
-  if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN
-  const t1 = typeof o1,
-    t2 = typeof o2;
-  if (t1 !== t2 || t1 !== "object") return false;
-  const tup = [o1, o2];
-  if (tup.every(Array.isArray)) return _arraysEq(o1, o2);
-  if (tup.every(isDate)) return o1.getTime() === o2.getTime();
-  if (tup.every(isRegExp)) return o1.toString() === o2.toString();
-  if (tup.every(isFunction)) return true; // meh
-  if ([isFunction, Array.isArray, isDate, isRegExp].some((fn) => !!fn(tup))) {
-    return false;
-  }
-  const keys = {};
-
-  for (const key in o1) {
-    if (!equals(o1[key], o2[key])) return false;
-    keys[key] = true;
-  }
-  for (const key in o2) {
-    if (!keys[key]) return false;
-  }
-  return true;
-}
-
-/**
- * prototypal inheritance helper.
- * Creates a new object which has `parent` object as its prototype, and then copies the properties from `extra` onto it
- */
-
-/**
- * prototypal inheritance helper.
- * Creates a new object which has `parent` object as its prototype, and then copies the properties from `extra` onto it.
- *
- * @param {Object} parent - The object to be used as the prototype.
- * @param {Object} [extra] - The object containing additional properties to be copied.
- * @returns {Object} - A new object with `parent` as its prototype and properties from `extra`.
- */
-export function inherit(parent, extra) {
-  const newObj = Object.create(parent);
-  if (extra) {
-    Object.assign(newObj, extra);
-  }
-  return newObj;
-}
-
-/**
- * Given an array, and an item, if the item is found in the array, it removes it (in-place).
- * The same array is returned
- * @param {Array} array
- * @param {any} obj
- * @returns {Array}
- */
-export function removeFrom(array, obj) {
-  const i = array.indexOf(obj);
-  if (i !== -1) array.splice(i, 1);
-  return array;
-}
-
-/**
- * Applies a set of defaults to an options object.  The options object is filtered
- * to only those properties of the objects in the defaultsList.
- * Earlier objects in the defaultsList take precedence when applying defaults.
- */
-export function defaults(opts, ...defaultsList) {
-  const defaultVals = Object.assign({}, ...defaultsList.reverse());
-  return Object.assign(defaultVals, pick(opts || {}, Object.keys(defaultVals)));
-}
-
-/**
- * Finds the common ancestor path between two states.
- *
- * @param {Object} first The first state.
- * @param {Object} second The second state.
- * @return {Array} Returns an array of state names in descending order, not including the root.
- */
-export function ancestors(first, second) {
-  const path = [];
-  for (const n in first.path) {
-    if (first.path[n] !== second.path[n]) break;
-    path.push(first.path[n]);
-  }
-  return path;
-}
-/**
- * Return a copy of the object only containing the whitelisted properties.
- *
- * #### Example:
- * ```
- * var foo = { a: 1, b: 2, c: 3 };
- * var ab = pick(foo, ['a', 'b']); // { a: 1, b: 2 }
- * ```
- * @param obj the source object
- * @param propNames an Array of strings, which are the whitelisted property names
- */
-export function pick(obj, propNames) {
-  const objCopy = {};
-  for (const _prop in obj) {
-    if (propNames.indexOf(_prop) !== -1) {
-      objCopy[_prop] = obj[_prop];
-    }
-  }
-  return objCopy;
-}
-/**
- * Return a copy of the object omitting the blacklisted properties.
- *
- * @example
- * ```
- *
- * var foo = { a: 1, b: 2, c: 3 };
- * var ab = omit(foo, ['a', 'b']); // { c: 3 }
- * ```
- * @param obj the source object
- * @param propNames an Array of strings, which are the blacklisted property names
- */
-export function omit(obj, propNames) {
-  return Object.keys(obj)
-    .filter((x) => !propNames.includes(x))
-    .reduce((acc, key) => ((acc[key] = obj[key]), acc), {});
-}
-
-/** Filters an Array or an Object's properties based on a predicate */
-export function filter(collection, callback) {
-  const arr = Array.isArray(collection),
-    result = arr ? [] : {};
-  const accept = arr ? (x) => result.push(x) : (x, key) => (result[key] = x);
-  Object.entries(collection).forEach(([i, item]) => {
-    if (callback(item, i)) accept(item, i);
-  });
-  return result;
-}
-
-/** Finds an object from an array, or a property of an object, that matches a predicate */
-export function find(collection, callback) {
-  let result;
-  Object.entries(collection).forEach(([i, item]) => {
-    if (result) return;
-    if (callback(item, i)) result = item;
-  });
-  return result;
-}
-
-/** Maps an array or object properties using a callback function */
-export function map(collection, callback, target) {
-  target = target || (Array.isArray(collection) ? [] : {});
-  Object.entries(collection).forEach(
-    ([i, item]) => (target[i] = callback(item, i)),
-  );
-  return target;
-}
-
-/**
- * Reduce function that returns true if all of the values are truthy.
- *
- * @example
- * ```
- *
- * let vals = [ 1, true, {}, "hello world"];
- * vals.reduce(allTrueR, true); // true
- *
- * vals.push(0);
- * vals.reduce(allTrueR, true); // false
- * ```
- */
-export const allTrueR = (memo, elem) => memo && elem;
-/**
- * Reduce function that returns true if any of the values are truthy.
- *
- *  * @example
- * ```
- *
- * let vals = [ 0, null, undefined ];
- * vals.reduce(anyTrueR, true); // false
- *
- * vals.push("hello world");
- * vals.reduce(anyTrueR, true); // true
- * ```
- */
-export const anyTrueR = (memo, elem) => memo || elem;
-/**
- * Reduce function which un-nests a single level of arrays
- * @example
- * ```
- *
- * let input = [ [ "a", "b" ], [ "c", "d" ], [ [ "double", "nested" ] ] ];
- * input.reduce(unnestR, []) // [ "a", "b", "c", "d", [ "double, "nested" ] ]
- * ```
- */
-export const unnestR = (memo, elem) => memo.concat(elem);
-/**
- * Reduce function which recursively un-nests all arrays
- *
- * @example
- * ```
- *
- * let input = [ [ "a", "b" ], [ "c", "d" ], [ [ "double", "nested" ] ] ];
- * input.reduce(unnestR, []) // [ "a", "b", "c", "d", "double, "nested" ]
- * ```
- */
-export const flattenR = (memo, elem) =>
-  Array.isArray(elem)
-    ? memo.concat(elem.reduce(flattenR, []))
-    : pushR(memo, elem);
-/**
- * Reduce function that pushes an object to an array, then returns the array.
- * Mostly just for [[flattenR]] and [[uniqR]]
- */
-export function pushR(arr, obj) {
-  arr.push(obj);
-  return arr;
-}
-/** Reduce function that filters out duplicates */
-export const uniqR = (acc, token) =>
-  acc.includes(token) ? acc : pushR(acc, token);
-/**
- * Return a new array with a single level of arrays unnested.
- *
- * @example
- * ```
- *
- * let input = [ [ "a", "b" ], [ "c", "d" ], [ [ "double", "nested" ] ] ];
- * unnest(input) // [ "a", "b", "c", "d", [ "double, "nested" ] ]
- * ```
- */
-export const unnest = (arr) => arr.reduce(unnestR, []);
-
-/**
- * Given a .filter Predicate, builds a .filter Predicate which throws an error if any elements do not pass.
- * @example
- * ```
- *
- * let isNumber = (obj) => typeof(obj) === 'number';
- * let allNumbers = [ 1, 2, 3, 4, 5 ];
- * allNumbers.filter(assertPredicate(isNumber)); //OK
- *
- * let oneString = [ 1, 2, 3, 4, "5" ];
- * oneString.filter(assertPredicate(isNumber, "Not all numbers")); // throws Error(""Not all numbers"");
- * ```
- */
-export const assertPredicate = assertFn;
-
-export function assertFn(predicateOrMap, errMsg = "assert failure") {
-  return (obj) => {
-    const result = predicateOrMap(obj);
-    if (!result) {
-      throw new Error(errMsg);
-    }
-    return result;
-  };
-}
-/**
- * Like _.pairs: Given an object, returns an array of key/value pairs
- *
- * @example
- * ```
- *
- * pairs({ foo: "FOO", bar: "BAR }) // [ [ "foo", "FOO" ], [ "bar": "BAR" ] ]
- * ```
- */
-export const pairs = (obj) => Object.keys(obj).map((key) => [key, obj[key]]);
-/**
- * Given two or more parallel arrays, returns an array of tuples where
- * each tuple is composed of [ a[i], b[i], ... z[i] ]
- *
- * @example
- * ```
- *
- * let foo = [ 0, 2, 4, 6 ];
- * let bar = [ 1, 3, 5, 7 ];
- * let baz = [ 10, 30, 50, 70 ];
- * arrayTuples(foo, bar);       // [ [0, 1], [2, 3], [4, 5], [6, 7] ]
- * arrayTuples(foo, bar, baz);  // [ [0, 1, 10], [2, 3, 30], [4, 5, 50], [6, 7, 70] ]
- * ```
- */
-export function arrayTuples(...args) {
-  if (args.length === 0) return [];
-  const maxArrayLen = args.reduce(
-    (min, arr) => Math.min(arr.length, min),
-    9007199254740991,
-  ); // aka 2^53 − 1 aka Number.MAX_SAFE_INTEGER
-  const result = [];
-  for (let i = 0; i < maxArrayLen; i++) {
-    // This is a hot function
-    // Unroll when there are 1-4 arguments
-    switch (args.length) {
-      case 1:
-        result.push([args[0][i]]);
-        break;
-      case 2:
-        result.push([args[0][i], args[1][i]]);
-        break;
-      case 3:
-        result.push([args[0][i], args[1][i], args[2][i]]);
-        break;
-      case 4:
-        result.push([args[0][i], args[1][i], args[2][i], args[3][i]]);
-        break;
-      default:
-        result.push(args.map((array) => array[i]));
-        break;
-    }
-  }
-  return result;
-}
-/**
- * Reduce function which builds an object from an array of [key, value] pairs.
- *
- * Each iteration sets the key/val pair on the memo object, then returns the memo for the next iteration.
- *
- * Each keyValueTuple should be an array with values [ key: string, value: any ]
- *
- * @example
- * ```
- *
- * var pairs = [ ["fookey", "fooval"], ["barkey", "barval"] ]
- *
- * var pairsToObj = pairs.reduce((memo, pair) => applyPairs(memo, pair), {})
- * // pairsToObj == { fookey: "fooval", barkey: "barval" }
- *
- * // Or, more simply:
- * var pairsToObj = pairs.reduce(applyPairs, {})
- * // pairsToObj == { fookey: "fooval", barkey: "barval" }
- * ```
- */
-export function applyPairs(memo, keyValTuple) {
-  let key, value;
-  if (Array.isArray(keyValTuple)) [key, value] = keyValTuple;
-  if (!isString(key)) throw new Error("invalid parameters to applyPairs");
-  memo[key] = value;
-  return memo;
-}
-
-/**
- * Returns the last element of an array, or undefined if the array is empty.
- * @template T
- * @param {T[]} arr - The input array.
- * @returns {T | undefined} The last element or undefined.
- */
-export function tail(arr) {
-  return arr.length > 0 ? arr[arr.length - 1] : undefined;
-}
-
-/**
- * shallow copy from src to dest
- */
-export function copy(src, dest) {
-  if (dest) Object.keys(dest).forEach((key) => delete dest[key]);
-  if (!dest) dest = {};
-  return Object.assign(dest, src);
-}
-
-function _arraysEq(a1, a2) {
-  if (a1.length !== a2.length) return false;
-  return arrayTuples(a1, a2).reduce((b, t) => b && equals(t[0], t[1]), true);
-}
-// issue #2676
-export const silenceUncaughtInPromise = (promise) =>
-  promise.catch(() => 0) && promise;
-export const silentRejection = (error) =>
-  silenceUncaughtInPromise(Promise.reject(error));