@auscope/angular2parse 20.0.2 → 21.0.0

package/projects/angular2parse/src/lib/visitors/parse-visitor-resolver.ts

@@ -0,0 +1,208 @@
+import {
+    AST,
+    RecursiveAstVisitor,
+    PropertyRead,
+    MethodCall,
+    KeyedRead,
+    ImplicitReceiver,
+    LiteralPrimitive,
+    Binary,
+    Chain,
+    Conditional,
+    BindingPipe,
+    FunctionCall,
+    Interpolation,
+    KeyedWrite,
+    LiteralArray,
+    LiteralMap,
+    PrefixNot,
+    PropertyWrite,
+    SafePropertyRead,
+    SafeMethodCall,
+    Quote
+} from '../angular';
+import * as util from '../util';
+import { BinaryOperations } from '../util/binary-operations';
+
+export class ParseVisitorResolver extends RecursiveAstVisitor {
+
+    constructor(private pipes: Map<string, any>) {
+        super();
+    };
+
+    visitBinary(ast: Binary, context: any): any {
+        const execFn = BinaryOperations.get(ast.operation);
+
+        if (!execFn) {
+            throw new Error(`Parse ERROR: on visitBinary, unknown operator ${ast.operation}`);
+        }
+
+        return execFn(ast.left.visit(this, context), ast.right.visit(this, context));
+    }
+
+    // TODO
+    visitChain(ast: Chain, context: any): any {
+        return this.visitAll(ast.expressions, context);
+    }
+
+    visitConditional(ast: Conditional, context: any): any {
+        if (ast.condition.visit(this, context)) {
+            return ast.trueExp.visit(this, context);
+        }
+        else if (util.isPresent(ast.falseExp)) {
+            return ast.falseExp.visit(this, context);
+        }
+
+        return null;
+    }
+
+    visitPipe(ast: BindingPipe, context: any): any {
+        const pipe = this.pipes.get(ast.name);
+
+        if (!pipe) {
+            throw new Error(`pipe ${ast.name} not found.`);
+        }
+
+        if (!pipe.transform) {
+            throw new Error(`Parse ERROR: on visitPipe, transform method doesn't exist on pipe ${ast.name}.`);
+        }
+
+        const value = ast.exp.visit(this, context);
+        const pipeArgs = this.visitAll(ast.args, context);
+
+        pipeArgs.unshift(value);
+
+        return pipe.transform.apply(null, pipeArgs);
+    }
+
+    // TODO
+    visitFunctionCall(ast: FunctionCall, context: any): any {
+        const target = ast.target.visit(this, context);
+
+        if (!util.isFunction(target)) {
+            throw new Error(`Parse ERROR: on visitFunctionCall, target is not a function.`);
+        }
+
+        const args = this.visitAll(ast.args, context);
+        return target.apply(target, args);
+    }
+
+    visitImplicitReceiver(ast: ImplicitReceiver, context: any): any {
+        return context;
+    }
+
+    visitInterpolation(ast: Interpolation, context: any): any {
+        return this.visitAll(ast.expressions, context)[0];
+    }
+
+    visitKeyedRead(ast: KeyedRead, context: any): any {
+        const obj = ast.obj.visit(this, context);
+        const key = ast.key.visit(this, context);
+        return obj[key];
+    }
+
+    visitKeyedWrite(ast: KeyedWrite, context: any): any {
+        const obj = ast.obj.visit(this, context);
+        const key = ast.key.visit(this, context);
+        const value = ast.value.visit(this, context);
+        obj[key] = value;
+        return null;
+    }
+
+    visitLiteralArray(ast: LiteralArray, context: any): any {
+        return this.visitAll(ast.expressions, context);
+    }
+
+    visitLiteralMap(ast: LiteralMap, context: any): any {
+        const result: any = {};
+        const keys = ast.keys;
+        const values = this.visitAll(ast.values, context);
+
+        for (let i = 0, length = keys.length; i < length; i++) {
+            result[keys[i]] = values[i];
+        }
+
+        return result;
+    }
+
+    visitLiteralPrimitive(ast: LiteralPrimitive, context: any): any {
+        return ast.value;
+    }
+
+    visitMethodCall(ast: MethodCall, context: any): any {
+        const receiver = ast.receiver.visit(this, context);
+
+        if (!util.isJsObject(receiver)) {
+            throw new Error(`Parse ERROR: on visitMethodCall, invalid method receiver.`);
+        }
+
+        const method = receiver[ast.name];
+
+        if (!util.isFunction(method)) {
+            throw new Error(`Parse ERROR: on visitMethodCall, method ${ast.name} doesn't exist on receiver.`);
+        }
+
+        const args = this.visitAll(ast.args, context);
+        return method.apply(receiver, args);
+    }
+
+    visitPrefixNot(ast: PrefixNot, context: any): any {
+        return ast.expression.visit(this, context);
+    }
+
+    visitPropertyRead(ast: PropertyRead, context: any): any {
+        const receiver = ast.receiver.visit(this, context);
+
+        if (!util.isJsObject(receiver)) {
+            throw new Error(`Parse ERROR: on visitPropertyRead, invalid property receiver.`);
+        }
+
+        return receiver[ast.name];
+    }
+
+    visitPropertyWrite(ast: PropertyWrite, context: any): any {
+        const receiver = ast.receiver.visit(this, context);
+
+        if (!util.isJsObject(receiver)) {
+            throw new Error(`Parse ERROR: on visitPropertyRead, invalid property receiver.`);
+        }
+
+        receiver[ast.name] = ast.value.visit(this, context);
+        return null;
+    }
+
+    visitSafePropertyRead(ast: SafePropertyRead, context: any): any {
+        const receiver = ast.receiver.visit(this, context);
+
+        if (!util.isJsObject(receiver)) {
+            throw new Error(`Parse ERROR: on visitSafePropertyRead, invalid property receiver.`);
+        }
+
+        return receiver[ast.name];
+    }
+
+    visitSafeMethodCall(ast: SafeMethodCall, context: any): any {
+        const receiver = ast.receiver.visit(this, context);
+
+        if (!util.isJsObject(receiver)) {
+            throw new Error(`Parse ERROR: on visitSafeMethodCall, invalid method receiver.`);
+        }
+
+        const method = receiver[ast.name];
+
+        if (!util.isFunction(method)) {
+            throw new Error(`Parse ERROR: on visitSafeMethodCall, method ${ast.name} doesn't exist on receiver.`);
+        }
+
+        const args = this.visitAll(ast.args, context);
+        return method.apply(receiver, args);
+    }
+
+    visitAll(asts: AST[], context: any): any {
+        return asts.map(ast => ast.visit(this, context));
+    }
+
+    visitQuote(ast: Quote, context: any): any {
+        throw new Error(`Parse ERROR: on visitQuote, quote expression not allowed.`);
+    }
+}

