@angular-wave/angular.ts 0.9.4 → 0.9.5

package/src/core/di/ng-module.spec.js

@@ -1,263 +0,0 @@
-import {
-  INJECTOR_LITERAL,
-  NgModule,
-  COMPILE_LITERAL,
-  ANIMATION_LITERAL,
-  FILTER_LITERAL,
-  CONTROLLER_LITERAL,
-} from "./ng-module.js";
-import { $injectTokens } from "../../injection-tokens.js";
-
-describe("NgModule", () => {
-  /** @type {NgModule} */
-  let ngModule;
-  let a = new Object();
-  let b = () => {};
-  beforeEach(() => (ngModule = new NgModule("test", ["otherModule"])));
-
-  it("can be instantiated", () => {
-    expect(ngModule).toBeDefined();
-    expect(ngModule.name).toBeDefined();
-    expect(ngModule.requires).toEqual(["otherModule"]);
-  });
-
-  it("can't be instantiated without name or dependencies", () => {
-    expect(() => new NgModule()).toThrowError();
-    expect(() => new NgModule("test")).toThrowError();
-  });
-
-  it("can store constants", () => {
-    // when contants are registered
-    ngModule.constant("aConstant", 42);
-    expect(ngModule.invokeQueue[0]).toEqual([
-      $injectTokens.$provide,
-      "constant",
-      ["aConstant", 42],
-    ]);
-
-    // then they are prepended to invocation queue
-    ngModule.constant("bConstant", 24);
-    expect(ngModule.invokeQueue[0]).toEqual([
-      $injectTokens.$provide,
-      "constant",
-      ["bConstant", 24],
-    ]);
-    expect(ngModule.invokeQueue[1]).toEqual([
-      $injectTokens.$provide,
-      "constant",
-      ["aConstant", 42],
-    ]);
-  });
-
-  it("can store values", () => {
-    // when value are registered
-    ngModule.value("aValue", 42);
-    expect(ngModule.invokeQueue[0]).toEqual([
-      $injectTokens.$provide,
-      "value",
-      ["aValue", 42],
-    ]);
-
-    // then are pushed to invocation queue
-    ngModule.value("bValue", 24);
-    expect(ngModule.invokeQueue[1]).toEqual([
-      $injectTokens.$provide,
-      "value",
-      ["bValue", 24],
-    ]);
-    expect(ngModule.invokeQueue[0]).toEqual([
-      $injectTokens.$provide,
-      "value",
-      ["aValue", 42],
-    ]);
-  });
-
-  it("can store config blocks", () => {
-    // when config functions are registered
-    let fn1 = () => {};
-    let fn2 = () => {};
-    ngModule.config(fn1);
-    ngModule.config(fn2);
-
-    // then they are appended to config queue
-    expect(ngModule.configBlocks[0]).toEqual([
-      INJECTOR_LITERAL,
-      "invoke",
-      [fn1],
-    ]);
-    expect(ngModule.configBlocks[1]).toEqual([
-      INJECTOR_LITERAL,
-      "invoke",
-      [fn2],
-    ]);
-  });
-
-  it("can store components", () => {
-    ngModule.component("aComponent", a).component("bComponent", b);
-    expect(ngModule.invokeQueue[0]).toEqual([
-      COMPILE_LITERAL,
-      "component",
-      ["aComponent", a],
-    ]);
-
-    expect(ngModule.invokeQueue[1]).toEqual([
-      COMPILE_LITERAL,
-      "component",
-      ["bComponent", b],
-    ]);
-    // Objects do not get a name
-    expect(a.$$moduleName).toBeUndefined();
-    // Functions get a name
-    expect(b.$$moduleName).toBe("bComponent");
-  });
-
-  it("can store factories", () => {
-    ngModule.factory("aFactory", a).factory("bFactory", b);
-    expect(ngModule.invokeQueue[0]).toEqual([
-      $injectTokens.$provide,
-      "factory",
-      ["aFactory", a],
-    ]);
-
-    expect(ngModule.invokeQueue[1]).toEqual([
-      $injectTokens.$provide,
-      "factory",
-      ["bFactory", b],
-    ]);
-    // Objects do not get a name
-    expect(a.$$moduleName).toBeUndefined();
-    // Functions get a name
-    expect(b.$$moduleName).toBe("bFactory");
-  });
-
-  it("can store services", () => {
-    ngModule.service("aService", a).service("bService", b);
-    expect(ngModule.invokeQueue[0]).toEqual([
-      $injectTokens.$provide,
-      "service",
-      ["aService", a],
-    ]);
-
-    expect(ngModule.invokeQueue[1]).toEqual([
-      $injectTokens.$provide,
-      "service",
-      ["bService", b],
-    ]);
-    // Objects do not get a name
-    expect(a.$$moduleName).toBeUndefined();
-    // Functions get a name
-    expect(b.$$moduleName).toBe("bService");
-  });
-
-  it("can store providers", () => {
-    ngModule.provider("aProvider", a).provider("bProvider", b);
-    expect(ngModule.invokeQueue[0]).toEqual([
-      $injectTokens.$provide,
-      "provider",
-      ["aProvider", a],
-    ]);
-
-    expect(ngModule.invokeQueue[1]).toEqual([
-      $injectTokens.$provide,
-      "provider",
-      ["bProvider", b],
-    ]);
-    // Objects do not get a name
-    expect(a.$$moduleName).toBeUndefined();
-    // Functions get a name
-    expect(b.$$moduleName).toBe("bProvider");
-  });
-
-  it("can store decorators", () => {
-    ngModule.decorator("aDecorator", a).decorator("bDecorator", b);
-    expect(ngModule.configBlocks[0]).toEqual([
-      $injectTokens.$provide,
-      "decorator",
-      ["aDecorator", a],
-    ]);
-
-    expect(ngModule.configBlocks[1]).toEqual([
-      $injectTokens.$provide,
-      "decorator",
-      ["bDecorator", b],
-    ]);
-    // Objects do not get a name
-    expect(a.$$moduleName).toBeUndefined();
-    // Functions get a name
-    expect(b.$$moduleName).toBe("bDecorator");
-  });
-
-  it("can store directives", () => {
-    ngModule.directive("aDirective", a).directive("bDirective", b);
-    expect(ngModule.invokeQueue[0]).toEqual([
-      COMPILE_LITERAL,
-      "directive",
-      ["aDirective", a],
-    ]);
-
-    expect(ngModule.invokeQueue[1]).toEqual([
-      COMPILE_LITERAL,
-      "directive",
-      ["bDirective", b],
-    ]);
-    // Objects do not get a name
-    expect(a.$$moduleName).toBeUndefined();
-    // Functions get a name
-    expect(b.$$moduleName).toBe("bDirective");
-  });
-
-  it("can store animations", () => {
-    ngModule.animation("aAnimation", a).animation("bAnimation", b);
-    expect(ngModule.invokeQueue[0]).toEqual([
-      ANIMATION_LITERAL,
-      "register",
-      ["aAnimation", a],
-    ]);
-
-    expect(ngModule.invokeQueue[1]).toEqual([
-      ANIMATION_LITERAL,
-      "register",
-      ["bAnimation", b],
-    ]);
-    // Objects do not get a name
-    expect(a.$$moduleName).toBeUndefined();
-    // Functions get a name
-    expect(b.$$moduleName).toBe("bAnimation");
-  });
-
-  it("can store filters", () => {
-    ngModule.filter("aFilter", a).filter("bFilter", b);
-    expect(ngModule.invokeQueue[0]).toEqual([
-      FILTER_LITERAL,
-      "register",
-      ["aFilter", a],
-    ]);
-    expect(ngModule.invokeQueue[1]).toEqual([
-      FILTER_LITERAL,
-      "register",
-      ["bFilter", b],
-    ]);
-    // Objects do not get a name
-    expect(a.$$moduleName).toBeUndefined();
-    // Functions get a name
-    expect(b.$$moduleName).toBe("bFilter");
-  });
-
-  it("can store controllers", () => {
-    ngModule.controller("aController", a).controller("bController", b);
-    expect(ngModule.invokeQueue[0]).toEqual([
-      CONTROLLER_LITERAL,
-      "register",
-      ["aController", a],
-    ]);
-    expect(ngModule.invokeQueue[1]).toEqual([
-      CONTROLLER_LITERAL,
-      "register",
-      ["bController", b],
-    ]);
-    // Objects do not get a name
-    expect(a.$$moduleName).toBeUndefined();
-    // Functions get a name
-    expect(b.$$moduleName).toBe("bController");
-  });
-});

