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

NEO•ONE TypeScript smart contract compiler.

import { tsUtils } from '@neo-one/ts-utils';
import ts from 'typescript';
import { NodeCompiler } from '../NodeCompiler';
export class ImportDeclarationCompiler extends NodeCompiler {
    constructor() {
        super(...arguments);
        this.kind = ts.SyntaxKind.ImportDeclaration;
    }
    visitNode(sb, node, optionsIn) {
        const options = sb.pushValueOptions(optionsIn);
        const sourceFile = tsUtils.importExport.getModuleSpecifierSourceFile(sb.context.typeChecker, node);
        if (sourceFile === undefined) {
            return;
        }
        if (tsUtils.file.isDeclarationFile(sourceFile)) {
            return;
        }
        if (!tsUtils.importExport.hasValueReference(sb.context.program, sb.context.languageService, node)) {
            return;
        }
        sb.loadModule(sourceFile);
        const namespaceImport = 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 = 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 = tsUtils.node.getName(namedImport);
                    sb.scope.add(name);
                    sb.scope.set(sb, node, options, name);
                });
                sb.emitOp(node, 'DROP');
            }
        }
    }
    getExportedNamedImports(sb, node, sourceFile) {
        return tsUtils.importDeclaration
            .getNamedImports(node)
            .filter((namedImport) => sb.hasExport(sourceFile, this.getImportName(namedImport)));
    }
    getImportName(node) {
        const alias = tsUtils.node.getPropertyNameNode(node);
        return alias === undefined ? tsUtils.node.getName(node) : tsUtils.node.getText(alias);
    }
}

//# sourceMappingURL=ImportDeclarationCompiler.js.map