@abaplint/transpiler 2.5.37 → 2.5.39

package/build/src/expressions/component_cond.js

@@ -1,34 +1,34 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ComponentCondTranspiler = void 0;
-const abaplint = require("@abaplint/core");
-const chunk_1 = require("../chunk");
-class ComponentCondTranspiler {
-    transpile(node, traversal) {
-        let ret = "";
-        for (const c of node.getChildren()) {
-            if (c instanceof abaplint.Nodes.ExpressionNode) {
-                let cond = traversal.traverse(c).getCode();
-                cond = cond.replace(/^\(I\) => \{return /, "");
-                cond = cond.replace(/;\}$/, "");
-                ret += cond;
-            }
-            else if (c instanceof abaplint.Nodes.TokenNode) {
-                switch (c.get().getStr().toUpperCase()) {
-                    case "AND":
-                        ret += " && ";
-                        break;
-                    case "OR":
-                        ret += " || ";
-                        break;
-                    default:
-                        throw new Error("ComponentCondTranspiler, unexpected");
-                }
-            }
-        }
-        ret = `(I) => {return ${ret};}`;
-        return new chunk_1.Chunk(ret);
-    }
-}
-exports.ComponentCondTranspiler = ComponentCondTranspiler;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentCondTranspiler = void 0;
+const abaplint = require("@abaplint/core");
+const chunk_1 = require("../chunk");
+class ComponentCondTranspiler {
+    transpile(node, traversal) {
+        let ret = "";
+        for (const c of node.getChildren()) {
+            if (c instanceof abaplint.Nodes.ExpressionNode) {
+                let cond = traversal.traverse(c).getCode();
+                cond = cond.replace(/^\(I\) => \{return /, "");
+                cond = cond.replace(/;\}$/, "");
+                ret += cond;
+            }
+            else if (c instanceof abaplint.Nodes.TokenNode) {
+                switch (c.get().getStr().toUpperCase()) {
+                    case "AND":
+                        ret += " && ";
+                        break;
+                    case "OR":
+                        ret += " || ";
+                        break;
+                    default:
+                        throw new Error("ComponentCondTranspiler, unexpected");
+                }
+            }
+        }
+        ret = `(I) => {return ${ret};}`;
+        return new chunk_1.Chunk(ret);
+    }
+}
+exports.ComponentCondTranspiler = ComponentCondTranspiler;
 //# sourceMappingURL=component_cond.js.map

package/build/src/expressions/component_cond_sub.d.ts

@@ -1,7 +1,7 @@
-import { Nodes } from "@abaplint/core";
-import { IExpressionTranspiler } from "./_expression_transpiler";
-import { Traversal } from "../traversal";
-import { Chunk } from "../chunk";
-export declare class ComponentCondSubTranspiler implements IExpressionTranspiler {
-    transpile(node: Nodes.ExpressionNode, traversal: Traversal): Chunk;
-}
+import { Nodes } from "@abaplint/core";
+import { IExpressionTranspiler } from "./_expression_transpiler";
+import { Traversal } from "../traversal";
+import { Chunk } from "../chunk";
+export declare class ComponentCondSubTranspiler implements IExpressionTranspiler {
+    transpile(node: Nodes.ExpressionNode, traversal: Traversal): Chunk;
+}

package/build/src/expressions/component_cond_sub.js

