@flamework-experimental/transformer 2.0.0-alpha.0

package/out/transformer.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+// internals declared locally in src/types/tsInternals.d.ts
+var typescript_1 = __importDefault(require("typescript"));
+var path_1 = __importDefault(require("path"));
+var transformFile_1 = require("./transformations/transformFile");
+var transformState_1 = require("./classes/transformState");
+var logger_1 = require("./classes/logger");
+var factory_1 = require("./util/factory");
+var chalk_1 = __importDefault(require("chalk"));
+var emitTypescriptMismatch_1 = require("./util/functions/emitTypescriptMismatch");
+var constants_1 = require("./util/constants");
+function default_1(program, config) {
+    return function (context) {
+        if (logger_1.Logger.verbose)
+            logger_1.Logger.write("\n");
+        factory_1.f.setFactory(context.factory);
+        var state = new transformState_1.TransformState(program, context, config !== null && config !== void 0 ? config : {});
+        var projectFlameworkVersion = state.buildInfo.getFlameworkVersion();
+        if (projectFlameworkVersion !== constants_1.PKG_VERSION) {
+            logger_1.Logger.writeLine("".concat(chalk_1.default.red("Project was compiled on different version of Flamework.")), "Please recompile by deleting the ".concat(path_1.default.relative(state.currentDirectory, state.outDir), " directory"), "Current Flamework Version: ".concat(chalk_1.default.yellow(constants_1.PKG_VERSION)), "Previous Flamework Version: ".concat(chalk_1.default.yellow(projectFlameworkVersion)));
+            process.exit(1);
+        }
+        setTimeout(function () { return state.saveArtifacts(); });
+        return function (file) {
+            if (!typescript_1.default.isSourceFile(file)) {
+                (0, emitTypescriptMismatch_1.emitTypescriptMismatch)(state, chalk_1.default.red("Failed to load! TS version mismatch detected"));
+            }
+            if (state.config.noSemanticDiagnostics !== true) {
+                var originalFile = typescript_1.default.getParseTreeNode(file, typescript_1.default.isSourceFile);
+                if (originalFile) {
+                    var preEmitDiagnostics = typescript_1.default.getPreEmitDiagnostics(program, originalFile);
+                    if (preEmitDiagnostics.some(function (x) { return x.category === typescript_1.default.DiagnosticCategory.Error; })) {
+                        preEmitDiagnostics
+                            .filter(typescript_1.default.isDiagnosticWithLocation)
+                            .forEach(function (diag) { return context.addDiagnostic(diag); });
+                        return file;
+                    }
+                }
+                else {
+                    var relativeName = path_1.default.relative(state.srcDir, file.fileName);
+                    logger_1.Logger.warn("Failed to validate '".concat(relativeName, "' due to lack of parse tree node."));
+                }
+            }
+            return (0, transformFile_1.transformFile)(state, file);
+        };
+    };
+}

package/out/util/cache.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = void 0;
+/**
+ * Global cache that is only reset when rbxtsc is restarted.
+ */
+exports.Cache = {
+    isInitialCompile: true,
+    pkgJsonCache: new Map(),
+};

package/out/util/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PKG_VERSION = void 0;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+exports.PKG_VERSION = require("../../package.json").version;

package/out/util/diagnosticsUtils.js

