@flamework-experimental/transformer 2.0.0-alpha.0

package/out/classes/logger.js

@@ -0,0 +1,201 @@
+"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.Logger = void 0;
+var chalk_1 = __importDefault(require("chalk"));
+function getTime() {
+    var hrTime = process.hrtime();
+    return hrTime[0] * 1000 + hrTime[1] / 1e6;
+}
+var Logger = /** @class */ (function () {
+    function Logger() {
+    }
+    Logger.timer = function (name) {
+        this.queueTimer();
+        this.timers.push([name, getTime()]);
+    };
+    Logger.timerEnd = function () {
+        var timer = this.timers.pop();
+        if (!timer)
+            return;
+        var currentValue = this.timerTotals.get(timer[0]);
+        if (!currentValue)
+            this.timerTotals.set(timer[0], (currentValue = [0, 0]));
+        currentValue[0] += getTime() - timer[1];
+        currentValue[1]++;
+    };
+    Logger.queueTimer = function () {
+        var _this = this;
+        if (this.timerHandle !== undefined) {
+            this.timerHandle.refresh();
+            return;
+        }
+        this.timerHandle = setTimeout(function () {
+            var e_1, _a;
+            var totals = _this.timerTotals;
+            _this.timerTotals = new Map();
+            try {
+                for (var totals_1 = __values(totals), totals_1_1 = totals_1.next(); !totals_1_1.done; totals_1_1 = totals_1.next()) {
+                    var _b = __read(totals_1_1.value, 2), name_1 = _b[0], _c = __read(_b[1], 2), total = _c[0], count = _c[1];
+                    console.log("Timer '".concat(name_1, "' took ").concat(total.toFixed(2), "ms (").concat(count, ")"));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (totals_1_1 && !totals_1_1.done && (_a = totals_1.return)) _a.call(totals_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        });
+    };
+    Logger.write = function (message) {
+        process.stdout.write(message);
+    };
+    Logger.writeLine = function () {
+        var e_2, _a;
+        var messages = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            messages[_i] = arguments[_i];
+        }
+        if (!this.debug)
+            return;
+        try {
+            for (var messages_1 = __values(messages), messages_1_1 = messages_1.next(); !messages_1_1.done; messages_1_1 = messages_1.next()) {
+                var message = messages_1_1.value;
+                var text = typeof message === "string" ? "".concat(message) : "".concat(JSON.stringify(message, undefined, "\t"));
+                var flameworkPrefix = "[".concat(chalk_1.default.gray("Flamework"), "]: ");
+                this.write("".concat(flameworkPrefix).concat(text.replace(/\n/g, "\n".concat(flameworkPrefix)), "\n"));
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (messages_1_1 && !messages_1_1.done && (_a = messages_1.return)) _a.call(messages_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    };
+    Logger.writeLineIfVerbose = function () {
+        var messages = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            messages[_i] = arguments[_i];
+        }
+        if (this.verbose)
+            return this.writeLine.apply(this, __spreadArray([], __read(messages), false));
+    };
+    Logger.info = function () {
+        var messages = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            messages[_i] = arguments[_i];
+        }
+        this.writeLine.apply(this, __spreadArray([], __read(messages.map(function (x) { return chalk_1.default.blue(x); })), false));
+    };
+    Logger.infoIfVerbose = function () {
+        var messages = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            messages[_i] = arguments[_i];
+        }
+        if (this.verbose)
+            return this.info.apply(this, __spreadArray([], __read(messages), false));
+    };
+    Logger.warn = function () {
+        var messages = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            messages[_i] = arguments[_i];
+        }
+        this.writeLine.apply(this, __spreadArray([], __read(messages.map(function (x) { return chalk_1.default.yellow(x); })), false));
+    };
+    Logger.warnIfVerbose = function () {
+        var messages = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            messages[_i] = arguments[_i];
+        }
+        if (this.verbose)
+            return this.warn.apply(this, __spreadArray([], __read(messages), false));
+    };
+    Logger.error = function () {
+        var messages = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            messages[_i] = arguments[_i];
+        }
+        this.writeLine.apply(this, __spreadArray([], __read(messages.map(function (x) { return chalk_1.default.red(x); })), false));
+    };
+    Logger.benchmark = function (label) {
+        if (!this.debug)
+            return;
+        var depth = this.benchmarkLabels.length;
+        this.benchmarkLabels.push({
+            start: new Date().getTime(),
+            label: label,
+        });
+        this.benchmarkOutput += "".concat("\t".repeat(depth), "Begin ").concat(label, "\n");
+    };
+    Logger.benchmarkEnd = function () {
+        if (!this.debug)
+            return;
+        var label = this.benchmarkLabels.pop();
+        var depth = this.benchmarkLabels.length;
+        if (!label)
+            throw new Error("Unexpected benchmarkEnd()");
+        var timeDifference = new Date().getTime() - label.start;
+        this.benchmarkOutput += "".concat("\t".repeat(depth), "End ").concat(label.label, " (").concat(timeDifference, "ms)\n");
+        if (depth === 0) {
+            this.info(this.benchmarkOutput);
+            this.benchmarkOutput = "";
+        }
+    };
+    Logger.debug = true;
+    Logger.verbose = process.argv.includes("--verbose");
+    Logger.timerTotals = new Map();
+    Logger.timers = new Array();
+    Logger.benchmarkLabels = [];
+    Logger.benchmarkOutput = "";
+    (function () {
+        // Workaround for vscode PTY not having color highlighting.
+        if (process.env.VSCODE_CWD !== undefined) {
+            // ANSI 256
+            chalk_1.default.level = 2;
+        }
+    })();
+    return Logger;
+}());
+exports.Logger = Logger;