@@ -1,37 +1,37 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ComponentCondSubTranspiler = void 0;
-const abaplint = require("@abaplint/core");
-const chunk_1 = require("../chunk");
-class ComponentCondSubTranspiler {
-    transpile(node, traversal) {
-        let ret = "";
-        for (const c of node.getChildren()) {
-            if (c instanceof abaplint.Nodes.ExpressionNode) {
-                let cond = traversal.traverse(c).getCode();
-                cond = cond.replace(/^\(I\) => \{return /, "");
-                cond = cond.replace(/;\}$/, "");
-                ret += cond;
-            }
-            else if (c instanceof abaplint.Nodes.TokenNode) {
-                switch (c.get().getStr().toUpperCase()) {
-                    case "(":
-                        ret += "(";
-                        break;
-                    case ")":
-                        ret += ")";
-                        break;
-                    case "NOT":
-                        ret += "!";
-                        break;
-                    default:
-                        throw new Error("ComponentCondSubTranspiler, unexpected: " + node.concatTokens());
-                }
-            }
-        }
-        ret = `(I) => {return ${ret};}`;
-        return new chunk_1.Chunk(ret);
-    }
-}
-exports.ComponentCondSubTranspiler = ComponentCondSubTranspiler;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentCondSubTranspiler = void 0;
+const abaplint = require("@abaplint/core");
+const chunk_1 = require("../chunk");
+class ComponentCondSubTranspiler {
+    transpile(node, traversal) {
+        let ret = "";
+        for (const c of node.getChildren()) {
+            if (c instanceof abaplint.Nodes.ExpressionNode) {
+                let cond = traversal.traverse(c).getCode();
+                cond = cond.replace(/^\(I\) => \{return /, "");
+                cond = cond.replace(/;\}$/, "");
+                ret += cond;
+            }
+            else if (c instanceof abaplint.Nodes.TokenNode) {
+                switch (c.get().getStr().toUpperCase()) {
+                    case "(":
+                        ret += "(";
+                        break;
+                    case ")":
+                        ret += ")";
+                        break;
+                    case "NOT":
+                        ret += "!";
+                        break;
+                    default:
+                        throw new Error("ComponentCondSubTranspiler, unexpected: " + node.concatTokens());
+                }
+            }
+        }
+        ret = `(I) => {return ${ret};}`;
+        return new chunk_1.Chunk(ret);
+    }
+}
+exports.ComponentCondSubTranspiler = ComponentCondSubTranspiler;
 //# sourceMappingURL=component_cond_sub.js.map

package/build/src/expressions/cond.d.ts

@@ -1,7 +1,7 @@
-import { Nodes } from "@abaplint/core";
-import { IExpressionTranspiler } from "./_expression_transpiler";
-import { Traversal } from "../traversal";
-import { Chunk } from "../chunk";
-export declare class CondTranspiler implements IExpressionTranspiler {
-    transpile(node: Nodes.ExpressionNode, traversal: Traversal): Chunk;
-}
+import { Nodes } from "@abaplint/core";
+import { IExpressionTranspiler } from "./_expression_transpiler";
+import { Traversal } from "../traversal";
+import { Chunk } from "../chunk";
+export declare class CondTranspiler implements IExpressionTranspiler {
+    transpile(node: Nodes.ExpressionNode, traversal: Traversal): Chunk;
+}

package/build/src/expressions/cond.js

@@ -1,27 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CondTranspiler = void 0;
-const core_1 = require("@abaplint/core");
-const chunk_1 = require("../chunk");
-class CondTranspiler {
-    transpile(node, traversal) {
-        const ret = new chunk_1.Chunk();
-        for (const c of node.getChildren()) {
-            if (c.get() instanceof core_1.Expressions.Compare
-                || c.get() instanceof core_1.Expressions.CondSub) {
-                ret.appendChunk(traversal.traverse(c));
-            }
-            else if (c instanceof core_1.Nodes.TokenNode
-                && c.getFirstToken().getStr().toUpperCase() === "OR") {
-                ret.append(" || ", c, traversal);
-            }
-            else if (c instanceof core_1.Nodes.TokenNode
-                && c.getFirstToken().getStr().toUpperCase() === "AND") {
-                ret.append(" && ", c, traversal);
-            }
-        }
-        return ret;
-    }
-}
-exports.CondTranspiler = CondTranspiler;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CondTranspiler = void 0;
+const core_1 = require("@abaplint/core");
+const chunk_1 = require("../chunk");
+class CondTranspiler {
+    transpile(node, traversal) {
+        const ret = new chunk_1.Chunk();
+        for (const c of node.getChildren()) {
+            if (c.get() instanceof core_1.Expressions.Compare
+                || c.get() instanceof core_1.Expressions.CondSub) {
+                ret.appendChunk(traversal.traverse(c));
+            }
+            else if (c instanceof core_1.Nodes.TokenNode
+                && c.getFirstToken().getStr().toUpperCase() === "OR") {
+                ret.append(" || ", c, traversal);
+            }
+            else if (c instanceof core_1.Nodes.TokenNode
+                && c.getFirstToken().getStr().toUpperCase() === "AND") {
+                ret.append(" && ", c, traversal);
+            }
+        }
+        return ret;
+    }
+}
+exports.CondTranspiler = CondTranspiler;
 //# sourceMappingURL=cond.js.map

package/build/src/expressions/cond_sub.d.ts

@@ -1,7 +1,7 @@
-import { Nodes } from "@abaplint/core";
-import { IExpressionTranspiler } from "./_expression_transpiler";
-import { Traversal } from "../traversal";
-import { Chunk } from "../chunk";
-export declare class CondSubTranspiler implements IExpressionTranspiler {
-    transpile(node: Nodes.ExpressionNode, traversal: Traversal): Chunk;
-}
+import { Nodes } from "@abaplint/core";
+import { IExpressionTranspiler } from "./_expression_transpiler";
+import { Traversal } from "../traversal";
+import { Chunk } from "../chunk";
+export declare class CondSubTranspiler implements IExpressionTranspiler {
+    transpile(node: Nodes.ExpressionNode, traversal: Traversal): Chunk;
+}

