@angular-wave/angular.ts 0.0.46 → 0.0.48

package/src/core/parser/interpreter.js

@@ -0,0 +1,422 @@
+import {
+  assignableAST,
+  findConstantAndWatchExpressions,
+  getInputs,
+  getStringValue,
+  plusFn,
+} from "./shared";
+import { forEach, isDefined } from "../../shared/utils";
+import { ASTType } from "./ast-type";
+
+export function ASTInterpreter($filter) {
+  this.$filter = $filter;
+}
+
+ASTInterpreter.prototype = {
+  compile(ast) {
+    const self = this;
+    findConstantAndWatchExpressions(ast, self.$filter);
+    let assignable;
+    let assign;
+    if ((assignable = assignableAST(ast))) {
+      assign = this.recurse(assignable);
+    }
+    const toWatch = getInputs(ast.body);
+    let inputs;
+    if (toWatch) {
+      inputs = [];
+      forEach(toWatch, (watch, key) => {
+        const input = self.recurse(watch);
+        input.isPure = watch.isPure;
+        watch.input = input;
+        inputs.push(input);
+        watch.watchId = key;
+      });
+    }
+    const expressions = [];
+    forEach(ast.body, (expression) => {
+      expressions.push(self.recurse(expression.expression));
+    });
+    const fn =
+      ast.body.length === 0
+        ? () => {}
+        : ast.body.length === 1
+          ? expressions[0]
+          : function (scope, locals) {
+              let lastValue;
+              forEach(expressions, (exp) => {
+                lastValue = exp(scope, locals);
+              });
+              return lastValue;
+            };
+    if (assign) {
+      fn.assign = function (scope, value, locals) {
+        return assign(scope, locals, value);
+      };
+    }
+    if (inputs) {
+      fn.inputs = inputs;
+    }
+    return fn;
+  },
+
+  recurse(ast, context, create) {
+    let left;
+    let right;
+    const self = this;
+    let args;
+    if (ast.input) {
+      return this.inputs(ast.input, ast.watchId);
+    }
+    switch (ast.type) {
+      case ASTType.Literal:
+        return this.value(ast.value, context);
+      case ASTType.UnaryExpression:
+        right = this.recurse(ast.argument);
+        return this[`unary${ast.operator}`](right, context);
+      case ASTType.BinaryExpression:
+        left = this.recurse(ast.left);
+        right = this.recurse(ast.right);
+        return this[`binary${ast.operator}`](left, right, context);
+      case ASTType.LogicalExpression:
+        left = this.recurse(ast.left);
+        right = this.recurse(ast.right);
+        return this[`binary${ast.operator}`](left, right, context);
+      case ASTType.ConditionalExpression:
+        return this["ternary?:"](
+          this.recurse(ast.test),
+          this.recurse(ast.alternate),
+          this.recurse(ast.consequent),
+          context,
+        );
+      case ASTType.Identifier:
+        return self.identifier(ast.name, context, create);
+      case ASTType.MemberExpression:
+        left = this.recurse(ast.object, false, !!create);
+        if (!ast.computed) {
+          right = ast.property.name;
+        }
+        if (ast.computed) right = this.recurse(ast.property);
+        return ast.computed
+          ? this.computedMember(left, right, context, create)
+          : this.nonComputedMember(left, right, context, create);
+      case ASTType.CallExpression:
+        args = [];
+        forEach(ast.arguments, (expr) => {
+          args.push(self.recurse(expr));
+        });
+        if (ast.filter) right = this.$filter(ast.callee.name);
+        if (!ast.filter) right = this.recurse(ast.callee, true);
+        return ast.filter
+          ? function (scope, locals, assign, inputs) {
+              const values = [];
+              for (let i = 0; i < args.length; ++i) {
+                values.push(args[i](scope, locals, assign, inputs));
+              }
+              const value = right.apply(undefined, values, inputs);
+              return context
+                ? { context: undefined, name: undefined, value }
+                : value;
+            }
+          : function (scope, locals, assign, inputs) {
+              const rhs = right(scope, locals, assign, inputs);
+              let value;
+              if (rhs.value != null) {
+                const values = [];
+                for (let i = 0; i < args.length; ++i) {
+                  values.push(args[i](scope, locals, assign, inputs));
+                }
+                value = rhs.value.apply(rhs.context, values);
+              }
+              return context ? { value } : value;
+            };
+      case ASTType.AssignmentExpression:
+        left = this.recurse(ast.left, true, 1);
+        right = this.recurse(ast.right);
+        return function (scope, locals, assign, inputs) {
+          const lhs = left(scope, locals, assign, inputs);
+          const rhs = right(scope, locals, assign, inputs);
+          lhs.context[lhs.name] = rhs;
+          return context ? { value: rhs } : rhs;
+        };
+      case ASTType.ArrayExpression:
+        args = [];
+        forEach(ast.elements, (expr) => {
+          args.push(self.recurse(expr));
+        });
+        return function (scope, locals, assign, inputs) {
+          const value = [];
+          for (let i = 0; i < args.length; ++i) {
+            value.push(args[i](scope, locals, assign, inputs));
+          }
+          return context ? { value } : value;
+        };
+      case ASTType.ObjectExpression:
+        args = [];
+        forEach(ast.properties, (property) => {
+          if (property.computed) {
+            args.push({
+              key: self.recurse(property.key),
+              computed: true,
+              value: self.recurse(property.value),
+            });
+          } else {
+            args.push({
+              key:
+                property.key.type === ASTType.Identifier
+                  ? property.key.name
+                  : `${property.key.value}`,
+              computed: false,
+              value: self.recurse(property.value),
+            });
+          }
+        });
+        return function (scope, locals, assign, inputs) {
+          const value = {};
+          for (let i = 0; i < args.length; ++i) {
+            if (args[i].computed) {
+              value[args[i].key(scope, locals, assign, inputs)] = args[i].value(
+                scope,
+                locals,
+                assign,
+                inputs,
+              );
+            } else {
+              value[args[i].key] = args[i].value(scope, locals, assign, inputs);
+            }
+          }
+          return context ? { value } : value;
+        };
+      case ASTType.ThisExpression:
+        return function (scope) {
+          return context ? { value: scope } : scope;
+        };
+      case ASTType.LocalsExpression:
+        return function (scope, locals) {
+          return context ? { value: locals } : locals;
+        };
+      case ASTType.NGValueParameter:
+        return function (scope, locals, assign) {
+          return context ? { value: assign } : assign;
+        };
+    }
+  },
+
+  "unary+": function (argument, context) {
+    return function (scope, locals, assign, inputs) {
+      let arg = argument(scope, locals, assign, inputs);
+      if (isDefined(arg)) {
+        arg = +arg;
+      } else {
+        arg = 0;
+      }
+      return context ? { value: arg } : arg;
+    };
+  },
+
+  "unary-": function (argument, context) {
+    return function (scope, locals, assign, inputs) {
+      let arg = argument(scope, locals, assign, inputs);
+      if (isDefined(arg)) {
+        arg = -arg;
+      } else {
+        arg = -0;
+      }
+      return context ? { value: arg } : arg;
+    };
+  },
+  "unary!": function (argument, context) {
+    return function (scope, locals, assign, inputs) {
+      const arg = !argument(scope, locals, assign, inputs);
+      return context ? { value: arg } : arg;
+    };
+  },
+  "binary+": function (left, right, context) {
+    return function (scope, locals, assign, inputs) {
+      const lhs = left(scope, locals, assign, inputs);
+      const rhs = right(scope, locals, assign, inputs);
+      const arg = plusFn(lhs, rhs);
+      return context ? { value: arg } : arg;
+    };
+  },
+  "binary-": function (left, right, context) {
+    return function (scope, locals, assign, inputs) {
+      const lhs = left(scope, locals, assign, inputs);
+      const rhs = right(scope, locals, assign, inputs);
+      const arg = (isDefined(lhs) ? lhs : 0) - (isDefined(rhs) ? rhs : 0);
+      return context ? { value: arg } : arg;
+    };
+  },
+  "binary*": function (left, right, context) {
+    return function (scope, locals, assign, inputs) {
+      const arg =
+        left(scope, locals, assign, inputs) *
+        right(scope, locals, assign, inputs);
+      return context ? { value: arg } : arg;
+    };
+  },
+  "binary/": function (left, right, context) {
+    return function (scope, locals, assign, inputs) {
+      const arg =
+        left(scope, locals, assign, inputs) /
+        right(scope, locals, assign, inputs);
+      return context ? { value: arg } : arg;
+    };
+  },
+  "binary%": function (left, right, context) {
+    return function (scope, locals, assign, inputs) {
+      const arg =
+        left(scope, locals, assign, inputs) %
+        right(scope, locals, assign, inputs);
+      return context ? { value: arg } : arg;
+    };
+  },
+  "binary===": function (left, right, context) {
+    return function (scope, locals, assign, inputs) {
+      const arg =
+        left(scope, locals, assign, inputs) ===
+        right(scope, locals, assign, inputs);
+      return context ? { value: arg } : arg;
+    };
+  },
+  "binary!==": function (left, right, context) {
+    return function (scope, locals, assign, inputs) {
+      const arg =
+        left(scope, locals, assign, inputs) !==
+        right(scope, locals, assign, inputs);
+      return context ? { value: arg } : arg;
+    };
+  },
+  "binary==": function (left, right, context) {
+    return function (scope, locals, assign, inputs) {
+      const arg =
+        left(scope, locals, assign, inputs) ==
+        right(scope, locals, assign, inputs);
+      return context ? { value: arg } : arg;
+    };
+  },
+  "binary!=": function (left, right, context) {
+    return function (scope, locals, assign, inputs) {
+      const arg =
+        left(scope, locals, assign, inputs) !=
+        right(scope, locals, assign, inputs);
+      return context ? { value: arg } : arg;
+    };
+  },
+  "binary<": function (left, right, context) {
+    return function (scope, locals, assign, inputs) {
+      const arg =
+        left(scope, locals, assign, inputs) <
+        right(scope, locals, assign, inputs);
+      return context ? { value: arg } : arg;
+    };
+  },
+  "binary>": function (left, right, context) {
+    return function (scope, locals, assign, inputs) {
+      const arg =
+        left(scope, locals, assign, inputs) >
+        right(scope, locals, assign, inputs);
+      return context ? { value: arg } : arg;
+    };
+  },
+  "binary<=": function (left, right, context) {
+    return function (scope, locals, assign, inputs) {
+      const arg =
+        left(scope, locals, assign, inputs) <=
+        right(scope, locals, assign, inputs);
+      return context ? { value: arg } : arg;
+    };
+  },
+  "binary>=": function (left, right, context) {
+    return function (scope, locals, assign, inputs) {
+      const arg =
+        left(scope, locals, assign, inputs) >=
+        right(scope, locals, assign, inputs);
+      return context ? { value: arg } : arg;
+    };
+  },
+  "binary&&": function (left, right, context) {
+    return function (scope, locals, assign, inputs) {
+      const arg =
+        left(scope, locals, assign, inputs) &&
+        right(scope, locals, assign, inputs);
+      return context ? { value: arg } : arg;
+    };
+  },
+  "binary||": function (left, right, context) {
+    return function (scope, locals, assign, inputs) {
+      const arg =
+        left(scope, locals, assign, inputs) ||
+        right(scope, locals, assign, inputs);
+      return context ? { value: arg } : arg;
+    };
+  },
+  "ternary?:": function (test, alternate, consequent, context) {
+    return function (scope, locals, assign, inputs) {
+      const arg = test(scope, locals, assign, inputs)
+        ? alternate(scope, locals, assign, inputs)
+        : consequent(scope, locals, assign, inputs);
+      return context ? { value: arg } : arg;
+    };
+  },
+  value(value, context) {
+    return function () {
+      return context ? { context: undefined, name: undefined, value } : value;
+    };
+  },
+  identifier(name, context, create) {
+    return function (scope, locals) {
+      const base = locals && name in locals ? locals : scope;
+      if (create && create !== 1 && base && base[name] == null) {
+        base[name] = {};
+      }
+      const value = base ? base[name] : undefined;
+      if (context) {
+        return { context: base, name, value };
+      }
+      return value;
+    };
+  },
+  computedMember(left, right, context, create) {
+    return function (scope, locals, assign, inputs) {
+      const lhs = left(scope, locals, assign, inputs);
+      let rhs;
+      let value;
+      if (lhs != null) {
+        rhs = right(scope, locals, assign, inputs);
+        rhs = getStringValue(rhs);
+        if (create && create !== 1) {
+          if (lhs && !lhs[rhs]) {
+            lhs[rhs] = {};
+          }
+        }
+        value = lhs[rhs];
+      }
+      if (context) {
+        return { context: lhs, name: rhs, value };
+      }
+      return value;
+    };
+  },
+  nonComputedMember(left, right, context, create) {
+    return function (scope, locals, assign, inputs) {
+      const lhs = left(scope, locals, assign, inputs);
+      if (create && create !== 1) {
+        if (lhs && lhs[right] == null) {
+          lhs[right] = {};
+        }
+      }
+      const value = lhs != null ? lhs[right] : undefined;
+      if (context) {
+        return { context: lhs, name: right, value };
+      }
+      return value;
+    };
+  },
+  inputs(input, watchId) {
+    return function (scope, value, locals, inputs) {
+      if (inputs) return inputs[watchId];
+      return input(scope, value, locals);
+    };
+  },
+};

