@flamework-experimental/transformer 2.0.0-alpha.0

package/out/index.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+/* eslint-disable @typescript-eslint/no-require-imports */
+var fs_1 = require("fs");
+var module_1 = require("module");
+var path_1 = __importDefault(require("path"));
+var isPathDescendantOf_1 = require("./util/functions/isPathDescendantOf");
+var logger_1 = require("./classes/logger");
+function resolve(moduleName, path) {
+    try {
+        return require.resolve(moduleName, { paths: [path] });
+    }
+    finally {
+    }
+}
+var cwd = process.cwd();
+var originalRequire = module_1.Module.prototype.require;
+function shouldTryHooking() {
+    if (process.argv.includes("--no-flamework-hook")) {
+        return false;
+    }
+    if (process.argv.includes("--force-flamework-hook")) {
+        return true;
+    }
+    // Ensure we're running in the context of a project and not a multiplace repository or something,
+    // as we don't have access to the project directory until roblox-ts invokes the transformer.
+    //
+    // A node_modules folder is deliberately not required: a package inside a workspace with hoisted
+    // dependencies has none of its own, and resolving roblox-ts from here (see hook) already tells us
+    // whether there is an install to switch to.
+    if (!(0, fs_1.existsSync)(path_1.default.join(cwd, "tsconfig.json")) || !(0, fs_1.existsSync)(path_1.default.join(cwd, "package.json"))) {
+        return false;
+    }
+    return true;
+}
+function hook() {
+    var robloxTsPath = resolve("roblox-ts", cwd);
+    if (!robloxTsPath) {
+        return;
+    }
+    var robloxTsTypeScriptPath = resolve("typescript", robloxTsPath);
+    if (!robloxTsTypeScriptPath) {
+        return;
+    }
+    var flameworkTypeScript = require("typescript");
+    var robloxTsTypeScript = require(robloxTsTypeScriptPath);
+    // Flamework and roblox-ts are referencing the same TypeScript module.
+    if (flameworkTypeScript === robloxTsTypeScript) {
+        return;
+    }
+    if (flameworkTypeScript.versionMajorMinor !== robloxTsTypeScript.versionMajorMinor) {
+        if (logger_1.Logger.verbose) {
+            logger_1.Logger.write("\n");
+        }
+        logger_1.Logger.warn("TypeScript version differs", "Flamework: v".concat(flameworkTypeScript.version, ", roblox-ts: v").concat(robloxTsTypeScript.version), "Flamework will switch to v".concat(robloxTsTypeScript.version, ", ") +
+            "but you can get rid of this warning by running: npm i -D typescript@".concat(robloxTsTypeScript.version));
+    }
+    module_1.Module.prototype.require = function flameworkHook(id) {
+        // Overwrite any Flamework TypeScript imports to roblox-ts' version.
+        // To be on the safe side, this won't hook it in packages.
+        if (id === "typescript" && (0, isPathDescendantOf_1.isPathDescendantOf)(this.filename, __dirname)) {
+            return robloxTsTypeScript;
+        }
+        return originalRequire.call(this, id);
+    };
+}
+if (shouldTryHooking()) {
+    hook();
+}
+var transformer = require("./transformer");
+// After loading Flamework, we can unhook require.
+module_1.Module.prototype.require = originalRequire;
+module.exports = transformer;

package/out/transformations/expressions/transformAccessExpression.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformAccessExpression = transformAccessExpression;
+var factory_1 = require("../../util/factory");
+var diagnostics_1 = require("../../classes/diagnostics");
+function transformAccessExpression(state, node) {
+    var _a;
+    return (_a = transformNetworkEvent(state, node)) !== null && _a !== void 0 ? _a : state.transform(node);
+}
+function transformNetworkEvent(state, node) {
+    var type = state.typeChecker.getTypeAtLocation(node.expression);
+    var hashType = state.typeChecker.getTypeOfPropertyOfType(type, "_flamework_key_obfuscation");
+    if (!hashType || !hashType.isStringLiteral())
+        return;
+    // If the access expression doesn't have a name known at compile-time, we must throw an error.
+    var name = getAccessName(node);
+    if (name === undefined) {
+        // This is prevents compiler errors when we're defining obfuscated objects, or accessing them internally.
+        if (factory_1.f.is.elementAccessExpression(node) && factory_1.f.is.asExpression(node.argumentExpression)) {
+            return;
+        }
+        diagnostics_1.Diagnostics.error(node, "This object has key obfuscation enabled and must be accessed directly.");
+    }
+    return factory_1.f.elementAccessExpression(state.transformNode(node.expression), factory_1.f.as(factory_1.f.string(state.obfuscateText(name, hashType.value)), factory_1.f.literalType(factory_1.f.string(name))), node.questionDotToken);
+}
+function getAccessName(node) {
+    if (factory_1.f.is.propertyAccessExpression(node)) {
+        return node.name.text;
+    }
+    else {
+        if (factory_1.f.is.string(node.argumentExpression)) {
+            return node.argumentExpression.text;
+        }
+    }
+}

