xray16 1.0.17 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xray16",
-  "version": "1.0.17",
+  "version": "1.1.0",
   "author": "Neloreck",
   "repository": "https://github.com/stalker-xrts/xray-16-types",
   "private": false,

package/plugins/{inject_filename.js → inject_file_meta.js}

@@ -4,6 +4,7 @@ const path = require("path");
 const typescript_1 = require("typescript");
 const typescript_to_lua_1 = require("typescript-to-lua");
 const FILENAME_IDENTIFIER = "$filename";
+const DIRNAME_IDENTIFIER = "$dirname";
 /**
  * Plugin that injects FILE_NAME in compile-time.
  */
@@ -13,6 +14,9 @@ const plugin = {
             if (node.text === FILENAME_IDENTIFIER) {
                 return (0, typescript_to_lua_1.createStringLiteral)(path.parse(context.sourceFile.fileName).name);
             }
+            if (node.text === DIRNAME_IDENTIFIER) {
+                return (0, typescript_to_lua_1.createStringLiteral)(path.basename(path.dirname(context.sourceFile.fileName)));
+            }
             return context.superTransformExpression(node);
         },
     },

package/plugins/inline.js

@@ -1,89 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const typescript_1 = require("typescript");
-const typescript_to_lua_1 = require("typescript-to-lua");
-const diagnostics_1 = require("./utils/diagnostics");
-const INLINE_MACROS = "$inline";
-const expectedFunctionExpressionInInline = (0, diagnostics_1.createErrorDiagnosticFactory)("Expected a function expression in '__inline'.");
-/**
- * Plugin for transformation of casting methods.
- * Simplifies TS/Lua testing and interoperation.
- *
- * Reference: https://gist.github.com/Cheatoid/ea4573c6bd1992fc4940090543ec9380
- */
-const plugin = {
-    visitors: {
-        [typescript_1.SyntaxKind.ExpressionStatement]: (node, context) => {
-            const result = context.superTransformStatements(node);
-            if ((0, typescript_1.isExpressionStatement)(node)) {
-                const expr = node.expression;
-                if ((0, typescript_1.isCallExpression)(expr) && (0, typescript_1.isIdentifier)(expr.expression)) {
-                    switch (expr.expression.text) {
-                        case INLINE_MACROS: {
-                            if (expr.arguments.length > 0) {
-                                let bodyArg = expr.arguments[0];
-                                if ((0, typescript_1.isIdentifier)(bodyArg)) {
-                                    try {
-                                        bodyArg = context.checker.getSymbolAtLocation(bodyArg).getDeclarations()[0];
-                                    }
-                                    catch (error) {
-                                        context.diagnostics.push(expectedFunctionExpressionInInline(node));
-                                        break;
-                                    }
-                                    if (!bodyArg) {
-                                        context.diagnostics.push(expectedFunctionExpressionInInline(node));
-                                        break;
-                                    }
-                                }
-                                const paramNames = [];
-                                let funcExpr;
-                                if ((0, typescript_1.isFunctionLike)(bodyArg)) {
-                                    const bodyNode = context.transformNode(bodyArg)[0];
-                                    if (!bodyNode) {
-                                        context.diagnostics.push(expectedFunctionExpressionInInline(node));
-                                        break;
-                                    }
-                                    if ((0, typescript_to_lua_1.isVariableDeclarationStatement)(bodyNode) && bodyNode.right) {
-                                        if ((0, typescript_to_lua_1.isFunctionExpression)(bodyNode.right[0])) {
-                                            funcExpr = bodyNode.right[0];
-                                        }
-                                    }
-                                    paramNames.push(...bodyArg.parameters.map((p) => p.name.getText()));
-                                }
-                                for (const stmt of result) {
-                                    if ((0, typescript_to_lua_1.isExpressionStatement)(stmt)) {
-                                        const callExpr = stmt.expression;
-                                        if ((0, typescript_to_lua_1.isCallExpression)(callExpr) &&
-                                            (0, typescript_to_lua_1.isIdentifier)(callExpr.expression) &&
-                                            callExpr.expression.text === expr.expression.text) {
-                                            const paramCount = callExpr.params.length;
-                                            if (paramCount > 0) {
-                                                let body = callExpr.params[0];
-                                                if ((0, typescript_to_lua_1.isIdentifier)(body)) {
-                                                    body = funcExpr;
-                                                }
-                                                if (body && (0, typescript_to_lua_1.isFunctionExpression)(body)) {
-                                                    const statements = body.body.statements;
-                                                    for (let index = 1; index < paramCount; ++index) {
-                                                        // Skip the body parameter.
-                                                        const param = callExpr.params[index];
-                                                        statements.unshift((0, typescript_to_lua_1.createVariableDeclarationStatement)([(0, typescript_to_lua_1.createIdentifier)(paramNames[index - 1])], [param]));
-                                                    }
-                                                    return (0, typescript_to_lua_1.createDoStatement)(statements, node);
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                            context.diagnostics.push(expectedFunctionExpressionInInline(node));
-                            break;
-                        }
-                    }
-                }
-            }
-            return result;
-        },
-    },
-};
-exports.default = plugin;

package/plugins/plugins/built_at_info.js

@@ -1,12 +0,0 @@
-const comment = `-- Generated by xrf util at: ${new Date().toString()}\n\n`;
-const plugin = {
-    beforeEmit(program, options, emitHost, result) {
-        void program;
-        void options;
-        void emitHost;
-        for (const file of result) {
-            file.code = comment + file.code;
-        }
-    },
-};
-export default plugin;

package/plugins/plugins/from_cast_utils.js

@@ -1,27 +0,0 @@
-import { isIdentifier, SyntaxKind } from "typescript";
-import { createErrorDiagnosticFactory } from "./utils/diagnostics";
-const FROM_CAST_METHODS = ["$fromObject", "$fromArray", "$fromLuaArray", "$fromLuaTable"];
-/**
- * Push generic error to notify about usage issue.
- */
-const createInvalidFunctionCallError = createErrorDiagnosticFactory((name) => {
-    return `Invalid transformer call, expected function to have exactly 1 argument.`;
-});
-/**
- * Plugin for transformation of casting methods.
- * Simplifies TS/Lua testing and interoperation.
- */
-const plugin = {
-    visitors: {
-        [SyntaxKind.CallExpression]: (node, context) => {
-            if (isIdentifier(node.expression) && FROM_CAST_METHODS.includes(node.expression.text)) {
-                if (node.arguments.length !== 1) {
-                    context.diagnostics.push(createInvalidFunctionCallError(node));
-                }
-                return context.transformExpression(node.arguments[0]);
-            }
-            return context.superTransformExpression(node);
-        },
-    },
-};
-export default plugin;

package/plugins/plugins/global_declarations_transform.js

@@ -1,18 +0,0 @@
-import { SyntaxKind } from "typescript";
-const XRF_GLOBALS = ["xray16"];
-/**
- * Plugin that removes imports from 'global' libraries like engine typedefs.
- */
-const plugin = {
-    visitors: {
-        [SyntaxKind.ImportDeclaration]: (node, context) => {
-            const module = node.moduleSpecifier.getText().slice(1, -1);
-            const shouldNotBeTransformed = XRF_GLOBALS.includes(module);
-            if (shouldNotBeTransformed) {
-                return undefined;
-            }
-            return context.superTransformStatements(node);
-        },
-    },
-};
-export default plugin;

package/plugins/plugins/inject_filename.js

@@ -1,18 +0,0 @@
-import * as path from "path";
-import { SyntaxKind } from "typescript";
-import { createStringLiteral } from "typescript-to-lua";
-const FILENAME_IDENTIFIER = "$filename";
-/**
- * Plugin that injects FILE_NAME in compile-time.
- */
-const plugin = {
-    visitors: {
-        [SyntaxKind.Identifier]: (node, context) => {
-            if (node.text === FILENAME_IDENTIFIER) {
-                return createStringLiteral(path.parse(context.sourceFile.fileName).name);
-            }
-            return context.superTransformExpression(node);
-        },
-    },
-};
-export default plugin;

package/plugins/plugins/strip_lua_logger.js

@@ -1,51 +0,0 @@
-import { factory, SyntaxKind, } from "typescript";
-const LUA_LOGGER_STRIP_TARGET = "LuaLogger";
-const IS_LUA_LOGGER_DISABLED = process.argv.includes("--no-lua-logs");
-/**
- * Plugin that removes all LuaLogger instance creations and calls when possible.
- */
-const plugin = {
-    visitors: {
-        [SyntaxKind.VariableStatement]: (statement, context) => {
-            if (IS_LUA_LOGGER_DISABLED) {
-                let elementsCount = 0;
-                const list = statement.declarationList;
-                const nodes = [];
-                list.forEachChild((it) => {
-                    const checker = context.program.getTypeChecker();
-                    const typeSymbol = checker.getTypeAtLocation(it);
-                    if (typeSymbol.symbol?.name === LUA_LOGGER_STRIP_TARGET) {
-                        // nothing
-                    }
-                    else {
-                        nodes.push(it);
-                    }
-                    elementsCount += 1;
-                });
-                if (nodes.length === 0) {
-                    return undefined;
-                }
-                else if (nodes.length !== elementsCount) {
-                    return context.superTransformStatements(factory.createVariableStatement(statement.modifiers, factory.updateVariableDeclarationList(list, nodes)));
-                }
-            }
-            return context.superTransformStatements(statement);
-        },
-        [SyntaxKind.ExpressionStatement]: (statement, context) => {
-            if (IS_LUA_LOGGER_DISABLED && statement.expression?.kind === SyntaxKind.CallExpression) {
-                const expression = statement.expression;
-                const propertyAccess = expression.expression;
-                if (propertyAccess.expression?.kind === SyntaxKind.Identifier) {
-                    const checker = context.program.getTypeChecker();
-                    const identifier = propertyAccess.expression;
-                    const typeSymbol = checker.getTypeAtLocation(identifier);
-                    if (typeSymbol.symbol?.name === LUA_LOGGER_STRIP_TARGET) {
-                        return undefined;
-                    }
-                }
-            }
-            return context.superTransformStatements(statement);
-        },
-    },
-};
-export default plugin;

package/plugins/plugins/transform_luabind_class/plugin.js

@@ -1,34 +0,0 @@
-import { SyntaxKind } from "typescript";
-import { isLuabindClassSuperCall, isLuabindClassSuperMethodCall, isLuabindClassType, isLuabindDecoratedClass, transformClassSuperMethodExpression, transformLuabindClassDeclaration, transformLuabindConstructorSuperCall, transformNewCallExpression, } from "./transformation";
-/**
- * Plugin that transform TS classes marked with decorator to luabind class declaration.
- */
-const plugin = {
-    visitors: {
-        [SyntaxKind.CallExpression]: (expression, context) => {
-            if (isLuabindClassSuperCall(expression, context)) {
-                return transformLuabindConstructorSuperCall(expression, context);
-            }
-            return context.superTransformExpression(expression);
-        },
-        [SyntaxKind.ClassDeclaration]: (declaration, context) => {
-            if (isLuabindDecoratedClass(declaration)) {
-                return transformLuabindClassDeclaration(declaration, context);
-            }
-            return context.superTransformStatements(declaration);
-        },
-        [SyntaxKind.NewExpression]: (expression, context) => {
-            if (isLuabindClassType(expression, context)) {
-                return transformNewCallExpression(expression, context);
-            }
-            return context.superTransformExpression(expression);
-        },
-        [SyntaxKind.SuperKeyword]: (expression, context) => {
-            if (isLuabindClassSuperMethodCall(expression, context)) {
-                return transformClassSuperMethodExpression(expression, context);
-            }
-            return context.superTransformExpression(expression);
-        },
-    },
-};
-export default plugin;

package/plugins/plugins/transform_luabind_class/transformation/class_declaration.js

@@ -1,141 +0,0 @@
-import { canHaveDecorators, factory, getDecorators, isAccessor, isConstructorDeclaration, isMethodDeclaration, isPropertyDeclaration, } from "typescript";
-import * as tstl from "typescript-to-lua";
-import { LuaTarget } from "typescript-to-lua";
-import { createDefaultExportExpression, createExportedIdentifier, hasDefaultExportModifier, hasExportModifier, } from "typescript-to-lua/dist/transformation/utils/export";
-import { createSelfIdentifier } from "typescript-to-lua/dist/transformation/utils/lua-ast";
-import { transformInPrecedingStatementScope } from "typescript-to-lua/dist/transformation/utils/preceding-statements";
-import { createSafeName, isUnsafeName } from "typescript-to-lua/dist/transformation/utils/safe-names";
-import { transformIdentifier } from "typescript-to-lua/dist/transformation/visitors/identifier";
-import { LUABIND_CONSTRUCTOR_METHOD } from "./constants";
-import { checkLuabindClassDecoratorExpression } from "./decorators";
-import { unsupportedStaticMethod } from "./errors";
-import { transformAccessorDeclarations } from "./members/accessors";
-import { createConstructorName, transformConstructorDeclaration } from "./members/constructor";
-import { transformClassInstanceFields, verifyPropertyDecoratingExpression } from "./members/fields";
-import { transformMethodDeclaration, verifyMethodDecoratingExpression } from "./members/method";
-import { createClassSetup } from "./setup";
-import { getExtendedNode, getExtendedType, isStaticNode, markTypeAsLuabind } from "./utils";
-export const transformLuabindClassDeclaration = (declaration, context) => {
-    // If declaration is a default export, transform to export variable assignment instead
-    if (hasDefaultExportModifier(declaration)) {
-        // Class declaration including assignment to ____exports.default are in preceding statements
-        const { precedingStatements } = transformInPrecedingStatementScope(context, () => {
-            transformClassAsExpression(declaration, context);
-            return [];
-        });
-        return precedingStatements;
-    }
-    const { statements } = transformClassLikeDeclaration(declaration, context);
-    return statements;
-};
-export function transformClassAsExpression(expression, context) {
-    const { statements, name } = transformClassLikeDeclaration(expression, context);
-    context.addPrecedingStatements(statements);
-    return name;
-}
-export function transformClassLikeDeclaration(classDeclaration, context, nameOverride) {
-    let className;
-    if (nameOverride !== undefined) {
-        className = nameOverride;
-    }
-    else if (classDeclaration.name !== undefined) {
-        className = transformIdentifier(context, classDeclaration.name);
-    }
-    else {
-        className = tstl.createIdentifier(context.createTempName("class"), classDeclaration);
-    }
-    markTypeAsLuabind(classDeclaration, context);
-    // Get type that is extended
-    const extendedTypeNode = getExtendedNode(classDeclaration);
-    const extendedType = getExtendedType(context, classDeclaration);
-    context.classSuperInfos.push({ className, classDeclaration: classDeclaration, extendedTypeNode });
-    // Get all properties with value
-    const properties = classDeclaration.members.filter(isPropertyDeclaration).filter((member) => member.initializer);
-    // Divide properties into static and non-static
-    const instanceFields = properties.filter((prop) => !isStaticNode(prop));
-    const result = [];
-    let localClassName;
-    if (isUnsafeName(className.text, context.options)) {
-        localClassName = tstl.createIdentifier(createSafeName(className.text), undefined, className.symbolId, className.text);
-        tstl.setNodePosition(localClassName, className);
-    }
-    else {
-        localClassName = className;
-    }
-    result.push(...createClassSetup(context, classDeclaration, className, localClassName));
-    // Find first constructor with body
-    const constructor = classDeclaration.members.find((n) => isConstructorDeclaration(n) && n.body !== undefined);
-    if (constructor) {
-        // Add constructor plus initialization of instance fields
-        const constructorResult = transformConstructorDeclaration(context, constructor, localClassName, instanceFields, classDeclaration);
-        if (constructorResult)
-            result.push(constructorResult);
-    }
-    else if (!extendedType) {
-        // Generate a constructor if none was defined in a base class
-        const constructorResult = transformConstructorDeclaration(context, factory.createConstructorDeclaration([], [], factory.createBlock([], true)), localClassName, instanceFields, classDeclaration);
-        if (constructorResult)
-            result.push(constructorResult);
-    }
-    else {
-        // Generate a constructor if none was defined in a class with instance fields that need initialization
-        // localClassName.__init = function(self, ...)
-        //     baseClassName.__init(self, ...)  // or unpack(arg) for Lua 5.0
-        //     ...
-        // Also luabind always needs definition of call expression to use table as class.
-        const constructorBody = transformClassInstanceFields(context, instanceFields);
-        const argsExpression = context.luaTarget === LuaTarget.Lua50
-            ? tstl.createCallExpression(tstl.createIdentifier("unpack"), [tstl.createArgLiteral()])
-            : tstl.createDotsLiteral();
-        const superCall = tstl.createExpressionStatement(tstl.createCallExpression(tstl.createTableIndexExpression(context.transformExpression(factory.createSuper()), tstl.createStringLiteral(LUABIND_CONSTRUCTOR_METHOD)), [createSelfIdentifier(), argsExpression]));
-        constructorBody.unshift(superCall);
-        const constructorFunction = tstl.createFunctionExpression(tstl.createBlock(constructorBody), [createSelfIdentifier()], tstl.createDotsLiteral(), tstl.NodeFlags.Declaration);
-        result.push(tstl.createAssignmentStatement(createConstructorName(localClassName), constructorFunction, classDeclaration));
-    }
-    // Transform accessors
-    for (const member of classDeclaration.members) {
-        if (!isAccessor(member))
-            continue;
-        const accessors = context.resolver.getAllAccessorDeclarations(member);
-        if (accessors.firstAccessor !== member)
-            continue;
-        const accessorsResult = transformAccessorDeclarations(context, accessors, localClassName);
-        if (accessorsResult) {
-            result.push(accessorsResult);
-        }
-    }
-    const decorationStatements = [];
-    for (const member of classDeclaration.members) {
-        if (isAccessor(member)) {
-            verifyPropertyDecoratingExpression(context, member);
-        }
-        else if (isMethodDeclaration(member)) {
-            const statement = transformMethodDeclaration(context, member, localClassName);
-            if (statement)
-                result.push(statement);
-            if (member.body) {
-                verifyMethodDecoratingExpression(context, member);
-            }
-        }
-        else if (isPropertyDeclaration(member)) {
-            if (isStaticNode(member)) {
-                context.diagnostics.push(unsupportedStaticMethod(member));
-            }
-            verifyPropertyDecoratingExpression(context, member);
-        }
-    }
-    result.push(...decorationStatements);
-    // Decorate the class
-    if (canHaveDecorators(classDeclaration) && getDecorators(classDeclaration)) {
-        getDecorators(classDeclaration)?.forEach((d) => checkLuabindClassDecoratorExpression(context, d));
-        if (hasExportModifier(classDeclaration)) {
-            const exportExpression = hasDefaultExportModifier(classDeclaration)
-                ? createDefaultExportExpression(classDeclaration)
-                : createExportedIdentifier(context, className);
-            const classAssignment = tstl.createAssignmentStatement(exportExpression, localClassName);
-            result.push(classAssignment);
-        }
-    }
-    context.classSuperInfos.pop();
-    return { statements: result, name: className };
-}

package/plugins/plugins/transform_luabind_class/transformation/constants.js

@@ -1,4 +0,0 @@
-export const LUABIND_NAME_FIELD = "__name";
-export const LUABIND_DECORATOR = "LuabindClass";
-export const LUABIND_CONSTRUCTOR_METHOD = "__init";
-export const LUABIND_SYMBOL = Symbol("IS_LUABIND_CLASS");

package/plugins/plugins/transform_luabind_class/transformation/decorators.js

@@ -1,12 +0,0 @@
-import { LUABIND_DECORATOR } from "./constants";
-import { unsupportedClassDecorator } from "./errors";
-/**
- * Transform decorator call expressions for luabind class.
- */
-export function checkLuabindClassDecoratorExpression(context, decorator) {
-    const expression = decorator.expression;
-    // Do not transform luabind decorator.
-    if (expression.expression.text !== LUABIND_DECORATOR) {
-        context.diagnostics.push(unsupportedClassDecorator(expression));
-    }
-}

package/plugins/plugins/transform_luabind_class/transformation/errors.js

@@ -1,25 +0,0 @@
-import { createErrorDiagnosticFactory } from "../../utils/diagnostics";
-export const unsupportedStaticMethod = createErrorDiagnosticFactory((name) => {
-    const nameReference = name ? ` '${name}'` : "";
-    return `Unable transform static properties for luabind classes${nameReference}.`;
-});
-export const unsupportedClassDecorator = createErrorDiagnosticFactory((name) => {
-    const nameReference = name ? ` '${name}'` : "";
-    return `Unable transform class decorators for luabind classes${nameReference}.`;
-});
-export const unsupportedPropertyDecorator = createErrorDiagnosticFactory((name) => {
-    const nameReference = name ? ` '${name}'` : "";
-    return `Unable transform property decorator for luabind classes${nameReference}.`;
-});
-export const unsupportedParameterDecorator = createErrorDiagnosticFactory((name) => {
-    const nameReference = name ? ` '${name}'` : "";
-    return `Unable transform parameter decorator for luabind classes${nameReference}.`;
-});
-export const unsupportedMethodDecorator = createErrorDiagnosticFactory((name) => {
-    const nameReference = name ? ` '${name}'` : "";
-    return `Unable transform method decorator for luabind classes${nameReference}.`;
-});
-export const unsupportedStaticAccessor = createErrorDiagnosticFactory((name) => {
-    const nameReference = name ? ` '${name}'` : "";
-    return `Unable transform static accessors for luabind classes${nameReference}.`;
-});

package/plugins/plugins/transform_luabind_class/transformation/index.js

@@ -1,5 +0,0 @@
-export * from "./constants";
-export * from "./utils";
-export * from "./class_declaration";
-export * from "./super";
-export * from "./new";

package/plugins/plugins/transform_luabind_class/transformation/members/accessors.js

@@ -1,35 +0,0 @@
-import { LuaLibFeature } from "typescript-to-lua";
-import * as lua from "typescript-to-lua";
-import { createSelfIdentifier } from "typescript-to-lua/dist/transformation/utils/lua-ast";
-import { transformLuaLibFunction } from "typescript-to-lua/dist/transformation/utils/lualib";
-import { transformFunctionBody, transformParameters } from "typescript-to-lua/dist/transformation/visitors/function";
-import { transformPropertyName } from "typescript-to-lua/dist/transformation/visitors/literal";
-import { unsupportedStaticAccessor } from "../errors";
-import { isStaticNode } from "../utils";
-function transformAccessor(context, node) {
-    const [params, dot, restParam] = transformParameters(context, node.parameters, createSelfIdentifier());
-    const body = node.body ? transformFunctionBody(context, node.parameters, node.body, restParam)[0] : [];
-    return lua.createFunctionExpression(lua.createBlock(body), params, dot, lua.NodeFlags.Declaration);
-}
-export function transformAccessorDeclarations(context, { firstAccessor, getAccessor, setAccessor }, className) {
-    const propertyName = transformPropertyName(context, firstAccessor.name);
-    const descriptor = lua.createTableExpression([]);
-    if (getAccessor) {
-        const getterFunction = transformAccessor(context, getAccessor);
-        descriptor.fields.push(lua.createTableFieldExpression(getterFunction, lua.createStringLiteral("get")));
-    }
-    if (setAccessor) {
-        const setterFunction = transformAccessor(context, setAccessor);
-        descriptor.fields.push(lua.createTableFieldExpression(setterFunction, lua.createStringLiteral("set")));
-    }
-    const isStatic = isStaticNode(firstAccessor);
-    if (isStatic) {
-        context.diagnostics.push(unsupportedStaticAccessor(firstAccessor));
-        return;
-    }
-    const target = lua.cloneIdentifier(className);
-    const feature = LuaLibFeature.ObjectDefineProperty;
-    const parameters = [target, propertyName, descriptor];
-    const call = transformLuaLibFunction(context, feature, undefined, ...parameters);
-    return lua.createExpressionStatement(call);
-}

package/plugins/plugins/transform_luabind_class/transformation/members/constructor.js

@@ -1,56 +0,0 @@
-import { isCallExpression, isExpressionStatement, isIdentifier, SyntaxKind, } from "typescript";
-import * as lua from "typescript-to-lua";
-import { createSelfIdentifier } from "typescript-to-lua/dist/transformation/utils/lua-ast";
-import { ScopeType } from "typescript-to-lua/dist/transformation/utils/scope";
-import { transformFunctionBodyContent, transformFunctionBodyHeader, transformParameters, } from "typescript-to-lua/dist/transformation/visitors/function";
-import { transformIdentifier } from "typescript-to-lua/dist/transformation/visitors/identifier";
-import { LUABIND_CONSTRUCTOR_METHOD } from "../constants";
-import { transformClassInstanceFields } from "./fields";
-export function createConstructorName(className) {
-    return lua.createTableIndexExpression(lua.cloneIdentifier(className), lua.createStringLiteral(LUABIND_CONSTRUCTOR_METHOD));
-}
-export function transformConstructorDeclaration(context, statement, className, instanceFields, classDeclaration) {
-    // Don't transform methods without body (overload declarations)
-    if (!statement.body) {
-        return undefined;
-    }
-    // Transform body
-    const scope = context.pushScope(ScopeType.Function);
-    const body = transformFunctionBodyContent(context, statement.body);
-    const [params, dotsLiteral, restParamName] = transformParameters(context, statement.parameters, createSelfIdentifier());
-    // Make sure default parameters are assigned before fields are initialized
-    const bodyWithFieldInitializers = transformFunctionBodyHeader(context, scope, statement.parameters, restParamName);
-    // Check for field declarations in constructor
-    const constructorFieldsDeclarations = statement.parameters.filter((p) => p.modifiers !== undefined);
-    const classInstanceFields = transformClassInstanceFields(context, instanceFields);
-    // If there are field initializers and the first statement is a super call,
-    // move super call between default assignments and initializers
-    if ((constructorFieldsDeclarations.length > 0 || classInstanceFields.length > 0) &&
-        statement.body &&
-        statement.body.statements.length > 0) {
-        const firstStatement = statement.body.statements[0];
-        if (isExpressionStatement(firstStatement) &&
-            isCallExpression(firstStatement.expression) &&
-            firstStatement.expression.expression.kind === SyntaxKind.SuperKeyword) {
-            const superCall = body.shift();
-            if (superCall) {
-                bodyWithFieldInitializers.push(superCall);
-            }
-        }
-    }
-    // Add in instance field declarations
-    for (const declaration of constructorFieldsDeclarations) {
-        if (isIdentifier(declaration.name)) {
-            // self.declarationName = declarationName
-            const assignment = lua.createAssignmentStatement(lua.createTableIndexExpression(createSelfIdentifier(), lua.createStringLiteral(declaration.name.text)), transformIdentifier(context, declaration.name));
-            bodyWithFieldInitializers.push(assignment);
-        }
-        // else { TypeScript error: A parameter property may not be declared using a binding pattern }
-    }
-    bodyWithFieldInitializers.push(...classInstanceFields);
-    bodyWithFieldInitializers.push(...body);
-    const block = lua.createBlock(bodyWithFieldInitializers);
-    const constructorWasGenerated = statement.pos === -1;
-    context.popScope();
-    return lua.createAssignmentStatement(createConstructorName(className), lua.createFunctionExpression(block, params, dotsLiteral, lua.NodeFlags.Declaration), constructorWasGenerated ? classDeclaration : statement);
-}

package/plugins/plugins/transform_luabind_class/transformation/members/fields.js

@@ -1,36 +0,0 @@
-import { canHaveDecorators, getDecorators } from "typescript";
-import * as tstl from "typescript-to-lua";
-import { createSelfIdentifier } from "typescript-to-lua/dist/transformation/utils/lua-ast";
-import { transformInPrecedingStatementScope } from "typescript-to-lua/dist/transformation/utils/preceding-statements";
-import { transformPropertyName } from "typescript-to-lua/dist/transformation/visitors/literal";
-import { unsupportedPropertyDecorator } from "../errors";
-/**
- * Verify whether decorators provided for luabind class.
- */
-export function verifyPropertyDecoratingExpression(context, node) {
-    if (!canHaveDecorators(node))
-        return;
-    const decorators = getDecorators(node);
-    if (!decorators)
-        return;
-    decorators.forEach((decorator) => {
-        context.diagnostics.push(unsupportedPropertyDecorator(decorator));
-    });
-}
-export function transformClassInstanceFields(context, instanceFields) {
-    const statements = [];
-    for (const f of instanceFields) {
-        const { precedingStatements, result: statement } = transformInPrecedingStatementScope(context, () => {
-            // Get identifier
-            const fieldName = transformPropertyName(context, f.name);
-            const value = f.initializer ? context.transformExpression(f.initializer) : undefined;
-            // self[fieldName]
-            const selfIndex = tstl.createTableIndexExpression(createSelfIdentifier(), fieldName);
-            // self[fieldName] = value
-            const assignClassField = tstl.createAssignmentStatement(selfIndex, value, f);
-            return assignClassField;
-        });
-        statements.push(...precedingStatements, statement);
-    }
-    return statements;
-}

package/plugins/plugins/transform_luabind_class/transformation/members/method.js

@@ -1,49 +0,0 @@
-import { getDecorators } from "typescript";
-import * as lua from "typescript-to-lua";
-import { transformFunctionToExpression } from "typescript-to-lua/dist/transformation/visitors/function";
-import { transformPropertyName } from "typescript-to-lua/dist/transformation/visitors/literal";
-import { unsupportedMethodDecorator, unsupportedParameterDecorator, unsupportedStaticMethod } from "../errors";
-import { isStaticNode } from "../utils";
-export function transformMemberExpressionOwnerName(node, className) {
-    return lua.cloneIdentifier(className);
-}
-export function transformMethodName(context, node) {
-    const methodName = transformPropertyName(context, node.name);
-    if (lua.isStringLiteral(methodName) && methodName.value === "toString") {
-        return lua.createStringLiteral("__tostring", node.name);
-    }
-    return methodName;
-}
-export function transformMethodDeclaration(context, node, className) {
-    // Don't transform methods without body (overload declarations)
-    if (!node.body)
-        return;
-    // Don't transform static methods for luabind classes.
-    if (isStaticNode(node)) {
-        context.diagnostics.push(unsupportedStaticMethod(node));
-        return;
-    }
-    const methodTable = transformMemberExpressionOwnerName(node, className);
-    const methodName = transformMethodName(context, node);
-    const [functionExpression] = transformFunctionToExpression(context, node);
-    return lua.createAssignmentStatement(lua.createTableIndexExpression(methodTable, methodName), functionExpression, node);
-}
-/**
- * Verify that method statement is not using decorators for methods/parameters.
- */
-export function verifyMethodDecoratingExpression(context, node) {
-    node.parameters.flatMap((parameter, index) => {
-        const decorators = getDecorators(parameter);
-        if (decorators?.length) {
-            decorators.forEach((decorator) => {
-                context.diagnostics.push(unsupportedParameterDecorator(decorator));
-            });
-        }
-    });
-    const decorators = getDecorators(node);
-    if (decorators?.length) {
-        decorators.forEach((decorator) => {
-            context.diagnostics.push(unsupportedMethodDecorator(decorator));
-        });
-    }
-}

package/plugins/plugins/transform_luabind_class/transformation/new.js

@@ -1,8 +0,0 @@
-import * as tstl from "typescript-to-lua";
-import { transformArguments } from "typescript-to-lua/dist/transformation/visitors/call";
-/**
- * Transform new call for luabind class as ClassConstructor() instead of TS_NEW from tstl.
- */
-export function transformNewCallExpression(expression, context) {
-    return tstl.createCallExpression(context.transformExpression(expression.expression), transformArguments(context, expression.arguments ?? []));
-}

package/plugins/plugins/transform_luabind_class/transformation/setup.js

@@ -1,76 +0,0 @@
-import { isIdentifier, isVariableDeclaration } from "typescript";
-import * as tstl from "typescript-to-lua";
-import { createDefaultExportStringLiteral, createExportedIdentifier, getIdentifierExportScope, hasDefaultExportModifier, } from "typescript-to-lua/dist/transformation/utils/export";
-import { createExportsIdentifier, createLocalOrExportedOrGlobalDeclaration, } from "typescript-to-lua/dist/transformation/utils/lua-ast";
-import { LUABIND_NAME_FIELD } from "./constants";
-import { getExtendedNode } from "./utils";
-/**
- * Create full class setup statement with name/super calls/methods/declaration/fields etc.
- */
-export function createClassSetup(context, statement, className, localClassName) {
-    const result = [];
-    // class("name")(base)
-    const classInitializer = createLuabindClassStatement(statement, context, localClassName);
-    result.push(tstl.createExpressionStatement(classInitializer));
-    const classReference = createLuabindClassGlobalClassRef(statement, context, localClassName);
-    const defaultExportLeftHandSide = hasDefaultExportModifier(statement)
-        ? tstl.createTableIndexExpression(createExportsIdentifier(), createDefaultExportStringLiteral(statement))
-        : undefined;
-    // [____exports.]className = class()
-    if (defaultExportLeftHandSide) {
-        result.push(tstl.createAssignmentStatement(defaultExportLeftHandSide, classReference, statement));
-    }
-    else {
-        result.push(...createLocalOrExportedOrGlobalDeclaration(context, className, classReference, statement));
-    }
-    if (defaultExportLeftHandSide) {
-        // local localClassName = ____exports.default
-        result.push(tstl.createVariableDeclarationStatement(localClassName, defaultExportLeftHandSide));
-    }
-    else {
-        const exportScope = getIdentifierExportScope(context, className);
-        if (exportScope) {
-            // local localClassName = ____exports.className
-            result.push(tstl.createVariableDeclarationStatement(localClassName, createExportedIdentifier(context, tstl.cloneIdentifier(className), exportScope)));
-        }
-    }
-    // localClassName.__name = className
-    result.push(tstl.createAssignmentStatement(tstl.createTableIndexExpression(tstl.cloneIdentifier(localClassName), tstl.createStringLiteral(LUABIND_NAME_FIELD)), getReflectionClassName(statement, className), statement));
-    return result;
-}
-export function getReflectionClassName(declaration, className) {
-    if (declaration.name) {
-        return tstl.createStringLiteral(declaration.name.text);
-    }
-    else if (isVariableDeclaration(declaration.parent) && isIdentifier(declaration.parent.name)) {
-        return tstl.createStringLiteral(declaration.parent.name.text);
-    }
-    else if (hasDefaultExportModifier(declaration)) {
-        return tstl.createStringLiteral("default");
-    }
-    if (getExtendedNode(declaration)) {
-        return tstl.createTableIndexExpression(className, tstl.createStringLiteral("name"));
-    }
-    return tstl.createStringLiteral("");
-}
-/**
- * Creates class("Name")(base) expression for luabind classes.
- */
-function createLuabindClassStatement(declaration, context, className) {
-    const extendedNode = getExtendedNode(declaration);
-    let classDeclaration = tstl.createCallExpression(tstl.createIdentifier("class"), [
-        getReflectionClassName(declaration, className),
-    ]);
-    if (extendedNode) {
-        classDeclaration = tstl.createCallExpression(classDeclaration, [
-            context.transformExpression(extendedNode.expression),
-        ]);
-    }
-    return classDeclaration;
-}
-/**
- * Creates name expression for luabind classes.
- */
-function createLuabindClassGlobalClassRef(declaration, context, className) {
-    return className;
-}

package/plugins/plugins/transform_luabind_class/transformation/super.js

@@ -1,65 +0,0 @@
-import { factory, isIdentifier, SyntaxKind } from "typescript";
-import * as tstl from "typescript-to-lua";
-import { isSymbolExported } from "typescript-to-lua/dist/transformation/utils/export";
-import { getCalledExpression, transformArguments } from "typescript-to-lua/dist/transformation/visitors/call";
-import { transformIdentifier } from "typescript-to-lua/dist/transformation/visitors/identifier";
-import { LUABIND_CONSTRUCTOR_METHOD } from "./constants";
-import { isLuabindClassType } from "./utils";
-/**
- * Transform generic methods super calls.
- * Example: super.parentMethod(first, second).
- */
-export function transformClassSuperMethodExpression(expression, context) {
-    const superInfos = context.classSuperInfos;
-    const superInfo = superInfos[superInfos.length - 1];
-    if (!superInfo.classDeclaration || !isLuabindClassType(superInfo.classDeclaration, context)) {
-        return context.superTransformExpression(expression);
-    }
-    const { extendedTypeNode } = superInfo;
-    // Using `super` without extended type node is a TypeScript error
-    const extendsExpression = extendedTypeNode?.expression;
-    let baseClassName;
-    if (extendsExpression && isIdentifier(extendsExpression)) {
-        const symbol = context.checker.getSymbolAtLocation(extendsExpression);
-        if (symbol && !isSymbolExported(context, symbol)) {
-            // Use "baseClassName" if base is a simple identifier
-            baseClassName = transformIdentifier(context, extendsExpression);
-        }
-    }
-    if (!baseClassName) {
-        throw new Error("Super without identifier - not supported with luabind.");
-    }
-    return baseClassName;
-}
-/**
- * Check if super() call is in luabind class target.
- */
-export function isLuabindClassSuperCall(expression, context) {
-    const calledExpression = getCalledExpression(expression);
-    if (calledExpression.kind !== SyntaxKind.SuperKeyword) {
-        return false;
-    }
-    else {
-        const superInfos = context.classSuperInfos;
-        const superInfo = superInfos[superInfos.length - 1];
-        // Handle super calls properly for luabind classes.
-        return superInfo?.classDeclaration ? isLuabindClassType(superInfo.classDeclaration, context) : false;
-    }
-}
-/**
- * Check if super.method() call is in luabind class target.
- */
-export function isLuabindClassSuperMethodCall(expression, context) {
-    const superInfos = context.classSuperInfos;
-    const superInfo = superInfos[superInfos.length - 1];
-    // Handle super calls properly for luabind classes.
-    return superInfo?.classDeclaration ? isLuabindClassType(superInfo.classDeclaration, context) : false;
-}
-/**
- * Transform super() call in luabind classes to base_class.__init(self, param).
- */
-export function transformLuabindConstructorSuperCall(expression, context) {
-    const signature = context.checker.getResolvedSignature(expression);
-    const parameters = transformArguments(context, expression.arguments, signature, factory.createThis());
-    return tstl.createCallExpression(tstl.createTableIndexExpression(context.transformExpression(factory.createSuper()), tstl.createStringLiteral(LUABIND_CONSTRUCTOR_METHOD)), parameters, expression);
-}

package/plugins/plugins/transform_luabind_class/transformation/utils.js

@@ -1,67 +0,0 @@
-import { getDecorators, SyntaxKind, } from "typescript";
-import { LUABIND_DECORATOR, LUABIND_SYMBOL } from "./constants";
-/**
- * Whether method / field is static.
- */
-export function isStaticNode(node) {
-    return node.modifiers?.some((m) => m.kind === SyntaxKind.StaticKeyword) === true;
-}
-/**
- * Get class extends node.
- */
-export function getExtendsClause(node) {
-    return node.heritageClauses?.find((clause) => clause.token === SyntaxKind.ExtendsKeyword);
-}
-/**
- * Get class extended node.
- */
-export function getExtendedNode(node) {
-    const extendsClause = getExtendsClause(node);
-    if (!extendsClause)
-        return;
-    return extendsClause.types[0];
-}
-/**
- * Get class extended node.
- */
-export function getExtendedType(context, node) {
-    const extendedNode = getExtendedNode(node);
-    return extendedNode && context.checker.getTypeAtLocation(extendedNode);
-}
-/**
- * Check if class is decorated with provided decorator name.
- */
-export function isLuabindDecoratedClass(declaration) {
-    const decorators = getDecorators(declaration);
-    if (!decorators) {
-        return false;
-    }
-    return decorators.some((it) => it.expression.expression?.escapedText === LUABIND_DECORATOR);
-}
-/**
- * Mark provided class as Luabind target.
- */
-export function markTypeAsLuabind(declaration, context) {
-    const typeAtLocation = context.checker.getTypeAtLocation(declaration);
-    const typeSymbol = typeAtLocation.symbol || typeAtLocation.aliasSymbol;
-    typeSymbol[LUABIND_SYMBOL] = true;
-}
-/**
- * Check if provided class is specified as LuaBind.
- */
-export function isLuabindClassType(declaration, context) {
-    const typeAtLocation = context.checker.getTypeAtLocation(declaration);
-    const typeSymbol = typeAtLocation.symbol || typeAtLocation.aliasSymbol;
-    if (typeSymbol) {
-        const isMarked = typeSymbol[LUABIND_SYMBOL] === true;
-        if (isMarked) {
-            return true;
-        }
-        else {
-            return isLuabindDecoratedClass(typeSymbol.declarations[0]);
-        }
-    }
-    else {
-        return false;
-    }
-}

package/plugins/plugins/utils/diagnostics.js

@@ -1,17 +0,0 @@
-import { DiagnosticCategory, getOriginalNode } from "typescript";
-import { createSerialDiagnosticFactory } from "typescript-to-lua/dist/utils";
-/**
- * Create diagnostics factory to push errors when transpile lua to typescript.
- */
-export function createDiagnosticFactory(category, message) {
-    return createSerialDiagnosticFactory((node, ...args) => ({
-        file: getOriginalNode(node).getSourceFile(),
-        start: getOriginalNode(node).getStart(),
-        length: getOriginalNode(node).getWidth(),
-        messageText: typeof message === "string" ? message : message(...args),
-        category,
-    }));
-}
-export function createErrorDiagnosticFactory(message) {
-    return createDiagnosticFactory(DiagnosticCategory.Error, message);
-}