@angular-wave/angular.ts 0.0.48 → 0.0.49

package/src/core/parser/lexer.js

@@ -17,18 +17,45 @@ const OPERATORS = new Set(
 );
 
 /**
- * @constructor
+ * @typedef {Object} LexerOptions
+ * @property {(ch: string, codePoint: number) => boolean} [isIdentifierStart] Custom function to determine if a character is a valid identifier start.
+ * @property {(ch: string, codePoint: number) => boolean} [isIdentifierContinue] Custom function to determine if a character is a valid identifier continuation.
  */
-export const Lexer = function Lexer(options) {
-  this.options = options;
-};
 
-Lexer.prototype = {
-  constructor: Lexer,
+/**
+ * Represents a token produced by the lexer.
+ * @typedef {Object} Token
+ * @property {number} index Index of the token.
+ * @property {string} text Text of the token.
+ * @property {boolean} [identifier] Indicates if token is an identifier.
+ * @property {boolean} [constant] Indicates if token is a constant.
+ * @property {string|number} [value] Value of the token if it's a constant.
+ * @property {boolean} [operator] Indicates if token is an operator.
+ */
+
+/**
+ * Represents a lexer that tokenizes input text. The Lexer takes the original expression string and returns an array of tokens parsed from that string.
+ * For example, the string "a + b" would result in tokens for a, +, and b.
+ */
+export class Lexer {
+  /**
+   * Creates an instance of Lexer.
+   * @param {LexerOptions} options Lexer options.
+   */
+  constructor(options) {
+    /** @type {LexerOptions} */
+    this.options = options;
+  }
 
+  /**
+   * Tokenizes the input text.
+   * @param {string} text Input text to lex.
+   * @returns {Array<Token>} Array of tokens.
+   */
   lex(text) {
     this.text = text;
     this.index = 0;
+    /** @type {Array<Token>} */
     this.tokens = [];
 
     while (this.index < this.text.length) {
@@ -37,7 +64,7 @@ Lexer.prototype = {
         this.readString(ch);
       } else if (
         this.isNumber(ch) ||
-        (ch === "." && this.isNumber(this.peek()))
+        (ch === "." && this.isNumber(/** @type {string} */ (this.peek())))
       ) {
         this.readNumber();
       } else if (this.isIdentifierStart(this.peekMultichar())) {
@@ -67,23 +94,44 @@ Lexer.prototype = {
       }
     }
     return this.tokens;
-  },
+  }
 
+  /**
+   * Checks if a character is contained in a set of characters.
+   * @param {string} ch Character to check.
+   * @param {string} chars Set of characters.
+   * @returns {boolean} True if character is in the set, false otherwise.
+   */
   is(ch, chars) {
     return chars.indexOf(ch) !== -1;
-  },
+  }
 
+  /**
+   * Peeks at the next character in the text.
+   * @param {number} [i=1] Number of characters to peek.
+   * @returns {string|false} Next character or false if end of text.
+   */
   peek(i) {
     const num = i || 1;
     return this.index + num < this.text.length
       ? this.text.charAt(this.index + num)
       : false;
-  },
+  }
 
+  /**
+   * Checks if a character is a number.
+   * @param {string} ch Character to check.
+   * @returns {boolean} True if character is a number, false otherwise.
+   */
   isNumber(ch) {
     return ch >= "0" && ch <= "9" && typeof ch === "string";
-  },
+  }
 
+  /**
+   * Checks if a character is whitespace.
+   * @param {string} ch Character to check.
+   * @returns {boolean} True if character is whitespace, false otherwise.
+   */
   isWhitespace(ch) {
     // IE treats non-breaking space as \u00A0
     return (
@@ -94,39 +142,52 @@ Lexer.prototype = {
       ch === "\v" ||
       ch === "\u00A0"
     );
-  },
+  }
 