package/out/transformations/expressions/transformBinaryExpression.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformBinaryExpression = transformBinaryExpression;
+var typescript_1 = __importDefault(require("typescript"));
+var diagnostics_1 = require("../../classes/diagnostics");
+var factory_1 = require("../../util/factory");
+var getIndexExpression_1 = require("../../util/functions/getIndexExpression");
+var isAttributesAccess_1 = require("../../util/functions/isAttributesAccess");
+var packages_1 = require("../../util/packages");
+var MUTATING_OPERATORS = new Map([
+    [typescript_1.default.SyntaxKind.EqualsToken, typescript_1.default.SyntaxKind.EqualsToken],
+    [typescript_1.default.SyntaxKind.BarEqualsToken, typescript_1.default.SyntaxKind.BarToken],
+    [typescript_1.default.SyntaxKind.PlusEqualsToken, typescript_1.default.SyntaxKind.PlusToken],
+    [typescript_1.default.SyntaxKind.MinusEqualsToken, typescript_1.default.SyntaxKind.MinusToken],
+    [typescript_1.default.SyntaxKind.CaretEqualsToken, typescript_1.default.SyntaxKind.CaretToken],
+    [typescript_1.default.SyntaxKind.SlashEqualsToken, typescript_1.default.SyntaxKind.SlashToken],
+    [typescript_1.default.SyntaxKind.BarBarEqualsToken, typescript_1.default.SyntaxKind.BarBarToken],
+    [typescript_1.default.SyntaxKind.PercentEqualsToken, typescript_1.default.SyntaxKind.PercentToken],
+    [typescript_1.default.SyntaxKind.AsteriskEqualsToken, typescript_1.default.SyntaxKind.AsteriskToken],
+    [typescript_1.default.SyntaxKind.AmpersandEqualsToken, typescript_1.default.SyntaxKind.AmpersandToken],
+    [typescript_1.default.SyntaxKind.QuestionQuestionEqualsToken, typescript_1.default.SyntaxKind.QuestionQuestionToken],
+    [typescript_1.default.SyntaxKind.AsteriskAsteriskEqualsToken, typescript_1.default.SyntaxKind.AsteriskAsteriskToken],
+    [typescript_1.default.SyntaxKind.LessThanLessThanEqualsToken, typescript_1.default.SyntaxKind.LessThanLessThanToken],
+    [typescript_1.default.SyntaxKind.AmpersandAmpersandEqualsToken, typescript_1.default.SyntaxKind.AmpersandAmpersandToken],
+    [typescript_1.default.SyntaxKind.GreaterThanGreaterThanEqualsToken, typescript_1.default.SyntaxKind.GreaterThanGreaterThanToken],
+    [typescript_1.default.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken, typescript_1.default.SyntaxKind.GreaterThanGreaterThanGreaterThanToken],
+]);
+/**
+ * Writes to `this.attributes` go through the component, which writes the value back to the
+ * instance. `attributes` is an ordinary field otherwise, so the rewrite is what makes assignment
+ * mean anything at all.
+ */
+function transformBinaryExpression(state, node) {
+    var nonAssignmentOperator = MUTATING_OPERATORS.get(node.operatorToken.kind);
+    if (nonAssignmentOperator) {
+        if ((0, isAttributesAccess_1.isAttributesAccess)(state, node.left)) {
+            var name_1 = (0, getIndexExpression_1.getIndexExpression)(node.left);
+            if (!name_1)
+                diagnostics_1.Diagnostics.error(node.left, "could not get index expression");
+            if (!factory_1.f.is.accessExpression(node.left.expression))
+                diagnostics_1.Diagnostics.error(node.left, "assignments not supported with direct access");
+            var attributeSetter = state.addFileImport(node.getSourceFile(), "".concat(packages_1.COMPONENTS_PACKAGE, "/out/baseComponent"), "SYMBOL_ATTRIBUTE_SETTER");
+            var thisAccess = node.left.expression.expression;
+            var valueExpr = nonAssignmentOperator === typescript_1.default.SyntaxKind.EqualsToken
+                ? node.right
+                : factory_1.f.binary(node.left, nonAssignmentOperator, node.right);
+            return factory_1.f.call(factory_1.f.field(state.transformNode(thisAccess), attributeSetter, true), [
+                name_1,
+                state.transformNode(valueExpr),
+            ]);
+        }
+    }
+    return state.transform(node);
+}

