typescript-to-lua - npm Package Compare versions

Comparing version 0.4.0 to 0.5.0

CHANGELOG.md

+# Changelog
+
+## 0.4.0
+* Added support for `typeof`
+* Added support for `instanceof`
+* Added support for [TypeScript overloads](https://www.typescriptlang.org/docs/handbook/functions.html#overloads)

dist/CommandLineParser.js

@@ -146,2 +146,3 @@ "use strict";
     var configPath;
+    /* istanbul ignore else: Testing else part is not really possible via automated tests */
     if (path.isAbsolute(commandLine.options.project)) {
@@ -151,2 +152,3 @@ configPath = commandLine.options.project;
     else {
+        // TODO check if commandLine.options.project can even contain non absolute paths
         configPath = path.join(process.cwd(), commandLine.options.project);
@@ -153,0 +155,0 @@ }

dist/lualib/typescript.lua

@@ -149,4 +149,6 @@ -- Ternary operator
     self._items = {}
+    self.size = 0
     if other then
-        for a, _ in pairs(other) do
+        self.size = #other
+        for _, a in pairs(other) do
             self._items[a] = true
@@ -156,23 +158,39 @@ end
 end
-function Set.add(self, item) self._items[item] = true end
-function Set.contains(self, item) return self._items[item] ~= nil end
-function Set.remove(self, item)
-    local contains = Set.contains(self, item)
+function Set.add(self, item) 
+    self._items[item] = true 
+    self.size = self.size + 1
+end
+function Set.clear(self)
+    self._items = {}
+    self.size = 0
+end
+function Set.delete(self, item)
+    local contains = Set.has(self, item)
     self._items[item] = nil
+    self.size = self.size - 1
     return contains
 end
-function Set.items(self)
+function Set.entries(self)
     local out = {}
     for item, _ in pairs(self._items) do
-        table.insert(out, item)
+        table.insert(out, {item, item})
     end
     return out
 end
-function Set.count(self)
-    local count = 0
-    for item, _ in pairs(self._items) do
-        count = count + 1
+function Set.forEach(self, callbackFn)
+    for k, v in pairs(self._items) do
+        callbackFn(k, k, self)
     end
-    return count
 end
+function Set.has(self, item) return self._items[item] ~= nil end
+function Set.keys(self)
+    return Set.values(self)
+end
+function Set.values(self)
+    local out = {}
+    for k, _ in pairs(self._items) do
+        table.insert(out, k)
+    end
+    return out
+end
 
@@ -189,43 +207,52 @@ -- Set data structure implementation
     self._items = {}
+    self.size = 0
     if other then
-        for k, v in pairs(other) do
-            self._items[k] = v
+        self.size = #other
+        for _, v in pairs(other) do
+            self._items[v[1]] = v[2]
         end
     end
 end
-function Map.put(self, key, value) self._items[key] = value end
-function Map.containsKey(self, key) return self._items[key] ~= nil end
-function Map.remove(self, key)
-    local contains = self.containsKey(self, key)
+function Map.clear(self) 
+    self._items = {}
+    self.size = 0
+end
+function Map.delete(self, key)
+    local contains = self.has(self, key)
     self._items[key] = nil
+    self.size = self.size - 1
     return contains
 end
-function Map.get(self, key) return self._items[key] end
-function Map.keys(self)
+function Map.entries(self)
     local out = {}
     for k, v in pairs(self._items) do
-        table.insert(out, k)
+        table.insert(out, {k, v})
     end
     return out
 end
-function Map.values(self)
-    local out = {}
+function Map.forEach(self, callbackFn)
     for k, v in pairs(self._items) do
-        table.insert(out, v)
+        callbackFn(v, k, self)
     end
-    return out
 end
-function Map.items(self)
+function Map.get(self, key) return self._items[key] end
+function Map.has(self, key) return self._items[key] ~= nil end
+function Map.keys(self)
     local out = {}
     for k, v in pairs(self._items) do
-        table.insert(out, {key=k, value=v})
+        table.insert(out, k)
     end
     return out
 end
-function Map.count(self)
-    local count = 0
+function Map.set(self, key, value) 
+    self._items[key] = value
+    self.size = self.size + 1
+    return self
+end
+function Map.values(self)
+    local out = {}
     for k, v in pairs(self._items) do
-        count = count + 1
+        table.insert(out, v)
     end
-    return count
+    return out
 end

dist/targets/Transpiler.52.js

@@ -14,2 +14,3 @@ "use strict";
 var Transpiler_51_1 = require("./Transpiler.51");
+var ts = require("typescript");
 var LuaTranspiler52 = /** @class */ (function (_super) {
@@ -20,2 +21,3 @@ __extends(LuaTranspiler52, _super);
     }
+    /** @override */
     LuaTranspiler52.prototype.transpileLoopBody = function (node) {
@@ -32,5 +34,30 @@ this.loopStack.push(this.genVarCounter);
     };
+    /** @override */
     LuaTranspiler52.prototype.transpileContinue = function (node) {
         return this.indent + ("goto __continue" + this.loopStack[this.loopStack.length - 1] + "\n");
     };
+    /** @override */
+    LuaTranspiler52.prototype.transpileUnaryBitOperation = function (node, operand) {
+        switch (node.operator) {
+            case ts.SyntaxKind.TildeToken:
+                return "bit32.bnot(" + operand + ")";
+        }
+    };
+    /** @override */
+    LuaTranspiler52.prototype.transpileBitOperation = function (node, lhs, rhs) {
+        switch (node.operatorToken.kind) {
+            case ts.SyntaxKind.AmpersandToken:
+                return "bit32.band(" + lhs + "," + rhs + ")";
+            case ts.SyntaxKind.BarToken:
+                return "bit32.bor(" + lhs + "," + rhs + ")";
+            case ts.SyntaxKind.CaretToken:
+                return "bit32.bxor(" + lhs + "," + rhs + ")";
+            case ts.SyntaxKind.LessThanLessThanToken:
+                return "bit32.lshift(" + lhs + "," + rhs + ")";
+            case ts.SyntaxKind.GreaterThanGreaterThanToken:
+                return "bit32.rshift(" + lhs + "," + rhs + ")";
+            case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
+                return "bit32.arshift(" + lhs + "," + rhs + ")";
+        }
+    };
     return LuaTranspiler52;
@@ -37,0 +64,0 @@ }(Transpiler_51_1.LuaTranspiler51));

dist/targets/Transpiler.53.js

@@ -14,3 +14,2 @@ "use strict";
 var Transpiler_1 = require("../Transpiler");
-var TSHelper_1 = require("../TSHelper");
 var Transpiler_52_1 = require("./Transpiler.52");
@@ -23,38 +22,27 @@ var ts = require("typescript");
     }
