auto-cr-rules/dist/imports.js

Extensible static analysis rule set for the auto-cr automated code review toolkit

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.collectImportReferences = void 0;
var isSwcNode = function (value) {
    if (!value || typeof value !== 'object') {
        return false;
    }
    if (!('type' in value)) {
        return false;
    }
    return typeof value.type === 'string';
};
var traverse = function (value, visitor) {
    if (Array.isArray(value)) {
        for (var _i = 0, value_1 = value; _i < value_1.length; _i++) {
            var element = value_1[_i];
            traverse(element, visitor);
        }
        return;
    }
    if (!value || typeof value !== 'object') {
        return;
    }
    if (isSwcNode(value)) {
        visitor(value);
    }
    var record = value;
    for (var _a = 0, _b = Object.values(record); _a < _b.length; _a++) {
        var child = _b[_a];
        if (typeof child === 'object' && child !== null) {
            traverse(child, visitor);
        }
    }
};
var isImportDeclaration = function (node) { return node.type === 'ImportDeclaration'; };
var isCallExpression = function (node) { return node.type === 'CallExpression'; };
var collectImportReferences = function (module) {
    var results = [];
    traverse(module, function (node) {
        if (isImportDeclaration(node)) {
            results.push({
                kind: 'static',
                value: node.source.value,
                span: node.source.span,
            });
            return;
        }
        if (isCallExpression(node)) {
            var reference = extractFromCallExpression(node);
            if (reference) {
                results.push(reference);
            }
        }
    });
    return results;
};
exports.collectImportReferences = collectImportReferences;
var extractFromCallExpression = function (node) {
    if (!node.arguments.length) {
        return null;
    }
    var firstArgument = node.arguments[0];
    if (!firstArgument || isSpread(firstArgument)) {
        return null;
    }
    var literal = getStringLiteral(firstArgument);
    if (!literal) {
        return null;
    }
    if (node.callee.type === 'Import') {
        return createImportReference('dynamic', literal);
    }
    if (isRequireIdentifier(node.callee) || isRequireMember(node.callee)) {
        return createImportReference('require', literal);
    }
    return null;
};
var createImportReference = function (kind, literal) { return ({
    kind: kind,
    value: literal.value,
    span: literal.span,
}); };
var isSpread = function (argument) { return Boolean(argument.spread); };
var getStringLiteral = function (argument) {
    if (argument.expression.type === 'StringLiteral') {
        return argument.expression;
    }
    return null;
};
var isRequireIdentifier = function (expression) {
    return expression.type === 'Identifier' && expression.value === 'require';
};
var isRequireMember = function (expression) {
    return (expression.type === 'MemberExpression' &&
        expression.object.type === 'Identifier' &&
        expression.object.value === 'require');
};