package/build/src/expressions/cond_sub.js

@@ -1,27 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CondSubTranspiler = void 0;
-const core_1 = require("@abaplint/core");
-const chunk_1 = require("../chunk");
-class CondSubTranspiler {
-    transpile(node, traversal) {
-        const ret = new chunk_1.Chunk();
-        for (const c of node.getChildren()) {
-            if (c.get() instanceof core_1.Expressions.Cond) {
-                ret.appendChunk(traversal.traverse(c));
-            }
-            else if (c instanceof core_1.Nodes.TokenNode && c.getFirstToken().getStr() === "NOT") {
-                ret.append("!", c, traversal);
-            }
-            else if (c instanceof core_1.Nodes.TokenNode && c.getFirstToken().getStr().trim() === "(") {
-                ret.append("(", c, traversal);
-            }
-            else if (c instanceof core_1.Nodes.TokenNode && c.getFirstToken().getStr().trim() === ")") {
-                ret.append(")", c, traversal);
-            }
-        }
-        return ret;
-    }
-}
-exports.CondSubTranspiler = CondSubTranspiler;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CondSubTranspiler = void 0;
+const core_1 = require("@abaplint/core");
+const chunk_1 = require("../chunk");
+class CondSubTranspiler {
+    transpile(node, traversal) {
+        const ret = new chunk_1.Chunk();
+        for (const c of node.getChildren()) {
+            if (c.get() instanceof core_1.Expressions.Cond) {
+                ret.appendChunk(traversal.traverse(c));
+            }
+            else if (c instanceof core_1.Nodes.TokenNode && c.getFirstToken().getStr() === "NOT") {
+                ret.append("!", c, traversal);
+            }
+            else if (c instanceof core_1.Nodes.TokenNode && c.getFirstToken().getStr().trim() === "(") {
+                ret.append("(", c, traversal);
+            }
+            else if (c instanceof core_1.Nodes.TokenNode && c.getFirstToken().getStr().trim() === ")") {
+                ret.append(")", c, traversal);
+            }
+        }
+        return ret;
+    }
+}
+exports.CondSubTranspiler = CondSubTranspiler;
 //# sourceMappingURL=cond_sub.js.map

package/build/src/expressions/constant.d.ts

@@ -1,10 +1,10 @@
-import { Nodes } from "@abaplint/core";
-import { Chunk } from "../chunk";
-import { Traversal } from "../traversal";
-import { IExpressionTranspiler } from "./_expression_transpiler";
-export declare class ConstantTranspiler implements IExpressionTranspiler {
-    private readonly addGet;
-    constructor(addGet?: boolean);
-    transpile(node: Nodes.ExpressionNode, traversal: Traversal): Chunk;
-    escape(str: string): string;
-}
+import { Nodes } from "@abaplint/core";
+import { Chunk } from "../chunk";
+import { Traversal } from "../traversal";
+import { IExpressionTranspiler } from "./_expression_transpiler";
+export declare class ConstantTranspiler implements IExpressionTranspiler {
+    private readonly addGet;
+    constructor(addGet?: boolean);
+    transpile(node: Nodes.ExpressionNode, traversal: Traversal): Chunk;
+    escape(str: string): string;
+}

package/build/src/expressions/constant.js

