@angular-wave/angular.ts 0.0.63 → 0.0.65

package/src/router/view/view.spec.js

@@ -1,6 +1,5 @@
 import { dealoc, JQLite } from "../../shared/jqlite/jqlite";
 import { Angular } from "../../loader";
-import { publishExternalAPI } from "../../public";
 import { curry } from "../../shared/hof";
 import { StateMatcher } from "../../router/state/state-matcher";
 import { StateBuilder } from "../../router/state/state-builder";
@@ -29,7 +28,7 @@ describe("view", () => {
   beforeEach(() => {
     dealoc(document.getElementById("dummy"));
     window.angular = new Angular();
-    publishExternalAPI();
+    window.angular = new Angular();
 
     window.angular
       .module("defaultModule", ["ng.router"])

package/src/router/view-hook.spec.js

@@ -1,6 +1,5 @@
 import { dealoc } from "../shared/jqlite/jqlite";
 import { Angular } from "../loader";
-import { publishExternalAPI } from "../public";
 import { wait } from "../shared/test-utils";
 
 describe("view hooks", () => {
@@ -23,7 +22,6 @@ describe("view hooks", () => {
   beforeEach(() => {
     dealoc(document.getElementById("dummy"));
     window.angular = new Angular();
-    publishExternalAPI();
     app = window.angular
       .module("defaultModule", ["ng.router"])
       .config(($stateProvider) => {

package/src/router/view-scroll.spec.js

@@ -1,6 +1,5 @@
 import { dealoc } from "../shared/jqlite/jqlite";
 import { Angular } from "../loader";
-import { publishExternalAPI } from "../public";
 import { wait } from "../shared/test-utils";
 
 describe("ngView", () => {
@@ -10,7 +9,6 @@ describe("ngView", () => {
     beforeEach(() => {
       dealoc(document.getElementById("dummy"));
       window.angular = new Angular();
-      publishExternalAPI();
       window.angular.module("defaultModule", ["ng.router"]);
       let $injector = window.angular.bootstrap(
         document.getElementById("dummy"),
@@ -48,7 +46,6 @@ describe("ngView", () => {
     beforeEach(() => {
       dealoc(document.getElementById("dummy"));
       window.angular = new Angular();
-      publishExternalAPI();
       let module = window.angular.module("defaultModule", ["ng.router"]);
       module.config(($provide, $ngViewScrollProvider) => {
         $provide.decorator("$anchorScroll", function ($delegate) {

package/src/services/http/http.spec.js

@@ -1,6 +1,6 @@
-import { createInjector } from "../../injector";
+import { createInjector } from "../../core/di/injector";
 import { isObject } from "../../shared/utils";
-import { publishExternalAPI } from "../../public";
+import { Angular } from "../../loader";
 
 export function getLastAjaxRequest() {
   let ajaxEntries = performance
@@ -13,7 +13,7 @@ describe("$http", function () {
   let $http, $injector, $httpBackend, requests, response, $rootScope, $q;
 
   beforeEach(function () {
-    publishExternalAPI();
+    window.angular = new Angular();
     requests = [];
     $injector = createInjector(["ng"]);
     $http = $injector.get("$http");

package/src/services/http/template-request.spec.js

@@ -1,11 +1,11 @@
-import { createInjector } from "../../injector";
-import { publishExternalAPI } from "../../public";
+import { createInjector } from "../../core/di/injector";
+import { Angular } from "../../loader";
 
 describe("$templateRequest", () => {
-  let module, $rootScope, $templateRequest, $templateCache, $sce;
+  let module, $rootScope, $templateRequest, $templateCache, $sce, angular;
 
   beforeEach(() => {
-    publishExternalAPI();
+    angular = window.angular = new Angular();
     module = angular.module("test", ["ng"]);
     let injector = createInjector(["test"]);
     $rootScope = injector.get("$rootScope");

package/src/services/http-backend/http-backend.spec.js

@@ -1,5 +1,5 @@
-import { createInjector } from "../../injector";
-import { publishExternalAPI } from "../../public";
+import { createInjector } from "../../core/di/injector";
+import { Angular } from "../../loader";
 import { createHttpBackend } from "./http-backend";
 import sinon from "sinon";
 
@@ -9,6 +9,7 @@ describe("$httpBackend", () => {
   let xhr;
   let callback;
   let requests;
+  let angular;
 
   beforeEach(() => {
     xhr = sinon.useFakeXMLHttpRequest();
@@ -16,7 +17,7 @@ describe("$httpBackend", () => {
     xhr.onCreate = function (req) {
       requests.push(req);
     };
-    publishExternalAPI();
+    angular = window.angular = new Angular();
     let $injector = createInjector(["ng"]);
     $browser = $injector.get("$browser");
     xhr = sinon.useFakeXMLHttpRequest();

package/src/shared/jqlite/jqlite.js

@@ -744,11 +744,9 @@ JQLite.prototype.triggerHandler = function (event, extraParameters) {
     if (isUndefined(value)) {
       value = fn(this[i], event, extraParameters);
       if (isDefined(value)) {
-        // @ts-ignore
         value = JQLite(value);
       }
     } else {
-      // @ts-ignore
       addNodes(value, fn(this[i], event, extraParameters));
     }
   }

package/src/shared/jqlite/jqlite.spec.js

@@ -6,9 +6,8 @@ import {
   getOrSetCacheData,
   removeElementData,
 } from "./jqlite";
-import { angularInit } from "../../loader";
-import { createInjector } from "../../injector";
-import { publishExternalAPI } from "../../public";
+import { Angular } from "../../loader";
+import { createInjector } from "../../core/di/injector";
 import { equals, forEach } from "../../shared/utils";
 import { browserTrigger } from "../../shared/test-utils";
 import { CACHE, EXPANDO } from "../../core/cache/cache";
@@ -27,7 +26,7 @@ describe("jqLite", () => {
   });
 
   beforeEach(() => {
-    publishExternalAPI();
+    window.angular = new Angular();
     injector = createInjector(["ng"]);
     scope = injector.get("$rootScope");
     jasmine.addMatchers({
@@ -363,7 +362,7 @@ describe("jqLite", () => {
     it("should retrieve injector attached to the current element or its parent", () => {
       const template = JQLite("<div><span></span></div>");
       const span = template.children().eq(0);
-      const injector = angularInit(template[0]);
+      const injector = window.angular.init(template[0]);
 
       expect(span.injector()).toBe(injector);
       dealoc(template);

package/src/shared/test-utils.js

@@ -1,7 +1,7 @@
 import { JQLite } from "./jqlite/jqlite";
 
 /**
- * @param {HTMLElement} element
+ * @param {HTMLElement|JQLite} element
  * @param {string} event
  */
 export function browserTrigger(element, event) {

package/src/shared/utils.js

@@ -1070,7 +1070,16 @@ export function shallowCopy(src, dst) {
 }
 
 /**
- * throw error if the argument is falsy.
+ * Throw error if the argument is false
+ * @param {boolean} argument
+ * @param {string} errorMsg
+ */
+export function assert(argument, errorMsg = "Assertion failed") {
+  if (!argument) throw new Error(errorMsg);
+}
+
+/**
+ * Throw error if the argument is falsy.
  */
 export function assertArg(arg, name, reason) {
   if (!arg) {

package/src/src.html

@@ -12,7 +12,6 @@
     <script src="/jasmine/jasmine-5.1.2/boot1.js"></script>
     <script type="module" src="/src/angular.spec.js"></script>
     <script type="module" src="/src/binding.spec.js"></script>
-    <script type="module" src="/src/injector.spec.js"></script>
     <script type="module" src="/src/loader.spec.js"></script>
     <script type="module" src="/src/public.spec.js"></script>
   </head>

package/types/animations/module.d.ts

@@ -1 +1 @@
-export function initAnimateModule(): void;
+export function initAnimateModule(angular: any): void;

package/types/core/di/injector.d.ts

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param {Array<String|Function>} modulesToLoad
+ * @param {boolean} [strictDi]
+ * @returns {import("../../types").InjectorService}
+ */
+export function createInjector(modulesToLoad: Array<string | Function>, strictDi?: boolean): import("../../types").InjectorService;
+export namespace createInjector {
+    export { annotate as $$annotate };
+}
+declare function annotate(fn: any, strictDi: any, name: any): any;
+export {};

package/types/core/di/ng-module.d.ts

@@ -0,0 +1,79 @@
+export const PROVIDE_LITERAL: "$provide";
+export const INJECTOR_LITERAL: "$injector";
+export const COMPILE_LITERAL: "$compileProvider";
+export const ANIMATION_LITERAL: "$animateProvider";
+export const FILTER_LITERAL: "$filterProvider";
+export const CONTROLLER_LITERAL: "$controllerProvider";
+/**
+ * Modules are collections of application configuration information for components:
+ * controllers, directives, filters, etc. They provide recipes for the injector
+ * to do the actual instantiation. A module itself has no behaviour but only state.
+ * A such, it acts as a data structure between the Angular instance and the injector service.
+ *
+ * Since this is an internal structure that is exposed only via the Angular instance,
+ * it contains no validation of the items it receives. It is up to the instantiator on
+ * modules to do the actual validation.
+ */
+export class NgModule {
+    /**
+     *
+     * @param {String} name - Name of the module
+     * @param {Array<String>} requires - List of modules which the injector will load before the current module
+     * @param {Function} [configFn]
+     */
+    constructor(name: string, requires: Array<string>, configFn?: Function);
+    /**
+     * @type {string}
+     * Name of the module.
+     */
+    name: string;
+    /**
+     * Holds the list of modules which the injector will load before the current module is
+     * loaded.
+     */
+    requires: string[];
+    /**
+     * Holds a collection of tasks, required to instantiate an angular component
+     * @type {!Array<Array<*>>}
+     */
+    invokeQueue: Array<Array<any>>;
+    /** @type {!Array<Array<*>>} */
+    configBlocks: Array<Array<any>>;
+    /** @type {!Array.<Function>} */
+    runBlocks: Array<Function>;
+    /** @type {Object} */
+    infoState: any;
+    /**
+     * @param {Object} value
+     * @returns
+     */
+    info(value: any): any;
+    /**
+     * @param {String} name
+     * @param {any} object
+     * @returns {NgModule}
+     */
+    value(name: string, object: any): NgModule;
+    /**
+     * @param {String} name
+     * @param {any} object
+     * @returns {NgModule}
+     */
+    constant(name: string, object: any): NgModule;
+    /**
+     *
+     * @param {Function} configFn
+     * @returns {NgModule}
+     */
+    config(configFn: Function): NgModule;
+    run(block: any): this;
+    component(name: any, options: any): this;
+    factory(name: any, providerFunction: any): this;
+    service(name: any, serviceFunction: any): this;
+    provider(name: any, providerType: any): this;
+    decorator(name: any, decorFn: any): this;
+    directive(name: any, directiveFactory: any): this;
+    animation(name: any, animationFactory: any): this;
+    filter(name: any, filterFn: any): this;
+    controller(name: any, ctlFn: any): this;
+}

package/types/exts/aria/aria.d.ts

@@ -1 +1 @@
-export function initAriaModule(): void;
+export function initAriaModule(angular: any): void;

package/types/exts/messages/messages.d.ts

@@ -1 +1 @@
-export function initMessageModule(): void;
+export function initMessageModule(angular: any): void;

package/types/index.d.ts

@@ -1,5 +1,2 @@
-/**
- * @type {Angular}
- */
 export const angular: Angular;
 import { Angular } from "./loader";

package/types/loader.d.ts

@@ -1,170 +1,9 @@
-/**
- * @ngdoc directive
- * @name ngApp
- *
- * @element ANY
- * @param {import('./types').Module} ngApp an optional application
- *   {@link angular.module module} name to load.
- * @param {boolean=} ngStrictDi if this attribute is present on the app element, the injector will be
- *   created in "strict-di" mode. This means that the application will fail to invoke functions which
- *   do not use explicit function annotation (and are thus unsuitable for minification), as described
- *   in {@link guide/di the Dependency Injection guide}, and useful debugging info will assist in
- *   tracking down the root of these bugs.
- *
- * @description
- *
- * Use this directive to **auto-bootstrap** an AngularJS application. The `ngApp` directive
- * designates the **root element** of the application and is typically placed near the root element
- * of the page - e.g. on the `<body>` or `<html>` tags.
- *
- * There are a few things to keep in mind when using `ngApp`:
- * - only one AngularJS application can be auto-bootstrapped per HTML document. The first `ngApp`
- *   found in the document will be used to define the root element to auto-bootstrap as an
- *   application. To run multiple applications in an HTML document you must manually bootstrap them using
- *   {@link angular.bootstrap} instead.
- * - AngularJS applications cannot be nested within each other.
- * - Do not use a directive that uses {@link ng.$compile#transclusion transclusion} on the same element as `ngApp`.
- *   This includes directives such as {@link ng.ngIf `ngIf`}, {@link ng.ngInclude `ngInclude`} and
- *   {@link ngRoute.ngView `ngView`}.
- *   Doing this misplaces the app {@link ng.$rootElement `$rootElement`} and the app's {@link auto.$injector injector},
- *   causing animations to stop working and making the injector inaccessible from outside the app.
- *
- * You can specify an **AngularJS module** to be used as the root module for the application.  This
- * module will be loaded into the {@link auto.$injector} when the application is bootstrapped. It
- * should contain the application code needed or have dependencies on other modules that will
- * contain the code. See {@link angular.module} for more information.
- *
- * In the example below if the `ngApp` directive were not placed on the `html` element then the
- * document would not be compiled, the `AppController` would not be instantiated and the `{{ a+b }}`
- * would not be resolved to `3`.
- *
- * @example
- *
- * ### Simple Usage
- *
- * `ngApp` is the easiest, and most common way to bootstrap an application.
- *
- <example module="ngAppDemo" name="ng-app">
-   <file name="index.html">
-   <div ng-controller="ngAppDemoController">
-     I can add: {{a}} + {{b}} =  {{ a+b }}
-   </div>
-   </file>
-   <file name="script.js">
-   angular.module('ngAppDemo', []).controller('ngAppDemoController', function($scope) {
-     $scope.a = 1;
-     $scope.b = 2;
-   });
-   </file>
- </example>
- *
- * @example
- *
- * ### With `ngStrictDi`
- *
- * Using `ngStrictDi`, you would see something like this:
- *
- <example ng-app-included="true" name="strict-di">
-   <file name="index.html">
-   <div ng-app="ngAppStrictDemo" ng-strict-di>
-       <div ng-controller="GoodController1">
-           I can add: {{a}} + {{b}} =  {{ a+b }}
-
-           <p>This renders because the controller does not fail to
-              instantiate, by using explicit annotation style (see
-              script.js for details)
-           </p>
-       </div>
-
-       <div ng-controller="GoodController2">
-           Name: <input ng-model="name"><br />
-           Hello, {{name}}!
-
-           <p>This renders because the controller does not fail to
-              instantiate, by using explicit annotation style
-              (see script.js for details)
-           </p>
-       </div>
-
-       <div ng-controller="BadController">
-           I can add: {{a}} + {{b}} =  {{ a+b }}
-
-           <p>The controller could not be instantiated, due to relying
-              on automatic function annotations (which are disabled in
-              strict mode). As such, the content of this section is not
-              interpolated, and there should be an error in your web console.
-           </p>
-       </div>
-   </div>
-   </file>
-   <file name="script.js">
-   angular.module('ngAppStrictDemo', [])
-     // BadController will fail to instantiate, due to relying on automatic function annotation,
-     // rather than an explicit annotation
-     .controller('BadController', function($scope) {
-       $scope.a = 1;
-       $scope.b = 2;
-     })
-     // Unlike BadController, GoodController1 and GoodController2 will not fail to be instantiated,
-     // due to using explicit annotations using the array style and $inject property, respectively.
-     .controller('GoodController1', ['$scope', function($scope) {
-       $scope.a = 1;
-       $scope.b = 2;
-     }])
-     .controller('GoodController2', GoodController2);
-     function GoodController2($scope) {
-       $scope.name = 'World';
-     }
-     GoodController2.$inject = ['$scope'];
-   </file>
-   <file name="style.css">
-   div[ng-controller] {
-       margin-bottom: 1em;
-       -webkit-border-radius: 4px;
-       border-radius: 4px;
-       border: 1px solid;
-       padding: .5em;
-   }
-   div[ng-controller^=Good] {
-       border-color: #d6e9c6;
-       background-color: #dff0d8;
-       color: #3c763d;
-   }
-   div[ng-controller^=Bad] {
-       border-color: #ebccd1;
-       background-color: #f2dede;
-       color: #a94442;
-       margin-bottom: 0;
-   }
-   </file>
- </example>
- */
-/**
- * @param {Element|Document} element
- */
-export function angularInit(element: Element | Document): void;
-/**
- * @ngdoc type
- * @name import('./types').Module
- * @module ng
- * @description
- *
- * Interface for configuring AngularJS {@link angular.module modules}.
- */
-export function setupModuleLoader(window: any): any;
-/**
- * @type {string} `version` from `package.json`, injected by Rollup plugin
- */
-export const VERSION: string;
 /**
  * Configuration option for AngularTS bootstrap process.
  *
  * @typedef {Object} AngularBootstrapConfig
  * @property {boolean} [strictDi] - Disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. Defaults to `false`.
  */
-/**
- * @class
- */
 export class Angular {
     /** @type {Map<number, import("./core/cache/cache").ExpandoStore>} */
     cache: Map<number, import("./core/cache/cache").ExpandoStore>;
@@ -189,18 +28,11 @@ export class Angular {
     /**
      * Use this function to manually start up AngularJS application.
      *
-     * For more information, see the {@link guide/bootstrap Bootstrap guide}.
-     *
      * AngularJS will detect if it has been loaded into the browser more than once and only allow the
      * first loaded script to be bootstrapped and will report a warning to the browser console for
      * each of the subsequent scripts. This prevents strange results in applications, where otherwise
      * multiple instances of AngularJS try to work on the DOM.
-     *
-     * <div class="alert alert-warning">
-     * **Note:** Protractor based end-to-end tests cannot use this function to bootstrap manually.
-     * They must use {@link ng.directive:ngApp ngApp}.
-     * </div>
-     *
+     *   *
      * <div class="alert alert-warning">
      * **Note:** Do not bootstrap the app on an element with a directive that uses {@link ng.$compile#transclusion transclusion},
      * such as {@link ng.ngIf `ngIf`}, {@link ng.ngInclude `ngInclude`} and {@link ngRoute.ngView `ngView`}.
@@ -251,16 +83,57 @@ export class Angular {
      */
     injector(modules: any[], strictDi: boolean | null): import("./types").InjectorService;
     /**
-   * @module angular
-   * @function reloadWithDebugInfo
-  
-   * @description
-   * Use this function to reload the current application with debug information turned on.
-   * This takes precedence over a call to `$compileProvider.debugInfoEnabled(false)`.
-   *
-   * See {@link ng.$compileProvider#debugInfoEnabled} for more.
-   */
-    reloadWithDebugInfo(): void;
+     * @param {Element|Document} element
+     */
+    init(element: Element | Document): void;
+    /**
+     *
+     * The `angular.module` is a global place for creating, registering and retrieving AngularJS
+     * modules.
+     * All modules (AngularJS core or 3rd party) that should be available to an application must be
+     * registered using this mechanism.
+     *
+     * Passing one argument retrieves an existing {@link import('./types').Module},
+     * whereas passing more than one argument creates a new {@link import('./types').Module}
+     *
+     *
+     * # Module
+     *
+     * A module is a collection of services, directives, controllers, filters, and configuration information.
+     * `angular.module` is used to configure the {@link auto.$injector $injector}.
+     *
+     * ```js
+     * // Create a new module
+     * let myModule = angular.module('myModule', []);
+     *
+     * // register a new service
+     * myModule.value('appName', 'MyCoolApp');
+     *
+     * // configure existing services inside initialization blocks.
+     * myModule.config(['$locationProvider', function($locationProvider) {
+     *   // Configure existing providers
+     *   $locationProvider.hashPrefix('!');
+     * }]);
+     * ```
+     *
+     * Then you can create an injector and load your modules like this:
+     *
+     * ```js
+     * let injector = angular.injector(['ng', 'myModule'])
+     * ```
+     *
+     * However it's more likely that you'll just use
+     * {@link ng.directive:ngApp ngApp} or
+     * {@link angular.bootstrap} to simplify this process for you.
+     *
+     * @param {string} name The name of the module to create or retrieve.
+     * @param {Array.<string>} [requires] If specified then new module is being created. If
+     *        unspecified then the module is being retrieved for further configuration.
+     * @param {Function} [configFn] Optional configuration function for the module. Same as
+     *        {@link import('./types').Module#config Module#config()}.
+     * @returns {NgModule} A newly registered module.
+     */
+    module(name: string, requires?: Array<string>, configFn?: Function): NgModule;
 }
 /**
  * Configuration option for AngularTS bootstrap process.
@@ -271,3 +144,4 @@ export type AngularBootstrapConfig = {
      */
     strictDi?: boolean;
 };
+import { NgModule } from "./core/di/ng-module";

package/types/public.d.ts

@@ -1,5 +1,10 @@
 /**
  * Initializes `ng`, `animate`, `message`, `aria` and `router` modules.
+ * @param {import('./loader').Angular} angular
  * @returns {import('./types').Module} `ng`module
  */
-export function publishExternalAPI(): import("./types").Module;
+export function publishExternalAPI(angular: import("./loader").Angular): import("./types").Module;
+/**
+ * @type {string} `version` from `package.json`, injected by Rollup plugin
+ */
+export const VERSION: string;

package/types/router/index.d.ts

@@ -1 +1 @@
-export function initRouter(): void;
+export function initRouter(angular: any): void;

package/types/shared/test-utils.d.ts

@@ -1,11 +1,12 @@
 /**
- * @param {HTMLElement} element
+ * @param {HTMLElement|JQLite} element
  * @param {string} event
  */
-export function browserTrigger(element: HTMLElement, event: string): void;
+export function browserTrigger(element: HTMLElement | JQLite, event: string): void;
 /**
  *
  * @param {number} t milliseconds to wait
  * @returns
  */
 export function wait(t: number): Promise<any>;
+import { JQLite } from "./jqlite/jqlite";

package/types/shared/utils.d.ts

@@ -486,7 +486,13 @@ export function getNgAttribute(element: any, ngAttr: any): any;
  */
 export function shallowCopy(src: any, dst: any): any;
 /**
- * throw error if the argument is falsy.
+ * Throw error if the argument is false
+ * @param {boolean} argument
+ * @param {string} errorMsg
+ */
+export function assert(argument: boolean, errorMsg?: string): void;
+/**
+ * Throw error if the argument is falsy.
  */
 export function assertArg(arg: any, name: any, reason: any): any;
 export function assertArgFn(arg: any, name: any, acceptArrayAnnotation: any): any;

package/types/injector.d.ts

@@ -1,12 +0,0 @@
-/**
- *
- * @param {*} modulesToLoad
- * @param {*} strictDi
- * @returns {import("./types").InjectorService}
- */
-export function createInjector(modulesToLoad: any, strictDi: any): import("./types").InjectorService;
-export namespace createInjector {
-    export { annotate as $$annotate };
-}
-declare function annotate(fn: any, strictDi: any, name: any): any;
-export {};