+    /** @override */
+    LuaTranspiler53.prototype.transpileUnaryBitOperation = function (node, operand) {
+        switch (node.operator) {
+            case ts.SyntaxKind.TildeToken:
+                return "~" + operand;
+        }
+    };
+    /** @override */
     LuaTranspiler53.prototype.transpileBitOperation = function (node, lhs, rhs) {
         switch (node.operatorToken.kind) {
             case ts.SyntaxKind.AmpersandToken:
-                return lhs + "&" + rhs;
-            case ts.SyntaxKind.AmpersandEqualsToken:
-                if (TSHelper_1.TSHelper.hasSetAccessor(node.left, this.checker)) {
-                    return this.transpileSetAccessor(node.left, lhs + "&" + rhs);
-                }
-                return lhs + "=" + lhs + "&" + rhs;
+                return lhs + " & " + rhs;
             case ts.SyntaxKind.BarToken:
-                return lhs + "|" + rhs;
-            case ts.SyntaxKind.BarEqualsToken:
-                if (TSHelper_1.TSHelper.hasSetAccessor(node.left, this.checker)) {
-                    return this.transpileSetAccessor(node.left, lhs + "|" + rhs);
-                }
-                return lhs + "=" + lhs + "|" + rhs;
+                return lhs + " | " + rhs;
+            case ts.SyntaxKind.CaretToken:
+                return lhs + " ~ " + rhs;
             case ts.SyntaxKind.LessThanLessThanToken:
-                return lhs + "<<" + rhs;
-            case ts.SyntaxKind.LessThanLessThanEqualsToken:
-                if (TSHelper_1.TSHelper.hasSetAccessor(node.left, this.checker)) {
-                    return this.transpileSetAccessor(node.left, lhs + "<<" + rhs);
-                }
-                return lhs + "=" + lhs + "<<" + rhs;
+                return lhs + " << " + rhs;
             case ts.SyntaxKind.GreaterThanGreaterThanToken:
-                return lhs + ">>" + rhs;
-            case ts.SyntaxKind.GreaterThanGreaterThanEqualsToken:
-                if (TSHelper_1.TSHelper.hasSetAccessor(node.left, this.checker)) {
-                    return this.transpileSetAccessor(node.left, lhs + ">>" + rhs);
-                }
-                return lhs + "=" + lhs + ">>" + rhs;
+                return lhs + " >> " + rhs;
             case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
                 throw new Transpiler_1.TranspileError("Bitwise operator >>> not supported in Lua 5.3", node);
-            case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken:
-                throw new Transpiler_1.TranspileError("Bitwise operator >>> not supported in Lua 5.3", node);
         }
     };