+  /**
+   * Checks if a character is a valid identifier start.
+   * @param {string} ch Character to check.
+   * @returns {boolean} True if character is a valid identifier start, false otherwise.
+   */
   isIdentifierStart(ch) {
     return this.options.isIdentifierStart
       ? this.options.isIdentifierStart(ch, this.codePointAt(ch))
-      : this.isValidIdentifierStart(ch);
-  },
-
-  isValidIdentifierStart(ch) {
-    return (
-      (ch >= "a" && ch <= "z") ||
-      (ch >= "A" && ch <= "Z") ||
-      ch === "_" ||
-      ch === "$"
-    );
-  },
+      : (ch >= "a" && ch <= "z") ||
+          (ch >= "A" && ch <= "Z") ||
+          ch === "_" ||
+          ch === "$";
+  }
 
+  /**
+   * Checks if a character is a valid identifier continuation.
+   * @param {string} ch Character to check.
+   * @returns {boolean} True if character is a valid identifier continuation, false otherwise.
+   */
   isIdentifierContinue(ch) {
     return this.options.isIdentifierContinue
       ? this.options.isIdentifierContinue(ch, this.codePointAt(ch))
-      : this.isValidIdentifierContinue(ch);
-  },
-
-  isValidIdentifierContinue(ch) {
-    return this.isValidIdentifierStart(ch) || this.isNumber(ch);
-  },
+      : (ch >= "a" && ch <= "z") ||
+          (ch >= "A" && ch <= "Z") ||
+          ch === "_" ||
+          ch === "$" ||
+          (ch >= "0" && ch <= "9");
+  }
 
+  /**
+   * Converts a character to its Unicode code point.
+   * @param {string} ch Character to convert.
+   * @returns {number} Unicode code point.
+   */
   codePointAt(ch) {
     if (ch.length === 1) return ch.charCodeAt(0);
 
     return (ch.charCodeAt(0) << 10) + ch.charCodeAt(1) - 0x35fdc00;
-  },
+  }
 
+  /**
+   * Peeks at the next multicharacter sequence in the text.
+   * @returns {string} Next multicharacter sequence.
+   */
   peekMultichar() {
     const ch = this.text.charAt(this.index);
     const peek = this.peek();
@@ -139,12 +200,24 @@ Lexer.prototype = {
       return ch + peek;
     }
     return ch;
-  },
+  }
 
+  /**
+   * Checks if a character is an exponent operator.
+   * @param {string} ch Character to check.
+   * @returns {boolean} True if character is an exponent operator, false otherwise.
+   */
   isExpOperator(ch) {
     return ch === "-" || ch === "+" || this.isNumber(ch);
-  },
+  }
 
+  /**
+   * Throws a lexer error.
+   * @param {string} error Error message.
+   * @param {number} [start] Start index.
+   * @param {number} [end] End index.
+   * @throws {Error} Lexer error.
+   */
   throwError(error, start, end) {
     end = end || this.index;
     const colStr = isDefined(start)
@@ -152,13 +225,13 @@ Lexer.prototype = {
       : ` ${end}`;
     throw $parseMinErr(
       "lexerr",
-      "Lexer Error: {0} at column{1} in expression [{2}].",
-      error,
-      colStr,
-      this.text,
+      `Lexer Error: ${error} at column${colStr} in expression [${this.text}].`,
     );
-  },
+  }
 
+  /**
+   * Reads and tokenizes a number from the text.
+   */
   readNumber() {
     let number = "";
     const start = this.index;
@@ -168,7 +241,7 @@ Lexer.prototype = {
         number += ch;
       } else {
         const peekCh = this.peek();
-        if (ch === "e" && this.isExpOperator(peekCh)) {
+        if (ch === "e" && this.isExpOperator(/** @type {string} */ (peekCh))) {
           number += ch;
         } else if (
           this.isExpOperator(ch) &&
@@ -195,8 +268,11 @@ Lexer.prototype = {
       constant: true,
       value: Number(number),
     });
-  },
+  }
 
+  /**
+   * Reads and tokenizes an identifier from the text.
+   */
   readIdent() {
     const start = this.index;
     this.index += this.peekMultichar().length;
@@ -212,46 +288,58 @@ Lexer.prototype = {
       text: this.text.slice(start, this.index),
       identifier: true,
     });
-  },
+  }
 
