@angular-wave/angular.ts 0.0.50 → 0.0.52

package/src/core/animate/anomate.md

@@ -0,0 +1,13 @@
+/\*\*
+
+- @ngdoc provider
+- @name $animateProvider
+-
+- @description
+- Default implementation of $animate that doesn't perform any animations, instead just
+- synchronously performs DOM updates and resolves the returned runner promise.
+-
+- In order to enable animations the `ngAnimate` module has to be loaded.
+-
+- To see the functional implementation check out `src/ngAnimate/animate.js`.
+  \*/

package/src/core/compile/compile.spec.js

@@ -4995,37 +4995,36 @@ describe("$compile", () => {
       // We compile the contents of element (i.e. not element itself)
       // Then delete these contents and check the cache has been reset to zero
       // Clear cache
-      // Update: THIS TEST IS IRRELEVANT IF WE DONT POLLUTE THE CACHE
       CACHE.clear();
       window.angular.module("test1", ["ng"]);
       createInjector(["test1"]).invoke(($compile) => {
-        expect(CACHE.size).toEqual(1);
+        expect(CACHE.size).toEqual(0);
         // First with only elements at the top level
         element = JQLite("<div><div></div></div>");
         $compile(element[0].childNodes)($rootScope);
         // expect(CACHE.size).toEqual(2);
         element.empty();
-        expect(CACHE.size).toEqual(1);
+        expect(CACHE.size).toEqual(0);
 
         // Next with non-empty text nodes at the top level
         // (in this case the compiler will wrap them in a <span>)
         element = JQLite("<div>xxx</div>");
         $compile(element[0].childNodes)($rootScope);
         element.empty();
-        expect(CACHE.size).toEqual(1);
+        expect(CACHE.size).toEqual(0);
 
         // Next with comment nodes at the top level
         element = JQLite("<div><!-- comment --></div>");
         $compile(element[0].childNodes)($rootScope);
         element.empty();
-        expect(CACHE.size).toEqual(1);
+        expect(CACHE.size).toEqual(0);
 
         // Finally with empty text nodes at the top level
         element = JQLite("<div>   \n<div></div>   </div>");
         $compile(element[0].childNodes)($rootScope);
         //expect(CACHE.size).toEqual(2);
         element.empty();
-        expect(CACHE.size).toEqual(1);
+        expect(CACHE.size).toEqual(0);
       });
     });
 

package/src/core/core.html

@@ -11,7 +11,6 @@
     <script src="/jasmine/jasmine-5.1.2/boot0.js"></script>
     <script src="/jasmine/jasmine-5.1.2/boot1.js"></script>
     <script type="module" src="/src/core/cookie-reader.spec.js"></script>
-    <script type="module" src="/src/core/document.spec.js"></script>
     <script type="module" src="/src/core/on.spec.js"></script>
     <script type="module" src="/src/core/prop.spec.js"></script>
     <script type="module" src="/src/core/root-element.spec.js"></script>

package/src/core/parser/ast-type.js

@@ -1,22 +1,23 @@
 /**
- * @typedef {("Program"|"ExpressionStatement"|"AssignmentExpression"|"ConditionalExpression"|"LogicalExpression"|"BinaryExpression"|"UnaryExpression"|"CallExpression"|"MemberExpression"|"Identifier"|"Literal"|"ArrayExpression"|"Property"|"ObjectExpression"|"ThisExpression"|"LocalsExpression"|"NGValueParameter")} ASTType
+ * @readonly
+ * @enum {number}
  */
-export const ASTType = {
-  Program: "Program",
-  ExpressionStatement: "ExpressionStatement",
-  AssignmentExpression: "AssignmentExpression",
-  ConditionalExpression: "ConditionalExpression",
-  LogicalExpression: "LogicalExpression",
-  BinaryExpression: "BinaryExpression",
-  UnaryExpression: "UnaryExpression",
-  CallExpression: "CallExpression",
-  MemberExpression: "MemberExpression",
-  Identifier: "Identifier",
-  Literal: "Literal",
-  ArrayExpression: "ArrayExpression",
-  Property: "Property",
-  ObjectExpression: "ObjectExpression",
-  ThisExpression: "ThisExpression",
-  LocalsExpression: "LocalsExpression",
-  NGValueParameter: "NGValueParameter",
-};
+export const ASTType = Object.freeze({
+  Program: 1,
+  ExpressionStatement: 2,
+  AssignmentExpression: 3,
+  ConditionalExpression: 4,
+  LogicalExpression: 5,
+  BinaryExpression: 6,
+  UnaryExpression: 7,
+  CallExpression: 8,
+  MemberExpression: 9,
+  Identifier: 10,
+  Literal: 11,
+  ArrayExpression: 12,
+  Property: 13,
+  ObjectExpression: 14,
+  ThisExpression: 15,
+  LocalsExpression: 16,
+  NGValueParameter: 17,
+});

package/src/core/parser/ast.js

@@ -1,10 +1,12 @@
-import { $parseMinErr } from "./parse";
-import { isAssignable } from "./shared";
+import { isAssignable } from "./interpreter";
 import { ASTType } from "./ast-type";