@@ -0,0 +1,112 @@
+"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.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureDiagnostic = captureDiagnostic;
+exports.relocateDiagnostic = relocateDiagnostic;
+exports.catchDiagnostic = catchDiagnostic;
+exports.withDiagnosticContext = withDiagnosticContext;
+var typescript_1 = __importDefault(require("typescript"));
+var diagnostics_1 = require("../classes/diagnostics");
+function captureDiagnostic(cb) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    try {
+        return { success: true, value: cb.apply(void 0, __spreadArray([], __read(args), false)) };
+    }
+    catch (e) {
+        if ("diagnostic" in e) {
+            /// Temporary workaround for 1.1.1
+            if (typescript_1.default.version.startsWith("1.1.1") &&
+                !typescript_1.default.version.startsWith("1.1.1-dev") &&
+                !globalThis.RBXTSC_DEV) {
+                e.diagnostic = undefined;
+                throw e;
+            }
+            return { success: false, diagnostic: e.diagnostic };
+        }
+        throw e;
+    }
+}
+function relocateDiagnostic(node, cb) {
+    var params = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        params[_i - 2] = arguments[_i];
+    }
+    var result = captureDiagnostic.apply(void 0, __spreadArray([cb], __read(params), false));
+    if (result.success) {
+        return result.value;
+    }
+    diagnostics_1.Diagnostics.relocate(result.diagnostic, node);
+}
+function catchDiagnostic(fallback, cb) {
+    var _a;
+    var result = captureDiagnostic(cb);
+    if (!result.success) {
+        diagnostics_1.Diagnostics.addDiagnostic(result.diagnostic);
+    }
+    return (_a = result.value) !== null && _a !== void 0 ? _a : fallback;
+}
+function withDiagnosticContext(node, message, callback) {
+    var e_1, _a;
+    var _b;
+    var result = captureDiagnostic(callback);
+    if (!result.success) {
+        var newDiagnostic = diagnostics_1.Diagnostics.createDiagnostic(node, typescript_1.default.DiagnosticCategory.Error, typeof message === "string" ? message : message());
+        typescript_1.default.addRelatedInfo(newDiagnostic, result.diagnostic);
+        try {
+            for (var _c = __values((_b = result.diagnostic.relatedInformation) !== null && _b !== void 0 ? _b : []), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var relatedInfo = _d.value;
+                typescript_1.default.addRelatedInfo(newDiagnostic, relatedInfo);
+            }
+        }
+        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; }
+        }
+        throw new diagnostics_1.DiagnosticError(newDiagnostic);
+    }
+    return result.value;
+}

package/out/util/env.js