+    /** @override */
     LuaTranspiler53.prototype.getValidStringProperties = function () {
@@ -61,0 +49,0 @@ return {

dist/targets/Transpiler.JIT.js

@@ -13,3 +13,2 @@ "use strict";
 exports.__esModule = true;
-var TSHelper_1 = require("../TSHelper");
 var Transpiler_52_1 = require("./Transpiler.52");
@@ -22,2 +21,10 @@ var ts = require("typescript");
     }
+    /** @override */
+    LuaTranspilerJIT.prototype.transpileUnaryBitOperation = function (node, operand) {
+        switch (node.operator) {
+            case ts.SyntaxKind.TildeToken:
+                return "bit.bnot(" + operand + ")";
+        }
+    };
+    /** @override */
     LuaTranspilerJIT.prototype.transpileBitOperation = function (node, lhs, rhs) {
@@ -27,35 +34,12 @@ switch (node.operatorToken.kind) {
                 return "bit.band(" + lhs + "," + rhs + ")";
-            case ts.SyntaxKind.AmpersandEqualsToken:
-                if (TSHelper_1.TSHelper.hasSetAccessor(node.left, this.checker)) {
-                    return this.transpileSetAccessor(node.left, "bit.band(" + lhs + "," + rhs + ")");
-                }
-                return lhs + "=bit.band(" + lhs + "," + rhs + ")";
             case ts.SyntaxKind.BarToken:
                 return "bit.bor(" + lhs + "," + rhs + ")";
-            case ts.SyntaxKind.BarEqualsToken:
-                if (TSHelper_1.TSHelper.hasSetAccessor(node.left, this.checker)) {
-                    return this.transpileSetAccessor(node.left, "bit.bor(" + lhs + "," + rhs + ")");
-                }
-                return lhs + "=bit.bor(" + lhs + "," + rhs + ")";
+            case ts.SyntaxKind.CaretToken:
+                return "bit.bxor(" + lhs + "," + rhs + ")";
             case ts.SyntaxKind.LessThanLessThanToken:
                 return "bit.lshift(" + lhs + "," + rhs + ")";
-            case ts.SyntaxKind.LessThanLessThanEqualsToken:
-                if (TSHelper_1.TSHelper.hasSetAccessor(node.left, this.checker)) {
-                    return this.transpileSetAccessor(node.left, "bit.lshift(" + lhs + "," + rhs + ")");
-                }
-                return lhs + "=bit.lshift(" + lhs + "," + rhs + ")";
             case ts.SyntaxKind.GreaterThanGreaterThanToken:
+                return "bit.rshift(" + lhs + "," + rhs + ")";
+            case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
                 return "bit.arshift(" + lhs + "," + rhs + ")";
-            case ts.SyntaxKind.GreaterThanGreaterThanEqualsToken:
-                if (TSHelper_1.TSHelper.hasSetAccessor(node.left, this.checker)) {
-                    return this.transpileSetAccessor(node.left, "bit.arshift(" + lhs + "," + rhs + ")");
-                }
-                return lhs + "=bit.arshift(" + lhs + "," + rhs + ")";
-            case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
-                return "bit.rshift(" + lhs + "," + rhs + ")";
-            case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken:
-                if (TSHelper_1.TSHelper.hasSetAccessor(node.left, this.checker)) {
-                    return this.transpileSetAccessor(node.left, "bit.rshift(" + lhs + "," + rhs + ")");
-                }
-                return lhs + "=bit.rshift(" + lhs + "," + rhs + ")";
         }
@@ -62,0 +46,0 @@ };

dist/Transpiler.js

@@ -84,15 +84,22 @@ "use strict";
     };
