typescript-to-lua 1.12.0 → 1.13.0

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tableExtensionTransformers = exports.tableNewExtensions = exports.isTableNewCall = void 0;
-const ts = require("typescript");
 const lua = require("../../../LuaAST");
 const language_extensions_1 = require("../../utils/language-extensions");
 const expression_list_1 = require("../expression-list");
@@ -19,62 +18,57 @@ exports.tableExtensionTransformers = {
     [language_extensions_1.ExtensionKind.TableHasMethodType]: transformTableHasExpression,
     [language_extensions_1.ExtensionKind.TableSetType]: transformTableSetExpression,
     [language_extensions_1.ExtensionKind.TableSetMethodType]: transformTableSetExpression,
-    [language_extensions_1.ExtensionKind.TableAddKeyType]: transformTableAddExpression,
-    [language_extensions_1.ExtensionKind.TableAddKeyMethodType]: transformTableAddExpression,
+    [language_extensions_1.ExtensionKind.TableAddKeyType]: transformTableAddKeyExpression,
+    [language_extensions_1.ExtensionKind.TableAddKeyMethodType]: transformTableAddKeyExpression,
 };
 function transformTableDeleteExpression(context, node, extensionKind) {
-    const args = node.arguments.slice();
-    if (extensionKind === language_extensions_1.ExtensionKind.TableDeleteMethodType &&
-        (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
-        // In case of method (no table argument), push method owner to front of args list
-        args.unshift(node.expression.expression);
+    const args = (0, language_extensions_1.getBinaryCallExtensionArgs)(context, node, extensionKind);
+    if (!args) {
+        return lua.createNilLiteral();
     }
-    const [table, accessExpression] = (0, expression_list_1.transformExpressionList)(context, args);
+    const [table, key] = (0, expression_list_1.transformOrderedExpressions)(context, args);
     // arg0[arg1] = nil
-    context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, accessExpression), lua.createNilLiteral(), node));
+    context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, key), lua.createNilLiteral(), node));
     return lua.createBooleanLiteral(true);
 }
-function transformWithTableArgument(context, node) {
-    if (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression)) {
-        return (0, expression_list_1.transformExpressionList)(context, [node.expression.expression, ...node.arguments]);
-    }
-    // todo: report diagnostic?
-    return [lua.createNilLiteral(), ...(0, expression_list_1.transformExpressionList)(context, node.arguments)];
-}
 function transformTableGetExpression(context, node, extensionKind) {
-    const args = extensionKind === language_extensions_1.ExtensionKind.TableGetMethodType
-        ? transformWithTableArgument(context, node)
-        : (0, expression_list_1.transformExpressionList)(context, node.arguments);
-    const [table, accessExpression] = args;
+    const args = (0, language_extensions_1.getBinaryCallExtensionArgs)(context, node, extensionKind);
+    if (!args) {
+        return lua.createNilLiteral();
+    }
+    const [table, key] = (0, expression_list_1.transformOrderedExpressions)(context, args);
     // arg0[arg1]
-    return lua.createTableIndexExpression(table, accessExpression, node);
+    return lua.createTableIndexExpression(table, key, node);
 }
 function transformTableHasExpression(context, node, extensionKind) {
-    const args = extensionKind === language_extensions_1.ExtensionKind.TableHasMethodType
-        ? transformWithTableArgument(context, node)
-        : (0, expression_list_1.transformExpressionList)(context, node.arguments);
-    const [table, accessExpression] = args;
+    const args = (0, language_extensions_1.getBinaryCallExtensionArgs)(context, node, extensionKind);
+    if (!args) {
+        return lua.createNilLiteral();
+    }
+    const [table, key] = (0, expression_list_1.transformOrderedExpressions)(context, args);
     // arg0[arg1]
-    const tableIndexExpression = lua.createTableIndexExpression(table, accessExpression);
+    const tableIndexExpression = lua.createTableIndexExpression(table, key);
     // arg0[arg1] ~= nil
     return lua.createBinaryExpression(tableIndexExpression, lua.createNilLiteral(), lua.SyntaxKind.InequalityOperator, node);
 }
 function transformTableSetExpression(context, node, extensionKind) {
-    const args = extensionKind === language_extensions_1.ExtensionKind.TableSetMethodType
-        ? transformWithTableArgument(context, node)
-        : (0, expression_list_1.transformExpressionList)(context, node.arguments);
-    const [table, accessExpression, value] = args;
+    const args = (0, language_extensions_1.getNaryCallExtensionArgs)(context, node, extensionKind, 3);
+    if (!args) {
+        return lua.createNilLiteral();
+    }
+    const [table, key, value] = (0, expression_list_1.transformOrderedExpressions)(context, args);
     // arg0[arg1] = arg2
-    context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, accessExpression), value, node));
+    context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, key), value, node));
     return lua.createNilLiteral();
 }
