xray16 1.0.0 → 1.0.1

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformConstructorDeclaration = exports.createConstructorName = void 0;
+const typescript_1 = require("typescript");
+const lua = require("typescript-to-lua");
+const lua_ast_1 = require("typescript-to-lua/dist/transformation/utils/lua-ast");
+const scope_1 = require("typescript-to-lua/dist/transformation/utils/scope");
+const function_1 = require("typescript-to-lua/dist/transformation/visitors/function");
+const identifier_1 = require("typescript-to-lua/dist/transformation/visitors/identifier");
+const constants_1 = require("../constants");
+const fields_1 = require("./fields");
+function createConstructorName(className) {
+    return lua.createTableIndexExpression(lua.cloneIdentifier(className), lua.createStringLiteral(constants_1.LUABIND_CONSTRUCTOR_METHOD));
+}
+exports.createConstructorName = createConstructorName;
+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(scope_1.ScopeType.Function);
+    const body = (0, function_1.transformFunctionBodyContent)(context, statement.body);
+    const [params, dotsLiteral, restParamName] = (0, function_1.transformParameters)(context, statement.parameters, (0, lua_ast_1.createSelfIdentifier)());
+    // Make sure default parameters are assigned before fields are initialized
+    const bodyWithFieldInitializers = (0, function_1.transformFunctionBodyHeader)(context, scope, statement.parameters, restParamName);
+    // Check for field declarations in constructor
+    const constructorFieldsDeclarations = statement.parameters.filter((p) => p.modifiers !== undefined);
+    const classInstanceFields = (0, fields_1.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 ((0, typescript_1.isExpressionStatement)(firstStatement) &&
+            (0, typescript_1.isCallExpression)(firstStatement.expression) &&
+            firstStatement.expression.expression.kind === typescript_1.SyntaxKind.SuperKeyword) {
+            const superCall = body.shift();
+            if (superCall) {
+                bodyWithFieldInitializers.push(superCall);
+            }
+        }
+    }
+    // Add in instance field declarations
+    for (const declaration of constructorFieldsDeclarations) {
+        if ((0, typescript_1.isIdentifier)(declaration.name)) {
+            // self.declarationName = declarationName
+            const assignment = lua.createAssignmentStatement(lua.createTableIndexExpression((0, lua_ast_1.createSelfIdentifier)(), lua.createStringLiteral(declaration.name.text)), (0, identifier_1.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);
+}
+exports.transformConstructorDeclaration = transformConstructorDeclaration;

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformClassInstanceFields = exports.verifyPropertyDecoratingExpression = void 0;
+const typescript_1 = require("typescript");
+const tstl = require("typescript-to-lua");
+const lua_ast_1 = require("typescript-to-lua/dist/transformation/utils/lua-ast");
+const preceding_statements_1 = require("typescript-to-lua/dist/transformation/utils/preceding-statements");
+const literal_1 = require("typescript-to-lua/dist/transformation/visitors/literal");
+const errors_1 = require("../errors");
+/**
+ * Verify whether decorators provided for luabind class.
+ */
+function verifyPropertyDecoratingExpression(context, node) {
+    if (!(0, typescript_1.canHaveDecorators)(node))
+        return;
+    const decorators = (0, typescript_1.getDecorators)(node);
+    if (!decorators)
+        return;
+    decorators.forEach((decorator) => {
+        context.diagnostics.push((0, errors_1.unsupportedPropertyDecorator)(decorator));
+    });
+}
+exports.verifyPropertyDecoratingExpression = verifyPropertyDecoratingExpression;
+function transformClassInstanceFields(context, instanceFields) {
+    const statements = [];
+    for (const f of instanceFields) {
+        const { precedingStatements, result: statement } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
+            // Get identifier
+            const fieldName = (0, literal_1.transformPropertyName)(context, f.name);
+            const value = f.initializer ? context.transformExpression(f.initializer) : undefined;
+            // self[fieldName]
+            const selfIndex = tstl.createTableIndexExpression((0, lua_ast_1.createSelfIdentifier)(), fieldName);
+            // self[fieldName] = value
+            const assignClassField = tstl.createAssignmentStatement(selfIndex, value, f);
+            return assignClassField;
+        });
+        statements.push(...precedingStatements, statement);
+    }
+    return statements;
+}
+exports.transformClassInstanceFields = transformClassInstanceFields;

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyMethodDecoratingExpression = exports.transformMethodDeclaration = exports.transformMethodName = exports.transformMemberExpressionOwnerName = void 0;
+const typescript_1 = require("typescript");
+const lua = require("typescript-to-lua");
+const function_1 = require("typescript-to-lua/dist/transformation/visitors/function");
+const literal_1 = require("typescript-to-lua/dist/transformation/visitors/literal");
+const errors_1 = require("../errors");
+const utils_1 = require("../utils");
+function transformMemberExpressionOwnerName(node, className) {
+    return lua.cloneIdentifier(className);
+}
+exports.transformMemberExpressionOwnerName = transformMemberExpressionOwnerName;
+function transformMethodName(context, node) {
+    const methodName = (0, literal_1.transformPropertyName)(context, node.name);
+    if (lua.isStringLiteral(methodName) && methodName.value === "toString") {
+        return lua.createStringLiteral("__tostring", node.name);
+    }
+    return methodName;
+}
+exports.transformMethodName = transformMethodName;
+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 ((0, utils_1.isStaticNode)(node)) {
+        context.diagnostics.push((0, errors_1.unsupportedStaticMethod)(node));
+        return;
+    }
+    const methodTable = transformMemberExpressionOwnerName(node, className);
+    const methodName = transformMethodName(context, node);
+    const [functionExpression] = (0, function_1.transformFunctionToExpression)(context, node);
+    return lua.createAssignmentStatement(lua.createTableIndexExpression(methodTable, methodName), functionExpression, node);
+}
+exports.transformMethodDeclaration = transformMethodDeclaration;
+/**
+ * Verify that method statement is not using decorators for methods/parameters.
+ */
+function verifyMethodDecoratingExpression(context, node) {
+    node.parameters.flatMap((parameter, index) => {
+        const decorators = (0, typescript_1.getDecorators)(parameter);
+        if (decorators?.length) {
+            decorators.forEach((decorator) => {
+                context.diagnostics.push((0, errors_1.unsupportedParameterDecorator)(decorator));
+            });
+        }
+    });
+    const decorators = (0, typescript_1.getDecorators)(node);
+    if (decorators?.length) {
+        decorators.forEach((decorator) => {
+            context.diagnostics.push((0, errors_1.unsupportedMethodDecorator)(decorator));
+        });
+    }
+}
+exports.verifyMethodDecoratingExpression = verifyMethodDecoratingExpression;