package/out/classes/nodeMetadata.js

@@ -0,0 +1,232 @@
+"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.NodeMetadata = void 0;
+var typescript_1 = __importDefault(require("typescript"));
+var factory_1 = require("../util/factory");
+var NodeMetadata = /** @class */ (function () {
+    function NodeMetadata(state, node) {
+        this.set = new Set();
+        this.symbols = new Map();
+        this.types = new Map();
+        this.trace = new Map();
+        this.parse(state, node);
+    }
+    NodeMetadata.fromSymbol = function (state, symbol) {
+        if (symbol.valueDeclaration) {
+            return NodeMetadata.fromCache(state, symbol.valueDeclaration);
+        }
+    };
+    NodeMetadata.fromCache = function (state, node) {
+        var existing = NodeMetadata.metadataCache.get(node);
+        if (existing) {
+            return existing;
+        }
+        var metadata = new NodeMetadata(state, node);
+        NodeMetadata.metadataCache.set(node, metadata);
+        return metadata;
+    };
+    NodeMetadata.prototype.parseText = function (text, node) {
+        var e_1, _a;
+        try {
+            for (var _b = __values(text.trim().replace(/\s+/, " ").split(" ")), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var name_1 = _c.value;
+                this.set.add(name_1);
+                this.trace.set(name_1, node);
+            }
+        }
+        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; }
+        }
+    };
+    NodeMetadata.prototype.parseMetadata = function (state, tag) {
+        var e_2, _a;
+        if (typeof tag.comment === "string") {
+            this.parseText(tag.comment, tag);
+        }
+        else if (tag.comment) {
+            try {
+                for (var _b = __values(tag.comment), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var comment = _c.value;
+                    if (typescript_1.default.isJSDocLinkLike(comment)) {
+                        if (!comment.name)
+                            continue;
+                        var symbol = state.getSymbol(comment.name);
+                        if (!symbol)
+                            continue;
+                        var type = symbol.flags & typescript_1.default.SymbolFlags.TypeAlias
+                            ? state.typeChecker.getDeclaredTypeOfSymbol(symbol)
+                            : state.typeChecker.getTypeAtLocation(comment.name);
+                        var symbols = this.symbols.get(comment.text);
+                        var types = this.types.get(comment.text);
+                        if (!types)
+                            this.types.set(comment.text, (types = []));
+                        if (!symbols)
+                            this.symbols.set(comment.text, (symbols = []));
+                        symbols.push(symbol);
+                        types.push(type);
+                        this.trace.set(symbol, comment);
+                        this.trace.set(type, comment);
+                    }
+                    else {
+                        this.parseText(comment.text, comment);
+                    }
+                }
+            }
+            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; }
+            }
+        }
+    };
+    NodeMetadata.prototype.parse = function (state, node) {
+        var e_3, _a, e_4, _b, e_5, _c, e_6, _d, e_7, _e, e_8, _f;
+        var _g, _h;
+        var tags = typescript_1.default.getJSDocTags(node);
+        try {
+            for (var tags_1 = __values(tags), tags_1_1 = tags_1.next(); !tags_1_1.done; tags_1_1 = tags_1.next()) {
+                var tag = tags_1_1.value;
+                if (tag.tagName.text === "metadata") {
+                    this.parseMetadata(state, tag);
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (tags_1_1 && !tags_1_1.done && (_a = tags_1.return)) _a.call(tags_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        var decorators = typescript_1.default.canHaveDecorators(node) ? typescript_1.default.getDecorators(node) : undefined;
+        if (decorators) {
+            try {
+                for (var decorators_1 = __values(decorators), decorators_1_1 = decorators_1.next(); !decorators_1_1.done; decorators_1_1 = decorators_1.next()) {
+                    var decorator = decorators_1_1.value;
+                    var expression = decorator.expression;
+                    var symbol = state.getSymbol(factory_1.f.is.call(expression) ? expression.expression : expression);
+                    if (!symbol || !symbol.declarations)
+                        continue;
+                    try {
+                        for (var _j = (e_5 = void 0, __values(symbol.declarations)), _k = _j.next(); !_k.done; _k = _j.next()) {
+                            var declaration = _k.value;
+                            this.parse(state, declaration);
+                        }
+                    }
+                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                    finally {
+                        try {
+                            if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                    }
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (decorators_1_1 && !decorators_1_1.done && (_b = decorators_1.return)) _b.call(decorators_1);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+        }
+        if (typescript_1.default.isClassElement(node) && node.name) {
+            // Interfaces are able to request metadata for their own property/methods.
+            var name_2 = typescript_1.default.getNameFromPropertyName(node.name);
+            if (name_2 && typescript_1.default.isClassLike(node.parent)) {
+                var implementNodes = typescript_1.default.getEffectiveImplementsTypeNodes(node.parent);
+                if (implementNodes) {
+                    try {
+                        for (var implementNodes_1 = __values(implementNodes), implementNodes_1_1 = implementNodes_1.next(); !implementNodes_1_1.done; implementNodes_1_1 = implementNodes_1.next()) {
+                            var implement = implementNodes_1_1.value;
+                            var symbol = state.getSymbol(implement.expression);
+                            var member = (_g = symbol === null || symbol === void 0 ? void 0 : symbol.members) === null || _g === void 0 ? void 0 : _g.get(typescript_1.default.escapeLeadingUnderscores(name_2));
+                            if (member && member.declarations) {
+                                try {
+                                    for (var _l = (e_7 = void 0, __values(member.declarations)), _m = _l.next(); !_m.done; _m = _l.next()) {
+                                        var declaration = _m.value;
+                                        this.parse(state, declaration);
+                                    }
+                                }
+                                catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                                finally {
+                                    try {
+                                        if (_m && !_m.done && (_e = _l.return)) _e.call(_l);
+                                    }
+                                    finally { if (e_7) throw e_7.error; }
+                                }
+                            }
+                        }
+                    }
+                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                    finally {
+                        try {
+                            if (implementNodes_1_1 && !implementNodes_1_1.done && (_d = implementNodes_1.return)) _d.call(implementNodes_1);
+                        }
+                        finally { if (e_6) throw e_6.error; }
+                    }
+                }
+            }
+        }
+        else if (typescript_1.default.isClassLike(node)) {
+            // Interfaces are able to request metadata for the object it is implemented on.
+            var implementNodes = typescript_1.default.getEffectiveImplementsTypeNodes(node);
+            if (implementNodes) {
+                try {
+                    for (var implementNodes_2 = __values(implementNodes), implementNodes_2_1 = implementNodes_2.next(); !implementNodes_2_1.done; implementNodes_2_1 = implementNodes_2.next()) {
+                        var implement = implementNodes_2_1.value;
+                        var symbol = state.getSymbol(implement.expression);
+                        if (symbol && ((_h = symbol.declarations) === null || _h === void 0 ? void 0 : _h[0])) {
+                            this.parse(state, symbol.declarations[0]);
+                        }
+                    }
+                }
+                catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                finally {
+                    try {
+                        if (implementNodes_2_1 && !implementNodes_2_1.done && (_f = implementNodes_2.return)) _f.call(implementNodes_2);
+                    }
+                    finally { if (e_8) throw e_8.error; }
+                }
+            }
+        }
+    };
+    NodeMetadata.prototype.isRequested = function (metadata) {
+        if (this.set.has("~".concat(metadata))) {
+            return false;
+        }
+        return this.set.has(metadata) || this.set.has("*");
+    };
+    NodeMetadata.prototype.getSymbol = function (key) {
+        return this.symbols.get(key);
+    };
+    NodeMetadata.prototype.getType = function (key) {
+        return this.types.get(key);
+    };
+    NodeMetadata.prototype.getTrace = function (name) {
+        return this.trace.get(name);
+    };
+    NodeMetadata.metadataCache = new WeakMap();
+    return NodeMetadata;
+}());
+exports.NodeMetadata = NodeMetadata;