package/out/transformations/expressions/transformCallExpression.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformCallExpression = transformCallExpression;
+var typescript_1 = __importDefault(require("typescript"));
+var transformNode_1 = require("../transformNode");
+var transformUserMacro_1 = require("../transformUserMacro");
+var factory_1 = require("../../util/factory");
+var transformNetworkingCall_1 = require("../transformNetworkingCall");
+function transformCallExpression(state, node) {
+    var _a;
+    var symbol = state.getSymbol(node.expression);
+    if (symbol) {
+        if (state.isUserMacro(symbol)) {
+            // We skip `super()` expressions as we likely do not have enough information to evaluate it.
+            if (factory_1.f.is.superExpression(node.expression)) {
+                return state.transform(node);
+            }
+            var signature = state.typeChecker.getResolvedSignature(node);
+            if (signature) {
+                return (_a = (0, transformUserMacro_1.transformUserMacro)(state, node, signature)) !== null && _a !== void 0 ? _a : state.transform(node);
+            }
+        }
+    }
+    // With networking serialization on, sends and function callbacks pack their values right here.
+    var networking = (0, transformNetworkingCall_1.transformNetworkingCall)(state, node);
+    if (networking) {
+        return networking;
+    }
+    return typescript_1.default.visitEachChild(node, function (node) { return (0, transformNode_1.transformNode)(state, node); }, state.context);
+}

package/out/transformations/expressions/transformDeleteExpression.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformDeleteExpression = transformDeleteExpression;
+var diagnostics_1 = require("../../classes/diagnostics");
+var factory_1 = require("../../util/factory");
+var getIndexExpression_1 = require("../../util/functions/getIndexExpression");
+var isAttributesAccess_1 = require("../../util/functions/isAttributesAccess");
+var packages_1 = require("../../util/packages");
+/** `delete this.attributes.label` clears the attribute on the instance. */
+function transformDeleteExpression(state, node) {
+    if ((0, isAttributesAccess_1.isAttributesAccess)(state, node.expression)) {
+        var name_1 = (0, getIndexExpression_1.getIndexExpression)(node.expression);
+        if (!name_1)
+            diagnostics_1.Diagnostics.error(node.expression, "could not get index expression");
+        if (!factory_1.f.is.accessExpression(node.expression.expression))
+            diagnostics_1.Diagnostics.error(node.expression, "assignments not supported with direct access");
+        var attributeSetter = state.addFileImport(node.getSourceFile(), "".concat(packages_1.COMPONENTS_PACKAGE, "/out/baseComponent"), "SYMBOL_ATTRIBUTE_SETTER");
+        var thisAccess = node.expression.expression.expression;
+        return factory_1.f.call(factory_1.f.field(state.transformNode(thisAccess), attributeSetter, true), [name_1, factory_1.f.nil()]);
+    }
+    return state.transform(node);
+}

package/out/transformations/expressions/transformNewExpression.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformNewExpression = transformNewExpression;
+var transformUserMacro_1 = require("../transformUserMacro");
+function transformNewExpression(state, node) {
+    var _a;
+    var symbol = state.getSymbol(node.expression);
+    if (symbol) {
+        if (state.isUserMacro(symbol)) {
+            var signature = state.typeChecker.getResolvedSignature(node);
+            if (signature) {
+                return (_a = (0, transformUserMacro_1.transformUserMacro)(state, node, signature)) !== null && _a !== void 0 ? _a : state.transform(node);
+            }
+        }
+    }
+    return state.transform(node);
+}

package/out/transformations/expressions/transformUnaryExpression.js