+    LuaTranspiler.prototype.getAbsouluteImportPath = function (relativePath) {
+        if (relativePath.charAt(0) !== "." && this.options.baseUrl) {
+            return path.resolve(this.options.baseUrl, relativePath);
+        }
+        return path.resolve(path.dirname(this.sourceFile.fileName), relativePath);
+    };
     LuaTranspiler.prototype.getImportPath = function (relativePath) {
         // Calculate absolute path to import
-        var absolutePathToImport = path.resolve(path.dirname(this.sourceFile.fileName), relativePath);
+        var absolutePathToImport = this.getAbsouluteImportPath(relativePath);
         if (this.options.rootDir) {
             // Calculate path realtive to project root
             // and replace path.sep with dots (lua doesn't know paths)
-            var relativePathToRoot = absolutePathToImport.replace(this.options.rootDir, "")
-                .replace(new RegExp("\\\\|\/", "g"), ".")
-                .slice(1);
+            var relativePathToRoot = this.pathToLuaRequirePath(absolutePathToImport.replace(this.options.rootDir, "").slice(1));
             return "\"" + relativePathToRoot + "\"";
         }
-        return "\"" + relativePath.replace(new RegExp("\\\\|\/", "g"), ".") + "\"";
+        return "\"" + this.pathToLuaRequirePath(relativePath) + "\"";
     };
+    LuaTranspiler.prototype.pathToLuaRequirePath = function (filePath) {
+        return filePath.replace(new RegExp("\\\\|\/", "g"), ".");
+    };
     // Transpile a source file