-function transformTableAddExpression(context, node, extensionKind) {
-    const args = extensionKind === language_extensions_1.ExtensionKind.TableAddKeyMethodType
-        ? transformWithTableArgument(context, node)
-        : (0, expression_list_1.transformExpressionList)(context, node.arguments);
-    const [table, value] = args;
+function transformTableAddKeyExpression(context, node, extensionKind) {
+    const args = (0, language_extensions_1.getNaryCallExtensionArgs)(context, node, extensionKind, 2);
+    if (!args) {
+        return lua.createNilLiteral();
+    }
+    const [table, key] = (0, expression_list_1.transformOrderedExpressions)(context, args);
     // arg0[arg1] = true
-    context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, value), lua.createBooleanLiteral(true), node));
+    context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, key), lua.createBooleanLiteral(true), node));
     return lua.createNilLiteral();
 }
 //# sourceMappingURL=table.js.map

package/dist/transformation/visitors/loops/do-while.js

@@ -9,7 +9,7 @@ const transformWhileStatement = (statement, context) => {
     // Check if we need to add diagnostic about Lua truthiness
     (0, conditional_1.checkOnlyTruthyCondition)(statement.expression, context);
     const body = (0, utils_1.transformLoopBody)(context, statement);
-    let [conditionPrecedingStatements, condition] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(statement.expression));
+    let { precedingStatements: conditionPrecedingStatements, result: condition } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(statement.expression));
     // If condition has preceding statements, ensure they are executed every iteration by using the form:
     //
     // while true do
@@ -31,7 +31,7 @@ const transformDoStatement = (statement, context) => {
     // Check if we need to add diagnostic about Lua truthiness
     (0, conditional_1.checkOnlyTruthyCondition)(statement.expression, context);
     const body = lua.createDoStatement((0, utils_1.transformLoopBody)(context, statement));
-    let [conditionPrecedingStatements, condition] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, utils_1.invertCondition)(context.transformExpression(statement.expression)));
+    let { precedingStatements: conditionPrecedingStatements, result: condition } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, utils_1.invertCondition)(context.transformExpression(statement.expression)));
     // If condition has preceding statements, ensure they are executed every iteration by using the form:
     //
     // repeat

package/dist/transformation/visitors/loops/for.js

@@ -21,9 +21,9 @@ const transformForStatement = (statement, context) => {
     const body = (0, utils_1.transformLoopBody)(context, statement);
     let condition;
     if (statement.condition) {
-        let conditionPrecedingStatements;
         const tsCondition = statement.condition;
-        [conditionPrecedingStatements, condition] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(tsCondition));
+        const { precedingStatements: conditionPrecedingStatements, result } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(tsCondition));
+        condition = result;
         // If condition has preceding statements, ensure they are executed every iteration by using the form:
         //
         // while true do

package/dist/transformation/visitors/loops/utils.js

