@angular-wave/angular.ts 0.2.3 → 0.3.0

package/src/core/cache/cache-factory.spec.js

@@ -1,334 +0,0 @@
-import { Angular } from "../../loader";
-import { createInjector } from "../di/injector";
-
-describe("$cacheFactory", () => {
-  let $cacheFactory;
-
-  beforeEach(() => {
-    window.angular = new Angular();
-    createInjector(["ng"]).invoke((_$cacheFactory_) => {
-      $cacheFactory = _$cacheFactory_;
-    });
-  });
-
-  it("should be injected", () => {
-    expect($cacheFactory).toBeDefined();
-  });
-
-  it("should return a new cache whenever called", () => {
-    const cache1 = $cacheFactory("cache1");
-    const cache2 = $cacheFactory("cache2");
-    expect(cache1).not.toEqual(cache2);
-  });
-
-  it("should complain if the cache id is being reused", () => {
-    $cacheFactory("cache1");
-    expect(() => {
-      $cacheFactory("cache1");
-    }).toThrowError(/iid/);
-  });
-
-  describe("info", () => {
-    it("should provide info about all created caches", () => {
-      expect($cacheFactory.info()).toEqual({});
-
-      const cache1 = $cacheFactory("cache1");
-      expect($cacheFactory.info()).toEqual({
-        cache1: { id: "cache1", size: 0 },
-      });
-
-      cache1.put("foo", "bar");
-      expect($cacheFactory.info()).toEqual({
-        cache1: { id: "cache1", size: 1 },
-      });
-    });
-  });
-
-  describe("get", () => {
-    it("should return a cache if looked up by id", () => {
-      const cache1 = $cacheFactory("cache1");
-      const cache2 = $cacheFactory("cache2");
-
-      expect(cache1).not.toBe(cache2);
-      expect(cache1).toBe($cacheFactory.get("cache1"));
-      expect(cache2).toBe($cacheFactory.get("cache2"));
-    });
-  });
-
-  describe("cache", () => {
-    let cache;
-
-    beforeEach(() => {
-      cache = $cacheFactory("test");
-    });
-
-    describe("put, get & remove", () => {
-      it("should add cache entries via add and retrieve them via get", () => {
-        cache.put("key1", "bar");
-        cache.put("key2", { bar: "baz" });
-
-        expect(cache.get("key2")).toEqual({ bar: "baz" });
-        expect(cache.get("key1")).toBe("bar");
-      });
-
-      it("should ignore put if the value is undefined", () => {
-        cache.put();
-        cache.put("key1");
-        cache.put("key2", undefined);
-
-        expect(cache.info().size).toBe(0);
-      });
-
-      it("should remove entries via remove", () => {
-        cache.put("k1", "foo");
-        cache.put("k2", "bar");
-
-        cache.remove("k2");
-
-        expect(cache.get("k1")).toBe("foo");
-        expect(cache.get("k2")).toBeUndefined();
-
-        cache.remove("k1");
-
-        expect(cache.get("k1")).toBeUndefined();
-        expect(cache.get("k2")).toBeUndefined();
-      });
-
-      it("should return undefined when entry does not exist", () => {
-        expect(cache.remove("non-existent")).toBeUndefined();
-      });
-
-      it("should stringify keys", () => {
-        cache.put("123", "foo");
-        cache.put(123, "bar");
-
-        expect(cache.get("123")).toBe("bar");
-        expect(cache.info().size).toBe(1);
-
-        cache.remove(123);
-        expect(cache.info().size).toBe(0);
-      });
-
-      it("should return value from put", () => {
-        const obj = {};
-        expect(cache.put("k1", obj)).toBe(obj);
-      });
-    });
-
-    describe("info", () => {
-      it("should size increment with put and decrement with remove", () => {
-        expect(cache.info().size).toBe(0);
-
-        cache.put("foo", "bar");
-        expect(cache.info().size).toBe(1);
-
-        cache.put("baz", "boo");
-        expect(cache.info().size).toBe(2);
-
-        cache.remove("baz");
-        expect(cache.info().size).toBe(1);
-
-        cache.remove("foo");
-        expect(cache.info().size).toBe(0);
-      });
-
-      it("should only decrement size when an element is actually removed via remove", () => {
-        cache.put("foo", "bar");
-        expect(cache.info().size).toBe(1);
-
-        cache.remove("undefined");
-        expect(cache.info().size).toBe(1);
-
-        cache.remove("hasOwnProperty");
-        expect(cache.info().size).toBe(1);
-
-        cache.remove("foo");
-        expect(cache.info().size).toBe(0);
-      });
-
-      it("should return cache id", () => {
-        expect(cache.info().id).toBe("test");
-      });
-    });
-
-    describe("removeAll", () => {
-      it("should blow away all data", () => {
-        cache.put("id1", 1);
-        cache.put("id2", 2);
-        cache.put("id3", 3);
-        expect(cache.info().size).toBe(3);
-
-        cache.removeAll();
-
-        expect(cache.info().size).toBe(0);
-        expect(cache.get("id1")).toBeUndefined();
-        expect(cache.get("id2")).toBeUndefined();
-        expect(cache.get("id3")).toBeUndefined();
-      });
-    });
-
-    describe("destroy", () => {
-      it("should make the cache unusable and remove references to it from $cacheFactory", () => {
-        cache.put("foo", "bar");
-        cache.destroy();
-
-        expect(() => {
-          cache.get("foo");
-        }).toThrow();
-        expect(() => {
-          cache.get("neverexisted");
-        }).toThrow();
-        expect(() => {
-          cache.put("foo", "bar");
-        }).toThrow();
-
-        expect($cacheFactory.get("test")).toBeUndefined();
-        expect($cacheFactory.info()).toEqual({});
-      });
-    });
-  });
-
-  describe("LRU cache", () => {
-    it("should create cache with defined capacity", () => {
-      const cache = $cacheFactory("cache1", { capacity: 5 });
-      expect(cache.info().size).toBe(0);
-
-      for (let i = 0; i < 5; i++) {
-        cache.put(`id${i}`, i);
-      }
-
-      expect(cache.info().size).toBe(5);
-
-      cache.put("id5", 5);
-      expect(cache.info().size).toBe(5);
-      cache.put("id6", 6);
-      expect(cache.info().size).toBe(5);
-    });
-
-    describe("eviction", () => {
-      let cache;
-
-      beforeEach(() => {
-        cache = $cacheFactory("cache1", { capacity: 2 });
-
-        cache.put("id0", 0);
-        cache.put("id1", 1);
-      });
-
-      it("should kick out the first entry on put", () => {
-        cache.put("id2", 2);
-        expect(cache.get("id0")).toBeUndefined();
-        expect(cache.get("id1")).toBe(1);
-        expect(cache.get("id2")).toBe(2);
-      });
-
-      it("should refresh an entry via get", () => {
-        cache.get("id0");
-        cache.put("id2", 2);
-        expect(cache.get("id0")).toBe(0);
-        expect(cache.get("id1")).toBeUndefined();
-        expect(cache.get("id2")).toBe(2);
-      });
-
-      it("should refresh an entry via put", () => {
-        cache.put("id0", "00");
-        cache.put("id2", 2);
-        expect(cache.get("id0")).toBe("00");
-        expect(cache.get("id1")).toBeUndefined();
-        expect(cache.get("id2")).toBe(2);
-      });
-
-      it("should not purge an entry if another one was removed", () => {
-        cache.remove("id1");
-        cache.put("id2", 2);
-        expect(cache.get("id0")).toBe(0);
-        expect(cache.get("id1")).toBeUndefined();
-        expect(cache.get("id2")).toBe(2);
-      });
-
-      it("should purge the next entry if the stalest one was removed", () => {
-        cache.remove("id0");
-        cache.put("id2", 2);
-        cache.put("id3", 3);
-        expect(cache.get("id0")).toBeUndefined();
-        expect(cache.get("id1")).toBeUndefined();
-        expect(cache.get("id2")).toBe(2);
-        expect(cache.get("id3")).toBe(3);
-      });
-
-      it("should correctly recreate the linked list if all cache entries were removed", () => {
-        cache.remove("id0");
-        cache.remove("id1");
-        cache.put("id2", 2);
-        cache.put("id3", 3);
-        cache.put("id4", 4);
-        expect(cache.get("id0")).toBeUndefined();
-        expect(cache.get("id1")).toBeUndefined();
-        expect(cache.get("id2")).toBeUndefined();
-        expect(cache.get("id3")).toBe(3);
-        expect(cache.get("id4")).toBe(4);
-      });
-
-      it("should blow away the entire cache via removeAll and start evicting when full", () => {
-        cache.put("id0", 0);
-        cache.put("id1", 1);
-        cache.removeAll();
-
-        cache.put("id2", 2);
-        cache.put("id3", 3);
-        cache.put("id4", 4);
-
-        expect(cache.info().size).toBe(2);
-        expect(cache.get("id0")).toBeUndefined();
-        expect(cache.get("id1")).toBeUndefined();
-        expect(cache.get("id2")).toBeUndefined();
-        expect(cache.get("id3")).toBe(3);
-        expect(cache.get("id4")).toBe(4);
-      });
-
-      it("should correctly refresh and evict items if operations are chained", () => {
-        cache = $cacheFactory("cache2", { capacity: 3 });
-
-        cache.put("id0", 0); // 0
-        cache.put("id1", 1); // 1,0
-        cache.put("id2", 2); // 2,1,0
-        cache.get("id0"); // 0,2,1
-        cache.put("id3", 3); // 3,0,2
-        cache.put("id0", 9); // 0,3,2
-        cache.put("id4", 4); // 4,0,3
-
-        expect(cache.get("id3")).toBe(3);
-        expect(cache.get("id0")).toBe(9);
-        expect(cache.get("id4")).toBe(4);
-
-        cache.remove("id0"); // 4,3
-        cache.remove("id3"); // 4
-        cache.put("id5", 5); // 5,4
-        cache.put("id6", 6); // 6,5,4
-        cache.get("id4"); // 4,6,5
-        cache.put("id7", 7); // 7,4,6
-
-        expect(cache.get("id0")).toBeUndefined();
-        expect(cache.get("id1")).toBeUndefined();
-        expect(cache.get("id2")).toBeUndefined();
-        expect(cache.get("id3")).toBeUndefined();
-        expect(cache.get("id4")).toBe(4);
-        expect(cache.get("id5")).toBeUndefined();
-        expect(cache.get("id6")).toBe(6);
-        expect(cache.get("id7")).toBe(7);
-
-        cache.removeAll();
-        cache.put("id0", 0); // 0
-        cache.put("id1", 1); // 1,0
-        cache.put("id2", 2); // 2,1,0
-        cache.put("id3", 3); // 3,2,1
-
-        expect(cache.info().size).toBe(3);
-        expect(cache.get("id0")).toBeUndefined();
-        expect(cache.get("id1")).toBe(1);
-        expect(cache.get("id2")).toBe(2);
-        expect(cache.get("id3")).toBe(3);
-      });
-    });
-  });
-});