package/src/core/parser/lexer.js

@@ -0,0 +1,257 @@
+import { $parseMinErr } from "./parse";
+
+import { isDefined } from "../../shared/utils";
+
+const ESCAPE = {
+  n: "\n",
+  f: "\f",
+  r: "\r",
+  t: "\t",
+  v: "\v",
+  "'": "'",
+  '"': '"',
+};
+
+const OPERATORS = new Set(
+  "+ - * / % === !== == != < > <= >= && || ! = |".split(" "),
+);
+
+/**
+ * @constructor
+ */
+export const Lexer = function Lexer(options) {
+  this.options = options;
+};
+
+Lexer.prototype = {
+  constructor: Lexer,
+
+  lex(text) {
+    this.text = text;
+    this.index = 0;
+    this.tokens = [];
+
+    while (this.index < this.text.length) {
+      const ch = this.text.charAt(this.index);
+      if (ch === '"' || ch === "'") {
+        this.readString(ch);
+      } else if (
+        this.isNumber(ch) ||
+        (ch === "." && this.isNumber(this.peek()))
+      ) {
+        this.readNumber();
+      } else if (this.isIdentifierStart(this.peekMultichar())) {
+        this.readIdent();
+      } else if (this.is(ch, "(){}[].,;:?")) {
+        this.tokens.push({ index: this.index, text: ch });
+        this.index++;
+      } else if (this.isWhitespace(ch)) {
+        this.index++;
+      } else {
+        const ch2 = ch + this.peek();
+        const ch3 = ch2 + this.peek(2);
+        const op1 = OPERATORS.has(ch);
+        const op2 = OPERATORS.has(ch2);
+        const op3 = OPERATORS.has(ch3);
+        if (op1 || op2 || op3) {
+          const token = op3 ? ch3 : op2 ? ch2 : ch;
+          this.tokens.push({ index: this.index, text: token, operator: true });
+          this.index += token.length;
+        } else {
+          this.throwError(
+            "Unexpected next character ",
+            this.index,
+            this.index + 1,
+          );
+        }
+      }
+    }
+    return this.tokens;
+  },
+
+  is(ch, chars) {
+    return chars.indexOf(ch) !== -1;
+  },
+
+  peek(i) {
+    const num = i || 1;
+    return this.index + num < this.text.length
+      ? this.text.charAt(this.index + num)
+      : false;
+  },
+
+  isNumber(ch) {
+    return ch >= "0" && ch <= "9" && typeof ch === "string";
+  },
+
+  isWhitespace(ch) {
+    // IE treats non-breaking space as \u00A0
+    return (
+      ch === " " ||
+      ch === "\r" ||
+      ch === "\t" ||
+      ch === "\n" ||
+      ch === "\v" ||
+      ch === "\u00A0"
+    );
+  },
+
+  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 === "$"
+    );
+  },
+
+  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);
+  },
+
+  codePointAt(ch) {
+    if (ch.length === 1) return ch.charCodeAt(0);
+
+    return (ch.charCodeAt(0) << 10) + ch.charCodeAt(1) - 0x35fdc00;
+  },
+
+  peekMultichar() {
+    const ch = this.text.charAt(this.index);
+    const peek = this.peek();
+    if (!peek) {
+      return ch;
+    }
+    const cp1 = ch.charCodeAt(0);
+    const cp2 = peek.charCodeAt(0);
+    if (cp1 >= 0xd800 && cp1 <= 0xdbff && cp2 >= 0xdc00 && cp2 <= 0xdfff) {
+      return ch + peek;
+    }
+    return ch;
+  },
+
+  isExpOperator(ch) {
+    return ch === "-" || ch === "+" || this.isNumber(ch);
+  },
+
+  throwError(error, start, end) {
+    end = end || this.index;
+    const colStr = isDefined(start)
+      ? `s ${start}-${this.index} [${this.text.substring(start, end)}]`
+      : ` ${end}`;
+    throw $parseMinErr(
+      "lexerr",
+      "Lexer Error: {0} at column{1} in expression [{2}].",
+      error,
+      colStr,
+      this.text,
+    );
+  },
+
+  readNumber() {
+    let number = "";
+    const start = this.index;
+    while (this.index < this.text.length) {
+      const ch = this.text.charAt(this.index).toLowerCase();
+      if (ch === "." || this.isNumber(ch)) {
+        number += ch;
+      } else {
+        const peekCh = this.peek();
+        if (ch === "e" && this.isExpOperator(peekCh)) {
+          number += ch;
+        } else if (
+          this.isExpOperator(ch) &&
+          peekCh &&
+          this.isNumber(peekCh) &&
+          number.charAt(number.length - 1) === "e"
+        ) {
+          number += ch;
+        } else if (
+          this.isExpOperator(ch) &&
+          (!peekCh || !this.isNumber(peekCh)) &&
+          number.charAt(number.length - 1) === "e"
+        ) {
+          this.throwError("Invalid exponent");
+        } else {
+          break;
+        }
+      }
+      this.index++;
+    }
+    this.tokens.push({
+      index: start,
+      text: number,
+      constant: true,
+      value: Number(number),
+    });
+  },
+
+  readIdent() {
+    const start = this.index;
+    this.index += this.peekMultichar().length;
+    while (this.index < this.text.length) {
+      const ch = this.peekMultichar();
+      if (!this.isIdentifierContinue(ch)) {
+        break;
+      }
+      this.index += ch.length;
+    }
+    this.tokens.push({
+      index: start,
+      text: this.text.slice(start, this.index),
+      identifier: true,
+    });
+  },
+
+  readString(quote) {
+    const start = this.index;
+    this.index++;
+    let string = "";
+    let rawString = quote;
+    let escape = false;
+    while (this.index < this.text.length) {
+      const ch = this.text.charAt(this.index);
+      rawString += ch;
+      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));
+        } else {
+          const rep = ESCAPE[ch];
+          string += rep || ch;
+        }
+        escape = false;
+      } else if (ch === "\\") {
+        escape = true;
+      } else if (ch === quote) {
+        this.index++;
+        this.tokens.push({
+          index: start,
+          text: rawString,
+          constant: true,
+          value: string,
+        });
+        return;
+      } else {
+        string += ch;
+      }
+      this.index++;
+    }
+    this.throwError("Unterminated quote", start);
+  },
+};