@angular-wave/angular.ts 0.0.58 → 0.0.60

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

@@ -0,0 +1,300 @@
+import { Lexer } from "./lexer";
+import { publishExternalAPI } from "../../public";
+import { createInjector } from "../../injector";
+
+describe("lexer", () => {
+  let $rootScope;
+  let $parse;
+  let logs = [];
+
+  beforeEach(() => {
+    publishExternalAPI().decorator("$exceptionHandler", function () {
+      return (exception, cause) => {
+        logs.push(exception);
+        console.error(exception, cause);
+      };
+    });
+    let injector = createInjector(["ng"]);
+    $parse = injector.get("$parse");
+    $rootScope = injector.get("$rootScope");
+  });
+
+  describe("lexer", () => {
+    let lex;
+
+    beforeEach(() => {
+      lex = function () {
+        const lexer = new Lexer({});
+        return lexer.lex.apply(lexer, arguments);
+      };
+    });
+
+    it("should only match number chars with isNumber", () => {
+      expect(Lexer.prototype.isNumber("0")).toBe(true);
+      expect(Lexer.prototype.isNumber("")).toBeFalsy();
+      expect(Lexer.prototype.isNumber(" ")).toBeFalsy();
+      expect(Lexer.prototype.isNumber(0)).toBeFalsy();
+      expect(Lexer.prototype.isNumber(false)).toBeFalsy();
+      expect(Lexer.prototype.isNumber(true)).toBeFalsy();
+      expect(Lexer.prototype.isNumber(undefined)).toBeFalsy();
+      expect(Lexer.prototype.isNumber(null)).toBeFalsy();
+    });
+
+    it("should tokenize a string", () => {
+      const tokens = lex("a.bc[22]+1.3|f:'a\\'c':\"d\\\"e\"");
+      let i = 0;
+      expect(tokens[i].index).toEqual(0);
+      expect(tokens[i].text).toEqual("a");
+
+      i++;
+      expect(tokens[i].index).toEqual(1);
+      expect(tokens[i].text).toEqual(".");
+
+      i++;
+      expect(tokens[i].index).toEqual(2);
+      expect(tokens[i].text).toEqual("bc");
+
+      i++;
+      expect(tokens[i].index).toEqual(4);
+      expect(tokens[i].text).toEqual("[");
+
+      i++;
+      expect(tokens[i].index).toEqual(5);
+      expect(tokens[i].text).toEqual("22");
+      expect(tokens[i].value).toEqual(22);
+      expect(tokens[i].constant).toEqual(true);
+
+      i++;
+      expect(tokens[i].index).toEqual(7);
+      expect(tokens[i].text).toEqual("]");
+
+      i++;
+      expect(tokens[i].index).toEqual(8);
+      expect(tokens[i].text).toEqual("+");
+
+      i++;
+      expect(tokens[i].index).toEqual(9);
+      expect(tokens[i].text).toEqual("1.3");
+      expect(tokens[i].value).toEqual(1.3);
+      expect(tokens[i].constant).toEqual(true);
+
+      i++;
+      expect(tokens[i].index).toEqual(12);
+      expect(tokens[i].text).toEqual("|");
+
+      i++;
+      expect(tokens[i].index).toEqual(13);
+      expect(tokens[i].text).toEqual("f");
+
+      i++;
+      expect(tokens[i].index).toEqual(14);
+      expect(tokens[i].text).toEqual(":");
+
+      i++;
+      expect(tokens[i].index).toEqual(15);
+      expect(tokens[i].value).toEqual("a'c");
+
+      i++;
+      expect(tokens[i].index).toEqual(21);
+      expect(tokens[i].text).toEqual(":");
+
+      i++;
+      expect(tokens[i].index).toEqual(22);
+      expect(tokens[i].value).toEqual('d"e');
+    });
+
+    it("should tokenize identifiers with spaces around dots the same as without spaces", () => {
+      function getText(t) {
+        return t.text;
+      }
+      const spaces = lex("foo. bar . baz").map(getText);
+      const noSpaces = lex("foo.bar.baz").map(getText);
+
+      expect(spaces).toEqual(noSpaces);
+    });
+
+    it("should use callback functions to know when an identifier is valid", () => {
+      function getText(t) {
+        return t.text;
+      }
+      const isIdentifierStart = jasmine.createSpy("start");
+      const isIdentifierContinue = jasmine.createSpy("continue");
+      isIdentifierStart.and.returnValue(true);
+      const lex = new Lexer({
+        isIdentifierStart,
+        isIdentifierContinue,
+      });
+
+      isIdentifierContinue.and.returnValue(true);
+      let tokens = lex.lex("πΣε").map(getText);
+      expect(tokens).toEqual(["πΣε"]);
+
+      isIdentifierContinue.and.returnValue(false);
+      tokens = lex.lex("πΣε").map(getText);
+      expect(tokens).toEqual(["π", "Σ", "ε"]);
+    });
+
+    it("should send the unicode characters and code points", () => {
+      function getText(t) {
+        return t.text;
+      }
+      const isIdentifierStart = jasmine.createSpy("start");
+      const isIdentifierContinue = jasmine.createSpy("continue");
+      isIdentifierStart.and.returnValue(true);
+      isIdentifierContinue.and.returnValue(true);
+      const lex = new Lexer({
+        isIdentifierStart,
+        isIdentifierContinue,
+      });
+      const tokens = lex.lex("\uD801\uDC37\uD852\uDF62\uDBFF\uDFFF");
+      expect(isIdentifierStart).toHaveBeenCalledTimes(1);
+      expect(isIdentifierStart.calls.argsFor(0)).toEqual([
+        "\uD801\uDC37",
+        0x10437,
+      ]);
+      expect(isIdentifierContinue).toHaveBeenCalledTimes(2);
+      expect(isIdentifierContinue.calls.argsFor(0)).toEqual([
+        "\uD852\uDF62",
+        0x24b62,
+      ]);
+      expect(isIdentifierContinue.calls.argsFor(1)).toEqual([
+        "\uDBFF\uDFFF",
+        0x10ffff,
+      ]);
+    });
+
+    it("should tokenize undefined", () => {
+      const tokens = lex("undefined");
+      const i = 0;
+      expect(tokens[i].index).toEqual(0);
+      expect(tokens[i].text).toEqual("undefined");
+    });
+
+    it("should tokenize quoted string", () => {
+      const str = "['\\'', \"\\\"\"]";
+      const tokens = lex(str);
+
+      expect(tokens[1].index).toEqual(1);
+      expect(tokens[1].value).toEqual("'");
+
+      expect(tokens[3].index).toEqual(7);
+      expect(tokens[3].value).toEqual('"');
+    });
+
+    it("should tokenize escaped quoted string", () => {
+      const str = '"\\"\\n\\f\\r\\t\\v\\u00A0"';
+      const tokens = lex(str);
+
+      expect(tokens[0].value).toEqual('"\n\f\r\t\v\u00A0');
+    });
+
+    it("should tokenize unicode", () => {
+      const tokens = lex('"\\u00A0"');
+      expect(tokens.length).toEqual(1);
+      expect(tokens[0].value).toEqual("\u00a0");
+    });
+
+    it("should ignore whitespace", () => {
+      const tokens = lex("a \t \n \r b");
+      expect(tokens[0].text).toEqual("a");
+      expect(tokens[1].text).toEqual("b");
+    });
+
+    it("should tokenize relation and equality", () => {
+      const tokens = lex("! == != < > <= >= === !==");
+      expect(tokens[0].text).toEqual("!");
+      expect(tokens[1].text).toEqual("==");
+      expect(tokens[2].text).toEqual("!=");
+      expect(tokens[3].text).toEqual("<");
+      expect(tokens[4].text).toEqual(">");
+      expect(tokens[5].text).toEqual("<=");
+      expect(tokens[6].text).toEqual(">=");
+      expect(tokens[7].text).toEqual("===");
+      expect(tokens[8].text).toEqual("!==");
+    });
+
+    it("should tokenize logical and ternary", () => {
+      const tokens = lex("&& || ? :");
+      expect(tokens[0].text).toEqual("&&");
+      expect(tokens[1].text).toEqual("||");
+      expect(tokens[2].text).toEqual("?");
+      expect(tokens[3].text).toEqual(":");
+    });
+
+    it("should tokenize statements", () => {
+      const tokens = lex("a;b;");
+      expect(tokens[0].text).toEqual("a");
+      expect(tokens[1].text).toEqual(";");
+      expect(tokens[2].text).toEqual("b");
+      expect(tokens[3].text).toEqual(";");
+    });
+
+    it("should tokenize function invocation", () => {
+      const tokens = lex("a()");
+      expect(tokens.map((t) => t.text)).toEqual(["a", "(", ")"]);
+    });
+
+    it("should tokenize method invocation", () => {
+      const tokens = lex("a.b.c (d) - e.f()");
+      expect(tokens.map((t) => t.text)).toEqual([
+        "a",
+        ".",
+        "b",
+        ".",
+        "c",
+        "(",
+        "d",
+        ")",
+        "-",
+        "e",
+        ".",
+        "f",
+        "(",
+        ")",
+      ]);
+    });
+
+    it("should tokenize number", () => {
+      const tokens = lex("0.5");
+      expect(tokens[0].value).toEqual(0.5);
+    });
+
+    it("should tokenize negative number", () => {
+      let value = $rootScope.$eval("-0.5");
+      expect(value).toEqual(-0.5);
+
+      value = $rootScope.$eval("{a:-0.5}");
+      expect(value).toEqual({ a: -0.5 });
+    });
+
+    it("should tokenize number with exponent", () => {
+      let tokens = lex("0.5E-10");
+      expect(tokens[0].value).toEqual(0.5e-10);
+      expect($rootScope.$eval("0.5E-10")).toEqual(0.5e-10);
+
+      tokens = lex("0.5E+10");
+      expect(tokens[0].value).toEqual(0.5e10);
+    });
+
+    it("should throws exception for invalid exponent", () => {
+      expect(() => {
+        lex("0.5E-");
+      }).toThrowError(/lexerr/);
+
+      expect(() => {
+        lex("0.5E-A");
+      }).toThrowError(/lexerr/);
+    });
+
+    it("should tokenize number starting with a dot", () => {
+      const tokens = lex(".5");
+      expect(tokens[0].value).toEqual(0.5);
+    });
+
+    it("should throw error on invalid unicode", () => {
+      expect(() => {
+        lex("'\\u1''bla'");
+      }).toThrowError(/lexerr/);
+    });
+  });
+});