@@ -577,3 +584,12 @@ LuaTranspiler.prototype.transpileSourceFile = function () {
         var rhs = this.transpileExpression(node.right, true);
-        // Rewrite some non-existant binary operators
+        // Check if this is an assignment token, then handle accordingly
+        var _a = TSHelper_1.TSHelper.isBinaryAssignmentToken(node.operatorToken.kind), isAssignment = _a[0], operator = _a[1];
+        if (isAssignment) {
+            var valueExpression = ts.createBinary(node.left, operator, node.right);
+            var value = this.transpileBinaryExpression(valueExpression);
+            if (TSHelper_1.TSHelper.hasSetAccessor(node.left, this.checker)) {
+                return this.transpileSetAccessor(node.left, value);
+            }
+            return lhs + " = " + value;
+        }
         var result = "";
@@ -583,11 +599,7 @@ // Transpile Bitops
             case ts.SyntaxKind.AmpersandToken:
-            case ts.SyntaxKind.AmpersandEqualsToken:
             case ts.SyntaxKind.BarToken:
-            case ts.SyntaxKind.BarEqualsToken:
+            case ts.SyntaxKind.CaretToken:
             case ts.SyntaxKind.LessThanLessThanToken:
-            case ts.SyntaxKind.LessThanLessThanEqualsToken:
             case ts.SyntaxKind.GreaterThanGreaterThanToken:
-            case ts.SyntaxKind.GreaterThanGreaterThanEqualsToken:
             case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
-            case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken:
                 result = this.transpileBitOperation(node, lhs, rhs);
@@ -598,26 +610,2 @@ }
             switch (node.operatorToken.kind) {
-                case ts.SyntaxKind.PlusEqualsToken:
-                    if (TSHelper_1.TSHelper.hasSetAccessor(node.left, this.checker)) {
-                        return this.transpileSetAccessor(node.left, lhs + "+" + rhs);
-                    }
-                    result = lhs + "=" + lhs + "+" + rhs;
-                    break;
-                case ts.SyntaxKind.MinusEqualsToken:
-                    if (TSHelper_1.TSHelper.hasSetAccessor(node.left, this.checker)) {
-                        return this.transpileSetAccessor(node.left, lhs + "-" + rhs);
-                    }
-                    result = lhs + "=" + lhs + "-" + rhs;
-                    break;
-                case ts.SyntaxKind.AsteriskEqualsToken:
-                    if (TSHelper_1.TSHelper.hasSetAccessor(node.left, this.checker)) {
-                        return this.transpileSetAccessor(node.left, lhs + "*" + rhs);
-                    }
-                    result = lhs + "=" + lhs + "*" + rhs;
-                    break;
-                case ts.SyntaxKind.SlashEqualsToken:
-                    if (TSHelper_1.TSHelper.hasSetAccessor(node.left, this.checker)) {
-                        return this.transpileSetAccessor(node.left, lhs + "/" + rhs);
-                    }
-                    result = lhs + "=" + lhs + "/" + rhs;
-                    break;
                 case ts.SyntaxKind.AmpersandAmpersandToken:
@@ -645,2 +633,5 @@ result = lhs + " and " + rhs;
                     break;
+                case ts.SyntaxKind.AsteriskAsteriskToken:
+                    result = lhs + "^" + rhs;
+                    break;
                 case ts.SyntaxKind.SlashToken:
@@ -668,3 +659,3 @@ result = lhs + "/" + rhs;
                     }
-                    result = lhs + "=" + rhs;
+                    result = lhs + " = " + rhs;
                     break;
@@ -697,4 +688,7 @@ case ts.SyntaxKind.EqualsEqualsToken:
     };
+    LuaTranspiler.prototype.transpileUnaryBitOperation = function (node, operand) {
+        throw new TranspileError("Bit operations are not supported in Lua " + this.options.target, node);
+    };
     LuaTranspiler.prototype.transpileBitOperation = function (node, lhs, rhs) {
-        throw new TranspileError("Bit Oeprations are not supported in Lua " + this.options.target, node);
+        throw new TranspileError("Bit operations are not supported in Lua " + this.options.target, node);
     };
@@ -736,2 +730,4 @@ LuaTranspiler.prototype.transpileTemplateExpression = function (node) {
         switch (node.operator) {
+            case ts.SyntaxKind.TildeToken:
+                return this.transpileUnaryBitOperation(node, operand);
             case ts.SyntaxKind.PlusPlusToken:
@@ -738,0 +734,0 @@ return operand + "=" + operand + "+1";

dist/TSHelper.js

@@ -53,6 +53,2 @@ "use strict";
     };
-    TSHelper.isTupleType = function (type, checker) {
-        var typeNode = checker.typeToTypeNode(type);
-        return typeNode && typeNode.kind === ts.SyntaxKind.TupleType;
-    };
     TSHelper.isCompileMembersOnlyEnum = function (type, checker) {
@@ -139,2 +135,31 @@ return type.symbol
     };
+    TSHelper.isBinaryAssignmentToken = function (token) {
+        switch (token) {
+            case ts.SyntaxKind.BarEqualsToken:
+                return [true, ts.SyntaxKind.BarToken];
+            case ts.SyntaxKind.PlusEqualsToken:
+                return [true, ts.SyntaxKind.PlusToken];
+            case ts.SyntaxKind.CaretEqualsToken:
+                return [true, ts.SyntaxKind.CaretToken];
+            case ts.SyntaxKind.MinusEqualsToken:
+                return [true, ts.SyntaxKind.MinusToken];
+            case ts.SyntaxKind.SlashEqualsToken:
+                return [true, ts.SyntaxKind.SlashToken];
+            case ts.SyntaxKind.PercentEqualsToken:
+                return [true, ts.SyntaxKind.PercentToken];
+            case ts.SyntaxKind.AsteriskEqualsToken:
+                return [true, ts.SyntaxKind.AsteriskToken];
+            case ts.SyntaxKind.AmpersandEqualsToken:
+                return [true, ts.SyntaxKind.AmpersandToken];
+            case ts.SyntaxKind.AsteriskAsteriskEqualsToken:
+                return [true, ts.SyntaxKind.AsteriskAsteriskToken];
+            case ts.SyntaxKind.LessThanLessThanEqualsToken:
+                return [true, ts.SyntaxKind.LessThanLessThanToken];
+            case ts.SyntaxKind.GreaterThanGreaterThanEqualsToken:
+                return [true, ts.SyntaxKind.GreaterThanGreaterThanToken];
+            case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken:
+                return [true, ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken];
+        }
+        return [false, null];
+    };
     return TSHelper;
@@ -141,0 +166,0 @@ }());