+  /**
+   * Reads and tokenizes a string from the text.
+   * @param {string} quote Quote character used for the string.
+   */
   readString(quote) {
     const start = this.index;
-    this.index++;
     let string = "";
-    let rawString = quote;
     let escape = false;
+
+    this.index++; // Skip opening quote
+
     while (this.index < this.text.length) {
-      const ch = this.text.charAt(this.index);
-      rawString += ch;
+      const ch = this.text[this.index];
+
       if (escape) {
         if (ch === "u") {
-          const hex = this.text.substring(this.index + 1, this.index + 5);
-          if (!hex.match(/[\da-f]{4}/i)) {
-            this.throwError(`Invalid unicode escape [\\u${hex}]`);
-          }
-          this.index += 4;
-          string += String.fromCharCode(parseInt(hex, 16));
+          // Handle unicode escapes
+          // Simplified for brevity
+          string += this.handleUnicodeEscape();
         } else {
-          const rep = ESCAPE[ch];
-          string += rep || ch;
+          string += ESCAPE[ch] || ch;
         }
         escape = false;
       } else if (ch === "\\") {
         escape = true;
       } else if (ch === quote) {
-        this.index++;
         this.tokens.push({
           index: start,
-          text: rawString,
+          text: this.text.slice(start, this.index + 1),
           constant: true,
           value: string,
         });
+        this.index++; // Skip closing quote
         return;
       } else {
         string += ch;
       }
+
       this.index++;
     }
+
     this.throwError("Unterminated quote", start);
-  },
-};
+  }
+
+  handleUnicodeEscape() {
+    const hex = this.text.substring(this.index + 1, this.index + 5);
+    if (!hex.match(/[\da-f]{4}/i)) {
+      this.throwError(`Invalid unicode escape [\\u${hex}]`);
+    }
+    this.index += 4; // Move index past the four hexadecimal digits
+    return String.fromCharCode(parseInt(hex, 16));
+  }
+}

package/src/core/parser/parse.js

