rbxts-transformer-t-new-new/out/index.js

TypeScript transformer which converts TypeScript types to t entities

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = transformer;
var typescript_1 = __importStar(require("typescript"));
var path_1 = __importDefault(require("path"));
var fs_1 = __importDefault(require("fs"));
var transformerUtil = __importStar(require("./transformer"));
var transformer_1 = require("./transformer");
function transformer(program) {
    return function (context) { return function (file) {
        var replaceIndexNode = function (file) {
            var importFilter = transformerUtil.is_t_ImportDeclaration(program);
            return typescript_1.default.factory.updateSourceFile(file, file.statements.filter(function (s) { return !importFilter(s); }), file.isDeclarationFile, file.referencedFiles, file.typeReferenceDirectives, file.hasNoDefaultLib, file.libReferenceDirectives);
        };
        return visitNodeAndChildren(replaceIndexNode(file), program, context);
    }; };
}
function visitNodeAndChildren(node, program, context) {
    return typescript_1.default.visitEachChild(visitNode(node, program), function (childNode) { return visitNodeAndChildren(childNode, program, context); }, context);
}
function visitNode(node, program) {
    if (isModuleImportExpression(node, program)) {
        return [
            typescript_1.factory.createImportDeclaration(undefined, typescript_1.factory.createImportClause(false, undefined, typescript_1.factory.createNamedImports([
                typescript_1.factory.createImportSpecifier(false, undefined, typescript_1.factory.createIdentifier(transformerUtil.OBJECT_NAME)),
            ])), typescript_1.factory.createStringLiteral("@rbxts/t")),
            node,
        ];
    }
    if (typescript_1.default.isCallExpression(node))
        return visitCallExpression(node, program);
    return node;
}
function handleTerrifyCallExpression(node, functionName, typeChecker) {
    switch (functionName) {
        case transformerUtil.MARCO_NAME: {
            var typeArguments = node.typeArguments;
            if (typeArguments === undefined || typeArguments.length === 0)
                throw new Error("Please pass a type argument to the $terrify function");
            var type = typeChecker.getTypeFromTypeNode(typeArguments[0]);
            return (0, transformer_1.buildType)(type, typeChecker);
        }
        default:
            throw "function ".concat(functionName, " cannot be handled by this version of rbxts-interface-to-t");
    }
}
function visitCallExpression(node, program) {
    var typeChecker = program.getTypeChecker();
    var signature = typeChecker.getResolvedSignature(node);
    if (!signature)
        return node;
    var declaration = signature.declaration;
    if (!declaration ||
        typescript_1.default.isJSDocSignature(declaration) ||
        !isModule(declaration.getSourceFile()))
        return node;
    var functionName = declaration.name && declaration.name.getText();
    if (!functionName)
        return node;
    return handleTerrifyCallExpression(node, functionName, typeChecker);
}
var sourceText = fs_1.default.readFileSync(path_1.default.join(__dirname, "..", "index.d.ts"), "utf8");
function isModule(sourceFile) {
    return sourceFile.text === sourceText;
}
function isModuleImportExpression(node, program) {
    if (!typescript_1.default.isImportDeclaration(node))
        return false;
    if (!node.importClause)
        return false;
    var namedBindings = node.importClause.namedBindings;
    if (!node.importClause.name && !namedBindings)
        return false;
    var importSymbol = program
        .getTypeChecker()
        .getSymbolAtLocation(node.moduleSpecifier);
    if (!importSymbol ||
        !isModule(importSymbol.valueDeclaration.getSourceFile()))
        // TODO
        return false;
    return true;
}