@@ -0,0 +1,267 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENV_FILES = void 0;
+exports.parseEnvFile = parseEnvFile;
+exports.loadEnv = loadEnv;
+exports.substituteEnv = substituteEnv;
+exports.coerceBySchema = coerceBySchema;
+var fs_1 = __importDefault(require("fs"));
+var path_1 = __importDefault(require("path"));
+/** The files read next to `flamework.config.json`, in order; a later file overrides an earlier one. */
+exports.ENV_FILES = [".env", ".env.local"];
+/**
+ * Parses a dotenv file: one `KEY=value` per line, an optional `export ` prefix, `#` comments and
+ * blank lines. A value in double quotes honours `\n`, `\t`, `\r`, `\\` and `\"`; one in single
+ * quotes is taken as written; an unquoted value is trimmed and ends at a ` #` comment.
+ */
+function parseEnvFile(text) {
+    var e_1, _a;
+    var result = {};
+    try {
+        for (var _b = __values(text.split(/\r?\n/)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var rawLine = _c.value;
+            var line = rawLine.trim();
+            if (line === "" || line.startsWith("#")) {
+                continue;
+            }
+            var match = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(line);
+            if (!match) {
+                continue;
+            }
+            var _d = __read(match, 3), key = _d[1], rest = _d[2];
+            result[key] = parseEnvValue(rest);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return result;
+}
+function parseEnvValue(rest) {
+    var quote = rest[0];
+    if (quote === '"' || quote === "'") {
+        var value = "";
+        for (var i = 1; i < rest.length; i++) {
+            var char = rest[i];
+            if (char === quote) {
+                return value;
+            }
+            if (quote === '"' && char === "\\" && i + 1 < rest.length) {
+                var next = rest[++i];
+                value += next === "n" ? "\n" : next === "t" ? "\t" : next === "r" ? "\r" : next;
+                continue;
+            }
+            value += char;
+        }
+        // No closing quote: the rest of the line is the value, quote included, as dotenv does.
+        return rest;
+    }
+    var comment = rest.search(/\s#/);
+    return (comment === -1 ? rest : rest.slice(0, comment)).trim();
+}
+/**
+ * The environment a config file is substituted from: `.env`, then `.env.local` on top, both from
+ * the given directory, with the process environment on top of both.
+ */
+function loadEnv(directory, processEnv) {
+    var e_2, _a, e_3, _b;
+    if (processEnv === void 0) { processEnv = process.env; }
+    var env = {};
+    try {
+        for (var ENV_FILES_1 = __values(exports.ENV_FILES), ENV_FILES_1_1 = ENV_FILES_1.next(); !ENV_FILES_1_1.done; ENV_FILES_1_1 = ENV_FILES_1.next()) {
+            var file = ENV_FILES_1_1.value;
+            var envPath = path_1.default.join(directory, file);
+            if (fs_1.default.existsSync(envPath)) {
+                Object.assign(env, parseEnvFile(fs_1.default.readFileSync(envPath, "utf8")));
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (ENV_FILES_1_1 && !ENV_FILES_1_1.done && (_a = ENV_FILES_1.return)) _a.call(ENV_FILES_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    try {
+        for (var _c = __values(Object.entries(processEnv)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var _e = __read(_d.value, 2), key = _e[0], value = _e[1];
+            if (value !== undefined) {
+                env[key] = value;
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return env;
+}
+var PLACEHOLDER = /\$\$|\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g;
+/**
+ * Replaces `${NAME}` and `${NAME:-fallback}` in every string of a parsed config with the variable's
+ * value, and `$$` with a literal dollar. Keys are left alone.
+ *
+ * A variable that is not set and has no fallback raises, naming the variable and where it was used.
+ */
+function substituteEnv(value, env, describe) {
+    var substituted = new Set();
+    var visit = function (current, pointer) {
+        var e_4, _a;
+        if (typeof current === "string") {
+            // `replace` with a global pattern starts from the beginning every time; `test` would not.
+            var matched_1 = false;
+            var replaced = current.replace(PLACEHOLDER, function (match, name, fallback) {
+                matched_1 = true;
+                if (match === "$$") {
+                    return "$";
+                }
+                var found = env[name];
+                if (found !== undefined) {
+                    return found;
+                }
+                if (fallback !== undefined) {
+                    return fallback;
+                }
+                throw new Error("".concat(describe(pointer), " uses $").concat(name, ", which is not set in the environment, .env or .env.local ") +
+                    "and has no fallback. Set it, or write ${".concat(name, ":-value} to give it one."));
+            });
+            if (matched_1) {
+                substituted.add(pointer);
+            }
+            return replaced;
+        }
+        if (Array.isArray(current)) {
+            return current.map(function (item, index) { return visit(item, "".concat(pointer, "/").concat(index)); });
+        }
+        if (current !== null && typeof current === "object") {
+            var result = {};
+            try {
+                for (var _b = __values(Object.entries(current)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var _d = __read(_c.value, 2), key = _d[0], item = _d[1];
+                    result[key] = visit(item, "".concat(pointer, "/").concat(key));
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+            return result;
+        }
+        return current;
+    };
+    return { value: visit(value, ""), substituted: substituted };
+}
+/**
+ * Converts strings sitting where a JSON schema expects a boolean, a number or a list of strings. A
+ * value from the environment is always a string, so `"obfuscation": "${OBFUSCATE:-false}"` has to
+ * become a boolean before the schema sees it.
+ *
+ * Booleans accept `true`/`false`/`1`/`0`, case-insensitively. A list splits on commas, trims, and
+ * drops empty entries, so an empty string is an empty list. A string that does not parse raises.
+ */
+function coerceBySchema(value, schema, describe) {
+    var visit = function (current, node, pointer) {
+        var e_5, _a;
+        if (node === undefined) {
+            return current;
+        }
+        if (typeof current === "string") {
+            return coerceString(current, node, function () { return describe(pointer); });
+        }
+        if (Array.isArray(current)) {
+            return current.map(function (item, index) { return visit(item, node.items, "".concat(pointer, "/").concat(index)); });
+        }
+        if (current !== null && typeof current === "object" && node.properties) {
+            var result = {};
+            try {
+                for (var _b = __values(Object.entries(current)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var _d = __read(_c.value, 2), key = _d[0], item = _d[1];
+                    result[key] = visit(item, node.properties[key], "".concat(pointer, "/").concat(key));
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+            return result;
+        }
+        return current;
+    };
+    return visit(value, schema, "");
+}
+function coerceString(value, node, where) {
+    var _a;
+    switch (node.type) {
+        case "boolean": {
+            var lowered = value.trim().toLowerCase();
+            if (lowered === "true" || lowered === "1")
+                return true;
+            if (lowered === "false" || lowered === "0")
+                return false;
+            throw new Error("".concat(where(), " is \"").concat(value, "\", which is not a boolean (true, false, 1 or 0)."));
+        }
+        case "number":
+        case "integer": {
+            var parsed = Number(value.trim());
+            if (value.trim() === "" || Number.isNaN(parsed)) {
+                throw new Error("".concat(where(), " is \"").concat(value, "\", which is not a number."));
+            }
+            return parsed;
+        }
+        case "array": {
+            if (((_a = node.items) === null || _a === void 0 ? void 0 : _a.type) !== "string") {
+                return value;
+            }
+            return value
+                .split(",")
+                .map(function (entry) { return entry.trim(); })
+                .filter(function (entry) { return entry !== ""; });
+        }
+        default:
+            return value;
+    }
+}