@@ -14,47 +14,7 @@ export const $parseMinErr = minErr("$parse");
 /// ////////////////////////////////
 
 /**
- * @typedef {function(string|function(import('../scope/scope').Scope):any, function(any, Scope, any):any=, boolean=): import('../../types').CompiledExpression} ParseService
- */
-
-/**
- * @ngdoc service
- * @name $parse
- * @kind function
- *
- * @description
- *
- * Converts AngularJS {@link guide/expression expression} into a function.
- *
- * ```js
- *   let getter = $parse('user.name');
- *   let setter = getter.assign;
- *   let context = {user:{name:'AngularJS'}};
- *   let locals = {user:{name:'local'}};
- *
- *   expect(getter(context)).toEqual('AngularJS');
- *   setter(context, 'newValue');
- *   expect(context.user.name).toEqual('newValue');
- *   expect(getter(context, locals)).toEqual('local');
- * ```
- *
- *
- * @param {string} expression String expression to compile.
- * @returns {function(context, locals)} a function which represents the compiled expression:
- *
- *    * `context` – `{object}` – an object against which any expressions embedded in the strings
- *      are evaluated against (typically a scope object).
- *    * `locals` – `{object=}` – local variables context object, useful for overriding values in
- *      `context`.
- *
- *    The returned function also has the following properties:
- *      * `literal` – `{boolean}` – whether the expression's top-level node is a JavaScript
- *        literal.
- *      * `constant` – `{boolean}` – whether the expression is made entirely of JavaScript
- *        constant literals.
- *      * `assign` – `{?function(context, value)}` – if the expression is assignable, this will be
- *        set to a function to change its value on the given context.
- *
+ * @typedef {function(string|function(import('../scope/scope').Scope):any, function(any, import('../scope/scope').Scope, any):any=, boolean=): import('../../types').CompiledExpression} ParseService
  */
 
 export const literals = {
@@ -64,15 +24,6 @@ export const literals = {
   undefined,
 };
 
-/**
- * @ngdoc provider
- * @name $parseProvider
- *
- *
- * @description
- * `$parseProvider` can be used for configuring the default behavior of the {@link ng.$parse $parse}
- *  service.
- */
 export function $ParseProvider() {
   const cache = Object.create(null);
   const literals = {
@@ -81,7 +32,11 @@ export function $ParseProvider() {
     null: null,
     undefined: undefined,
   };
-  var identStart, identContinue;
+  /** @type {function(any):boolean?} */
+  var identStart;
+
+  /** @type {function(any):boolean?} */
+  var identContinue;
 
   /**
    * @ngdoc method
@@ -117,9 +72,9 @@ export function $ParseProvider() {
    * Since this function will be called extensively, keep the implementation of these functions fast,
    * as the performance of these functions have a direct impact on the expressions parsing speed.
    *
-   * @param {function=} identifierStart The function that will decide whether the given character is
+   * @param {function(any):boolean=} identifierStart The function that will decide whether the given character is
    *   a valid identifier start character.
-   * @param {function=} identifierContinue The function that will decide whether the given character is
+   * @param {function(any):boolean=} identifierContinue The function that will decide whether the given character is
    *   a valid identifier continue character.
    */
   this.setIdentifierFns = function (identifierStart, identifierContinue) {
@@ -152,7 +107,10 @@ export function $ParseProvider() {
             parsedExpression = cache[cacheKey];
 
             if (!parsedExpression) {
-              var lexer = new Lexer($parseOptions);
+              var lexer = new Lexer({
+                isIdentifierContinue: $parseOptions.isIdentifierContinue,
+                isIdentifierStart: $parseOptions.isIdentifierStart,
+              });
               var parser = new Parser(lexer, $filter, $parseOptions);
               parsedExpression = parser.parse(exp);
 
@@ -597,7 +555,8 @@ export function chainInterceptors(first, second) {
   return chainedInterceptor;
 }
 
-export function expressionInputDirtyCheck(
+/** @private */
+function expressionInputDirtyCheck(
   newValue,
   oldValueOfValue,
   compareObjectIdentity,
@@ -629,7 +588,8 @@ export function expressionInputDirtyCheck(
   );
 }
 
-export function isAllDefined(value) {
+/** @private */
+function isAllDefined(value) {
   let allDefined = true;
   forEach(value, (val) => {
     if (!isDefined(val)) allDefined = false;

package/src/core/parser/parse.md

@@ -11,3 +11,60 @@
 // content then it is possible that your application contains a security vulnerability to an XSS style attack.
 //
 // See https://docs.angularjs.org/guide/security
+
+/\*\*
+
+- @ngdoc service
+- @name $parse
+- @kind function
+-
+- @description
+-
+- Converts AngularJS {@link guide/expression expression} into a function.
+-
+- ```js
+
+  ```
+
+- let getter = $parse('user.name');
+- let setter = getter.assign;
+- let context = {user:{name:'AngularJS'}};
+- let locals = {user:{name:'local'}};
+-
+- expect(getter(context)).toEqual('AngularJS');
+- setter(context, 'newValue');
+- expect(context.user.name).toEqual('newValue');
+- expect(getter(context, locals)).toEqual('local');
+- ```
+
+  ```
+
+-
+-
+- @param {string} expression String expression to compile.
+- @returns {function(context, locals)} a function which represents the compiled expression:
+-
+- - `context` – `{object}` – an object against which any expressions embedded in the strings
+-      are evaluated against (typically a scope object).
+- - `locals` – `{object=}` – local variables context object, useful for overriding values in
+-      `context`.
+-
+- The returned function also has the following properties:
+-      * `literal` – `{boolean}` – whether the expression's top-level node is a JavaScript
+-        literal.
+-      * `constant` – `{boolean}` – whether the expression is made entirely of JavaScript
+-        constant literals.
+-      * `assign` – `{?function(context, value)}` – if the expression is assignable, this will be
+-        set to a function to change its value on the given context.
+- \*/
+
+/\*\*
+
+- @ngdoc provider
+- @name $parseProvider
+-
+-
+- @description
+- `$parseProvider` can be used for configuring the default behavior of the {@link ng.$parse $parse}
+- service.
+  \*/

package/src/core/parser/parser.js

@@ -7,6 +7,12 @@ import { ASTCompiler } from "./compiler";
  * @constructor
  */
 export class Parser {
+  /**
+   *
+   * @param {import('./lexer').Lexer} lexer
+   * @param {*} $filter
+   * @param {*} options
+   */
   constructor(lexer, $filter, options) {
     this.ast = new AST(lexer, options);
     this.astCompiler = options.csp

package/src/core/prop.spec.js

@@ -119,7 +119,7 @@ describe("ngProp*", () => {
   it("should work with different prefixes", () => {
     $rootScope.name = "Misko";
     const element = $compile(
-      '<span ng:prop:test="name" ng-Prop-test2="name" ng_Prop_test3="name"></span>',
+      '<span ng-prop-test="name" ng-Prop-test2="name" ng-Prop-test3="name"></span>',
     )($rootScope);
     expect(element[0].test).toBe("Misko");
     expect(element[0].test2).toBe("Misko");
@@ -138,7 +138,7 @@ describe("ngProp*", () => {
   it("should work if they are prefixed with x- or data- and different prefixes", () => {
     $rootScope.name = "Misko";
     const element = $compile(
-      '<span data-ng-prop-test2="name" ng-prop-test3="name" data-ng:prop-test4="name" ' +
+      '<span data-ng-prop-test2="name" ng-prop-test3="name" data-ng-prop-test4="name" ' +
         'ng-prop-test5="name" ng-prop-test6="name"></span>',
     )($rootScope);
     expect(element[0].test2).toBe("Misko");
@@ -179,7 +179,7 @@ describe("ngProp*", () => {
       }),
     );
     $compile(
-      '<div attr-exposer ng-prop-title="12" ng-prop-super-title="34" ng-prop-my-camel_title="56">',
+      '<div attr-exposer ng-prop-title="12" ng-prop-super-title="34" ng-prop-my-camel-title="56">',
     )($rootScope);
 
     expect(attrs.title).toBeUndefined();
@@ -195,7 +195,7 @@ describe("ngProp*", () => {
     expect(attrs.myCamelTitle).toBeUndefined();
     expect(attrs.$attr.myCamelTitle).toBeUndefined();
     expect(attrs.ngPropMyCamelTitle).toBe("56");
-    expect(attrs.$attr.ngPropMyCamelTitle).toBe("ng-prop-my-camel_title");
+    expect(attrs.$attr.ngPropMyCamelTitle).toBe("ng-prop-my-camel-title");
   });
 
   it("should not conflict with (ng-attr-)attribute mappings of the same name", () => {

package/src/core/scope/scope.js

@@ -55,7 +55,7 @@ let lastDirtyWatch = null;
 let applyAsyncId = null;
 
 /** Services required by each scope instance */
-/** @type {angular.IParseService} */
+/** @type {import('../parser/parse').ParseService} */
 let $parse;
 /** @type {import('../../services/browser').Browser} */
 let $browser;
@@ -89,7 +89,7 @@ export class $RootScopeProvider {
     "$browser",
     /**
      * @param {import('../exception-handler').ErrorHandler} exceptionHandler
-     * @param {angular.IParseService} parse
+     * @param {import('../parser/parse').ParseService} parse
      * @param {import('../../services/browser').Browser} browser
      * @returns {Scope} root scope
      */
@@ -148,7 +148,7 @@ export class Scope {
     this.$root = this;
 
     /**
-     * @type {[]}
+     * @type {Array<any>}
      */
     this.$$watchers = [];
 
@@ -263,7 +263,7 @@ export class Scope {
     if (isolate || parent !== this) {
       child.$on(
         "$destroy",
-        /** @param {angular.IAngularEvent} $event */
+        /** @param {any} $event */ //angular.IAngularEvent
         ($event) => {
           $event.currentScope.$$destroyed = true;
         },
@@ -440,10 +440,10 @@ export class Scope {
    *   values are examined for changes on every call to `$digest`.
    * - The `listener` is called whenever any expression in the `watchExpressions` array changes.
    *
-   * @param {Array.<string|Function(scope)>} watchExpressions Array of expressions that will be individually
+   * @param {Array.<string|((Scope)=>any)>} watchExpressions Array of expressions that will be individually
    * watched using {@link ng.$rootScope.Scope#$watch $watch()}
    *
-   * @param {function(newValues, oldValues, scope)} listener Callback called whenever the return value of any
+   * @param {function(any, any, Scope): any} listener Callback called whenever the return value of any
    *    expression in `watchExpressions` changes
    *    The `newValues` array contains the current values of the `watchExpressions`, with the indexes matching
    *    those of `watchExpression`
@@ -533,12 +533,12 @@ export class Scope {
    *
    *
    *
-   * @param {string|function(scope)} obj Evaluated as {@link guide/expression expression}. The
+   * @param {string|function(Scope):any} obj Evaluated as {@link guide/expression expression}. The
    *    expression value should evaluate to an object or an array which is observed on each
    *    {@link ng.$rootScope.Scope#$digest $digest} cycle. Any shallow change within the
    *    collection will trigger a call to the `listener`.
    *
-   * @param {function(newCollection, oldCollection, scope)} listener a callback function called
+   * @param {function(any[], any[], Scope):any} listener a callback function called
    *    when a change is detected.
    *    - The `newCollection` object is the newly modified data obtained from the `obj` expression
    *    - The `oldCollection` object is a copy of the former collection data.
@@ -1309,7 +1309,7 @@ export class Scope {
    *   - `defaultPrevented` - `{boolean}`: true if `preventDefault` was called.
    *
    * @param {string} name Event name to listen on.
-   * @param {function(angular.IAngularEvent): any} listener Function to call when the event is emitted.
+   * @param {function(any): any} listener Function to call when the event is emitted witn angular.IAngularEvent
    * @returns {function()} Returns a deregistration function for this listener.
    */
   $on(name, listener) {
@@ -1319,6 +1319,7 @@ export class Scope {
     }
     namedListeners.push(listener);
 
+    /** @type {Scope} */
     let current = this;
     do {
       current.$$listenerCount[name] = (current.$$listenerCount[name] ?? 0) + 1;
@@ -1389,6 +1390,7 @@ export class Scope {
   $emit(name, ...args) {
     const empty = [];
     let namedListeners;
+    /** @type {Scope} */
     let scope = this;
     let stopPropagation = false;
     const event = {
@@ -1429,7 +1431,7 @@ export class Scope {
         break;
       }
       // traverse upwards
-      scope = scope.$parent;
+      scope = /** @type {Scope} */ scope.$parent;
     } while (scope);
 
     event.currentScope = null;
@@ -1460,8 +1462,10 @@ export class Scope {
    */
   $broadcast(name, ...args) {
     const target = this;
+    /** @type {Scope} */
     let current = target;
 
+    /** @type {Scope} */
     let next = target;
     const event = {
       name,