@@ -1,87 +1,87 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConstantTranspiler = void 0;
-const core_1 = require("@abaplint/core");
-const chunk_1 = require("../chunk");
-class ConstantTranspiler {
-    constructor(addGet = false) {
-        this.addGet = addGet;
-    }
-    transpile(node, traversal) {
-        const int = node.findFirstExpression(core_1.Expressions.Integer);
-        if (int) {
-            const concat = int.concatTokens().trim();
-            let code = `new abap.types.Integer().set(${concat})`;
-            if (this.addGet === true) {
-                code += ".get()";
-            }
-            return new chunk_1.Chunk().append(code, node, traversal);
-        }
-        let str = node.findDirectExpression(core_1.Expressions.ConstantString);
-        if (str === undefined) {
-            str = node.findDirectExpression(core_1.Expressions.TextElementString);
-        }
-        if (str) {
-            let res = str.getFirstToken().getStr();
-            if (res.startsWith("'") && this.addGet === false) {
-                const code = "new abap.types.Character(" + (res.length - 2) + ").set(" + this.escape(res) + ")";
-                return new chunk_1.Chunk().append(code, node, traversal);
-            }
-            else if (res.startsWith("`") && this.addGet === false) {
-                const code = "new abap.types.String().set(" + this.escape(res) + ")";
-                return new chunk_1.Chunk().append(code, node, traversal);
-            }
-            else {
-                if (res.startsWith("'")) {
-                    res = "'" + res.substring(1, res.length - 1).trimEnd() + "'";
-                }
-                const code = this.escape(res);
-                return new chunk_1.Chunk().append(code, node, traversal);
-            }
-        }
-        const concat = node.findDirectExpression(core_1.Expressions.ConcatenatedConstant);
-        if (concat) {
-            const chunk = new chunk_1.Chunk().appendString("abap.operators.concat([");
-            let first = true;
-            for (const child of concat.getChildren()) {
-                const res = child.getFirstToken().getStr();
-                if (first === true) {
-                    first = false;
-                }
-                else if (res !== "&") {
-                    chunk.appendString(",");
-                }
-                if (res.startsWith("'") && this.addGet === false) {
-                    const code = "new abap.types.Character(" + (res.length - 2) + ").set(" + this.escape(res) + ")";
-                    chunk.append(code, node, traversal);
-                }
-                else if (res.startsWith("`") && this.addGet === false) {
-                    const code = "new abap.types.String().set(" + this.escape(res) + ")";
-                    chunk.append(code, node, traversal);
-                }
-            }
-            chunk.appendString("])");
-            return chunk;
-        }
-        return new chunk_1.Chunk(`todo, Constant`);
-    }
-    escape(str) {
-        str = str.replace(/\\/g, "\\\\");
-        if (str.startsWith("'")) {
-            const reg = new RegExp(/(.+)''(.+)/g);
-            while (reg.test(str)) {
-                str = str.replace(reg, "$1\\'$2");
-            }
-        }
-        if (str.startsWith("`")) {
-            const reg = new RegExp(/(.+)``(.+)/g);
-            while (reg.test(str)) {
-                str = str.replace(reg, "$1\\`$2");
-            }
-            str = str.replace(/\$\{/g, "\\${");
-        }
-        return str;
-    }
-}
-exports.ConstantTranspiler = ConstantTranspiler;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstantTranspiler = void 0;
+const core_1 = require("@abaplint/core");
+const chunk_1 = require("../chunk");
+class ConstantTranspiler {
+    constructor(addGet = false) {
+        this.addGet = addGet;
+    }
+    transpile(node, traversal) {
+        const int = node.findFirstExpression(core_1.Expressions.Integer);
+        if (int) {
+            const concat = int.concatTokens().trim();
+            let code = `new abap.types.Integer().set(${concat})`;
+            if (this.addGet === true) {
+                code += ".get()";
+            }
+            return new chunk_1.Chunk().append(code, node, traversal);
+        }
+        let str = node.findDirectExpression(core_1.Expressions.ConstantString);
+        if (str === undefined) {
+            str = node.findDirectExpression(core_1.Expressions.TextElementString);
+        }
+        if (str) {
+            let res = str.getFirstToken().getStr();
+            if (res.startsWith("'") && this.addGet === false) {
+                const code = "new abap.types.Character(" + (res.length - 2) + ").set(" + this.escape(res) + ")";
+                return new chunk_1.Chunk().append(code, node, traversal);
+            }
+            else if (res.startsWith("`") && this.addGet === false) {
+                const code = "new abap.types.String().set(" + this.escape(res) + ")";
+                return new chunk_1.Chunk().append(code, node, traversal);
+            }
+            else {
+                if (res.startsWith("'")) {
+                    res = "'" + res.substring(1, res.length - 1).trimEnd() + "'";
+                }
+                const code = this.escape(res);
+                return new chunk_1.Chunk().append(code, node, traversal);
+            }
+        }
+        const concat = node.findDirectExpression(core_1.Expressions.ConcatenatedConstant);
+        if (concat) {
+            const chunk = new chunk_1.Chunk().appendString("abap.operators.concat([");
+            let first = true;
+            for (const child of concat.getChildren()) {
+                const res = child.getFirstToken().getStr();
+                if (first === true) {
+                    first = false;
+                }
+                else if (res !== "&") {
+                    chunk.appendString(",");
+                }
+                if (res.startsWith("'") && this.addGet === false) {
+                    const code = "new abap.types.Character(" + (res.length - 2) + ").set(" + this.escape(res) + ")";
+                    chunk.append(code, node, traversal);
+                }
+                else if (res.startsWith("`") && this.addGet === false) {
+                    const code = "new abap.types.String().set(" + this.escape(res) + ")";
+                    chunk.append(code, node, traversal);
+                }
+            }
+            chunk.appendString("])");
+            return chunk;
+        }
+        return new chunk_1.Chunk(`todo, Constant`);
+    }
+    escape(str) {
+        str = str.replace(/\\/g, "\\\\");
+        if (str.startsWith("'")) {
+            const reg = new RegExp(/(.+)''(.+)/g);
+            while (reg.test(str)) {
+                str = str.replace(reg, "$1\\'$2");
+            }
+        }
+        if (str.startsWith("`")) {
+            const reg = new RegExp(/(.+)``(.+)/g);
+            while (reg.test(str)) {
+                str = str.replace(reg, "$1\\`$2");
+            }
+            str = str.replace(/\$\{/g, "\\${");
+        }
+        return str;
+    }
+}
+exports.ConstantTranspiler = ConstantTranspiler;
 //# sourceMappingURL=constant.js.map

package/build/src/expressions/database_table.d.ts

@@ -1,7 +1,7 @@
-import { Nodes } from "@abaplint/core";
-import { IExpressionTranspiler } from "./_expression_transpiler";
-import { Traversal } from "../traversal";
-import { Chunk } from "../chunk";
-export declare class DatabaseTableTranspiler implements IExpressionTranspiler {
-    transpile(node: Nodes.ExpressionNode, traversal: Traversal): Chunk;
-}
+import { Nodes } from "@abaplint/core";
+import { IExpressionTranspiler } from "./_expression_transpiler";
+import { Traversal } from "../traversal";
+import { Chunk } from "../chunk";
+export declare class DatabaseTableTranspiler implements IExpressionTranspiler {
+    transpile(node: Nodes.ExpressionNode, traversal: Traversal): Chunk;
+}

package/build/src/expressions/database_table.js

@@ -1,21 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatabaseTableTranspiler = void 0;
-const core_1 = require("@abaplint/core");
-const chunk_1 = require("../chunk");
-class DatabaseTableTranspiler {
-    transpile(node, traversal) {
-        const ret = new chunk_1.Chunk();
-        const dyn = node.findDirectExpression(core_1.Expressions.Dynamic);
-        if (dyn) {
-            const sub = dyn.getChildren()[1];
-            return traversal.traverse(sub);
-        }
-        else {
-            ret.appendString('"' + node.concatTokens() + '"');
-        }
-        return ret;
-    }
-}
-exports.DatabaseTableTranspiler = DatabaseTableTranspiler;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseTableTranspiler = void 0;
+const core_1 = require("@abaplint/core");
+const chunk_1 = require("../chunk");
+class DatabaseTableTranspiler {
+    transpile(node, traversal) {
+        const ret = new chunk_1.Chunk();
+        const dyn = node.findDirectExpression(core_1.Expressions.Dynamic);
+        if (dyn) {
+            const sub = dyn.getChildren()[1];
+            return traversal.traverse(sub);
+        }
+        else {
+            ret.appendString('"' + node.concatTokens() + '"');
+        }
+        return ret;
+    }
+}
+exports.DatabaseTableTranspiler = DatabaseTableTranspiler;
 //# sourceMappingURL=database_table.js.map

package/build/src/expressions/field_chain.d.ts

@@ -1,10 +1,10 @@
-import { Nodes } from "@abaplint/core";
-import { IExpressionTranspiler } from "./_expression_transpiler";
-import { Traversal } from "../traversal";
-import { Chunk } from "../chunk";
-export declare class FieldChainTranspiler implements IExpressionTranspiler {
-    private readonly addGet;
-    private addGetOffset;
-    constructor(addGet?: boolean);
-    transpile(node: Nodes.ExpressionNode, traversal: Traversal, prefix?: boolean, filename?: string, wrongScope?: boolean): Chunk;
-}
+import { Nodes } from "@abaplint/core";
+import { IExpressionTranspiler } from "./_expression_transpiler";
+import { Traversal } from "../traversal";
+import { Chunk } from "../chunk";
+export declare class FieldChainTranspiler implements IExpressionTranspiler {
+    private readonly addGet;
+    private addGetOffset;
+    constructor(addGet?: boolean);
+    transpile(node: Nodes.ExpressionNode, traversal: Traversal, prefix?: boolean, filename?: string, wrongScope?: boolean): Chunk;
+}