package/src/core/di/ng-module.test.js

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

package/src/core/filter/filter.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/filter/filter.spec.js"></script>
-  </head>
-  <body>
-    <div id="app"></div>
-  </body>
-</html>

package/src/core/filter/filter.js

@@ -1,55 +0,0 @@
-import { $injectTokens as $t } from "../../injection-tokens.js";
-import { isObject } from "../../shared/utils.js";
-import { filterFilter } from "../../filters/filter.js";
-import { jsonFilter } from "../../filters/filters.js";
-import { limitToFilter } from "../../filters/limit-to.js";
-import { orderByFilter } from "../../filters/order-by.js";
-import {
-  $IncludedByStateFilter,
-  $IsStateFilter,
-} from "../../router/state-filters.js";
-
-const SUFFIX = "Filter";
-
-export class FilterProvider {
-  /* @ignore */ static $inject = [$t.$provide];
-
-  /**
-   * @param {import('../../interface.ts').Provider} $provide
-   */
-  constructor($provide) {
-    this.$provide = $provide;
-    this.register({
-      filter: filterFilter,
-      json: jsonFilter,
-      limitTo: limitToFilter,
-      orderBy: orderByFilter,
-      isState: $IsStateFilter,
-      includedByState: $IncludedByStateFilter,
-    });
-  }
-
-  /**
-   * @param {string|Record<string, ng.FilterFn>} name
-   * @param {ng.FilterService} [factory]
-   * @return {import('../../interface.ts').Provider}
-   */
-  register(name, factory) {
-    if (isObject(name)) {
-      const filters = {};
-      Object.entries(name).forEach(([key, filter]) => {
-        filters[key] = this.register(key, filter);
-      });
-    }
-    return this.$provide.factory(name + SUFFIX, factory);
-  }
-
-  $get = [
-    $t.$injector,
-    /**
-     * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
-     * @returns {ng.FilterService}
-     */
-    ($injector) => (/** @type {string} */ name) => $injector.get(name + SUFFIX),
-  ];
-}

