@angular-wave/angular.ts 0.0.49 → 0.0.50

package/src/core/parser/compiler.js

@@ -1,561 +0,0 @@
-import {
-  findConstantAndWatchExpressions,
-  assignableAST,
-  getInputs,
-  ifDefined,
-  getStringValue,
-  plusFn,
-} from "./shared";
-import { forEach, isDefined, isNumber, isString } from "../../shared/utils";
-import { ASTType } from "./ast-type";
-import { $parseMinErr } from "./parse";
-
-export function ASTCompiler($filter) {
-  this.$filter = $filter;
-}
-
-ASTCompiler.prototype = {
-  compile(ast) {
-    const self = this;
-    this.state = {
-      nextId: 0,
-      filters: {},
-      fn: { vars: [], body: [], own: {} },
-      assign: { vars: [], body: [], own: {} },
-      inputs: [],
-    };
-    findConstantAndWatchExpressions(ast, self.$filter);
-    let extra = "";
-    let assignable;
-    this.stage = "assign";
-    if ((assignable = assignableAST(ast))) {
-      this.state.computing = "assign";
-      const result = this.nextId();
-      this.recurse(assignable, result);
-      this.return_(result);
-      extra = `fn.assign=${this.generateFunction("assign", "s,v,l")}`;
-    }
-    const toWatch = getInputs(ast.body);
-    self.stage = "inputs";
-    forEach(toWatch, (watch, key) => {
-      const fnKey = `fn${key}`;
-      self.state[fnKey] = { vars: [], body: [], own: {} };
-      self.state.computing = fnKey;
-      const intoId = self.nextId();
-      self.recurse(watch, intoId);
-      self.return_(intoId);
-      self.state.inputs.push({ name: fnKey, isPure: watch.isPure });
-      watch.watchId = key;
-    });
-    this.state.computing = "fn";
-    this.stage = "main";
-    this.recurse(ast);
-    const fnString = `\n${this.filterPrefix()}let fn=${this.generateFunction(
-      "fn",
-      "s,l,a,i",
-    )}${extra}${this.watchFns()}return fn;`;
-
-    const fn = new Function(
-      "$filter",
-      "getStringValue",
-      "ifDefined",
-      "plus",
-      fnString,
-    )(this.$filter, getStringValue, ifDefined, plusFn);
-    this.state = this.stage = undefined;
-    return fn;
-  },
-
-  watchFns() {
-    const result = [];
-    const { inputs } = this.state;
-    const self = this;
-    forEach(inputs, (input) => {
-      result.push(
-        `let ${input.name}=${self.generateFunction(input.name, "s")}`,
-      );
-      if (input.isPure) {
-        result.push(input.name, `.isPure=${JSON.stringify(input.isPure)};`);
-      }
-    });
-    if (inputs.length) {
-      result.push(`fn.inputs=[${inputs.map((i) => i.name).join(",")}];`);
-    }
-    return result.join("");
-  },
-
-  generateFunction(name, params) {
-    return `function(${params}){${this.varsPrefix(name)}${this.body(name)}};`;
-  },
-
-  filterPrefix() {
-    const parts = [];
-    const self = this;
-    forEach(this.state.filters, (id, filter) => {
-      parts.push(`${id}=$filter(${self.escape(filter)})`);
-    });
-    if (parts.length) return `let ${parts.join(",")};`;
-    return "";
-  },
-
-  varsPrefix(section) {
-    return this.state[section].vars.length
-      ? `let ${this.state[section].vars.join(",")};`
-      : "";
-  },
-
-  body(section) {
-    return this.state[section].body.join("");
-  },
-
-  recurse(ast, intoId, nameId, recursionFn, create, skipWatchIdCheck) {
-    let left;
-    let right;
-    const self = this;
-    let args;
-    let expression;
-    let computed;
-    recursionFn = recursionFn || (() => {});
-    if (!skipWatchIdCheck && isDefined(ast.watchId)) {
-      intoId = intoId || this.nextId();
-      this.if_(
-        "i",
-        this.lazyAssign(intoId, this.computedMember("i", ast.watchId)),
-        this.lazyRecurse(ast, intoId, nameId, recursionFn, create, true),
-      );
-      return;
-    }
-    switch (ast.type) {
-      case ASTType.Program:
-        forEach(ast.body, (expression, pos) => {
-          self.recurse(expression.expression, undefined, undefined, (expr) => {
-            right = expr;
-          });
-          if (pos !== ast.body.length - 1) {
-            self.current().body.push(right, ";");
-          } else {
-            self.return_(right);
-          }
-        });
-        break;
-      case ASTType.Literal:
-        expression = this.escape(ast.value);
-        this.assign(intoId, expression);
-        recursionFn(intoId || expression);
-        break;
-      case ASTType.UnaryExpression:
-        this.recurse(ast.argument, undefined, undefined, (expr) => {
-          right = expr;
-        });
-        expression = `${ast.operator}(${this.ifDefined(right, 0)})`;
-        this.assign(intoId, expression);
-        recursionFn(expression);
-        break;
-      case ASTType.BinaryExpression:
-        this.recurse(ast.left, undefined, undefined, (expr) => {
-          left = expr;
-        });
-        this.recurse(ast.right, undefined, undefined, (expr) => {
-          right = expr;
-        });
-        if (ast.operator === "+") {
-          expression = this.plus(left, right);
-        } else if (ast.operator === "-") {
-          expression =
-            this.ifDefined(left, 0) + ast.operator + this.ifDefined(right, 0);
-        } else {
-          expression = `(${left})${ast.operator}(${right})`;
-        }
-        this.assign(intoId, expression);
-        recursionFn(expression);
-        break;
-      case ASTType.LogicalExpression:
-        intoId = intoId || this.nextId();
-        self.recurse(ast.left, intoId);
-        self.if_(
-          ast.operator === "&&" ? intoId : self.not(intoId),
-          self.lazyRecurse(ast.right, intoId),
-        );
-        recursionFn(intoId);
-        break;
-      case ASTType.ConditionalExpression:
-        intoId = intoId || this.nextId();
-        self.recurse(ast.test, intoId);
-        self.if_(
-          intoId,
-          self.lazyRecurse(ast.alternate, intoId),
-          self.lazyRecurse(ast.consequent, intoId),
-        );
-        recursionFn(intoId);
-        break;
-      case ASTType.Identifier:
-        intoId = intoId || this.nextId();
-        if (nameId) {
-          nameId.context =
-            self.stage === "inputs"
-              ? "s"
-              : this.assign(
-                  this.nextId(),
-                  `${this.getHasOwnProperty("l", ast.name)}?l:s`,
-                );
-          nameId.computed = false;
-          nameId.name = ast.name;
-        }
-        self.if_(
-          self.stage === "inputs" ||
-            self.not(self.getHasOwnProperty("l", ast.name)),
-          () => {
-            self.if_(self.stage === "inputs" || "s", () => {
-              if (create && create !== 1) {
-                self.if_(
-                  self.isNull(self.nonComputedMember("s", ast.name)),
-                  self.lazyAssign(self.nonComputedMember("s", ast.name), "{}"),
-                );
-              }
-              self.assign(intoId, self.nonComputedMember("s", ast.name));
-            });
-          },
-          intoId &&
-            self.lazyAssign(intoId, self.nonComputedMember("l", ast.name)),
-        );
-        recursionFn(intoId);
-        break;
-      case ASTType.MemberExpression:
-        left = (nameId && (nameId.context = this.nextId())) || this.nextId();
-        intoId = intoId || this.nextId();
-        self.recurse(
-          ast.object,
-          left,
-          undefined,
-          () => {
-            self.if_(
-              self.notNull(left),
-              () => {
-                if (ast.computed) {
-                  right = self.nextId();
-                  self.recurse(ast.property, right);
-                  self.getStringValue(right);
-                  if (create && create !== 1) {
-                    self.if_(
-                      self.not(self.computedMember(left, right)),
-                      self.lazyAssign(self.computedMember(left, right), "{}"),
-                    );
-                  }
-                  expression = self.computedMember(left, right);
-                  self.assign(intoId, expression);
-                  if (nameId) {
-                    nameId.computed = true;
-                    nameId.name = right;
-                  }
-                } else {
-                  if (create && create !== 1) {
-                    self.if_(
-                      self.isNull(
-                        self.nonComputedMember(left, ast.property.name),
-                      ),
-                      self.lazyAssign(
-                        self.nonComputedMember(left, ast.property.name),
-                        "{}",
-                      ),
-                    );
-                  }
-                  expression = self.nonComputedMember(left, ast.property.name);
-                  self.assign(intoId, expression);
-                  if (nameId) {
-                    nameId.computed = false;
-                    nameId.name = ast.property.name;
-                  }
-                }
-              },
-              () => {
-                self.assign(intoId, "undefined");
-              },
-            );
-            recursionFn(intoId);
-          },
-          !!create,
-        );
-        break;
-      case ASTType.CallExpression:
-        intoId = intoId || this.nextId();
-        if (ast.filter) {
-          right = self.filter(ast.callee.name);
-          args = [];
-          forEach(ast.arguments, (expr) => {
-            const argument = self.nextId();
-            self.recurse(expr, argument);
-            args.push(argument);
-          });
-          expression = `${right}(${args.join(",")})`;
-          self.assign(intoId, expression);
-          recursionFn(intoId);
-        } else {
-          right = self.nextId();
-          left = {};
-          args = [];
-          self.recurse(ast.callee, right, left, () => {
-            self.if_(
-              self.notNull(right),
-              () => {
-                forEach(ast.arguments, (expr) => {
-                  self.recurse(
-                    expr,
-                    ast.constant ? undefined : self.nextId(),
-                    undefined,
-                    (argument) => {
-                      args.push(argument);
-                    },
-                  );
-                });
-                if (left.name) {
-                  expression = `${self.member(
-                    left.context,
-                    left.name,
-                    left.computed,
-                  )}(${args.join(",")})`;
-                } else {
-                  expression = `${right}(${args.join(",")})`;
-                }
-                self.assign(intoId, expression);
-              },
-              () => {
-                self.assign(intoId, "undefined");
-              },
-            );
-            recursionFn(intoId);
-          });
-        }
-        break;
-      case ASTType.AssignmentExpression:
-        right = this.nextId();
-        left = {};
-        this.recurse(
-          ast.left,
-          undefined,
-          left,
-          () => {
-            self.if_(self.notNull(left.context), () => {
-              self.recurse(ast.right, right);
-              expression =
-                self.member(left.context, left.name, left.computed) +
-                ast.operator +
-                right;
-              self.assign(intoId, expression);
-              recursionFn(intoId || expression);
-            });
-          },
-          1,
-        );
-        break;
-      case ASTType.ArrayExpression:
-        args = [];
-        forEach(ast.elements, (expr) => {
-          self.recurse(
-            expr,
-            ast.constant ? undefined : self.nextId(),
-            undefined,
-            (argument) => {
-              args.push(argument);
-            },
-          );
-        });
-        expression = `[${args.join(",")}]`;
-        this.assign(intoId, expression);
-        recursionFn(intoId || expression);
-        break;
-      case ASTType.ObjectExpression:
-        args = [];
-        computed = false;
-        forEach(ast.properties, (property) => {
-          if (property.computed) {
-            computed = true;
-          }
-        });
-        if (computed) {
-          intoId = intoId || this.nextId();
-          this.assign(intoId, "{}");
-          forEach(ast.properties, (property) => {
-            if (property.computed) {
-              left = self.nextId();
-              self.recurse(property.key, left);
-            } else {
-              left =
-                property.key.type === ASTType.Identifier
-                  ? property.key.name
-                  : `${property.key.value}`;
-            }
-            right = self.nextId();
-            self.recurse(property.value, right);
-            self.assign(self.member(intoId, left, property.computed), right);
-          });
-        } else {
-          forEach(ast.properties, (property) => {
-            self.recurse(
-              property.value,
-              ast.constant ? undefined : self.nextId(),
-              undefined,
-              (expr) => {
-                args.push(
-                  `${self.escape(
-                    property.key.type === ASTType.Identifier
-                      ? property.key.name
-                      : `${property.key.value}`,
-                  )}:${expr}`,
-                );
-              },
-            );
-          });
-          expression = `{${args.join(",")}}`;
-          this.assign(intoId, expression);
-        }
-        recursionFn(intoId || expression);
-        break;
-      case ASTType.ThisExpression:
-        this.assign(intoId, "s");
-        recursionFn(intoId || "s");
-        break;
-      case ASTType.LocalsExpression:
-        this.assign(intoId, "l");
-        recursionFn(intoId || "l");
-        break;
-      case ASTType.NGValueParameter:
-        this.assign(intoId, "v");
-        recursionFn(intoId || "v");
-        break;
-    }
-  },
-
-  getHasOwnProperty(element, property) {
-    const key = `${element}.${property}`;
-    const { own } = this.current();
-    if (!Object.prototype.hasOwnProperty.call(own, key)) {
-      own[key] = this.nextId(
-        false,
-        `${element}&&(${this.escape(property)} in ${element})`,
-      );
-    }
-    return own[key];
-  },
-
-  assign(id, value) {
-    if (!id) return;
-    this.current().body.push(id, "=", value, ";");
-    return id;
-  },
-
-  filter(filterName) {
-    if (!Object.prototype.hasOwnProperty.call(this.state.filters, filterName)) {
-      this.state.filters[filterName] = this.nextId(true);
-    }
-    return this.state.filters[filterName];
-  },
-
-  ifDefined(id, defaultValue) {
-    return `ifDefined(${id},${this.escape(defaultValue)})`;
-  },
-
-  plus(left, right) {
-    return `plus(${left},${right})`;
-  },
-
-  return_(id) {
-    this.current().body.push("return ", id, ";");
-  },
-
-  if_(test, alternate, consequent) {
-    if (test === true) {
-      alternate();
-    } else {
-      const { body } = this.current();
-      body.push("if(", test, "){");
-      alternate();
-      body.push("}");
-      if (consequent) {
-        body.push("else{");
-        consequent();
-        body.push("}");
-      }
-    }
-  },
-
-  not(expression) {
-    return `!(${expression})`;
-  },
-
-  isNull(expression) {
-    return `${expression}==null`;
-  },
-
-  notNull(expression) {
-    return `${expression}!=null`;
-  },
-
-  nonComputedMember(left, right) {
-    const SAFE_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/;
-    const UNSAFE_CHARACTERS = /[^$_a-zA-Z0-9]/g;
-    if (SAFE_IDENTIFIER.test(right)) {
-      return `${left}.${right}`;
-    }
-    return `${left}["${right.replace(
-      UNSAFE_CHARACTERS,
-      this.stringEscapeFn,
-    )}"]`;
-  },
-
-  computedMember(left, right) {
-    return `${left}[${right}]`;
-  },
-
-  member(left, right, computed) {
-    if (computed) return this.computedMember(left, right);
-    return this.nonComputedMember(left, right);
-  },
-
-  getStringValue(item) {
-    this.assign(item, `getStringValue(${item})`);
-  },
-
-  lazyRecurse(ast, intoId, nameId, recursionFn, create, skipWatchIdCheck) {
-    const self = this;
-    return function () {
-      self.recurse(ast, intoId, nameId, recursionFn, create, skipWatchIdCheck);
-    };
-  },
-
-  lazyAssign(id, value) {
-    const self = this;
-    return function () {
-      self.assign(id, value);
-    };
-  },
-
-  stringEscapeRegex: /[^ a-zA-Z0-9]/g,
-
-  stringEscapeFn(c) {
-    return `\\u${`0000${c.charCodeAt(0).toString(16)}`.slice(-4)}`;
-  },
-
-  escape(value) {
-    if (isString(value))
-      return `'${value.replace(this.stringEscapeRegex, this.stringEscapeFn)}'`;
-    if (isNumber(value)) return value.toString();
-    if (value === true) return "true";
-    if (value === false) return "false";
-    if (value === null) return "null";
-    if (typeof value === "undefined") return "undefined";
-
-    throw $parseMinErr("esc", "IMPOSSIBLE");
-  },
-
-  nextId(skip, init) {
-    const id = `v${this.state.nextId++}`;
-    if (!skip) {
-      this.current().vars.push(id + (init ? `=${init}` : ""));
-    }
-    return id;
-  },
-
-  current() {
-    return this.state[this.state.computing];
-  },
-};

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

