fix: not transforming declaration files

Used replica of typescript compiler visitor
- fix export * syntax

closes #13, #14

Author: anion155

.gitignore

@@ -1,3 +1,3 @@
 lib
 node_modules
-tests/**/*.js
+tests/out/

.travis.yml

@@ -3,7 +3,7 @@ node_js:
 - stable
 script:
 - npm test
-- npx prettier "{src,tests}/**/*.ts" -c
+- npx prettier "src/**/*.ts" -c
 deploy:
   provider: npm
   email: danielpza@protonmail.com

package.json

@@ -37,7 +37,7 @@
     "build": "tsc",
     "prepare": "npm run build",
     "release": "standard-version",
-    "test": "npm run build && ttsc -p tests/tsconfig.json && node tests/out/core/index.js"
+    "test": "./test.sh"
   },
   "dependencies": {
     "slash": "^3.0.0"

src/index.ts

@@ -2,55 +2,182 @@ import { dirname, relative, resolve } from "path";
 import ts from "typescript";
 import slash from "slash";
 
-const transformer = <T extends ts.Node>(_: ts.Program) => {
-  return (context: ts.TransformationContext) => (rootNode: T) => {
-    const compilerOptions = context.getCompilerOptions();
+const transformer = (_: ts.Program) => (context: ts.TransformationContext) => (
+  sourceFile: ts.SourceFile
+) => {
+  const resolver =
+    typeof (context as any).getEmitResolver === "function"
+      ? (context as any).getEmitResolver()
+      : undefined;
+  const compilerOptions = context.getCompilerOptions();
+  const sourceDir = dirname(sourceFile.fileName);
+
+  const { baseUrl = "", paths = {} } = compilerOptions;
+
+  const binds = Object.keys(paths)
+    .filter(key => paths[key].length)
+    .map(key => ({
+      regexp: new RegExp("^" + key.replace("*", "(.*)") + "$"),
+      path: paths[key][0]
+    }));
+
+  if (!baseUrl || binds.length === 0) {
+    // There is nothing we can do without baseUrl and paths specified.
+    return sourceFile;
+  }
+
+  function bindModuleToFile(moduleName: string) {
+    for (const { regexp, path } of binds) {
+      const match = regexp.exec(moduleName);
+      if (match) {
+        const out = path.replace(/\*/g, match[1]);
+        const file = slash(relative(sourceDir, resolve(baseUrl, out)));
+        return file[0] === "." ? file : `./${file}`;
+      }
+    }
+  }
+
+  function visit(node: ts.Node): ts.VisitResult<ts.Node> {
     if (
-      compilerOptions.baseUrl === undefined ||
-      compilerOptions.paths === undefined
+      resolver &&
+      ts.isExportDeclaration(node) &&
+      !node.exportClause &&
+      !compilerOptions.isolatedModules &&
+      !resolver.moduleExportsSomeValue(node.moduleSpecifier)
     ) {
-      throw new Error(
-        "Should define baseUrl and paths properties in the tsconfig"
+      return undefined;
+    }
+    if (ts.isImportDeclaration(node)) {
+      return unpathImportDeclaration(node);
+    }
+    if (ts.isExportDeclaration(node)) {
+      return unpathExportDeclaration(node);
+    }
+
+    return ts.visitEachChild(node, visit, context);
+  }
+
+  function unpathImportDeclaration(
+    node: ts.ImportDeclaration
+  ): ts.VisitResult<ts.Statement> {
+    if (!ts.isStringLiteral(node.moduleSpecifier)) {
+      return node;
+    }
+    const file = bindModuleToFile(node.moduleSpecifier.text);
+    if (!file) {
+      return node;
+    }
+    const fileLiteral = ts.createLiteral(file);
+
+    const importClause = ts.visitNode(
+      node.importClause,
+      visitImportClause as any,
+      ts.isImportClause
+    );
+    return node.importClause === importClause || importClause
+      ? ts.updateImportDeclaration(
+          node,
+          node.decorators,
+          node.modifiers,
+          node.importClause,
+          fileLiteral
+        )
+      : undefined;
+  }
+  function visitImportClause(
+    node: ts.ImportClause
+  ): ts.VisitResult<ts.ImportClause> {
+    const name = resolver.isReferencedAliasDeclaration(node)
+      ? node.name
+      : undefined;
+    const namedBindings = ts.visitNode(
+      node.namedBindings,
+      visitNamedImportBindings as any,
+      ts.isNamedImports
+    );
+    return name || namedBindings
+      ? ts.updateImportClause(node, name, namedBindings)
+      : undefined;
+  }
+  function visitNamedImportBindings(
+    node: ts.NamedImportBindings
+  ): ts.VisitResult<ts.NamedImportBindings> {
+    if (node.kind === ts.SyntaxKind.NamespaceImport) {
+      return resolver.isReferencedAliasDeclaration(node) ? node : undefined;
+    } else {
+      const elements = ts.visitNodes(
+        node.elements,
+        visitImportSpecifier as any,
+        ts.isImportSpecifier
       );
+      return elements.some(e => e)
+        ? ts.updateNamedImports(node, elements)
+        : undefined;
     }
-    const baseUrl = compilerOptions.baseUrl;
-    const paths = compilerOptions.paths;
-    const regPaths = Object.keys(paths).map(key => ({
-      regexp: new RegExp("^" + key.replace("*", "(.*)") + "$"),
-      resolve: paths[key][0]
-    }));
-    let fileDir = "";
-    function findFileInPaths(text: string) {
-      for (const path of regPaths) {
-        const match = text.match(path.regexp);
-        if (match) {
-          const out = path.resolve.replace(/\*/g, match[1]);
-          const file = slash(relative(fileDir, resolve(baseUrl, out)));
-          return file[0] === "." ? file : `./${file}`;
-        }
-      }
-      return null;
+  }
+  function visitImportSpecifier(
+    node: ts.ImportSpecifier
+  ): ts.VisitResult<ts.ImportSpecifier> {
+    return resolver.isReferencedAliasDeclaration(node) ? node : undefined;
+  }
+
+  function unpathExportDeclaration(
+    node: ts.ExportDeclaration
+  ): ts.VisitResult<ts.Statement> {
+    if (!node.moduleSpecifier || !ts.isStringLiteral(node.moduleSpecifier)) {
+      return node;
     }
-    function visit(node: ts.Node): ts.Node {
-      if (ts.isSourceFile(node)) {
-        fileDir = dirname(node.fileName);
-        return ts.visitEachChild(node, visit, context);
-      }
-      if (
-        (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) &&
-        node.moduleSpecifier &&
-        ts.isStringLiteral(node.moduleSpecifier)
-      ) {
-        const file = findFileInPaths(node.moduleSpecifier.text);
-        if (file) {
-          node.moduleSpecifier.text = file;
-          return node;
-        }
-      }
-      return ts.visitEachChild(node, visit, context);
+    if (
+      !node.exportClause &&
+      !compilerOptions.isolatedModules &&
+      !resolver.moduleExportsSomeValue(node.moduleSpecifier)
+    ) {
+      return node;
     }
-    return ts.visitNode(rootNode, visit);
-  };
+    if (node.exportClause && resolver.isValueAliasDeclaration(node)) {
+      return node;
+    }
+
+    const file = bindModuleToFile(node.moduleSpecifier.text);
+    if (!file) {
+      return node;
+    }
+    const fileLiteral = ts.createLiteral(file);
+
+    const exportClause = ts.visitNode(
+      node.exportClause,
+      visitNamedExports as any,
+      ts.isNamedExports
+    );
+    return node.exportClause === exportClause || exportClause
+      ? ts.updateExportDeclaration(
+          node,
+          node.decorators,
+          node.modifiers,
+          node.exportClause,
+          fileLiteral
+        )
+      : undefined;
+  }
+  function visitNamedExports(
+    node: ts.NamedExports
+  ): ts.VisitResult<ts.NamedExports> {
+    const elements = ts.visitNodes(
+      node.elements,
+      visitExportSpecifier as any,
+      ts.isExportSpecifier
+    );
+    return elements.some(e => e)
+      ? ts.updateNamedExports(node, elements)
+      : undefined;
+  }
+  function visitExportSpecifier(
+    node: ts.ExportSpecifier
+  ): ts.VisitResult<ts.ExportSpecifier> {
+    return resolver.isValueAliasDeclaration(node) ? node : undefined;
+  }
+
+  return ts.visitNode(sourceFile, visit);
 };
 
 export default transformer;

test.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+
+set -e
+
+npm run build
+npx ttsc -p tests/tsconfig.json
+node tests/out/core/index.js
+if fgrep '@utils' tests/out/*/* ;
+then
+  false
+fi

tests/tsconfig.json

@@ -5,6 +5,7 @@
 
     "strict": true,
 
+    "declaration": true,
     "outDir": "out/",
     "baseUrl": "./",
     "paths": {
@@ -13,6 +14,9 @@
 
     "esModuleInterop": true,
 
-    "plugins": [{ "transform": "../" }]
+    "plugins": [
+      { "transform": "../" },
+      { "transform": "../", "afterDeclarations": true }
+    ]
   }
 }

tests/utils/types-only.ts

@@ -1,3 +1,3 @@
 export type NoRuntimecodeHere = "never gonna give you up!";
 
-// throw new Error('Not supposed to be!');
+throw new Error("Not supposed to be!");

tsconfig.json

@@ -12,5 +12,5 @@
 
     "esModuleInterop": true
   },
-  "include": ["src/**/*"]
+  "exclude": ["tests", "lib"]
 }