package/src/core/filter/filter.md

@@ -1,132 +0,0 @@
-/\*\*
-
-- @ngdoc provider
-- @name $filterProvider
-- @description
--
-- Filters are just functions which transform input to an output. However filters need to be
-- Dependency Injected. To achieve this a filter definition consists of a factory function which is
-- annotated with dependencies and is responsible for creating a filter function.
--
-- <div class="alert alert-warning">
-- **Note:** Filter names must be valid AngularTS {@link expression} identifiers, such as `uppercase` or `orderBy`.
-- Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace
-- your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores
-- (`myapp_subsection_filterx`).
-- </div>
--
-- ```js
-
-  ```
-
-- // Filter registration
-- function MyModule($provide, $filterProvider) {
--     // create a service to demonstrate injection (not always needed)
--     $provide.value('greet', function(name){
--       return 'Hello ' + name + '!';
--     });
--
--     // register a filter factory which uses the
--     // greet service to demonstrate DI.
--     $filterProvider.register('greet', function(greet){
--       // return the filter function which uses the greet service
--       // to generate salutation
--       return function(text) {
--         // filters need to be forgiving so check input validity
--         return text && greet(text) || text;
--       };
--     });
-- }
-- ```
-
-  ```
-
--
-- The filter function is registered with the `$injector` under the filter name suffix with
-- `Filter`.
--
-- ```js
-
-  ```
-
-- it('should be the same instance', inject(
--     function($filterProvider) {
--       $filterProvider.register('reverse', function(){
--         return ...;
--       });
--     },
--     function($filter, reverseFilter) {
--       expect($filter('reverse')).toBe(reverseFilter);
--     });
-- ```
-
-  ```
-
--
--
-- For more information about how AngularTS filters work, and how to create your own filters, see
-- {@link guide/filter Filters} in the AngularTS Developer Guide.
-  \*/
-
-/\*\*
-
-- @ngdoc service
-- @name $filter
-- @kind function
-- @description
-- Filters are used for formatting data displayed to the user.
--
-- They can be used in view templates, controllers or services. AngularTS comes
-- with a collection of [built-in filters](api/ng/filter), but it is easy to
-- define your own as well.
--
-- The general syntax in templates is as follows:
--
-- ```html
-
-  ```
-
-- {{ expression [| filter_name[:parameter_value] ... ] }}
-- ```
-
-  ```
-
--
-- @param {String} name Name of the filter function to retrieve
-- @return {Function} the filter function
-- @example
-  <example name="$filter" module="filterExample">
-  <file name="index.html">
-  <div ng-controller="MainCtrl">`
-  <h3>{{ originalText }}</h3>
-  <h3>{{ filteredText }}</h3>
-  </div>
-  </file>
-
-     <file name="script.js">
-      angular.module('filterExample', [])
-      .controller('MainCtrl', function($scope, $filter) {
-        $scope.originalText = 'hello';
-        $scope.filteredText = $filter('uppercase')($scope.originalText);
-      });
-     </file>
-   </example>
-  */
-
-/\*\*
-
-- @ngdoc method
-- @name $filterProvider#register
-- @param {string|Object} name Name of the filter function, or an object map of filters where
-- the keys are the filter names and the values are the filter factories.
--
-- <div class="alert alert-warning">
-- **Note:** Filter names must be valid AngularTS {@link expression} identifiers, such as `uppercase` or `orderBy`.
-- Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace
-- your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores
-- (`myapp_subsection_filterx`).
-- </div>
-- @param {Function} factory If the first argument was a string, a factory function for the filter to be registered.
-- @returns {Object} Registered filter instance, or if a map of filters was provided then a map
-- of the registered filter instances.
-  \*/

package/src/core/filter/filter.spec.js

@@ -1,149 +0,0 @@
-import { Angular } from "../../angular.js";
-import { createInjector } from "../di/injector.js";
-
-describe("filter", function () {
-  beforeEach(() => {
-    window.angular = new Angular();
-  });
-  it("can be registered and obtained", () => {
-    const myFilter = () => {};
-    const myFilterFactory = () => {
-      return myFilter;
-    };
-    const injector = createInjector([
-      "ng",
-      function ($filterProvider) {
-        $filterProvider.register("my", myFilterFactory);
-      },
-    ]);
-    const $filter = injector.get("$filter");
-    expect($filter("my")).toBe(myFilter);
-  });
-
-  it("allows registering multiple filters with an object", () => {
-    const myFilter = () => {};
-    const myOtherFilter = () => {};
-    const injector = createInjector([
-      "ng",
-      function ($filterProvider) {
-        $filterProvider.register({
-          my: () => {
-            return myFilter;
-          },
-          myOther: () => {
-            return myOtherFilter;
-          },
-        });
-      },
-    ]);
-    const $filter = injector.get("$filter");
-    expect($filter("my")).toBe(myFilter);
-    expect($filter("myOther")).toBe(myOtherFilter);
-  });
-
-  it("is available through injector", () => {
-    const myFilter = () => {};
-    const injector = createInjector([
-      "ng",
-      function ($filterProvider) {
-        $filterProvider.register("my", () => {
-          return myFilter;
-        });
-      },
-    ]);
-    expect(injector.has("myFilter")).toBe(true);
-    expect(injector.get("myFilter")).toBe(myFilter);
-  });
-
-  it("may have dependencies in factory", () => {
-    const injector = createInjector([
-      "ng",
-      function ($provide, $filterProvider) {
-        $provide.constant("suffix", "!");
-        $filterProvider.register("my", function (suffix) {
-          return function (v) {
-            return suffix + v;
-          };
-        });
-      },
-    ]);
-    expect(injector.has("myFilter")).toBe(true);
-  });
-
-  it("can be registered through module API", () => {
-    const myFilter = () => {};
-    angular.module("myModule", []).filter("my", () => {
-      return myFilter;
-    });
-    const injector = createInjector(["ng", "myModule"]);
-    expect(injector.has("myFilter")).toBe(true);
-    expect(injector.get("myFilter")).toBe(myFilter);
-  });
-});
-
-describe("filter filter", function () {
-  beforeEach(function () {
-    window.angular = new Angular();
-  });
-  it("is available", function () {
-    const injector = createInjector(["ng"]);
-    expect(injector.has("filterFilter")).toBe(true);
-  });
-  // TODO
-});
-
-describe("$filter", () => {
-  let $filterProvider;
-  let $filter;
-
-  beforeEach(() => {
-    window.angular = new Angular();
-    const injector = createInjector([
-      "ng",
-      function (_$filterProvider_) {
-        $filterProvider = _$filterProvider_;
-      },
-    ]);
-    $filter = injector.get("$filter");
-  });
-
-  describe("provider", () => {
-    it("should allow registration of filters", () => {
-      const FooFilter = function () {
-        return function () {
-          return "foo";
-        };
-      };
-
-      $filterProvider.register("foo", FooFilter);
-
-      const fooFilter = $filter("foo");
-      expect(fooFilter()).toBe("foo");
-    });
-
-    it("should allow registration of a map of filters", () => {
-      const FooFilter = function () {
-        return function () {
-          return "foo";
-        };
-      };
-
-      const BarFilter = function () {
-        return function () {
-          return "bar";
-        };
-      };
-
-      $filterProvider.register({
-        foo: FooFilter,
-        bar: BarFilter,
-      });
-
-      const fooFilter = $filter("foo");
-      expect(fooFilter()).toBe("foo");
-
-      const barFilter = $filter("bar");
-      expect(barFilter()).toBe("bar");
-    });
-  });
-});

package/src/core/filter/filter.test.js

@@ -1,12 +0,0 @@
-import { test, expect } from "@playwright/test";
-
-const TEST_URL = "src/core/filter/filter.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/core/interpolate/interface.ts

@@ -1,14 +0,0 @@
-export interface InterpolationFunction {
-  (context: any): string;
-}
-
-export interface InterpolateService {
-  (
-    text: string,
-    mustHaveExpression?: boolean,
-    trustedContext?: string,
-    allOrNothing?: boolean,
-  ): InterpolationFunction | undefined;
-  endSymbol(): string;
-  startSymbol(): string;
-}

package/src/core/interpolate/interpolate.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/interpolate/interpolate.spec.js"
-    ></script>
-  </head>
-  <body>
-    <div id="app"></div>
-  </body>
-</html>