package/src/core/cache/cache-factory.test.js

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

package/src/services/cache-factory.js

@@ -1,289 +0,0 @@
-import { extend, forEach, isUndefined, minErr } from "../shared/utils";
-
-export function CacheFactoryProvider() {
-  this.$get = function () {
-    const caches = {};
-
-    /**
-     * @param {string} cacheId Name or id of the newly created cache.
-     * @param {object=} options Options object that specifies the cache behavior. Properties:
-     *
-     *   - `{number=}` `capacity` — turns the cache into LRU cache.
-     *
-     * @returns {object} Newly created cache object with the following set of methods:
-     *
-     * - `{object}` `info()` — Returns id, size, and options of cache.
-     * - `{{*}}` `put({string} key, {*} value)` — Puts a new key-value pair into the cache and returns
-     *   it.
-     * - `{{*}}` `get({string} key)` — Returns cached value for `key` or undefined for cache miss.
-     * - `{void}` `remove({string} key)` — Removes a key-value pair from the cache.
-     * - `{void}` `removeAll()` — Removes all cached values.
-     * - `{void}` `destroy()` — Removes references to this cache from $cacheFactory.
-     */
-    function cacheFactory(cacheId, options) {
-      if (cacheId in caches) {
-        throw minErr("$cacheFactory")(
-          "iid",
-          "CacheId '{0}' is already taken!",
-          cacheId,
-        );
-      }
-
-      let size = 0;
-      let stats = extend({}, options, { id: cacheId });
-      let data = Object.create(null);
-      const capacity = (options && options.capacity) || Number.MAX_VALUE;
-      let lruHash = Object.create(null);
-      let freshEnd = null;
-      let staleEnd = null;
-
-      /**
-       * A cache object used to store and retrieve data, primarily used by
-       * {@link $templateRequest $templateRequest} and the {@link ng.directive:script script}
-       * directive to cache templates and other data.
-       *
-       * ```js
-       *  angular.module('superCache')
-       *    .factory('superCache', ['$cacheFactory', function($cacheFactory) {
-       *      return $cacheFactory('super-cache');
-       *    }]);
-       * ```
-       *
-       * Example test:
-       *
-       * ```js
-       *  it('should behave like a cache', inject(function(superCache) {
-       *    superCache.put('key', 'value');
-       *    superCache.put('another key', 'another value');
-       *
-       *    expect(superCache.info()).toEqual({
-       *      id: 'super-cache',
-       *      size: 2
-       *    });
-       *
-       *    superCache.remove('another key');
-       *    expect(superCache.get('another key')).toBeUndefined();
-       *
-       *    superCache.removeAll();
-       *    expect(superCache.info()).toEqual({
-       *      id: 'super-cache',
-       *      size: 0
-       *    });
-       *  }));
-       * ```
-       */
-      return (caches[cacheId] = {
-        /**
-         * Inserts a named entry into the {@link $cacheFactory.Cache Cache} object to be
-         * retrieved later, and incrementing the size of the cache if the key was not already
-         * present in the cache. If behaving like an LRU cache, it will also remove stale
-         * entries from the set.
-         *
-         * It will not insert undefined values into the cache.
-         *
-         * @param {string} key the key under which the cached data is stored.
-         * @param {*} value the value to store alongside the key. If it is undefined, the key
-         *    will not be stored.
-         * @returns {*} the value stored.
-         */
-        put(key, value) {
-          if (isUndefined(value)) return;
-          if (capacity < Number.MAX_VALUE) {
-            const lruEntry = lruHash[key] || (lruHash[key] = { key });
-
-            refresh(lruEntry);
-          }
-
-          if (!(key in data)) size++;
-          data[key] = value;
-
-          if (size > capacity) {
-            this.remove(staleEnd.key);
-          }
-
-          return value;
-        },
-
-        /**
-         * Retrieves named data stored in the {@link $cacheFactory.Cache Cache} object.
-         *
-         * @param {string} key the key of the data to be retrieved
-         * @returns {*} the value stored.
-         */
-        get(key) {
-          if (capacity < Number.MAX_VALUE) {
-            const lruEntry = lruHash[key];
-
-            if (!lruEntry) return;
-
-            refresh(lruEntry);
-          }
-
-          return data[key];
-        },
-
-        /**
-         * Removes an entry from the {@link $cacheFactory.Cache Cache} object.
-         *
-         * @param {string} key the key of the entry to be removed
-         */
-        remove(key) {
-          if (capacity < Number.MAX_VALUE) {
-            const lruEntry = lruHash[key];
-
-            if (!lruEntry) return;
-
-            if (lruEntry === freshEnd) freshEnd = lruEntry.p;
-            if (lruEntry === staleEnd) staleEnd = lruEntry.n;
-            link(lruEntry.n, lruEntry.p);
-
-            delete lruHash[key];
-          }
-
-          if (!(key in data)) return;
-
-          delete data[key];
-          size--;
-        },
-
-        /**
-         * Clears the cache object of any entries.
-         */
-        removeAll() {
-          data = Object.create(null);
-          size = 0;
-          lruHash = Object.create(null);
-          freshEnd = staleEnd = null;
-        },
-
-        /**
-         * Destroys the {@link $cacheFactory.Cache Cache} object entirely,
-         * removing it from the {@link $cacheFactory $cacheFactory} set.
-         */
-        destroy() {
-          data = null;
-          stats = null;
-          lruHash = null;
-          delete caches[cacheId];
-        },
-
-        /**
-         * Retrieve information regarding a particular {@link $cacheFactory.Cache Cache}.
-         *
-         * @returns {object} an object with the following properties:
-         *   <ul>
-         *     <li>**id**: the id of the cache instance</li>
-         *     <li>**size**: the number of entries kept in the cache instance</li>
-         *     <li>**...**: any additional properties from the options object when creating the
-         *       cache.</li>
-         *   </ul>
-         */
-        info() {
-          return extend({}, stats, { size });
-        },
-      });
-
-      /**
-       * makes the `entry` the freshEnd of the LRU linked list
-       */
-      function refresh(entry) {
-        if (entry !== freshEnd) {
-          if (!staleEnd) {
-            staleEnd = entry;
-          } else if (staleEnd === entry) {
-            staleEnd = entry.n;
-          }
-
-          link(entry.n, entry.p);
-          link(entry, freshEnd);
-          freshEnd = entry;
-          freshEnd.n = null;
-        }
-      }
-
-      /**
-       * bidirectionally links two entries of the LRU linked list
-       */
-      function link(nextEntry, prevEntry) {
-        if (nextEntry !== prevEntry) {
-          if (nextEntry) nextEntry.p = prevEntry; // p stands for previous, 'prev' didn't minify
-          if (prevEntry) prevEntry.n = nextEntry; // n stands for next, 'next' didn't minify
-        }
-      }
-    }
-
-    /**
-     * Get information about all the caches that have been created
-     *
-     * @returns {Object} - key-value map of `cacheId` to the result of calling `cache#info`
-     */
-    cacheFactory.info = function () {
-      const info = {};
-      forEach(caches, (cache, cacheId) => {
-        info[cacheId] = cache.info();
-      });
-      return info;
-    };
-
-    /**
-     * Get access to a cache object by the `cacheId` used when it was created.
-     *
-     * @param {string} cacheId Name or id of a cache to access.
-     * @returns {object} Cache object identified by the cacheId or undefined if no such cache.
-     */
-    cacheFactory.get = function (cacheId) {
-      return caches[cacheId];
-    };
-
-    return cacheFactory;
-  };
-}
-
-/**
- * @name $templateCache
- *
- * @description
- * `$templateCache` is a {@link $cacheFactory.Cache Cache object} created by the
- * {@link ng.$cacheFactory $cacheFactory}.
- *
- * The first time a template is used, it is loaded in the template cache for quick retrieval. You
- * can load templates directly into the cache in a `script` tag, by using {@link $templateRequest},
- * or by consuming the `$templateCache` service directly.
- *
- * Adding via the `script` tag:
- *
- * ```html
- *   <script type="text/ng-template" id="templateId.html">
- *     <p>This is the content of the template</p>
- *   </script>
- * ```
- *
- * **Note:** the `script` tag containing the template does not need to be included in the `head` of
- * the document, but it must be a descendent of the {@link ng.$rootElement $rootElement} (e.g.
- * element with {@link ngApp} attribute), otherwise the template will be ignored.
- *
- * Adding via the `$templateCache` service:
- *
- * ```js
- * let myApp = angular.module('myApp', []);
- * myApp.run(function($templateCache) {
- *   $templateCache.put('templateId.html', 'This is the content of the template');
- * });
- * ```
- *
- * To retrieve the template later, simply use it in your component:
- * ```js
- * myApp.component('myComponent', {
- *    templateUrl: 'templateId.html'
- * });
- * ```
- *
- * or get it via the `$templateCache` service:
- * ```js
- * $templateCache.get('templateId.html')
- * ```
- *
- */
-export function TemplateCacheProvider() {
-  this.$get = ["$cacheFactory", ($cacheFactory) => $cacheFactory("templates")];
-}

