typescript-to-lua 1.16.2 → 1.17.0

package/dist/transformation/utils/language-extensions.d.ts

@@ -50,7 +50,9 @@ export declare enum ExtensionKind {
     TableSetType = "TableSet",
     TableSetMethodType = "TableSetMethod",
     TableAddKeyType = "TableAddKey",
-    TableAddKeyMethodType = "TableAddKeyMethod"
+    TableAddKeyMethodType = "TableAddKeyMethod",
+    TableIsEmptyType = "TableIsEmpty",
+    TableIsEmptyMethodType = "TableIsEmptyMethod"
 }
 export declare function getExtensionKindForType(context: TransformationContext, type: ts.Type): ExtensionKind | undefined;
 export declare function getExtensionKindForNode(context: TransformationContext, node: ts.Node): ExtensionKind | undefined;

package/dist/transformation/utils/language-extensions.js

@@ -55,6 +55,8 @@ var ExtensionKind;
     ExtensionKind["TableSetMethodType"] = "TableSetMethod";
     ExtensionKind["TableAddKeyType"] = "TableAddKey";
     ExtensionKind["TableAddKeyMethodType"] = "TableAddKeyMethod";
+    ExtensionKind["TableIsEmptyType"] = "TableIsEmpty";
+    ExtensionKind["TableIsEmptyMethodType"] = "TableIsEmptyMethod";
 })(ExtensionKind || (exports.ExtensionKind = ExtensionKind = {}));
 const extensionValues = new Set(Object.values(ExtensionKind));
 function getExtensionKindForType(context, type) {
@@ -113,31 +115,7 @@ function getIterableExtensionKindForNode(context, node) {
     return getIterableExtensionTypeForType(context, type);
 }
 exports.getIterableExtensionKindForNode = getIterableExtensionKindForNode;
-exports.methodExtensionKinds = new Set([
-    ExtensionKind.AdditionOperatorMethodType,
-    ExtensionKind.SubtractionOperatorMethodType,
-    ExtensionKind.MultiplicationOperatorMethodType,
-    ExtensionKind.DivisionOperatorMethodType,
-    ExtensionKind.ModuloOperatorMethodType,
-    ExtensionKind.PowerOperatorMethodType,
-    ExtensionKind.FloorDivisionOperatorMethodType,
-    ExtensionKind.BitwiseAndOperatorMethodType,
-    ExtensionKind.BitwiseOrOperatorMethodType,
-    ExtensionKind.BitwiseExclusiveOrOperatorMethodType,
-    ExtensionKind.BitwiseLeftShiftOperatorMethodType,
-    ExtensionKind.BitwiseRightShiftOperatorMethodType,
-    ExtensionKind.ConcatOperatorMethodType,
-    ExtensionKind.LessThanOperatorMethodType,
-    ExtensionKind.GreaterThanOperatorMethodType,
-    ExtensionKind.NegationOperatorMethodType,
-    ExtensionKind.BitwiseNotOperatorMethodType,
-    ExtensionKind.LengthOperatorMethodType,
-    ExtensionKind.TableDeleteMethodType,
-    ExtensionKind.TableGetMethodType,
-    ExtensionKind.TableHasMethodType,
-    ExtensionKind.TableSetMethodType,
-    ExtensionKind.TableAddKeyMethodType,
-]);
+exports.methodExtensionKinds = new Set(Object.values(ExtensionKind).filter(key => key.endsWith("Method")));
 function getNaryCallExtensionArgs(context, node, kind, numArgs) {
     let expressions;
     if (node.arguments.some(ts.isSpreadElement)) {

package/dist/transformation/visitors/language-extensions/table.js

@@ -20,6 +20,8 @@ exports.tableExtensionTransformers = {
     [language_extensions_1.ExtensionKind.TableSetMethodType]: transformTableSetExpression,
     [language_extensions_1.ExtensionKind.TableAddKeyType]: transformTableAddKeyExpression,
     [language_extensions_1.ExtensionKind.TableAddKeyMethodType]: transformTableAddKeyExpression,
+    [language_extensions_1.ExtensionKind.TableIsEmptyType]: transformTableIsEmptyExpression,
+    [language_extensions_1.ExtensionKind.TableIsEmptyMethodType]: transformTableIsEmptyExpression,
 };
 function transformTableDeleteExpression(context, node, extensionKind) {
     const args = (0, language_extensions_1.getBinaryCallExtensionArgs)(context, node, extensionKind);
@@ -71,4 +73,13 @@ function transformTableAddKeyExpression(context, node, extensionKind) {
     context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, key), lua.createBooleanLiteral(true), node));
     return lua.createNilLiteral();
 }
+function transformTableIsEmptyExpression(context, node, extensionKind) {
+    const args = (0, language_extensions_1.getUnaryCallExtensionArg)(context, node, extensionKind);
+    if (!args) {
+        return lua.createNilLiteral();
+    }
+    const table = context.transformExpression(args);
+    // next(arg0) == nil
+    return lua.createBinaryExpression(lua.createCallExpression(lua.createIdentifier("next"), [table], node), lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator, node);
+}
 //# sourceMappingURL=table.js.map

package/dist/transformation/visitors/switch.js

@@ -11,11 +11,17 @@ const containsBreakOrReturn = (nodes) => {
         if (ts.isBreakStatement(s) || ts.isReturnStatement(s)) {
             return true;
         }
-        else if (ts.isBlock(s) && containsBreakOrReturn(s.getChildren())) {
+        else if (ts.isBlock(s) && containsBreakOrReturn(s.statements)) {
             return true;
         }
-        else if (s.kind === ts.SyntaxKind.SyntaxList && containsBreakOrReturn(s.getChildren())) {
-            return true;
+        else if (s.kind === ts.SyntaxKind.SyntaxList) {
+            // We cannot use getChildren() because that breaks when using synthetic nodes from transformers
+            // So get children the long way
+            const children = [];
+            ts.forEachChild(s, c => children.push(c));
+            if (containsBreakOrReturn(children)) {
+                return true;
+            }
         }
     }
     return false;

package/dist/transpilation/plugins.d.ts

@@ -29,6 +29,7 @@ export interface Plugin {
      * This function is called after translating the input program to Lua, after resolving dependencies and after bundling.
      */
     beforeEmit?: (program: ts.Program, options: CompilerOptions, emitHost: EmitHost, result: EmitFile[]) => ts.Diagnostic[] | void;
+    moduleResolution?: (moduleIdentifier: string, requiringFile: string, options: CompilerOptions, emitHost: EmitHost) => string | undefined;
 }
 export declare function getPlugins(program: ts.Program): {
     diagnostics: ts.Diagnostic[];

package/dist/transpilation/resolve.d.ts

@@ -1,8 +1,9 @@
 import * as ts from "typescript";
 import { EmitHost, ProcessedFile } from "./utils";
+import { Plugin } from "./plugins";
 interface ResolutionResult {
     resolvedFiles: ProcessedFile[];
     diagnostics: ts.Diagnostic[];
 }
-export declare function resolveDependencies(program: ts.Program, files: ProcessedFile[], emitHost: EmitHost): ResolutionResult;
+export declare function resolveDependencies(program: ts.Program, files: ProcessedFile[], emitHost: EmitHost, plugins: Plugin[]): ResolutionResult;
 export {};

package/dist/transpilation/resolve.js

@@ -19,10 +19,11 @@ const resolver = resolve.ResolverFactory.createResolver({
     symlinks: false, // Do not resolve symlinks to their original paths (that breaks node_modules detection)
 });
 class ResolutionContext {
-    constructor(program, options, emitHost) {
+    constructor(program, options, emitHost, plugins) {
         this.program = program;
         this.options = options;
         this.emitHost = emitHost;
+        this.plugins = plugins;
         this.diagnostics = [];
         this.resolvedFiles = new Map();
         this.processedDependencies = new Set();
@@ -52,6 +53,7 @@ class ResolutionContext {
         }
     }
     resolveImport(file, required) {
+        var _a;
         // Do no resolve lualib - always use the lualib of the application entry point, not the lualib from external packages
         if (required.requirePath === "lualib_bundle") {
             this.resolvedFiles.set("lualib_bundle", { fileName: "lualib_bundle", code: "" });
@@ -63,7 +65,7 @@ class ResolutionContext {
             }
             return;
         }
-        const dependencyPath = this.resolveDependencyPath(file, required.requirePath);
+        const dependencyPath = (_a = this.resolveDependencyPathsWithPlugins(file, required.requirePath)) !== null && _a !== void 0 ? _a : this.resolveDependencyPath(file, required.requirePath);
         if (!dependencyPath)
             return this.couldNotResolveImport(required, file);
         if (this.options.tstlVerbose) {
@@ -77,6 +79,46 @@ class ResolutionContext {
             replaceRequireInSourceMap(file, required, resolvedRequire, this.options.extension);
         }
     }
+    resolveDependencyPathsWithPlugins(requiringFile, dependency) {
+        const requiredFromLuaFile = requiringFile.fileName.endsWith(".lua");
+        for (const plugin of this.plugins) {
+            if (plugin.moduleResolution != null) {
+                const pluginResolvedPath = plugin.moduleResolution(dependency, requiringFile.fileName, this.options, this.emitHost);
+                if (pluginResolvedPath !== undefined) {
+                    // If lua file is in node_module
+                    if (requiredFromLuaFile && isNodeModulesFile(requiringFile.fileName)) {
+                        // If requiring file is in lua module, try to resolve sibling in that file first
+                        const resolvedNodeModulesFile = this.resolveLuaDependencyPathFromNodeModules(requiringFile, pluginResolvedPath);
+                        if (resolvedNodeModulesFile) {
+                            if (this.options.tstlVerbose) {
+                                console.log(`Resolved file path for module ${dependency} to path ${pluginResolvedPath} using plugin.`);
+                            }
+                            return resolvedNodeModulesFile;
+                        }
+                    }
+                    const resolvedPath = this.formatPathToFile(pluginResolvedPath, requiringFile);
+                    const fileFromPath = this.getFileFromPath(resolvedPath);
+                    if (fileFromPath) {
+                        if (this.options.tstlVerbose) {
+                            console.log(`Resolved file path for module ${dependency} to path ${pluginResolvedPath} using plugin.`);
+                        }
+                        return fileFromPath;
+                    }
+                }
+            }
+        }
+    }
+    formatPathToFile(targetPath, required) {
+        var _a;
+        const isRelative = ["/", "./", "../"].some(p => targetPath.startsWith(p));
+        // // If the import is relative, always resolve it relative to the requiring file
+        // // If the import is not relative, resolve it relative to options.baseUrl if it is set
+        const fileDirectory = path.dirname(required.fileName);
+        const relativeTo = isRelative ? fileDirectory : (_a = this.options.baseUrl) !== null && _a !== void 0 ? _a : fileDirectory;
+        // // Check if file is a file in the project
+        const resolvedPath = path.join(relativeTo, targetPath);
+        return resolvedPath;
+    }
     processDependency(dependencyPath) {
         if (this.processedDependencies.has(dependencyPath))
             return;
@@ -102,7 +144,6 @@ class ResolutionContext {
         this.diagnostics.push((0, diagnostics_1.couldNotResolveRequire)(required.requirePath, path.relative((0, transpiler_1.getProjectRoot)(this.program), file.fileName)));
     }
     resolveDependencyPath(requiringFile, dependency) {
-        var _a;
         const fileDirectory = path.dirname(requiringFile.fileName);
         if (this.options.tstlVerbose) {
             console.log(`Resolving "${dependency}" from ${(0, utils_1.normalizeSlashes)(requiringFile.fileName)}`);
@@ -115,13 +156,8 @@ class ResolutionContext {
             if (resolvedNodeModulesFile)
                 return resolvedNodeModulesFile;
         }
-        // Check if the import is relative
-        const isRelative = ["/", "./", "../"].some(p => dependency.startsWith(p));
-        // If the import is relative, always resolve it relative to the requiring file
-        // If the import is not relative, resolve it relative to options.baseUrl if it is set
-        const relativeTo = isRelative ? fileDirectory : (_a = this.options.baseUrl) !== null && _a !== void 0 ? _a : fileDirectory;
         // Check if file is a file in the project
-        const resolvedPath = path.join(relativeTo, dependencyPath);
+        const resolvedPath = this.formatPathToFile(dependencyPath, requiringFile);
         const fileFromPath = this.getFileFromPath(resolvedPath);
         if (fileFromPath)
             return fileFromPath;
@@ -235,9 +271,9 @@ class ResolutionContext {
         }
     }
 }
-function resolveDependencies(program, files, emitHost) {
+function resolveDependencies(program, files, emitHost, plugins) {
     const options = program.getCompilerOptions();
-    const resolutionContext = new ResolutionContext(program, options, emitHost);
+    const resolutionContext = new ResolutionContext(program, options, emitHost, plugins);
     // Resolve dependencies for all processed files
     for (const file of files) {
         if (options.tstlVerbose) {

package/dist/transpilation/transpiler.d.ts

@@ -1,4 +1,5 @@
 import * as ts from "typescript";
+import { Plugin } from "./plugins";
 import { TranspileOptions } from "./transpile";
 import { EmitFile, EmitHost, ProcessedFile } from "./utils";
 export interface TranspilerOptions {
@@ -16,7 +17,7 @@ export declare class Transpiler {
     constructor({ emitHost }?: TranspilerOptions);
     emit(emitOptions: EmitOptions): EmitResult;
     private emitFiles;
-    protected getEmitPlan(program: ts.Program, diagnostics: ts.Diagnostic[], files: ProcessedFile[]): {
+    protected getEmitPlan(program: ts.Program, diagnostics: ts.Diagnostic[], files: ProcessedFile[], plugins: Plugin[]): {
         emitPlan: EmitFile[];
     };
     private getLuaLibBundleContent;

package/dist/transpilation/transpiler.js

@@ -23,7 +23,7 @@ class Transpiler {
             ...emitOptions,
             plugins,
         });
-        const { emitPlan } = this.getEmitPlan(program, transpileDiagnostics, freshFiles);
+        const { emitPlan } = this.getEmitPlan(program, transpileDiagnostics, freshFiles, plugins);
         const emitDiagnostics = this.emitFiles(program, plugins, emitPlan, writeFile);
         return {
             diagnostics: getPluginsDiagnostics.concat(transpileDiagnostics, emitDiagnostics),
@@ -60,14 +60,14 @@ class Transpiler {
         performance.endSection("emit");
         return diagnostics;
     }
-    getEmitPlan(program, diagnostics, files) {
+    getEmitPlan(program, diagnostics, files, plugins) {
         performance.startSection("getEmitPlan");
         const options = program.getCompilerOptions();
         if (options.tstlVerbose) {
             console.log("Constructing emit plan");
         }
         // Resolve imported modules and modify output Lua requires
-        const resolutionResult = (0, resolve_1.resolveDependencies)(program, files, this.emitHost);
+        const resolutionResult = (0, resolve_1.resolveDependencies)(program, files, this.emitHost, plugins);
         diagnostics.push(...resolutionResult.diagnostics);
         const lualibRequired = resolutionResult.resolvedFiles.some(f => f.fileName === "lualib_bundle");
         if (lualibRequired) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "typescript-to-lua",
-    "version": "1.16.2",
+    "version": "1.17.0",
     "description": "A generic TypeScript to Lua transpiler. Write your code in TypeScript and publish Lua!",
     "repository": "https://github.com/TypeScriptToLua/TypeScriptToLua",
     "homepage": "https://typescripttolua.github.io/",