package.json

 {
     "name": "typescript-to-lua",
     "license": "MIT",
-    "version": "0.4.0",
+    "version": "0.5.0",
     "repository": "https://github.com/Perryvw/TypescriptToLua",
+    "keywords": [
+        "typescript",
+        "lua",
+        "tstl",
+        "transpiler"
+    ],
     "scripts": {
@@ -20,2 +26,11 @@ "build": "tsc -p tsconfig.json",
     },
+    "nyc": {
+        "all": true,
+        "extension": [
+            ".ts"
+        ],
+        "include": [
+            "src/**/*"
+        ]
+    },
     "engines": {
@@ -25,16 +40,17 @@ "node": ">=8.5.0"
     "dependencies": {
-        "typescript": "^2.8.3",
+        "typescript": "^2.9.2",
         "yargs": "^11.1.0"
     },
     "devDependencies": {
-        "@types/node": "^9.6.7",
+        "@types/node": "^9.6.23",
         "@types/yargs": "^11.0.0",
         "alsatian": "^2.2.1",
-        "codecov": "^3.0.1",
+        "codecov": "3.0.2",
         "deep-equal": "^1.0.1",
         "fengari": "^0.1.2",
-        "nyc": "^11.7.1",
+        "nyc": "^11.9.0",
         "ts-node": "^7.0.0",
-        "tslint": "^5.9.1"
+        "tslint": "^5.10.0",
+        "tslint-override": "^0.1.2"
     }
 }

README.md

@@ -14,2 +14,4 @@ # TypescriptToLua
 
+Changelog can be found in [CHANGELOG.md](https://github.com/Perryvw/TypescriptToLua/blob/master/CHANGELOG.md)
+
 ## Usage Guide
@@ -16,0 +18,0 @@

New alerts

Dynamic require

Supply chain risk

Dynamic require can indicate the package is performing dangerous or unsafe dynamic code execution.

Found 1 instance in 1 package

Filesystem access

Supply chain risk

Accesses the file system, and could potentially read sensitive data.

Found 1 instance in 1 package

Long strings

Supply chain risk

Contains long string literals, which may be a sign of obfuscated or packed code.

Found 1 instance in 1 package

Fixed alerts

Dynamic require

Supply chain risk

Dynamic require can indicate the package is performing dangerous or unsafe dynamic code execution.

Found 1 instance in 1 package

Filesystem access

Supply chain risk

Accesses the file system, and could potentially read sensitive data.

Found 1 instance in 1 package

Long strings

Supply chain risk

Contains long string literals, which may be a sign of obfuscated or packed code.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

101980

1.24%

Number of package files

13

8.33%

Lines of code

1981

1.12%

Number of lines in readme file

63

3.28%

Worsened metrics

Dev dependency count

10

11.11%

Dependency changes

• Updated

  typescript@^2.9.2