@angular-wave/angular.ts 0.0.66 → 0.0.68

package/src/core/location/location.md

@@ -0,0 +1,114 @@
+/\*\*
+
+- The $location service parses the URL in the browser address bar (based on the
+- [window.location](https://developer.mozilla.org/en/window.location)) and makes the URL
+- available to your application. Changes to the URL in the address bar are reflected into
+- $location service and changes to $location are reflected into the browser address bar.
+-
+- **The $location service:**
+-
+- - Exposes the current URL in the browser address bar, so you can
+- - Watch and observe the URL.
+- - Change the URL.
+- - Synchronizes the URL with the browser when the user
+- - Changes the address bar.
+- - Clicks the back or forward button (or clicks a History link).
+- - Clicks on a link.
+- - Represents the URL object as a set of methods (protocol, host, port, path, search, hash).
+-
+- For more information see {@link guide/$location Developer Guide: Using $location}
+  \*/
+
+/\*\*
+
+- Use the `$locationProvider` to configure how the application deep linking paths are stored.
+  \*/
+
+/\*\*
+
+- @ngdoc event
+- @name $location#$locationChangeStart
+- @eventType broadcast on root scope
+- @description
+- Broadcasted before a URL will change.
+-
+- This change can be prevented by calling
+- `preventDefault` method of the event. See {@link ng.$rootScope.Scope#$on} for more
+- details about event object. Upon successful change
+- {@link ng.$location#$locationChangeSuccess $locationChangeSuccess} is fired.
+-
+- The `newState` and `oldState` parameters may be defined only in HTML5 mode and when
+- the browser supports the HTML5 History API.
+-
+- @param {Object} angularEvent Synthetic event object.
+- @param {string} newUrl New URL
+- @param {string=} oldUrl URL that was before it was changed.
+- @param {string=} newState New history state object
+- @param {string=} oldState History state object that was before it was changed.
+  \*/
+
+/\*\*
+
+- @ngdoc event
+- @name $location#$locationChangeSuccess
+- @eventType broadcast on root scope
+- @description
+- Broadcasted after a URL was changed.
+-
+- The `newState` and `oldState` parameters may be defined only in HTML5 mode and when
+- the browser supports the HTML5 History API.
+-
+- @param {Object} angularEvent Synthetic event object.
+- @param {string} newUrl New URL
+- @param {string=} oldUrl URL that was before it was changed.
+- @param {string=} newState New history state object
+- @param {string=} oldState History state object that was before it was changed.
+  \*/
+
+  /\*\*
+
+  - This method is getter / setter.
+  -
+  - Return search part (as object) of current URL when called without any parameter.
+  -
+  - Change search part when called with parameter and return `$location`.
+  -
+  -
+  - ```js
+
+    ```
+
+  - // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
+  - let searchObject = $location.search();
+  - // => {foo: 'bar', baz: 'xoxo'}
+  -
+  - // set foo to 'yipee'
+  - $location.search('foo', 'yipee');
+  - // $location.search() => {foo: 'yipee', baz: 'xoxo'}
+  - ```
+
+    ```
+
+  -
+  - @param {string|Object} search New search params - string or hash object.
+  -
+  - When called with a single argument the method acts as a setter, setting the `search` component
+  - of `$location` to the specified value.
+  -
+  - If the argument is a hash object containing an array of values, these values will be encoded
+  - as duplicate search parameters in the URL.
+  -
+  - @param {(string|Number|Array<string>|boolean)=} paramValue If `search` is a string or number, then `paramValue`
+  - will override only a single search property.
+  -
+  - If `paramValue` is an array, it will override the property of the `search` component of
+  - `$location` specified via the first argument.
+  -
+  - If `paramValue` is `null`, the property specified via the first argument will be deleted.
+  -
+  - If `paramValue` is `true`, the property specified via the first argument will be added with no
+  - value nor trailing equal sign.
+  -
+  - @return {Object} If called with no arguments returns the parsed `search` object. If called with
+  - one or more arguments returns `$location` object itself.
+    \*/

package/src/core/location/location.spec.js

@@ -2,7 +2,6 @@ import {
   LocationHtml5Url,
   LocationHashbangUrl,
   $LocationProvider,
-  LocationHashbangInHtml5Url,
 } from "./location";
 import { Angular } from "../../loader";
 import { createInjector } from "../../core/di/injector";
@@ -464,6 +463,7 @@ describe("$location", () => {
           .hash("abcd")
           .state({ a: 2 })
           .search("bar", "baz");
+
         expect(locationUrl.path()).toEqual("/foo");
         expect(locationUrl.state()).toEqual({ a: 2 });
         expect(locationUrl.search() && locationUrl.search().bar).toBe("baz");
@@ -3310,81 +3310,6 @@ describe("$location", () => {
     });
   });
 
-  describe("LocationHashbangInHtml5Url", () => {
-    /* global LocationHashbangInHtml5Url: false */
-    let locationUrl;
-    let locationIndexUrl;
-
-    beforeEach(() => {
-      locationUrl = new LocationHashbangInHtml5Url(
-        "http://server/pre/",
-        "http://server/pre/",
-        "#!",
-      );
-      locationIndexUrl = new LocationHashbangInHtml5Url(
-        "http://server/pre/index.html",
-        "http://server/pre/",
-        "#!",
-      );
-    });
-
-    it("should rewrite URL", () => {
-      expect(parseLinkAndReturn(locationUrl, "http://other")).toEqual(
-        undefined,
-      );
-      expect(parseLinkAndReturn(locationUrl, "http://server/pre")).toEqual(
-        "http://server/pre/#!",
-      );
-      expect(parseLinkAndReturn(locationUrl, "http://server/pre/")).toEqual(
-        "http://server/pre/#!",
-      );
-      expect(
-        parseLinkAndReturn(locationUrl, "http://server/pre/otherPath"),
-      ).toEqual("http://server/pre/#!/otherPath");
-      // Note: relies on the previous state!
-      expect(
-        parseLinkAndReturn(locationUrl, "someIgnoredAbsoluteHref", "#test"),
-      ).toEqual("http://server/pre/#!/otherPath#test");
-
-      expect(parseLinkAndReturn(locationIndexUrl, "http://server/pre")).toEqual(
-        "http://server/pre/index.html#!",
-      );
-      expect(
-        parseLinkAndReturn(locationIndexUrl, "http://server/pre/"),
-      ).toEqual(undefined);
-      expect(
-        parseLinkAndReturn(locationIndexUrl, "http://server/pre/otherPath"),
-      ).toEqual("http://server/pre/index.html#!/otherPath");
-      // Note: relies on the previous state!
-      expect(
-        parseLinkAndReturn(
-          locationIndexUrl,
-          "someIgnoredAbsoluteHref",
-          "#test",
-        ),
-      ).toEqual("http://server/pre/index.html#!/otherPath#test");
-    });
-
-    it("should throw on url(urlString, stateObject)", () => {
-      expectThrowOnStateChange(locationUrl);
-    });
-
-    // it("should not throw when base path is another domain", () => {
-    //   initService({ html5Mode: true, hashPrefix: "!", supportHistory: true });
-    //   inject(
-    //     initBrowser({
-    //       url: "http://domain.com/base/",
-    //       basePath: "http://otherdomain.com/base/",
-    //     }),
-    //     ($location) => {
-    //       expect(() => {
-    //         $location.absUrl();
-    //       }).not.toThrow();
-    //     },
-    //   );
-    // });
-  });
-
   // function mockUpBrowser(options) {
   //   module(($windowProvider, $browserProvider) => {
   //     let browser;

package/src/core/parser/parse.js

@@ -15,7 +15,7 @@ import { Parser } from "./parser";
  */
 
 /**
- * @typedef {function} CompiledExpressionFunction
+ * @typedef {Function} CompiledExpressionFunction
  * @param {import('../scope/scope').Scope} context - An object against which any expressions embedded in the strings are evaluated against (typically a scope object).
  * @param {object} [locals] - local variables context object, useful for overriding values in `context`.
  * @param {any} [assign]
@@ -81,7 +81,6 @@ export function $ParseProvider() {
         isIdentifierStart: isFunction(identStart) && identStart,
         isIdentifierContinue: isFunction(identContinue) && identContinue,
       };
-      $parse.$$getAst = $$getAst;
       return $parse;
 
       function $parse(exp, interceptorFn) {
@@ -111,16 +110,6 @@ export function $ParseProvider() {
         }
       }
 
-      /**
-       * @param {string} exp
-       * @returns {import("./ast").ASTNode}
-       */
-      function $$getAst(exp) {
-        var lexer = new Lexer($lexerOptions);
-        var parser = new Parser(lexer, $filter);
-        return parser.getAst(exp).ast;
-      }
-
       function addInterceptor(parsedExpression, interceptorFn) {
         if (!interceptorFn) return parsedExpression;
 

package/src/core/parser/parse.spec.js

@@ -1,7 +1,6 @@
 import { AST } from "./ast";
 import { Lexer } from "./lexer";
 import {
-  forEach,
   isFunction,
   sliceArgs,
   csp,
@@ -580,27 +579,24 @@ describe("parser", () => {
 
     it("should understand literals", () => {
       // In a strict sense, `undefined` is not a literal but an identifier
-      forEach(
-        {
-          123: 123,
-          '"123"': "123",
-          true: true,
-          false: false,
-          null: null,
-          undefined: undefined,
-        },
-        (value, expression) => {
-          expect(createAst(expression)).toEqual({
-            type: ASTType.Program,
-            body: [
-              {
-                type: ASTType.ExpressionStatement,
-                expression: { type: ASTType.Literal, value },
-              },
-            ],
-          });
-        },
-      );
+      Object.entries({
+        123: 123,
+        '"123"': "123",
+        true: true,
+        false: false,
+        null: null,
+        undefined: undefined,
+      }).forEach(([expression, value]) => {
+        expect(createAst(expression)).toEqual({
+          type: ASTType.Program,
+          body: [
+            {
+              type: ASTType.ExpressionStatement,
+              expression: { type: ASTType.Literal, value },
+            },
+          ],
+        });
+      });
     });
 
     it("should understand the `this` expression", () => {
@@ -628,8 +624,7 @@ describe("parser", () => {
     });
 
     it("should not confuse `this`, `$locals`, `undefined`, `true`, `false`, `null` when used as identifiers", () => {
-      forEach(
-        ["this", "$locals", "undefined", "true", "false", "null"],
+      ["this", "$locals", "undefined", "true", "false", "null"].forEach(
         (identifier) => {
           expect(createAst(`foo.${identifier}`)).toEqual({
             type: ASTType.Program,
@@ -662,7 +657,7 @@ describe("parser", () => {
     });
 
     it("should understand the unary operators `-`, `+` and `!`", () => {
-      forEach(["-", "+", "!"], (operator) => {
+      ["-", "+", "!"].forEach((operator) => {
         expect(createAst(`${operator}foo`)).toEqual({
           type: ASTType.Program,
           body: [
@@ -681,75 +676,69 @@ describe("parser", () => {
     });
 
     it("should handle all unary operators with the same precedence", () => {
-      forEach(
-        [
-          ["+", "-", "!"],
-          ["-", "!", "+"],
-          ["!", "+", "-"],
-        ],
-        (operators) => {
-          expect(createAst(`${operators.join("")}foo`)).toEqual({
-            type: ASTType.Program,
-            body: [
-              {
-                type: ASTType.ExpressionStatement,
-                expression: {
+      [
+        ["+", "-", "!"],
+        ["-", "!", "+"],
+        ["!", "+", "-"],
+      ].forEach((operators) => {
+        expect(createAst(`${operators.join("")}foo`)).toEqual({
+          type: ASTType.Program,
+          body: [
+            {
+              type: ASTType.ExpressionStatement,
+              expression: {
+                type: ASTType.UnaryExpression,
+                operator: operators[0],
+                prefix: true,
+                argument: {
                   type: ASTType.UnaryExpression,
-                  operator: operators[0],
+                  operator: operators[1],
                   prefix: true,
                   argument: {
                     type: ASTType.UnaryExpression,
-                    operator: operators[1],
+                    operator: operators[2],
                     prefix: true,
-                    argument: {
-                      type: ASTType.UnaryExpression,
-                      operator: operators[2],
-                      prefix: true,
-                      argument: { type: ASTType.Identifier, name: "foo" },
-                    },
+                    argument: { type: ASTType.Identifier, name: "foo" },
                   },
                 },
               },
-            ],
-          });
-        },
-      );
+            },
+          ],
+        });
+      });
     });
 
     it("should be able to understand binary operators", () => {
-      forEach(
-        [
-          "*",
-          "/",
-          "%",
-          "+",
-          "-",
-          "<",
-          ">",
-          "<=",
-          ">=",
-          "==",
-          "!=",
-          "===",
-          "!==",
-        ],
-        (operator) => {
-          expect(createAst(`foo${operator}bar`)).toEqual({
-            type: ASTType.Program,
-            body: [
-              {
-                type: ASTType.ExpressionStatement,
-                expression: {
-                  type: ASTType.BinaryExpression,
-                  operator,
-                  left: { type: ASTType.Identifier, name: "foo" },
-                  right: { type: ASTType.Identifier, name: "bar" },
-                },
+      [
+        "*",
+        "/",
+        "%",
+        "+",
+        "-",
+        "<",
+        ">",
+        "<=",
+        ">=",
+        "==",
+        "!=",
+        "===",
+        "!==",
+      ].forEach((operator) => {
+        expect(createAst(`foo${operator}bar`)).toEqual({
+          type: ASTType.Program,
+          body: [
+            {
+              type: ASTType.ExpressionStatement,
+              expression: {
+                type: ASTType.BinaryExpression,
+                operator,
+                left: { type: ASTType.Identifier, name: "foo" },
+                right: { type: ASTType.Identifier, name: "bar" },
               },
-            ],
-          });
-        },
-      );
+            },
+          ],
+        });
+      });
     });
 
     it("should associate binary operators with the same precedence left-to-right", () => {
@@ -759,9 +748,9 @@ describe("parser", () => {
         ["<", ">", "<=", ">="],
         ["==", "!=", "===", "!=="],
       ];
-      forEach(operatorsByPrecedence, (operators) => {
-        forEach(operators, (op1) => {
-          forEach(operators, (op2) => {
+      operatorsByPrecedence.forEach((operators) => {
+        operators.forEach((op1) => {
+          operators.forEach((op2) => {
             expect(createAst(`foo${op1}bar${op2}baz`)).toEqual({
               type: ASTType.Program,
               body: [
@@ -787,7 +776,7 @@ describe("parser", () => {
     });
 
     it("should give higher precedence to member calls than to unary expressions", () => {
-      forEach(["!", "+", "-"], (operator) => {
+      ["!", "+", "-"].forEach((operator) => {
         expect(createAst(`${operator}foo()`)).toEqual({
           type: ASTType.Program,
           body: [
@@ -848,8 +837,8 @@ describe("parser", () => {
     });
 
     it("should give higher precedence to unary operators over multiplicative operators", () => {
-      forEach(["!", "+", "-"], (op1) => {
-        forEach(["*", "/", "%"], (op2) => {
+      ["!", "+", "-"].forEach((op1) => {
+        ["*", "/", "%"].forEach((op2) => {
           expect(createAst(`${op1}foo${op2}${op1}bar`)).toEqual({
             type: ASTType.Program,
             body: [
@@ -886,8 +875,8 @@ describe("parser", () => {
         ["==", "!=", "===", "!=="],
       ];
       for (let i = 0; i < operatorsByPrecedence.length - 1; ++i) {
-        forEach(operatorsByPrecedence[i], (op1) => {
-          forEach(operatorsByPrecedence[i + 1], (op2) => {
+        operatorsByPrecedence[i].forEach((op1) => {
+          operatorsByPrecedence[i + 1].forEach((op2) => {
             expect(createAst(`foo${op1}bar${op2}baz${op1}man`)).toEqual({
               type: ASTType.Program,
               body: [
@@ -918,7 +907,7 @@ describe("parser", () => {
     });
 
     it("should understand logical operators", () => {
-      forEach(["||", "&&"], (operator) => {
+      ["||", "&&"].forEach((operator) => {
         expect(createAst(`foo${operator}bar`)).toEqual({
           type: ASTType.Program,
           body: [
@@ -937,7 +926,7 @@ describe("parser", () => {
     });
 
     it("should associate logical operators left-to-right", () => {
-      forEach(["||", "&&"], (op) => {
+      ["||", "&&"].forEach((op) => {
         expect(createAst(`foo${op}bar${op}baz`)).toEqual({
           type: ASTType.Program,
           body: [
@@ -1053,7 +1042,7 @@ describe("parser", () => {
     });
 
     it("should give higher precedence to equality than to the logical `and` operator", () => {
-      forEach(["==", "!=", "===", "!=="], (operator) => {
+      ["==", "!=", "===", "!=="].forEach((operator) => {
         expect(createAst(`foo${operator}bar && man${operator}shell`)).toEqual({
           type: ASTType.Program,
           body: [
@@ -1775,7 +1764,7 @@ describe("parser", () => {
     });
   });
 
-  forEach([true, false], (cspEnabled) => {
+  [true, false].forEach((cspEnabled) => {
     describe(`csp: ${cspEnabled}`, () => {
       beforeEach(() => {
         createInjector([
@@ -2016,7 +2005,7 @@ describe("parser", () => {
         expect(scope.$eval("a.b.c.d.e.f.g.h.i.j.k.l.m.n", scope)).toBe("nooo!");
       });
 
-      forEach([2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 42, 99], (pathLength) => {
+      [2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 42, 99].forEach((pathLength) => {
         it(`should resolve nested paths of length ${pathLength}`, () => {
           // Create a nested object {x2: {x3: {x4: ... {x[n]: 42} ... }}}.
           let obj = 42;
@@ -2397,23 +2386,20 @@ describe("parser", () => {
 
       it("should throw TypeError on using a 'broken' object as a key to access a property", () => {
         scope.object = {};
-        forEach(
-          [
-            { toString: 2 },
-            { toString: null },
-            {
-              toString() {
-                return {};
-              },
+        [
+          { toString: 2 },
+          { toString: null },
+          {
+            toString() {
+              return {};
             },
-          ],
-          (brokenObject) => {
-            scope.brokenObject = brokenObject;
-            expect(() => {
-              scope.$eval("object[brokenObject]");
-            }).toThrow();
           },
-        );
+        ].forEach((brokenObject) => {
+          scope.brokenObject = brokenObject;
+          expect(() => {
+            scope.$eval("object[brokenObject]");
+          }).toThrow();
+        });
       });
 
       it("should support method calls on primitive types", () => {