+import { minErr } from "../../shared/utils";
+
+const $parseMinErr = minErr("$parse");
 
 /**
  * @typedef {Object} ASTNode
- * @property {string} type - The type of the AST node.
+ * @property {number} type - The type of the AST node.
  * @property {string} [name] - The name of the identifier.
  * @property {string} [kind] - The kind of the property (e.g., 'init').
  * @property {*} [value] - The value of the node if it is a literal.
@@ -27,19 +29,30 @@ import { ASTType } from "./ast-type";
  * @property {ASTNode} [property] - The property of a member expression.
  * @property {boolean} [computed] - Indicates if a member expression is computed.
  * @property {string} [operator] - The operator of a binary or logical expression.
+ * @property {boolean} [filter]
  */
 
+// Keep this exported in case modification is required
+/** @type {Map<string,any>} */
+export const literals = new Map(
+  Object.entries({
+    true: true,
+    false: false,
+    null: null,
+    undefined,
+  }),
+);
+
 /**
- * @param {import('./lexer').Lexer} lexer - The lexer instance for tokenizing input
- * @param {import("./parser").ParserOptions} options
+ * @class
  */
 export class AST {
-  constructor(lexer, options) {
+  /**
+   * @param {import('./lexer').Lexer} lexer - The lexer instance for tokenizing input
+   */
+  constructor(lexer) {
     /** @type {import('./lexer').Lexer} */
     this.lexer = lexer;
-
-    /** @type  {import("./parser").ParserOptions} */
-    this.options = options;
     this.selfReferential = {
       this: { type: ASTType.ThisExpression },
       $locals: { type: ASTType.LocalsExpression },
@@ -54,13 +67,10 @@ export class AST {
   ast(text) {
     this.text = text;
     this.tokens = this.lexer.lex(text);
-
     const value = this.program();
-
     if (this.tokens.length !== 0) {
       this.throwError("is an unexpected token", this.tokens[0]);
     }
-
     return value;
   }
 
@@ -97,21 +107,13 @@ export class AST {
    * @returns {ASTNode} The filter chain node.
    */
   filterChain() {
-    let left = this.expression();
+    let left = this.assignment();
     while (this.expect("|")) {
       left = this.filter(left);
     }
     return left;
   }
 
-  /**
-   * Parses an expression.
-   * @returns {ASTNode} The expression node.
-   */
-  expression() {
-    return this.assignment();
-  }
-
   /**
    * Parses an assignment expression.
    * @returns {ASTNode} The assignment expression node.
@@ -142,9 +144,9 @@ export class AST {
     let alternate;
     let consequent;
     if (this.expect("?")) {
-      alternate = this.expression();
+      alternate = this.assignment();
       if (this.consume(":")) {
-        consequent = this.expression();
+        consequent = this.assignment();
         return {
           type: ASTType.ConditionalExpression,
           test,
@@ -300,14 +302,11 @@ export class AST {
     ) {
       primary = structuredClone(this.selfReferential[this.consume().text]);
     } else if (
-      Object.prototype.hasOwnProperty.call(
-        this.options.literals,
-        /** @type {import("./lexer").Token} */ (this.peek()).text,
-      )
+      literals.has(/** @type {import("./lexer").Token} */ (this.peek()).text)
     ) {
       primary = {
         type: ASTType.Literal,
-        value: this.options.literals[this.consume().text],
+        value: literals.get(this.consume().text),
       };
     } else if (
       /** @type {import("./lexer").Token} */ (this.peek()).identifier
@@ -335,7 +334,7 @@ export class AST {
         primary = {
           type: ASTType.MemberExpression,
           object: primary,
-          property: this.expression(),
+          property: this.assignment(),
           computed: true,
         };
         this.consume("]");
@@ -369,7 +368,7 @@ export class AST {
     };
 
     while (this.expect(":")) {
-      args.push(this.expression());
+      args.push(this.assignment());
     }
 
     return result;
@@ -424,7 +423,7 @@ export class AST {
           // Support trailing commas per ES5.1.
           break;
         }
-        elements.push(this.expression());
+        elements.push(this.assignment());
       } while (this.expect(","));
     }
     this.consume("]");
@@ -452,7 +451,7 @@ export class AST {
           property.key = this.constant();
           property.computed = false;
           this.consume(":");
-          property.value = this.expression();
+          property.value = this.assignment();
         } else if (
           /** @type {import("./lexer").Token} */ (this.peek()).identifier
         ) {
@@ -460,17 +459,17 @@ export class AST {
           property.computed = false;
           if (this.peek(":")) {
             this.consume(":");
-            property.value = this.expression();
+            property.value = this.assignment();
           } else {
             property.value = property.key;
           }
         } else if (this.peek("[")) {
           this.consume("[");
-          property.key = this.expression();
+          property.key = this.assignment();
           this.consume("]");
           property.computed = true;
           this.consume(":");
-          property.value = this.expression();
+          property.value = this.assignment();
         } else {
           this.throwError(
             "invalid key",