@@ -0,0 +1,63 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformUnaryExpression = transformUnaryExpression;
+var typescript_1 = __importDefault(require("typescript"));
+var diagnostics_1 = require("../../classes/diagnostics");
+var factory_1 = require("../../util/factory");
+var getIndexExpression_1 = require("../../util/functions/getIndexExpression");
+var isAttributesAccess_1 = require("../../util/functions/isAttributesAccess");
+var packages_1 = require("../../util/packages");
+var MUTATING_OPERATORS = new Map([
+    [typescript_1.default.SyntaxKind.PlusPlusToken, typescript_1.default.SyntaxKind.PlusToken],
+    [typescript_1.default.SyntaxKind.MinusMinusToken, typescript_1.default.SyntaxKind.MinusToken],
+]);
+/** `this.attributes.count++`, which is the same write as `count += 1`. */
+function transformUnaryExpression(state, node) {
+    var nonAssignmentOperator = MUTATING_OPERATORS.get(node.operator);
+    if (nonAssignmentOperator) {
+        if ((0, isAttributesAccess_1.isAttributesAccess)(state, node.operand)) {
+            var name_1 = (0, getIndexExpression_1.getIndexExpression)(node.operand);
+            if (!name_1)
+                diagnostics_1.Diagnostics.error(node.operand, "could not get index expression");
+            if (!factory_1.f.is.accessExpression(node.operand.expression))
+                diagnostics_1.Diagnostics.error(node.operand, "assignments not supported with direct access");
+            var attributeSetter = state.addFileImport(node.getSourceFile(), "".concat(packages_1.COMPONENTS_PACKAGE, "/out/baseComponent"), "SYMBOL_ATTRIBUTE_SETTER");
+            var thisAccess = node.operand.expression.expression;
+            // The value is transformed rather than handed over as written: the operand carries the
+            // receiver a second time, and a receiver can be a macro call whose id this very pass is
+            // what injects. Leaving it alone emits the call without its id, which then fails to
+            // resolve at runtime.
+            var args = [name_1, state.transformNode(factory_1.f.binary(node.operand, nonAssignmentOperator, 1))];
+            return factory_1.f.call(factory_1.f.field(state.transformNode(thisAccess), attributeSetter, true), factory_1.f.is.postfixUnary(node) ? __spreadArray(__spreadArray([], __read(args), false), [true], false) : args);
+        }
+    }
+    return state.transform(node);
+}

package/out/transformations/macros/intrinsics/components.js