@@ -40,7 +40,7 @@ function transformForInitializer(context, initializer, block) {
         // Declaration of new variable
         const binding = getVariableDeclarationBinding(context, initializer);
         if (ts.isArrayBindingPattern(binding) || ts.isObjectBindingPattern(binding)) {
-            const [precedingStatements, bindings] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, variable_declaration_1.transformBindingPattern)(context, binding, valueVariable));
+            const { precedingStatements, result: bindings } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, variable_declaration_1.transformBindingPattern)(context, binding, valueVariable));
             block.statements.unshift(...precedingStatements, ...bindings);
         }
         else {

package/dist/transformation/visitors/optional-chaining.d.ts

@@ -8,9 +8,10 @@ export interface ExpressionWithThisValue {
 export declare function captureThisValue(context: TransformationContext, expression: lua.Expression, thisValueCapture: lua.Identifier, tsOriginal: ts.Node): lua.Expression;
 export interface OptionalContinuation {
     contextualCall?: lua.CallExpression;
+    usedIdentifiers: lua.Identifier[];
 }
 export declare function isOptionalContinuation(node: ts.Node): boolean;
 export declare function getOptionalContinuationData(identifier: ts.Identifier): OptionalContinuation | undefined;
 export declare function transformOptionalChain(context: TransformationContext, node: ts.OptionalChain): lua.Expression;
-export declare function transformOptionalChainWithCapture(context: TransformationContext, node: ts.OptionalChain, thisValueCapture: lua.Identifier | undefined, isDelete?: ts.DeleteExpression): ExpressionWithThisValue;
+export declare function transformOptionalChainWithCapture(context: TransformationContext, tsNode: ts.OptionalChain, thisValueCapture: lua.Identifier | undefined, isDelete?: ts.DeleteExpression): ExpressionWithThisValue;
 export declare function transformOptionalDeleteExpression(context: TransformationContext, node: ts.DeleteExpression, innerExpression: ts.OptionalChain): lua.BooleanLiteral;

package/dist/transformation/visitors/optional-chaining.js

@@ -8,6 +8,8 @@ const utils_1 = require("../../utils");
 const preceding_statements_1 = require("../utils/preceding-statements");
 const access_1 = require("./access");
 const expression_list_1 = require("./expression-list");
+const typescript_1 = require("../utils/typescript");
+const expression_statement_1 = require("./expression-statement");
 function skipNonNullChains(chain) {
     while (ts.isNonNullChain(chain)) {
         chain = chain.expression;
@@ -39,7 +41,7 @@ function transformExpressionWithThisValueCapture(context, node, thisValueCapture
 }
 // returns thisValueCapture exactly if a temp variable was used.
 function captureThisValue(context, expression, thisValueCapture, tsOriginal) {
-    if (!(0, expression_list_1.shouldMoveToTemp)(context, expression, tsOriginal) && !isOptionalContinuation(tsOriginal)) {
+    if (!(0, expression_list_1.shouldMoveToTemp)(context, expression, tsOriginal)) {
         return expression;
     }
     const tempAssignment = lua.createAssignmentStatement(thisValueCapture, expression, tsOriginal);
@@ -52,7 +54,9 @@ const optionalContinuations = new WeakMap();
 function createOptionalContinuationIdentifier(text, tsOriginal) {
     const identifier = ts.factory.createIdentifier(text);
     ts.setOriginalNode(identifier, tsOriginal);
-    optionalContinuations.set(identifier, {});
+    optionalContinuations.set(identifier, {
+        usedIdentifiers: [],
+    });
     return identifier;
 }
 function isOptionalContinuation(node) {
@@ -67,12 +71,11 @@ function transformOptionalChain(context, node) {
     return transformOptionalChainWithCapture(context, node, undefined).expression;
 }
 exports.transformOptionalChain = transformOptionalChain;
-function transformOptionalChainWithCapture(context, node, thisValueCapture, isDelete) {
-    var _a;
-    const luaTemp = context.createTempNameForNode(node);
-    const { expression: tsLeftExpression, chain } = flattenChain(node);
+function transformOptionalChainWithCapture(context, tsNode, thisValueCapture, isDelete) {
+    const luaTempName = context.createTempName("opt");
+    const { expression: tsLeftExpression, chain } = flattenChain(tsNode);
     // build temp.b.c.d
-    const tsTemp = createOptionalContinuationIdentifier(luaTemp.text, tsLeftExpression);
+    const tsTemp = createOptionalContinuationIdentifier(luaTempName, tsLeftExpression);
     let tsRightExpression = tsTemp;
     for (const link of chain) {
         if (ts.isPropertyAccessExpression(link)) {
@@ -96,22 +99,21 @@ function transformOptionalChainWithCapture(context, node, thisValueCapture, isDe
     // transform right expression first to check if thisValue capture is needed
     // capture and return thisValue if requested from outside
     let returnThisValue;
-    const [rightPrecedingStatements, rightAssignment] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
-        let result;
-        if (thisValueCapture) {
-            ({ expression: result, thisValue: returnThisValue } = transformExpressionWithThisValueCapture(context, tsRightExpression, thisValueCapture));
-        }
-        else {
-            result = context.transformExpression(tsRightExpression);
+    const { precedingStatements: rightPrecedingStatements, result: rightExpression } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
+        if (!thisValueCapture) {
+            return context.transformExpression(tsRightExpression);
         }
-        return lua.createAssignmentStatement(luaTemp, result);
+        const { expression: result, thisValue } = transformExpressionWithThisValueCapture(context, tsRightExpression, thisValueCapture);
+        returnThisValue = thisValue;
+        return result;
     });
     // transform left expression, handle thisValue if needed by rightExpression
     const thisValueCaptureName = context.createTempName("this");
     const leftThisValueTemp = lua.createIdentifier(thisValueCaptureName, undefined, context_1.tempSymbolId);
     let capturedThisValue;
-    const rightContextualCall = (_a = getOptionalContinuationData(tsTemp)) === null || _a === void 0 ? void 0 : _a.contextualCall;
-    const [leftPrecedingStatements, leftExpression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
+    const optionalContinuationData = getOptionalContinuationData(tsTemp);
+    const rightContextualCall = optionalContinuationData === null || optionalContinuationData === void 0 ? void 0 : optionalContinuationData.contextualCall;
+    const { precedingStatements: leftPrecedingStatements, result: leftExpression } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
         let result;
         if (rightContextualCall) {
             ({ expression: result, thisValue: capturedThisValue } = transformExpressionWithThisValueCapture(context, tsLeftExpression, leftThisValueTemp));
@@ -146,22 +148,66 @@ function transformOptionalChainWithCapture(context, node, thisValueCapture, isDe
             }
         }
     }
-    // <left preceding statements>
-    // local temp = <left>
-    // if temp ~= nil then
-    //   <right preceding statements>
-    //   temp = temp.b.c.d
-    // end
-    // return temp
-    context.addPrecedingStatements([
-        ...leftPrecedingStatements,
-        lua.createVariableDeclarationStatement(luaTemp, leftExpression),
-        lua.createIfStatement(lua.createBinaryExpression(luaTemp, lua.createNilLiteral(), lua.SyntaxKind.InequalityOperator), lua.createBlock([...rightPrecedingStatements, rightAssignment])),
-    ]);
-    return {
-        expression: luaTemp,
-        thisValue: returnThisValue,
-    };
+    // evaluate optional chain
+    context.addPrecedingStatements(leftPrecedingStatements);
+    // try use existing variable instead of creating new one, if possible
+    let leftIdentifier;
+    const usedLuaIdentifiers = optionalContinuationData === null || optionalContinuationData === void 0 ? void 0 : optionalContinuationData.usedIdentifiers;
+    const reuseLeftIdentifier = usedLuaIdentifiers &&
+        usedLuaIdentifiers.length > 0 &&
+        lua.isIdentifier(leftExpression) &&
+        (rightPrecedingStatements.length === 0 || !(0, expression_list_1.shouldMoveToTemp)(context, leftExpression, tsLeftExpression));
+    if (reuseLeftIdentifier) {
+        leftIdentifier = leftExpression;
+        for (const usedIdentifier of usedLuaIdentifiers) {
+            usedIdentifier.text = leftIdentifier.text;
+        }
+    }
+    else {
+        leftIdentifier = lua.createIdentifier(luaTempName, undefined, context_1.tempSymbolId);
+        context.addPrecedingStatements(lua.createVariableDeclarationStatement(leftIdentifier, leftExpression));
+    }
+    if (!(0, typescript_1.expressionResultIsUsed)(tsNode) || isDelete) {
+        // if left ~= nil then
+        //   <right preceding statements>
+        //   <right expression>
+        // end
+        const innerExpression = (0, expression_statement_1.wrapInStatement)(rightExpression);
+        const innerStatements = rightPrecedingStatements;
+        if (innerExpression)
+            innerStatements.push(innerExpression);
+        context.addPrecedingStatements(lua.createIfStatement(lua.createBinaryExpression(leftIdentifier, lua.createNilLiteral(), lua.SyntaxKind.InequalityOperator), lua.createBlock(innerStatements)));
+        return { expression: lua.createNilLiteral(), thisValue: returnThisValue };
+    }
+    else if (rightPrecedingStatements.length === 0 &&
+        !(0, typescript_1.canBeFalsyWhenNotNull)(context, context.checker.getTypeAtLocation(tsLeftExpression))) {
+        // return a && a.b
+        return {
+            expression: lua.createBinaryExpression(leftIdentifier, rightExpression, lua.SyntaxKind.AndOperator, tsNode),
+            thisValue: returnThisValue,
+        };
+    }
+    else {
+        let resultIdentifier;
+        if (!reuseLeftIdentifier) {
+            // reuse temp variable for output
+            resultIdentifier = leftIdentifier;
+        }
+        else {
+            resultIdentifier = lua.createIdentifier(context.createTempName("opt_result"), undefined, context_1.tempSymbolId);
+            context.addPrecedingStatements(lua.createVariableDeclarationStatement(resultIdentifier));
+        }
+        // if left ~= nil then
+        //   <right preceding statements>
+        //   result = <right expression>
+        // end
+        // return result
+        context.addPrecedingStatements(lua.createIfStatement(lua.createBinaryExpression(leftIdentifier, lua.createNilLiteral(), lua.SyntaxKind.InequalityOperator), lua.createBlock([
+            ...rightPrecedingStatements,
+            lua.createAssignmentStatement(resultIdentifier, rightExpression),
+        ])));
+        return { expression: resultIdentifier, thisValue: returnThisValue };
+    }
 }
 exports.transformOptionalChainWithCapture = transformOptionalChainWithCapture;
 function transformOptionalDeleteExpression(context, node, innerExpression) {

package/dist/transformation/visitors/sourceFile.js

@@ -15,7 +15,7 @@ const transformSourceFileNode = (node, context) => {
         const [statement] = node.statements;
         if (statement) {
             (0, utils_1.assert)(ts.isExpressionStatement(statement));
-            const [precedingStatements, expression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(statement.expression));
+            const { precedingStatements, result: expression } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(statement.expression));
             statements.push(...precedingStatements);
             statements.push(lua.createReturnStatement([expression]));
         }

package/dist/transformation/visitors/switch.js

@@ -25,18 +25,21 @@ const createOrExpression = (context, left, right, rightPrecedingStatements) => {
         return (0, binary_expression_1.createShortCircuitBinaryExpressionPrecedingStatements)(context, left, right, rightPrecedingStatements, ts.SyntaxKind.BarBarToken);
     }
     else {
-        return [rightPrecedingStatements, lua.createBinaryExpression(left, right, lua.SyntaxKind.OrOperator)];
+        return {
+            precedingStatements: rightPrecedingStatements,
+            result: lua.createBinaryExpression(left, right, lua.SyntaxKind.OrOperator),
+        };
     }
 };
 const coalesceCondition = (condition, conditionPrecedingStatements, switchVariable, expression, context) => {
-    const [precedingStatements, transformedExpression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression));
+    const { precedingStatements, result: transformedExpression } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression));
     // Coalesce skipped statements
     const comparison = lua.createBinaryExpression(switchVariable, transformedExpression, lua.SyntaxKind.EqualityOperator);
     if (condition) {
         return createOrExpression(context, condition, comparison, precedingStatements);
     }
     // Next condition
-    return [[...conditionPrecedingStatements, ...precedingStatements], comparison];
+    return { precedingStatements: [...conditionPrecedingStatements, ...precedingStatements], result: comparison };
 };
 const transformSwitchStatement = (statement, context) => {
     const scope = context.pushScope(scope_1.ScopeType.Switch);
@@ -77,7 +80,9 @@ const transformSwitchStatement = (statement, context) => {
             }
             // Compute the condition for the if statement
             if (!ts.isDefaultClause(clause)) {
-                [conditionPrecedingStatements, condition] = coalesceCondition(condition, conditionPrecedingStatements, switchVariable, clause.expression, context);
+                const { precedingStatements, result } = coalesceCondition(condition, conditionPrecedingStatements, switchVariable, clause.expression, context);
+                conditionPrecedingStatements = precedingStatements;
+                condition = result;
                 // Skip empty clauses unless final clause (i.e side-effects)
                 if (i !== clauses.length - 1 && clause.statements.length === 0)
                     continue;
@@ -86,7 +91,9 @@ const transformSwitchStatement = (statement, context) => {
                     statements.push(...conditionPrecedingStatements, lua.createVariableDeclarationStatement(conditionVariable, condition));
                 }
                 else {
-                    [conditionPrecedingStatements, condition] = createOrExpression(context, conditionVariable, condition, conditionPrecedingStatements);
+                    const { precedingStatements, result } = createOrExpression(context, conditionVariable, condition, conditionPrecedingStatements);
+                    conditionPrecedingStatements = precedingStatements;
+                    condition = result;
                     statements.push(...conditionPrecedingStatements, lua.createAssignmentStatement(conditionVariable, condition));
                 }
                 isInitialCondition = false;
@@ -104,7 +111,9 @@ const transformSwitchStatement = (statement, context) => {
                 if (i === clauses.length - 1) {
                     // Evaluate the final condition that we may be skipping
                     if (condition) {
-                        [conditionPrecedingStatements, condition] = createOrExpression(context, conditionVariable, condition, conditionPrecedingStatements);
+                        const { precedingStatements, result } = createOrExpression(context, conditionVariable, condition, conditionPrecedingStatements);
+                        conditionPrecedingStatements = precedingStatements;
+                        condition = result;
                         statements.push(...conditionPrecedingStatements, lua.createAssignmentStatement(conditionVariable, condition));
                     }
                     continue;

package/dist/transformation/visitors/typeof.js

@@ -43,7 +43,7 @@ function transformTypeOfBinaryExpression(context, node) {
     }
     const innerExpression = context.transformExpression(typeOfExpression.expression);
     const typeCall = lua.createCallExpression(lua.createIdentifier("type"), [innerExpression], typeOfExpression);
-    const [precedingStatements, result] = (0, binary_expression_1.transformBinaryOperation)(context, typeCall, comparedExpression, [], operator, node);
+    const { precedingStatements, result } = (0, binary_expression_1.transformBinaryOperation)(context, typeCall, comparedExpression, [], operator, node);
     context.addPrecedingStatements(precedingStatements);
     return result;
 }

package/dist/transformation/visitors/variable-declaration.js

@@ -61,7 +61,7 @@ function transformBindingPattern(context, pattern, table, propertyAccessStack =
         const variableName = (0, identifier_1.transformIdentifier)(context, element.name);
         // The field to extract
         const elementName = (_a = element.propertyName) !== null && _a !== void 0 ? _a : element.name;
-        const [precedingStatements, propertyName] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, literal_1.transformPropertyName)(context, elementName));
+        const { precedingStatements, result: propertyName } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, literal_1.transformPropertyName)(context, elementName));
         result.push(...precedingStatements); // Keep property's preceding statements in order
         let expression;
         if (element.dotDotDotToken) {
@@ -101,7 +101,7 @@ function transformBindingPattern(context, pattern, table, propertyAccessStack =
         if (element.initializer) {
             const identifier = (0, export_1.addExportToIdentifier)(context, variableName);
             const tsInitializer = element.initializer;
-            const [initializerPrecedingStatements, initializer] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(tsInitializer));
+            const { precedingStatements: initializerPrecedingStatements, result: initializer } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(tsInitializer));
             result.push(lua.createIfStatement(lua.createBinaryExpression(identifier, lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator), lua.createBlock([
                 ...initializerPrecedingStatements,
                 lua.createAssignmentStatement(identifier, initializer),
@@ -124,7 +124,7 @@ function transformBindingVariableDeclaration(context, bindingPattern, initialize
             if ((0, multi_1.isMultiReturnCall)(context, initializer)) {
                 expression = (0, lua_ast_1.wrapInTable)(expression);
             }
-            const [moveStatements, movedExpr] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, expression_list_1.moveToPrecedingTemp)(context, expression, initializer));
+            const { precedingStatements: moveStatements, result: movedExpr } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, expression_list_1.moveToPrecedingTemp)(context, expression, initializer));
             statements.push(...moveStatements);
             table = movedExpr;
         }

package/dist/transformation/visitors/void.js

@@ -8,7 +8,7 @@ const expression_statement_1 = require("./expression-statement");
 const transformVoidExpression = (node, context) => {
     // If content is a literal it is safe to replace the entire expression with nil
     if (!ts.isLiteralExpression(node.expression)) {
-        const statements = (0, expression_statement_1.transformExpressionToStatement)(context, node.expression);
+        const statements = (0, expression_statement_1.wrapInStatement)(context.transformExpression(node.expression));
         if (statements)
             context.addPrecedingStatements(statements);
     }

package/dist/transpilation/diagnostics.js

@@ -17,7 +17,7 @@ exports.usingLuaBundleWithInlineMightGenerateDuplicateCode = (0, utils_1.createS
     messageText: "Using 'luaBundle' with 'luaLibImport: \"inline\"' might generate duplicate code. " +
         "It is recommended to use 'luaLibImport: \"require\"'.",
 }));
-exports.cannotBundleLibrary = createDiagnosticFactory(() => 'Cannot bundle probjects with"buildmode": "library". Projects including the library can still bundle (which will include external library files).');
+exports.cannotBundleLibrary = createDiagnosticFactory(() => 'Cannot bundle projects with "buildmode": "library". Projects including the library can still bundle (which will include external library files).');
 exports.unsupportedJsxEmit = createDiagnosticFactory(() => 'JSX is only supported with "react" jsx option.');
 exports.pathsWithoutBaseUrl = createDiagnosticFactory(() => "When configuring 'paths' in tsconfig.json, the option 'baseUrl' must also be provided.");
 //# sourceMappingURL=diagnostics.js.map

package/dist/transpilation/output-collector.d.ts

@@ -7,7 +7,7 @@ export interface TranspiledFile {
     declaration?: string;
     declarationMap?: string;
 }
-export declare function createEmitOutputCollector(): {
+export declare function createEmitOutputCollector(luaExtension?: string): {
     writeFile: ts.WriteFileCallback;
     files: TranspiledFile[];
 };

package/dist/transpilation/output-collector.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createEmitOutputCollector = void 0;
 const utils_1 = require("../utils");
-function createEmitOutputCollector() {
+function createEmitOutputCollector(luaExtension = ".lua") {
     const files = [];
     const writeFile = (fileName, data, _bom, _onError, sourceFiles = []) => {
         let file = files.find(f => (0, utils_1.intersection)(f.sourceFiles, sourceFiles).length > 0);
@@ -13,10 +13,10 @@ function createEmitOutputCollector() {
         else {
             file.sourceFiles = (0, utils_1.union)(file.sourceFiles, sourceFiles);
         }
-        if (fileName.endsWith(".lua")) {
+        if (fileName.endsWith(luaExtension)) {
             file.lua = data;
         }
-        else if (fileName.endsWith(".lua.map")) {
+        else if (fileName.endsWith(`${luaExtension}.map`)) {
             file.luaSourceMap = data;
         }
         else if (fileName.endsWith(".js")) {

package/dist/transpilation/resolve.js

@@ -15,6 +15,7 @@ const resolver = resolve.ResolverFactory.createResolver({
     enforceExtension: true,
     fileSystem: { ...new resolve.CachedInputFileSystem(fs) },
     useSyncFileSystemCalls: true,
+    conditionNames: ["require", "node", "tstl", "default"],
     symlinks: false, // Do not resolve symlinks to their original paths (that breaks node_modules detection)
 });
 class ResolutionContext {
@@ -40,8 +41,8 @@ class ResolutionContext {
                 // Remove @NoResolution prefix if not building in library mode
                 if (!isBuildModeLibrary(this.program)) {
                     const path = required.requirePath.replace("@NoResolution:", "");
-                    replaceRequireInCode(file, required, path);
-                    replaceRequireInSourceMap(file, required, path);
+                    replaceRequireInCode(file, required, path, this.options.extension);
+                    replaceRequireInSourceMap(file, required, path, this.options.extension);
                 }
                 // Skip
                 continue;
@@ -72,8 +73,8 @@ class ResolutionContext {
         // Figure out resolved require path and dependency output path
         if (shouldRewriteRequires(dependencyPath, this.program)) {
             const resolvedRequire = (0, transpiler_1.getEmitPathRelativeToOutDir)(dependencyPath, this.program);
-            replaceRequireInCode(file, required, resolvedRequire);
-            replaceRequireInSourceMap(file, required, resolvedRequire);
+            replaceRequireInCode(file, required, resolvedRequire, this.options.extension);
+            replaceRequireInSourceMap(file, required, resolvedRequire, this.options.extension);
         }
     }
     processDependency(dependencyPath) {
@@ -96,8 +97,8 @@ class ResolutionContext {
     }
     couldNotResolveImport(required, file) {
         const fallbackRequire = fallbackResolve(required, (0, transpiler_1.getSourceDir)(this.program), path.dirname(file.fileName));
-        replaceRequireInCode(file, required, fallbackRequire);
-        replaceRequireInSourceMap(file, required, fallbackRequire);
+        replaceRequireInCode(file, required, fallbackRequire, this.options.extension);
+        replaceRequireInSourceMap(file, required, fallbackRequire, this.options.extension);
         this.diagnostics.push((0, diagnostics_1.couldNotResolveRequire)(required.requirePath, path.relative((0, transpiler_1.getProjectRoot)(this.program), file.fileName)));
     }
     resolveDependencyPath(requiringFile, dependency) {
@@ -263,19 +264,27 @@ function shouldIncludeDependency(resolvedDependency, program) {
 function isBuildModeLibrary(program) {
     return program.getCompilerOptions().buildMode === CompilerOptions_1.BuildMode.Library;
 }
-function replaceRequireInCode(file, originalRequire, newRequire) {
-    const requirePath = (0, utils_1.formatPathToLuaPath)(newRequire.replace(".lua", ""));
+function replaceRequireInCode(file, originalRequire, newRequire, extension) {
+    const requirePath = requirePathForFile(newRequire, extension);
     file.code = file.code =
         file.code.substring(0, originalRequire.from) +
             `require("${requirePath}")` +
             file.code.substring(originalRequire.to + 1);
 }
-function replaceRequireInSourceMap(file, originalRequire, newRequire) {
-    const requirePath = (0, utils_1.formatPathToLuaPath)(newRequire.replace(".lua", ""));
+function replaceRequireInSourceMap(file, originalRequire, newRequire, extension) {
+    const requirePath = requirePathForFile(newRequire, extension);
     if (file.sourceMapNode) {
         replaceInSourceMap(file.sourceMapNode, file.sourceMapNode, `"${originalRequire.requirePath}"`, `"${requirePath}"`);
     }
 }
+function requirePathForFile(filePath, extension = ".lua") {
+    if (filePath.endsWith(extension)) {
+        return (0, utils_1.formatPathToLuaPath)(filePath.substring(0, filePath.length - extension.length));
+    }
+    else {
+        return (0, utils_1.formatPathToLuaPath)(filePath);
+    }
+}
 function replaceInSourceMap(node, parent, require, resolvedRequire) {
     if ((!node.children || node.children.length === 0) && node.toString() === require) {
         parent.children = [new source_map_1.SourceNode(node.line, node.column, node.source, [resolvedRequire])];

package/dist/transpilation/transpiler.d.ts

@@ -19,6 +19,7 @@ export declare class Transpiler {
     protected getEmitPlan(program: ts.Program, diagnostics: ts.Diagnostic[], files: ProcessedFile[]): {
         emitPlan: EmitFile[];
     };
+    private getLuaLibBundleContent;
 }
 export declare function getEmitPath(file: string, program: ts.Program): string;
 export declare function getEmitPathRelativeToOutDir(fileName: string, program: ts.Program): string;

package/dist/transpilation/transpiler.js

@@ -61,7 +61,6 @@ class Transpiler {
         return diagnostics;
     }
     getEmitPlan(program, diagnostics, files) {
-        var _a;
         performance.startSection("getEmitPlan");
         const options = program.getCompilerOptions();
         if (options.tstlVerbose) {
@@ -79,8 +78,8 @@ class Transpiler {
             }
             // Add lualib bundle to source dir 'virtually', will be moved to correct output dir in emitPlan
             const fileName = (0, utils_1.normalizeSlashes)(path.resolve(getSourceDir(program), "lualib_bundle.lua"));
-            const luaTarget = (_a = options.luaTarget) !== null && _a !== void 0 ? _a : CompilerOptions_1.LuaTarget.Universal;
-            resolutionResult.resolvedFiles.unshift({ fileName, code: (0, LuaLib_1.getLuaLibBundle)(luaTarget, this.emitHost) });
+            const code = this.getLuaLibBundleContent(options, resolutionResult.resolvedFiles);
+            resolutionResult.resolvedFiles.unshift({ fileName, code });
         }
         let emitPlan;
         if ((0, CompilerOptions_1.isBundleEnabled)(options)) {
@@ -97,6 +96,17 @@ class Transpiler {
         performance.endSection("getEmitPlan");
         return { emitPlan };
     }
+    getLuaLibBundleContent(options, resolvedFiles) {
+        var _a;
+        const luaTarget = (_a = options.luaTarget) !== null && _a !== void 0 ? _a : CompilerOptions_1.LuaTarget.Universal;
+        if (options.luaLibImport === CompilerOptions_1.LuaLibImportKind.RequireMinimal) {
+            const usedFeatures = (0, LuaLib_1.findUsedLualibFeatures)(luaTarget, this.emitHost, resolvedFiles.map(f => f.code));
+            return (0, LuaLib_1.buildMinimalLualibBundle)(usedFeatures, luaTarget, this.emitHost);
+        }
+        else {
+            return (0, LuaLib_1.getLuaLibBundle)(luaTarget, this.emitHost);
+        }
+    }
 }
 exports.Transpiler = Transpiler;
 function getEmitPath(file, program) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "typescript-to-lua",
-    "version": "1.12.0",
+    "version": "1.13.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/",