@flamework-experimental/transformer 2.0.0-alpha.0

package/out/util/functions/createPathTranslator.js

@@ -0,0 +1,54 @@
+"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.createPathTranslator = createPathTranslator;
+var path_1 = __importDefault(require("path"));
+var assert_1 = require("./assert");
+var path_translator_1 = require("@roblox-ts/path-translator");
+function findAncestorDir(dirs) {
+    dirs = dirs.map(path_1.default.normalize).map(function (v) { return (v.endsWith(path_1.default.sep) ? v : v + path_1.default.sep); });
+    var currentDir = dirs[0];
+    while (!dirs.every(function (v) { return v.startsWith(currentDir); })) {
+        currentDir = path_1.default.join(currentDir, "..");
+    }
+    return currentDir;
+}
+function getRootDirs(compilerOptions) {
+    var rootDirs = compilerOptions.rootDir ? [compilerOptions.rootDir] : compilerOptions.rootDirs;
+    if (!rootDirs)
+        (0, assert_1.assert)(false, "rootDir or rootDirs must be specified");
+    return rootDirs;
+}
+function createPathTranslator(program) {
+    var compilerOptions = program.getCompilerOptions();
+    var rootDir = findAncestorDir(__spreadArray([program.getCommonSourceDirectory()], __read(getRootDirs(compilerOptions)), false));
+    var outDir = compilerOptions.outDir;
+    return new path_translator_1.PathTranslator(rootDir, outDir, undefined, compilerOptions.declaration || false);
+}

package/out/util/functions/emitTypescriptMismatch.js

@@ -0,0 +1,80 @@
+"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.emitTypescriptMismatch = emitTypescriptMismatch;
+var chalk_1 = __importDefault(require("chalk"));
+var path_1 = __importDefault(require("path"));
+var typescript_1 = __importDefault(require("typescript"));
+var logger_1 = require("../../classes/logger");
+var getPackageJson_1 = require("./getPackageJson");
+var isPathDescendantOf_1 = require("./isPathDescendantOf");
+function tryResolve(name, path) {
+    try {
+        return require.resolve(name, { paths: [path] });
+    }
+    catch (e) { }
+}
+function emitMessages(messages) {
+    logger_1.Logger.writeLine.apply(logger_1.Logger, __spreadArray([], __read(messages), false));
+    process.exit(1);
+}
+/**
+ * Spits out information about the mismatch.
+ * This should only be called after a mismatch is detected.
+ */
+function emitTypescriptMismatch(state, baseMessage) {
+    var messages = [baseMessage];
+    // Check if they have a local install.
+    var robloxTsPath = tryResolve("roblox-ts", state.rootDirectory);
+    if (!robloxTsPath) {
+        messages.push("It is recommended that you use a local install of roblox-ts.", "You can install a local version using ".concat(chalk_1.default.green("npm install -D roblox-ts")));
+        emitMessages(messages);
+    }
+    // Check if they've used a global install.
+    if (require.main) {
+        if (!(0, isPathDescendantOf_1.isPathDescendantOf)(require.main.filename, path_1.default.join(state.rootDirectory, "node_modules"))) {
+            messages.push("It appears you've run the transformer using a global install.", "You can run using the locally installed version using ".concat(chalk_1.default.green("npx rbxtsc")));
+            emitMessages(messages);
+        }
+    }
+    // They're using a local install
+    // but they're using the wrong TypeScript version.
+    var robloxTsTypeScript = tryResolve("typescript", robloxTsPath);
+    if (robloxTsTypeScript) {
+        var typescriptPackage = (0, getPackageJson_1.getPackageJson)(robloxTsTypeScript);
+        if (typescriptPackage) {
+            var requiredVersion = typescriptPackage.result.version;
+            if (typescript_1.default.version !== requiredVersion) {
+                messages.push("Flamework is using TypeScript version ".concat(typescript_1.default.version), "roblox-ts requires TypeScript version ".concat(requiredVersion), "You can fix this by setting your TypeScript version: ".concat(chalk_1.default.green("npm install -D typescript@=".concat(requiredVersion))));
+            }
+        }
+    }
+    emitMessages(messages);
+}