package/plugins/transform_luabind_class/transformation/new.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformNewCallExpression = void 0;
+const tstl = require("typescript-to-lua");
+const call_1 = require("typescript-to-lua/dist/transformation/visitors/call");
+/**
+ * Transform new call for luabind class as ClassConstructor() instead of TS_NEW from tstl.
+ */
+function transformNewCallExpression(expression, context) {
+    return tstl.createCallExpression(context.transformExpression(expression.expression), (0, call_1.transformArguments)(context, expression.arguments ?? []));
+}
+exports.transformNewCallExpression = transformNewCallExpression;

package/plugins/transform_luabind_class/transformation/setup.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReflectionClassName = exports.createClassSetup = void 0;
+const typescript_1 = require("typescript");
+const tstl = require("typescript-to-lua");
+const export_1 = require("typescript-to-lua/dist/transformation/utils/export");
+const lua_ast_1 = require("typescript-to-lua/dist/transformation/utils/lua-ast");
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+/**
+ * Create full class setup statement with name/super calls/methods/declaration/fields etc.
+ */
+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 = (0, export_1.hasDefaultExportModifier)(statement)
+        ? tstl.createTableIndexExpression((0, lua_ast_1.createExportsIdentifier)(), (0, export_1.createDefaultExportStringLiteral)(statement))
+        : undefined;
+    // [____exports.]className = class()
+    if (defaultExportLeftHandSide) {
+        result.push(tstl.createAssignmentStatement(defaultExportLeftHandSide, classReference, statement));
+    }
+    else {
+        result.push(...(0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, className, classReference, statement));
+    }
+    if (defaultExportLeftHandSide) {
+        // local localClassName = ____exports.default
+        result.push(tstl.createVariableDeclarationStatement(localClassName, defaultExportLeftHandSide));
+    }
+    else {
+        const exportScope = (0, export_1.getIdentifierExportScope)(context, className);
+        if (exportScope) {
+            // local localClassName = ____exports.className
+            result.push(tstl.createVariableDeclarationStatement(localClassName, (0, export_1.createExportedIdentifier)(context, tstl.cloneIdentifier(className), exportScope)));
+        }
+    }
+    // localClassName.__name = className
+    result.push(tstl.createAssignmentStatement(tstl.createTableIndexExpression(tstl.cloneIdentifier(localClassName), tstl.createStringLiteral(constants_1.LUABIND_NAME_FIELD)), getReflectionClassName(statement, className), statement));
+    return result;
+}
+exports.createClassSetup = createClassSetup;
+function getReflectionClassName(declaration, className) {
+    if (declaration.name) {
+        return tstl.createStringLiteral(declaration.name.text);
+    }
+    else if ((0, typescript_1.isVariableDeclaration)(declaration.parent) && (0, typescript_1.isIdentifier)(declaration.parent.name)) {
+        return tstl.createStringLiteral(declaration.parent.name.text);
+    }
+    else if ((0, export_1.hasDefaultExportModifier)(declaration)) {
+        return tstl.createStringLiteral("default");
+    }
+    if ((0, utils_1.getExtendedNode)(declaration)) {
+        return tstl.createTableIndexExpression(className, tstl.createStringLiteral("name"));
+    }
+    return tstl.createStringLiteral("");
+}
+exports.getReflectionClassName = getReflectionClassName;
+/**
+ * Creates class("Name")(base) expression for luabind classes.
+ */
+function createLuabindClassStatement(declaration, context, className) {
+    const extendedNode = (0, utils_1.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/transform_luabind_class/transformation/super.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformLuabindConstructorSuperCall = exports.isLuabindClassSuperMethodCall = exports.isLuabindClassSuperCall = exports.transformClassSuperMethodExpression = void 0;
+const typescript_1 = require("typescript");
+const tstl = require("typescript-to-lua");
+const export_1 = require("typescript-to-lua/dist/transformation/utils/export");
+const call_1 = require("typescript-to-lua/dist/transformation/visitors/call");
+const identifier_1 = require("typescript-to-lua/dist/transformation/visitors/identifier");
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+/**
+ * Transform generic methods super calls.
+ * Example: super.parentMethod(first, second).
+ */
+function transformClassSuperMethodExpression(expression, context) {
+    const superInfos = context.classSuperInfos;
+    const superInfo = superInfos[superInfos.length - 1];
+    if (!superInfo.classDeclaration || !(0, utils_1.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 && (0, typescript_1.isIdentifier)(extendsExpression)) {
+        const symbol = context.checker.getSymbolAtLocation(extendsExpression);
+        if (symbol && !(0, export_1.isSymbolExported)(context, symbol)) {
+            // Use "baseClassName" if base is a simple identifier
+            baseClassName = (0, identifier_1.transformIdentifier)(context, extendsExpression);
+        }
+    }
+    if (!baseClassName) {
+        throw new Error("Super without identifier - not supported with luabind.");
+    }
+    return baseClassName;
+}
+exports.transformClassSuperMethodExpression = transformClassSuperMethodExpression;
+/**
+ * Check if super() call is in luabind class target.
+ */
+function isLuabindClassSuperCall(expression, context) {
+    const calledExpression = (0, call_1.getCalledExpression)(expression);
+    if (calledExpression.kind !== typescript_1.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 ? (0, utils_1.isLuabindClassType)(superInfo.classDeclaration, context) : false;
+    }
+}
+exports.isLuabindClassSuperCall = isLuabindClassSuperCall;
+/**
+ * Check if super.method() call is in luabind class target.
+ */
+function isLuabindClassSuperMethodCall(expression, context) {
+    const superInfos = context.classSuperInfos;
+    const superInfo = superInfos[superInfos.length - 1];
+    // Handle super calls properly for luabind classes.
+    return superInfo?.classDeclaration ? (0, utils_1.isLuabindClassType)(superInfo.classDeclaration, context) : false;
+}
+exports.isLuabindClassSuperMethodCall = isLuabindClassSuperMethodCall;
+/**
+ * Transform super() call in luabind classes to base_class.__init(self, param).
+ */
+function transformLuabindConstructorSuperCall(expression, context) {
+    const signature = context.checker.getResolvedSignature(expression);
+    const parameters = (0, call_1.transformArguments)(context, expression.arguments, signature, typescript_1.factory.createThis());
+    return tstl.createCallExpression(tstl.createTableIndexExpression(context.transformExpression(typescript_1.factory.createSuper()), tstl.createStringLiteral(constants_1.LUABIND_CONSTRUCTOR_METHOD)), parameters, expression);
+}
+exports.transformLuabindConstructorSuperCall = transformLuabindConstructorSuperCall;

package/plugins/transform_luabind_class/transformation/utils.js

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

package/plugins/utils/diagnostics.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createErrorDiagnosticFactory = exports.createDiagnosticFactory = void 0;
+const typescript_1 = require("typescript");
+const utils_1 = require("typescript-to-lua/dist/utils");
+/**
+ * Create diagnostics factory to push errors when transpile lua to typescript.
+ */
+function createDiagnosticFactory(category, message) {
+    return (0, utils_1.createSerialDiagnosticFactory)((node, ...args) => ({
+        file: (0, typescript_1.getOriginalNode)(node).getSourceFile(),
+        start: (0, typescript_1.getOriginalNode)(node).getStart(),
+        length: (0, typescript_1.getOriginalNode)(node).getWidth(),
+        messageText: typeof message === "string" ? message : message(...args),
+        category,
+    }));
+}
+exports.createDiagnosticFactory = createDiagnosticFactory;
+function createErrorDiagnosticFactory(message) {
+    return createDiagnosticFactory(typescript_1.DiagnosticCategory.Error, message);
+}
+exports.createErrorDiagnosticFactory = createErrorDiagnosticFactory;

package/types/index.d.ts

@@ -0,0 +1,63 @@
+import "./xr_lib/xr_fs";
+import "./xr_lib/xr_math";
+import "./xr_lib/xr_utils";
+import "./xr_map/xr_map";
+import "./xr_object/xr_action";
+import "./xr_object/xr_alife";
+import "./xr_object/xr_anomaly";
+import "./xr_object/xr_artefact";
+import "./xr_object/xr_client_object";
+import "./xr_object/xr_creature";
+import "./xr_object/xr_dialog";
+import "./xr_object/xr_item";
+import "./xr_object/xr_level";
+import "./xr_object/xr_physic";
+import "./xr_object/xr_quest";
+import "./xr_object/xr_server_object";
+import "./xr_online/xr_multiplayer";
+import "./xr_sound/xr_sound";
+import "./xr_type/xr_enums";
+import "./xr_type/xr_type";
+import "./xr_ui/xr_ui_core";
+import "./xr_ui/xr_ui_interface";
+import "./xr_constant";
+import "./xr_core";
+import "./xr_luabind";
+import "./xr_global";
+
+declare module "xray16" {
+  /**
+   * @group export
+   */
+  export const actor_stats: IXR_actor_stats;
+
+  /**
+   * @group export
+   */
+  export const ActorMenu: IXR_ActorMenu;
+
+  /**
+   * @group export
+   */
+  export const game: IXR_game;
+
+  /**
+   * @group export
+   */
+  export const level: IXR_level;
+
+  /**
+   * @group export
+   */
+  export const main_menu: IXR_main_menu;
+
+  /**
+   * @group export
+   */
+  export const object: typeof XR_object;
+
+  /**
+   * @group export
+   */
+  export const relation_registry: IXR_relation_registry;
+}

package/{src → types}/xr_object/xr_client_object.d.ts

@@ -1203,7 +1203,10 @@ declare module "xray16" {
     public command(entity_action: entity_action, is_high_priority: boolean): void;
     public hit(hit: hit): void;
     public inactualize_patrol_path(): void;
-    public iterate_inventory(cb: (this: void, owner: game_object, item: game_object) => void, object: game_object): void;
+    public iterate_inventory(
+      cb: (this: void, owner: game_object, item: game_object) => void,
+      object: game_object
+    ): void;
     public movement_enabled(): boolean;
     public movement_enabled(value: boolean): void;
     public set_condition(condition: f32): void;

package/plugins/built_at_info.ts

@@ -1,18 +0,0 @@
-import { Program } from "typescript";
-import { Plugin, CompilerOptions, EmitFile, EmitHost } from "typescript-to-lua";
-
-const comment: string = `-- Generated by xrf util at: ${new Date().toString()}\n\n`;
-
-const plugin: Plugin = {
-  beforeEmit(program: Program, options: CompilerOptions, emitHost: EmitHost, result: Array<EmitFile>) {
-    void program;
-    void options;
-    void emitHost;
-
-    for (const file of result) {
-      file.code = comment + file.code;
-    }
-  },
-};
-
-export default plugin;

package/plugins/from_cast_utils.ts

@@ -1,34 +0,0 @@
-import { isIdentifier, SyntaxKind } from "typescript";
-import { Plugin } from "typescript-to-lua";
-import { createErrorDiagnosticFactory } from "./utils/diagnostics";
-
-const FROM_CAST_METHODS: Array<string> = ["$fromObject", "$fromArray", "$fromLuaArray", "$fromLuaTable"];
-
-/**
- * Push generic error to notify about usage issue.
- */
-const createInvalidFunctionCallError = createErrorDiagnosticFactory((name?: string) => {
-  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: 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/global_declarations_transform.ts

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

package/plugins/inject_filename.ts

@@ -1,22 +0,0 @@
-import * as path from "path";
-import { SyntaxKind } from "typescript";
-import { createStringLiteral, Plugin } from "typescript-to-lua";
-
-const FILENAME_IDENTIFIER: string = "$filename";
-
-/**
- * Plugin that injects FILE_NAME in compile-time.
- */
-const plugin: 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;