@@ -1,49 +0,0 @@
-export function ASTCompiler($filter: any): void;
-export class ASTCompiler {
-    constructor($filter: any);
-    $filter: any;
-    compile(ast: any): any;
-    state: {
-        nextId: number;
-        filters: {};
-        fn: {
-            vars: any[];
-            body: any[];
-            own: {};
-        };
-        assign: {
-            vars: any[];
-            body: any[];
-            own: {};
-        };
-        inputs: any[];
-    };
-    stage: string;
-    watchFns(): string;
-    generateFunction(name: any, params: any): string;
-    filterPrefix(): string;
-    varsPrefix(section: any): string;
-    body(section: any): any;
-    recurse(ast: any, intoId: any, nameId: any, recursionFn: any, create: any, skipWatchIdCheck: any): void;
-    getHasOwnProperty(element: any, property: any): any;
-    assign(id: any, value: any): any;
-    filter(filterName: any): any;
-    ifDefined(id: any, defaultValue: any): string;
-    plus(left: any, right: any): string;
-    return_(id: any): void;
-    if_(test: any, alternate: any, consequent: any): void;
-    not(expression: any): string;
-    isNull(expression: any): string;
-    notNull(expression: any): string;
-    nonComputedMember(left: any, right: any): string;
-    computedMember(left: any, right: any): string;
-    member(left: any, right: any, computed: any): string;
-    getStringValue(item: any): void;
-    lazyRecurse(ast: any, intoId: any, nameId: any, recursionFn: any, create: any, skipWatchIdCheck: any): () => void;
-    lazyAssign(id: any, value: any): () => void;
-    stringEscapeRegex: RegExp;
-    stringEscapeFn(c: any): string;
-    escape(value: any): any;
-    nextId(skip: any, init: any): string;
-    current(): any;
-}