@@ -0,0 +1,64 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformComponentConfig = transformComponentConfig;
+var factory_1 = require("../../../util/factory");
+var updateComponentConfig_1 = require("../updateComponentConfig");
+function transformComponentConfig(state, declaration, signature, parameters, args) {
+    var e_1, _a;
+    var _loop_1 = function (parameter) {
+        var parameterIndex = signature.parameters.findIndex(function (v) { var _a; return ((_a = v.valueDeclaration) === null || _a === void 0 ? void 0 : _a.symbol) === parameter; });
+        var argument = args[parameterIndex];
+        var baseConfig = factory_1.f.is.object(argument) ? argument : factory_1.f.object([]);
+        var componentConfig = (0, updateComponentConfig_1.updateComponentConfig)(state, declaration, __spreadArray([], __read(baseConfig.properties), false));
+        args[parameterIndex] = factory_1.f.update.object(baseConfig, componentConfig.map(function (v) { return (baseConfig.properties.includes(v) ? state.transformNode(v) : v); }));
+    };
+    try {
+        for (var parameters_1 = __values(parameters), parameters_1_1 = parameters_1.next(); !parameters_1_1.done; parameters_1_1 = parameters_1.next()) {
+            var parameter = parameters_1_1.value;
+            _loop_1(parameter);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (parameters_1_1 && !parameters_1_1.done && (_a = parameters_1.return)) _a.call(parameters_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}

package/out/transformations/macros/intrinsics/env.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildEnvIntrinsic = buildEnvIntrinsic;
+var typescript_1 = __importDefault(require("typescript"));
+var diagnostics_1 = require("../../../classes/diagnostics");
+var factory_1 = require("../../../util/factory");
+/**
+ * Inlines an environment variable: `Flamework.env("NAME")` becomes the variable's value as a
+ * string literal, from the environment the compiler read when it started (`.env`, `.env.local`,
+ * the process), or `nil` when it is not set. A fallback is inlined in its place, and has to be a
+ * string literal: it is what lets the declared type promise a `string`, so one the compiler cannot
+ * read is refused rather than quietly dropped.
+ */
+function buildEnvIntrinsic(state, node, nameType, fallbackType) {
+    var _a;
+    if (!nameType.isStringLiteral()) {
+        diagnostics_1.Diagnostics.error(node, "Flamework.env expects the variable's name as a string literal, got: ".concat(state.typeChecker.typeToString(nameType)));
+    }
+    var fallback;
+    if (fallbackType !== undefined && (fallbackType.flags & typescript_1.default.TypeFlags.Undefined) === 0) {
+        if (!fallbackType.isStringLiteral()) {
+            diagnostics_1.Diagnostics.error(node, "Flamework.env expects the fallback as a string literal, got: ".concat(state.typeChecker.typeToString(fallbackType)), "The fallback is inlined at compile time, which is what makes the result a string rather than string | undefined.");
+        }
+        fallback = fallbackType.value;
+    }
+    var value = (_a = state.env[nameType.value]) !== null && _a !== void 0 ? _a : fallback;
+    return value === undefined ? factory_1.f.nil() : factory_1.f.string(value);
+}

package/out/transformations/macros/intrinsics/guards.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTupleGuardsIntrinsic = buildTupleGuardsIntrinsic;
+var typescript_1 = __importDefault(require("typescript"));
+var diagnostics_1 = require("../../../classes/diagnostics");
+var factory_1 = require("../../../util/factory");
+var buildGuardFromType_1 = require("../../../util/functions/buildGuardFromType");
+var isTupleType_1 = require("../../../util/functions/isTupleType");
+/**
+ * This intrinsic generates an array of element guards along with a rest guard for a tuple type.
+ *
+ * Whilst this is possible in TypeScript, it requires either slightly complex types or additional metadata.
+ * This serves as a simple fast path.
+ */
+function buildTupleGuardsIntrinsic(state, node, tupleType) {
+    var _a;
+    var file = state.getSourceFile(node);
+    // Tuples with only a rest element will get turned into an array
+    if ((0, isTupleType_1.isArrayType)(state, tupleType)) {
+        var guard = (0, buildGuardFromType_1.buildGuardFromType)(state, node, tupleType.typeArguments[0], file);
+        return factory_1.f.array([factory_1.f.array([]), guard]);
+    }
+    if (!(0, isTupleType_1.isTupleType)(state, tupleType) || !tupleType.typeArguments) {
+        diagnostics_1.Diagnostics.error(node, "Intrinsic encountered non-tuple type: ".concat(state.typeChecker.typeToString(tupleType)));
+    }
+    var guards = new Array();
+    var restGuard = factory_1.f.nil();
+    for (var i = 0; i < tupleType.typeArguments.length; i++) {
+        var element = tupleType.typeArguments[i];
+        var declaration = (_a = tupleType.target.labeledElementDeclarations) === null || _a === void 0 ? void 0 : _a[i];
+        var guard = (0, buildGuardFromType_1.buildGuardFromType)(state, declaration !== null && declaration !== void 0 ? declaration : node, element, file);
+        if (tupleType.target.elementFlags[i] & typescript_1.default.ElementFlags.Rest) {
+            restGuard = guard;
+        }
+        else {
+            guards.push(guard);
+        }
+    }
+    return factory_1.f.array([factory_1.f.array(guards), restGuard]);
+}

package/out/transformations/macros/intrinsics/inlining.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inlineMacroIntrinsic = inlineMacroIntrinsic;
+var typescript_1 = __importDefault(require("typescript"));
+var factory_1 = require("../../../util/factory");
+/**
+ * An inlining intrinsic: the call is replaced by the value generated for one of its parameters.
+ *
+ * The value is cast to the call's resolved return type rather than to the declaration's return
+ * type node: a declaration such as `F extends string ? string : string | undefined` names type
+ * parameters that mean nothing in the caller's file, whereas the resolved type of that call is a
+ * plain `string | undefined` the checker can write down there.
+ */
+function inlineMacroIntrinsic(state, node, signature, args, parameter) {
+    var parameterIndex = signature.parameters.findIndex(function (v) { var _a; return ((_a = v.valueDeclaration) === null || _a === void 0 ? void 0 : _a.symbol) === parameter; });
+    var argument = args[parameterIndex];
+    var returnType = state.typeChecker.typeToTypeNode(signature.getReturnType(), node, typescript_1.default.NodeBuilderFlags.NoTruncation);
+    return returnType !== undefined ? factory_1.f.as(argument, returnType) : argument;
+}

package/out/transformations/macros/intrinsics/networking.js

@@ -0,0 +1,131 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformNetworkingMiddlewareIntrinsic = transformNetworkingMiddlewareIntrinsic;
+exports.transformObfuscatedObjectIntrinsic = transformObfuscatedObjectIntrinsic;
+exports.transformShuffleArrayIntrinsic = transformShuffleArrayIntrinsic;
+var typescript_1 = __importDefault(require("typescript"));
+var assert_1 = __importDefault(require("assert"));
+var factory_1 = require("../../../util/factory");
+var diagnostics_1 = require("../../../classes/diagnostics");
+/**
+ * Obfuscates the names of events provided in networking middleware.
+ *
+ * This should eventually be replaced with a generic object obfuscation API.
+ */
+function transformNetworkingMiddlewareIntrinsic(state, signature, args, parameters) {
+    var e_1, _a;
+    var _loop_1 = function (parameter) {
+        var parameterIndex = signature.parameters.findIndex(function (v) { var _a; return ((_a = v.valueDeclaration) === null || _a === void 0 ? void 0 : _a.symbol) === parameter; });
+        var argument = args[parameterIndex];
+        if (!argument || !typescript_1.default.isObjectLiteralExpression(argument)) {
+            return "continue";
+        }
+        var obfuscateMiddleware = function (middlewareObject) {
+            return factory_1.f.update.object(middlewareObject, state.obfuscateArray(middlewareObject.properties).map(function (prop) {
+                if (factory_1.f.is.propertyAssignmentDeclaration(prop) && "text" in prop.name) {
+                    return factory_1.f.update.propertyAssignmentDeclaration(prop, factory_1.f.is.object(prop.initializer) ? obfuscateMiddleware(prop.initializer) : prop.initializer, factory_1.f.computedPropertyName(factory_1.f.as(factory_1.f.string(state.obfuscateText(prop.name.text, "remotes")), factory_1.f.literalType(factory_1.f.string(prop.name.text)))));
+                }
+                return prop;
+            }));
+        };
+        var transformedElements = argument.properties.map(function (element) {
+            var name = element.name && typescript_1.default.getPropertyNameForPropertyNameNode(element.name);
+            if (name !== "middleware") {
+                return element;
+            }
+            (0, assert_1.default)(factory_1.f.is.propertyAssignmentDeclaration(element));
+            var value = element.initializer;
+            if (!factory_1.f.is.object(value)) {
+                diagnostics_1.Diagnostics.error(value, "Networking middleware must be an object.");
+            }
+            return factory_1.f.update.propertyAssignmentDeclaration(element, obfuscateMiddleware(value));
+        });
+        args[parameterIndex] = factory_1.f.object(transformedElements, true);
+    };
+    try {
+        for (var parameters_1 = __values(parameters), parameters_1_1 = parameters_1.next(); !parameters_1_1.done; parameters_1_1 = parameters_1.next()) {
+            var parameter = parameters_1_1.value;
+            _loop_1(parameter);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (parameters_1_1 && !parameters_1_1.done && (_a = parameters_1.return)) _a.call(parameters_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}
+/**
+ * Obfuscates the keys of user macro metadata using the specified context.
+ *
+ * This should eventually be replaced with a generic object obfuscation API.
+ */
+function transformObfuscatedObjectIntrinsic(state, macro, hashType) {
+    var e_2, _a;
+    var hashContext = hashType.isStringLiteral() ? hashType.value : undefined;
+    if (macro.kind === "many" && macro.members instanceof Map) {
+        try {
+            // Maps are order-preserving, so we can shuffle the map directly.
+            for (var _b = __values(state.obfuscateArray(__spreadArray([], __read(macro.members), false))), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), key = _d[0], inner = _d[1];
+                macro.members.delete(key);
+                macro.members.set(state.obfuscateText(key, hashContext), inner);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    }
+}
+/**
+ * Shuffles the order of an array to prevent const-matching.
+ */
+function transformShuffleArrayIntrinsic(state, macro) {
+    if (macro.kind === "many" && Array.isArray(macro.members)) {
+        macro.members = state.obfuscateArray(macro.members);
+    }
+}