package/projects/angular2parse/src/lib/visitors.d.ts

@@ -0,0 +1,3 @@
+export * from './visitors/parse-visitor-compiler';
+export * from './visitors/parse-visitor-resolver';
+//# sourceMappingURL=visitors.d.ts.map

package/projects/angular2parse/src/lib/visitors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visitors.d.ts","sourceRoot":"","sources":["visitors.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAClD,cAAc,mCAAmC,CAAC"}

package/projects/angular2parse/src/lib/visitors.js

@@ -0,0 +1,3 @@
+export * from './visitors/parse-visitor-compiler';
+export * from './visitors/parse-visitor-resolver';
+//# sourceMappingURL=visitors.js.map

package/projects/angular2parse/src/lib/visitors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visitors.js","sourceRoot":"","sources":["visitors.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAClD,cAAc,mCAAmC,CAAC","sourcesContent":["export * from './visitors/parse-visitor-compiler';\r\nexport * from './visitors/parse-visitor-resolver';"]}

package/projects/angular2parse/src/lib/visitors.ts

@@ -0,0 +1,2 @@
+export * from './visitors/parse-visitor-compiler';
+export * from './visitors/parse-visitor-resolver';

package/projects/angular2parse/src/public-api.d.ts

@@ -0,0 +1,3 @@
+export * from './lib/module';
+export * from './lib/parse';
+//# sourceMappingURL=public-api.d.ts.map

package/projects/angular2parse/src/public-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-api.d.ts","sourceRoot":"","sources":["public-api.ts"],"names":[],"mappings":"AAGA,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAA"}

package/projects/angular2parse/src/public-api.js

@@ -0,0 +1,6 @@
+/*
+ * Public API Surface of angular2parse
+ */
+export * from './lib/module';
+export * from './lib/parse';
+//# sourceMappingURL=public-api.js.map

package/projects/angular2parse/src/public-api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-api.js","sourceRoot":"","sources":["public-api.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAA","sourcesContent":["/*\r\n * Public API Surface of angular2parse\r\n */\r\nexport * from './lib/module';\r\nexport * from './lib/parse'\r\n"]}

package/projects/angular2parse/src/public-api.ts

@@ -0,0 +1,5 @@
+/*
+ * Public API Surface of angular2parse
+ */
+export * from './lib/module';
+export * from './lib/parse'

package/projects/angular2parse/tsconfig.lib.json

@@ -0,0 +1,22 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/lib",
+    "declarationMap": true,
+    "declaration": true,
+    "inlineSources": true,
+    "types": []
+  },
+  "angularCompilerOptions": {
+    "skipTemplateCodegen": true,
+    "extendedDiagnostics": {
+      "checks": {
+        "nullishCoalescingNotNullable": "suppress",
+        "optionalChainNotNullable": "suppress"
+      }
+    },
+    "strictMetadataEmit": true,
+    "enableResourceInlining": true,
+    "strictTemplates": true
+  }
+}

package/projects/angular2parse/tsconfig.lib.prod.json

@@ -0,0 +1,15 @@
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial",
+    "extendedDiagnostics": {
+      "checks": {
+        "nullishCoalescingNotNullable": "suppress",
+        "optionalChainNotNullable": "suppress"
+      }
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "sourceMap": true,
+    "esModuleInterop": true,
+    "declaration": false,
+    "experimentalDecorators": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "importHelpers": true,
+    "target": "ES2022",
+    "typeRoots": [
+      "node_modules/@types"
+    ],
+    "useDefineForClassFields": false
+  },
+  "angularCompilerOptions": {
+    "fullTemplateTypeCheck": true,
+    "strictInjectionParameters": true
+  }
+}