package/out/util/functions/getDeclarationName.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDeclarationName = getDeclarationName;
+var typescript_1 = __importDefault(require("typescript"));
+var factory_1 = require("../factory");
+/**
+ * Calculates a name, including all named ancestors, such as Enum.Material.Air
+ * @param node The node to retrieve the name of
+ */
+function getDeclarationName(node) {
+    if (!factory_1.f.is.identifier(node.name))
+        return "$p:error";
+    var name = node.name.text;
+    for (var parent_1 = node.parent; parent_1 !== undefined; parent_1 = parent_1.parent) {
+        if (typescript_1.default.isNamedDeclaration(parent_1)) {
+            name = parent_1.name.getText() + "." + name;
+        }
+    }
+    return name;
+}

package/out/util/functions/getDeclarationOfType.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDeclarationOfType = getDeclarationOfType;
+function getDeclarationOfType(type) {
+    var _a, _b;
+    return (_b = (_a = type.symbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b[0];
+}

package/out/util/functions/getIndexExpression.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIndexExpression = getIndexExpression;
+var factory_1 = require("../factory");
+/**
+ * Gets the expression used to index the AccessExpression.
+ * Converts properties to strings.
+ */
+function getIndexExpression(expression) {
+    if (factory_1.f.is.propertyAccessExpression(expression)) {
+        return factory_1.f.string(expression.name.text);
+    }
+    else {
+        return expression.argumentExpression;
+    }
+}

package/out/util/functions/getInstanceTypeFromType.js

@@ -0,0 +1,75 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInstanceTypeFromType = getInstanceTypeFromType;
+var typescript_1 = __importDefault(require("typescript"));
+var diagnostics_1 = require("../../classes/diagnostics");
+var assert_1 = require("./assert");
+var getDeclarationOfType_1 = require("./getDeclarationOfType");
+function getInstanceTypeFromType(file, type) {
+    var e_1, _a, e_2, _b;
+    var _c, _d, _e;
+    (0, assert_1.assert)(type.getProperty("_nominal_Instance"), "non instance type was passed into getInstanceTypeFromType");
+    var diagnosticsLocation = (_c = (0, getDeclarationOfType_1.getDeclarationOfType)(type)) !== null && _c !== void 0 ? _c : file;
+    var nominalProperties = getNominalProperties(type);
+    var specificType = type, specificTypeCount = 0;
+    try {
+        for (var nominalProperties_1 = __values(nominalProperties), nominalProperties_1_1 = nominalProperties_1.next(); !nominalProperties_1_1.done; nominalProperties_1_1 = nominalProperties_1.next()) {
+            var property = nominalProperties_1_1.value;
+            var noNominalName = (_d = /_nominal_(.*)/.exec(property.name)) === null || _d === void 0 ? void 0 : _d[1];
+            (0, assert_1.assert)(noNominalName);
+            var instanceSymbol = type.checker.resolveName(noNominalName, undefined, typescript_1.default.SymbolFlags.Type, false);
+            if (!instanceSymbol)
+                continue;
+            var instanceDeclaration = (_e = instanceSymbol.declarations) === null || _e === void 0 ? void 0 : _e[0];
+            if (!instanceDeclaration)
+                continue;
+            var instanceType = type.checker.getTypeAtLocation(instanceDeclaration);
+            var subNominalProperties = getNominalProperties(instanceType);
+            if (subNominalProperties.length > specificTypeCount) {
+                specificType = instanceType;
+                specificTypeCount = subNominalProperties.length;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (nominalProperties_1_1 && !nominalProperties_1_1.done && (_a = nominalProperties_1.return)) _a.call(nominalProperties_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    try {
+        // intersection between two nominal types?
+        for (var nominalProperties_2 = __values(nominalProperties), nominalProperties_2_1 = nominalProperties_2.next(); !nominalProperties_2_1.done; nominalProperties_2_1 = nominalProperties_2.next()) {
+            var property = nominalProperties_2_1.value;
+            if (!specificType.getProperty(property.name)) {
+                diagnostics_1.Diagnostics.error(diagnosticsLocation, "Intersection between nominal types is forbidden.");
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (nominalProperties_2_1 && !nominalProperties_2_1.done && (_b = nominalProperties_2.return)) _b.call(nominalProperties_2);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return specificType;
+}
+function getNominalProperties(type) {
+    return type.getProperties().filter(function (x) { return x.name.startsWith("_nominal_"); });
+}

package/out/util/functions/getNodeList.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNodeList = getNodeList;
+function getNodeList(statements) {
+    return Array.isArray(statements) ? statements : [statements];
+}

package/out/util/functions/getPackageJson.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageJson = getPackageJson;
+var typescript_1 = __importDefault(require("typescript"));
+var path_1 = __importDefault(require("path"));
+var normalize_package_data_1 = __importDefault(require("normalize-package-data"));
+var isPathDescendantOf_1 = require("./isPathDescendantOf");
+var cache_1 = require("../cache");
+/**
+ * Looks recursively at ancestors until a package.json is found
+ * @param directory The directory to start under.
+ */
+function getPackageJson(directory) {
+    var existing = cache_1.Cache.pkgJsonCache.get(path_1.default.normalize(directory));
+    if (existing)
+        return existing;
+    var result = getPackageJsonInner(directory);
+    cache_1.Cache.pkgJsonCache.set(path_1.default.normalize(directory), result);
+    typescript_1.default.forEachAncestorDirectory(directory, function (dir) {
+        if ((0, isPathDescendantOf_1.isPathDescendantOf)(dir, result.directory)) {
+            cache_1.Cache.pkgJsonCache.set(path_1.default.normalize(dir), result);
+        }
+        else {
+            return true;
+        }
+    });
+    return result;
+}
+function getPackageJsonInner(directory) {
+    var packageJsonPath = typescript_1.default.findPackageJson(directory, typescript_1.default.sys);
+    if (!packageJsonPath)
+        throw new Error("package.json not found in ".concat(directory));
+    var text = packageJsonPath ? typescript_1.default.sys.readFile(packageJsonPath) : undefined;
+    var packageJson = text ? JSON.parse(text) : {};
+    (0, normalize_package_data_1.default)(packageJson);
+    return {
+        directory: path_1.default.dirname(packageJsonPath),
+        path: packageJsonPath,
+        result: packageJson,
+    };
+}

package/out/util/functions/getSuperClasses.js

@@ -0,0 +1,51 @@
+"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.getSuperClasses = getSuperClasses;
+var typescript_1 = __importDefault(require("typescript"));
+function getSuperClasses(typeChecker, node) {
+    var _a, _b, _c, _d;
+    var superClasses = new Array();
+    var superClass = (_c = (_b = (_a = node.heritageClauses) === null || _a === void 0 ? void 0 : _a.find(function (x) { return x.token === typescript_1.default.SyntaxKind.ExtendsKeyword; })) === null || _b === void 0 ? void 0 : _b.types) === null || _c === void 0 ? void 0 : _c[0];
+    if (superClass) {
+        var aliasSymbol = typeChecker.getSymbolAtLocation(superClass.expression);
+        if (aliasSymbol) {
+            var symbol = typescript_1.default.skipAlias(aliasSymbol, typeChecker);
+            var classDeclaration = (_d = symbol === null || symbol === void 0 ? void 0 : symbol.declarations) === null || _d === void 0 ? void 0 : _d.find(function (x) {
+                return typescript_1.default.isClassDeclaration(x);
+            });
+            if (classDeclaration) {
+                superClasses.push(classDeclaration);
+                superClasses.push.apply(superClasses, __spreadArray([], __read(getSuperClasses(typeChecker, classDeclaration)), false));
+            }
+        }
+    }
+    return superClasses;
+}

package/out/util/functions/isAttributesAccess.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAttributesAccess = isAttributesAccess;
+var factory_1 = require("../factory");
+var nodeMetadata_1 = require("../../classes/nodeMetadata");
+/**
+ * Checks if an expression is attempting to access component attributes.
+ * E.g `this.attributes.myProp`
+ */
+function isAttributesAccess(state, expression) {
+    if (!factory_1.f.is.accessExpression(expression)) {
+        return false;
+    }
+    var lhs = state.getSymbol(expression.expression);
+    if (!lhs) {
+        return false;
+    }
+    var metadata = nodeMetadata_1.NodeMetadata.fromSymbol(state, lhs);
+    if (!metadata) {
+        return false;
+    }
+    return metadata.isRequested("intrinsic-component-attributes");
+}

package/out/util/functions/isCleanBuildDirectory.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCleanBuildDirectory = isCleanBuildDirectory;
+var fs_1 = __importDefault(require("fs"));
+function isCleanBuildDirectory(compilerOptions) {
+    if (compilerOptions.incremental && compilerOptions.tsBuildInfoFile) {
+        return !fs_1.default.existsSync(compilerOptions.tsBuildInfoFile);
+    }
+    return true;
+}

package/out/util/functions/isDefinedType.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDefinedType = isDefinedType;
+var typescript_1 = __importDefault(require("typescript"));
+// https://github.com/roblox-ts/roblox-ts/blob/dc74f34fdab3caf20d65db080cf2dbf5c4f38fdc/src/TSTransformer/util/types.ts#L70
+function isDefinedType(type) {
+    return (type.flags === typescript_1.default.TypeFlags.Object &&
+        type.getProperties().length === 0 &&
+        type.getCallSignatures().length === 0 &&
+        type.getConstructSignatures().length === 0 &&
+        type.getNumberIndexType() === undefined &&
+        type.getStringIndexType() === undefined);
+}

package/out/util/functions/isPathDescendantOf.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPathDescendantOf = isPathDescendantOf;
+exports.isPathDescendantOfAny = isPathDescendantOfAny;
+var path_1 = __importDefault(require("path"));
+/**
+ * Checks if the `filePath` path is a descendant of the `dirPath` path.
+ * @param filePath A path to a file.
+ * @param dirPath A path to a directory.
+ */
+function isPathDescendantOf(filePath, dirPath) {
+    var relative = path_1.default.relative(dirPath, filePath);
+    return dirPath === filePath || (!relative.startsWith("..") && !path_1.default.isAbsolute(relative));
+}
+/**
+ * Checks if the `filePath` is a descendant of any of the specified `dirPaths` paths.
+ * @param filePath A path to a file.
+ * @param dirPaths The directories to check.
+ */
+function isPathDescendantOfAny(filePath, dirPaths) {
+    return dirPaths.some(function (dirPath) { return isPathDescendantOf(filePath, dirPath); });
+}

package/out/util/functions/isTupleType.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTupleType = isTupleType;
+exports.isArrayType = isArrayType;
+function isTupleType(state, type) {
+    return state.typeChecker.isTupleType(type);
+}
+function isArrayType(state, type) {
+    return state.typeChecker.isArrayType(type);
+}

package/out/util/functions/parseCommandLine.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.parseCommandLine = parseCommandLine;
+var typescript_1 = __importDefault(require("typescript"));
+var path_1 = __importDefault(require("path"));
+var fs_1 = __importDefault(require("fs"));
+function findTsConfigPath(projectPath) {
+    var tsConfigPath = path_1.default.resolve(projectPath);
+    if (!fs_1.default.existsSync(tsConfigPath) || !fs_1.default.statSync(tsConfigPath).isFile()) {
+        tsConfigPath = typescript_1.default.findConfigFile(tsConfigPath, typescript_1.default.sys.fileExists);
+        if (tsConfigPath === undefined) {
+            throw new Error("Unable to find tsconfig.json!");
+        }
+    }
+    return path_1.default.resolve(process.cwd(), tsConfigPath);
+}
+function parseCommandLine() {
+    var options = {};
+    var projectIndex = process.argv.findIndex(function (x) { return x === "-p" || x === "--project"; });
+    if (projectIndex !== -1) {
+        options.tsconfigPath = findTsConfigPath(process.argv[projectIndex + 1]);
+    }
+    else {
+        options.tsconfigPath = findTsConfigPath(".");
+    }
+    options.project = path_1.default.dirname(options.tsconfigPath);
+    return options;
+}

package/out/util/functions/shuffle.js

@@ -0,0 +1,39 @@
+"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));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shuffle = shuffle;
+function shuffle(array) {
+    return shuffleInPlace(__spreadArray([], __read(array), false));
+}
+function shuffleInPlace(array) {
+    var _a;
+    for (var i = array.length - 1; i >= 0; i--) {
+        var randomIndex = Math.floor(Math.random() * (i + 1));
+        _a = __read([array[randomIndex], array[i]], 2), array[i] = _a[0], array[randomIndex] = _a[1];
+    }
+    return array;
+}

package/out/util/functions/tryResolve.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryResolveTS = tryResolveTS;
+var typescript_1 = __importDefault(require("typescript"));
+/**
+ * Resolves a module the way the compiler would from `containingFile`, returning the file it lands on.
+ */
+function tryResolveTS(state, moduleName, containingFile) {
+    var _a;
+    var module = typescript_1.default.resolveModuleName(moduleName, containingFile, state.options, typescript_1.default.sys);
+    return (_a = module.resolvedModule) === null || _a === void 0 ? void 0 : _a.resolvedFileName;
+}

package/out/util/functions/validateConstraintMetadata.js

@@ -0,0 +1,60 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConstraintMetadata = validateConstraintMetadata;
+var typescript_1 = __importDefault(require("typescript"));
+var nodeMetadata_1 = require("../../classes/nodeMetadata");
+var assert_1 = require("./assert");
+var diagnostics_1 = require("../../classes/diagnostics");
+function validateConstraintMetadata(state, node, metadata) {
+    var e_1, _a;
+    var _b;
+    if (metadata === void 0) { metadata = nodeMetadata_1.NodeMetadata.fromCache(state, node); }
+    if (!node.name) {
+        return [];
+    }
+    var symbol = state.getSymbol(node.name);
+    (0, assert_1.assert)(symbol);
+    var constraintTypes = metadata.getType("constraint");
+    var nodeType = state.typeChecker.getTypeOfSymbolAtLocation(symbol, node);
+    try {
+        for (var _c = __values(constraintTypes !== null && constraintTypes !== void 0 ? constraintTypes : []), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var constraintType = _d.value;
+            if (!state.typeChecker.isTypeAssignableTo(nodeType, constraintType)) {
+                diagnostics_1.Diagnostics.addDiagnostic(getAssignabilityDiagnostics((_b = node.name) !== null && _b !== void 0 ? _b : node, nodeType, constraintType, metadata.getTrace(constraintType)));
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}
+function getAssignabilityDiagnostics(node, sourceType, constraintType, trace) {
+    var diagnostic = diagnostics_1.Diagnostics.createDiagnostic(node, typescript_1.default.DiagnosticCategory.Error, "Type '".concat(formatType(sourceType), "' does not satify constraint '").concat(formatType(constraintType), "'"));
+    if (trace) {
+        typescript_1.default.addRelatedInfo(diagnostic, diagnostics_1.Diagnostics.createDiagnostic(trace, typescript_1.default.DiagnosticCategory.Message, "The constraint is defined here."));
+    }
+    return diagnostic;
+}
+function formatType(type) {
+    var typeNode = type.checker.typeToTypeNode(type, undefined, typescript_1.default.NodeBuilderFlags.InTypeAlias | typescript_1.default.NodeBuilderFlags.IgnoreErrors);
+    var printer = typescript_1.default.createPrinter();
+    return printer.printNode(typescript_1.default.EmitHint.Unspecified, typeNode, undefined);
+}

package/out/util/packages.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_PACKAGE = exports.NETWORKING_PACKAGE = exports.COMPONENTS_PACKAGE = exports.CORE_PACKAGE = exports.FLAMEWORK_SCOPE = void 0;
+/**
+ * The npm scope every Flamework package is published under, and the package names the transformer
+ * emits imports for or resolves. Nothing else in the transformer spells the scope out.
+ */
+exports.FLAMEWORK_SCOPE = "@flamework-experimental";
+exports.CORE_PACKAGE = "".concat(exports.FLAMEWORK_SCOPE, "/core");
+exports.COMPONENTS_PACKAGE = "".concat(exports.FLAMEWORK_SCOPE, "/components");
+exports.NETWORKING_PACKAGE = "".concat(exports.FLAMEWORK_SCOPE, "/networking");
+exports.PLUGIN_PACKAGE = "".concat(exports.FLAMEWORK_SCOPE, "/transformer-plugin");