package/src/core/parser/parse.js

@@ -14,7 +14,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]
@@ -69,6 +69,11 @@ export function $ParseProvider() {
 
   this.$get = [
     "$filter",
+    /**
+     *
+     * @param {(any) => any} $filter
+     * @returns {ParseService}
+     */
     function ($filter) {
       /** @type {import("./lexer").LexerOptions} */
       var $lexerOptions = {

package/src/core/parser/parser.test.js

@@ -0,0 +1,19 @@
+import { test, expect } from "@playwright/test";
+
+test("lexer unit tests contain no errors", async ({ page }) => {
+  await page.goto("src/core/parser/lexer.html");
+  await page.content();
+  await page.waitForTimeout(100);
+  await expect(page.locator(".jasmine-overall-result")).toHaveText(
+    /0 failures/,
+  );
+});
+
+test("parser unit tests contain no errors", async ({ page }) => {
+  await page.goto("src/core/parser/parse.html");
+  await page.content();
+  await page.waitForTimeout(100);
+  await expect(page.locator(".jasmine-overall-result")).toHaveText(
+    /0 failures/,
+  );
+});

package/types/animations/animate-css.d.ts

@@ -1,6 +1,6 @@
 export function $AnimateCssProvider(): void;
 export class $AnimateCssProvider {
-    $get: (string | (($$AnimateRunner: any, $timeout: any, $$animateCache: any, $$rAFScheduler: any, $$animateQueue: any) => (element: any, initialOptions: any) => {
+    $get: (string | (($$AnimateRunner: any, $timeout: any, $$animateCache: any, $$rAFScheduler: import("./raf-scheduler").RafScheduler, $$animateQueue: any) => (element: any, initialOptions: any) => {
         $$willAnimate: boolean;
         start(): any;
         end: () => void;

package/types/animations/animation.d.ts

@@ -1,5 +1,5 @@
 export function $$AnimationProvider(): void;
 export class $$AnimationProvider {
     drivers: any[];
-    $get: (string | (($rootScope: any, $injector: any, $$AnimateRunner: any, $$rAFScheduler: any, $$animateCache: any) => (element: any, event: any, options: any) => any))[];
+    $get: (string | (($rootScope: any, $injector: any, $$AnimateRunner: any, $$rAFScheduler: import("./raf-scheduler").RafScheduler, $$animateCache: any) => (element: any, event: any, options: any) => any))[];
 }

package/types/animations/raf-scheduler.d.ts

@@ -1,34 +1,19 @@
 /**
- * @typedef {Object} Scheduler
+ * @typedef {Function} RafSchedulerFunction
+ * @typedef {Object} RafSchedulerObject
  * @property {Function} waitUntilQuiet - Function to wait until the animation frame is quiet.
- * @property {Array<Function>} queue - The queue of tasks to be processed.
- * @property {Function} scheduler - The function to add tasks to the queue and schedule the next tick.
+ * @typedef {RafSchedulerObject & RafSchedulerFunction} RafScheduler
  */
 /**
  * Creates a requestAnimationFrame scheduler.
- * @returns {Scheduler} The scheduler object.
+ * @returns {RafScheduler} The scheduler object.
  */
-export const $$rAFSchedulerFactory: (() => {
-    (tasks: Array<Function>): void;
-    queue: any[];
-    /**
-     * Waits until the animation frame is quiet before running the provided function.
-     * Cancels any previous animation frame requests.
-     * @param {Function} fn - The function to run when the animation frame is quiet.
-     */
-    waitUntilQuiet(fn: Function): void;
-})[];
-export type Scheduler = {
+export function $$rAFSchedulerFactory(): RafScheduler;
+export type RafSchedulerFunction = Function;
+export type RafSchedulerObject = {
     /**
      * - Function to wait until the animation frame is quiet.
      */
     waitUntilQuiet: Function;
-    /**
-     * - The queue of tasks to be processed.
-     */
-    queue: Array<Function>;
-    /**
-     * - The function to add tasks to the queue and schedule the next tick.
-     */
-    scheduler: Function;
 };
+export type RafScheduler = RafSchedulerObject & RafSchedulerFunction;

package/types/core/parser/parse.d.ts

@@ -8,7 +8,7 @@
  * @property {function(any, any): any} assign - Assigns a value to a context. If value is not provided,
  */
 /**
- * @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]