@neo-one/smart-contract-compiler/dist/cjs/compile/declaration/ImportDeclarationCompiler.js

NEO•ONE TypeScript smart contract compiler.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ImportDeclarationCompiler = void 0;
const tslib_1 = require("tslib");
const ts_utils_1 = require("@neo-one/ts-utils");
const typescript_1 = tslib_1.__importDefault(require("typescript"));
const NodeCompiler_1 = require("../NodeCompiler");
class ImportDeclarationCompiler extends NodeCompiler_1.NodeCompiler {
    constructor() {
        super(...arguments);
        this.kind = typescript_1.default.SyntaxKind.ImportDeclaration;
    }
    visitNode(sb, node, optionsIn) {
        const options = sb.pushValueOptions(optionsIn);
        const sourceFile = ts_utils_1.tsUtils.importExport.getModuleSpecifierSourceFile(sb.context.typeChecker, node);
        if (sourceFile === undefined) {
            return;
        }
        if (ts_utils_1.tsUtils.file.isDeclarationFile(sourceFile)) {
            return;
        }
        if (!ts_utils_1.tsUtils.importExport.hasValueReference(sb.context.program, sb.context.languageService, node)) {
            return;
        }
        sb.loadModule(sourceFile);
        const namespaceImport = ts_utils_1.tsUtils.importDeclaration.getNamespaceImportIdentifier(node);
        if (namespaceImport !== undefined) {
            const name = namespaceImport.getText();
            sb.scope.add(name);
            sb.emitHelper(node, options, sb.helpers.createPropertyObject);
            sb.scope.set(sb, node, options, name);
        }
        else {
            const defaultImport = ts_utils_1.tsUtils.importDeclaration.getDefaultImport(node);
            const namedImports = this.getExportedNamedImports(sb, node, sourceFile);
            if (defaultImport !== undefined) {
                if (namedImports.length > 0) {
                    sb.emitOp(node, 'DUP');
                }
                sb.emitPushString(node, 'default');
                sb.emitOp(node, 'PICKITEM');
                const name = defaultImport.getText();
                sb.scope.add(name);
                sb.scope.set(sb, node, options, name);
            }
            if (namedImports.length > 0) {
                namedImports.forEach((namedImport) => {
                    const importName = this.getImportName(namedImport);
                    sb.emitOp(node, 'DUP');
                    sb.emitPushString(node, importName);
                    sb.emitOp(node, 'PICKITEM');
                    const name = ts_utils_1.tsUtils.node.getName(namedImport);
                    sb.scope.add(name);
                    sb.scope.set(sb, node, options, name);
                });
                sb.emitOp(node, 'DROP');
            }
        }
    }
    getExportedNamedImports(sb, node, sourceFile) {
        return ts_utils_1.tsUtils.importDeclaration
            .getNamedImports(node)
            .filter((namedImport) => sb.hasExport(sourceFile, this.getImportName(namedImport)));
    }
    getImportName(node) {
        const alias = ts_utils_1.tsUtils.node.getPropertyNameNode(node);
        return alias === undefined ? ts_utils_1.tsUtils.node.getName(node) : ts_utils_1.tsUtils.node.getText(alias);
    }
}
exports.ImportDeclarationCompiler = ImportDeclarationCompiler;

//# sourceMappingURL=ImportDeclarationCompiler.js.map