package/src/services/cache-factory.md

@@ -1,75 +0,0 @@
-/\*\*
-
-- @ngdoc service
-- @name $cacheFactory
--
--
-- @description
-- Factory that constructs {@link $cacheFactory.Cache Cache} objects and gives access to
-- them.
--
-- ```js
-
-  ```
-
--
-- let cache = $cacheFactory('cacheId');
-- expect($cacheFactory.get('cacheId')).toBe(cache);
-- expect($cacheFactory.get('noSuchCacheId')).not.toBeDefined();
--
-- cache.put("key", "value");
-- cache.put("another key", "another value");
--
-- // We've specified no options on creation
-- expect(cache.info()).toEqual({id: 'cacheId', size: 2});
--
-- ```
-
-  ```
-
--
--
-- @example
-  <example module="cacheExampleApp" name="cache-factory">
-  <file name="index.html">
-  <div ng-controller="CacheController">
-  <input ng-model="newCacheKey" placeholder="Key">
-  <input ng-model="newCacheValue" placeholder="Value">
-  <button ng-click="put(newCacheKey, newCacheValue)">Cache</button>
-
-          <p ng-if="keys.length">Cached Values</p>
-          <div ng-repeat="key in keys">
-            <span ng-bind="key"></span>
-            <span>: </span>
-            <b ng-bind="cache.get(key)"></b>
-          </div>
-
-          <p>Cache Info</p>
-          <div ng-repeat="(key, value) in cache.info()">
-            <span ng-bind="key"></span>
-            <span>: </span>
-            <b ng-bind="value"></b>
-          </div>
-        </div>
-      </file>
-      <file name="script.js">
-        angular.module('cacheExampleApp', []).
-          controller('CacheController', ['$scope', '$cacheFactory', function($scope, $cacheFactory) {
-            $scope.keys = [];
-            $scope.cache = $cacheFactory('cacheId');
-            $scope.put = function(key, value) {
-              if (angular.isUndefined($scope.cache.get(key))) {
-                $scope.keys.push(key);
-              }
-              $scope.cache.put(key, angular.isUndefined(value) ? null : value);
-            };
-          }]);
-      </file>
-      <file name="style.css">
-        p {
-          margin: 10px 0 3px;
-        }
-      </file>
-
-    </example>
-  */