refactor: add support for relative import/export source replacement

Author: jedwards1211

src/compileReplacement/CallExpression.ts

@@ -0,0 +1,26 @@
+import { CallExpression, NodePath } from '../types'
+import { CompiledReplacement, CompileReplacementOptions } from '.'
+import compileRelativeSourceReplacement from './RelativeSource'
+import * as t from '@babel/types'
+
+export default function compileCallExpressionReplacement(
+  path: NodePath<CallExpression, CallExpression>,
+  compileOptions: CompileReplacementOptions
+): CompiledReplacement | void {
+  const pattern = path.value
+  const n = compileOptions.backend.t.namedTypes
+  if (n.Import.check(pattern.callee)) {
+    const sourceReplacement = compileRelativeSourceReplacement(
+      path.get('arguments').get(0),
+      compileOptions
+    )
+    if (sourceReplacement) {
+      return {
+        generate: (match, options) =>
+          t.callExpression(t.import(), [
+            sourceReplacement.generate(match, options) as t.StringLiteral,
+          ]),
+      }
+    }
+  }
+}

src/compileReplacement/ExportAllDeclaration.ts

@@ -0,0 +1,42 @@
+import { ExportAllDeclaration, NodePath, Node, StringLiteral } from '../types'
+import {
+  CompiledReplacement,
+  CompileReplacementOptions,
+  GenerateReplacementOptions,
+  ReplaceableMatch,
+} from '.'
+import compileGenericNodeReplacement from './GenericNodeReplacement'
+import transferComments from '../util/transferComments'
+import compileRelativeSourceReplacement from './RelativeSource'
+
+export default function compileExportAllDeclarationReplacement(
+  path: NodePath<ExportAllDeclaration, ExportAllDeclaration>,
+  compileOptions: CompileReplacementOptions
+): CompiledReplacement | void {
+  const replacement = compileGenericNodeReplacement(path, compileOptions)
+
+  const sourceReplacement = compileRelativeSourceReplacement(
+    path.get('source'),
+    compileOptions
+  )
+
+  return {
+    generate: (
+      match: ReplaceableMatch,
+      options: GenerateReplacementOptions
+    ): Node | Node[] => {
+      const result: ExportAllDeclaration = replacement.generate(
+        match,
+        options
+      ) as any
+      if (sourceReplacement) {
+        result.source = sourceReplacement.generate(
+          match,
+          options
+        ) as StringLiteral
+      }
+      transferComments(path.node, result)
+      return result
+    },
+  }
+}

src/compileReplacement/ExportNamedDeclaration.ts

@@ -1,21 +1,41 @@
-import { ExportNamedDeclaration, NodePath, Node } from '../types'
+import { ExportNamedDeclaration, NodePath, Node, StringLiteral } from '../types'
 import {
   CompiledReplacement,
   CompileReplacementOptions,
+  GenerateReplacementOptions,
   ReplaceableMatch,
 } from '.'
 import compileGenericNodeReplacement from './GenericNodeReplacement'
 import transferComments from '../util/transferComments'
+import compileRelativeSourceReplacement from './RelativeSource'
 
 export default function compileExportNamedDeclarationReplacement(
   path: NodePath<ExportNamedDeclaration, ExportNamedDeclaration>,
   compileOptions: CompileReplacementOptions
 ): CompiledReplacement | void {
   const n = compileOptions.backend.t.namedTypes
   const replacement = compileGenericNodeReplacement(path, compileOptions)
+
+  const sourceReplacement = compileRelativeSourceReplacement(
+    path.get('source'),
+    compileOptions
+  )
+
   return {
-    generate: (match: ReplaceableMatch): Node | Node[] => {
-      const result: ExportNamedDeclaration = replacement.generate(match) as any
+    generate: (
+      match: ReplaceableMatch,
+      options: GenerateReplacementOptions
+    ): Node | Node[] => {
+      const result: ExportNamedDeclaration = replacement.generate(
+        match,
+        options
+      ) as any
+      if (sourceReplacement) {
+        result.source = sourceReplacement.generate(
+          match,
+          options
+        ) as StringLiteral
+      }
       if (result.specifiers) {
         // move ExportDefaultSpecifier to beginning if necessary
         // because @babel/generator craps out otherwise

src/compileReplacement/GenericArrayReplacement.ts

@@ -2,6 +2,7 @@ import { NodePath, Node } from '../types'
 import compileReplacement, {
   CompiledReplacement,
   CompileReplacementOptions,
+  GenerateReplacementOptions,
   ReplaceableMatch,
 } from './index'
 import indentDebug from '../compileMatcher/indentDebug'
@@ -22,10 +23,13 @@ export default function compileGenericArrayReplacement(
   )
 
   return {
-    generate: (match: ReplaceableMatch): Node | Node[] => {
+    generate: (
+      match: ReplaceableMatch,
+      options: GenerateReplacementOptions
+    ): Node | Node[] => {
       const result: Node[] = []
       for (const elem of elemReplacements) {
-        const replacement = elem.generate(match)
+        const replacement = elem.generate(match, options)
         if (Array.isArray(replacement)) {
           replacement.forEach((elem) => result.push(elem))
         } else {

src/compileReplacement/GenericNodeReplacement.ts

@@ -2,6 +2,7 @@ import { Node, NodePath } from '../types'
 import compileReplacement, {
   CompiledReplacement,
   CompileReplacementOptions,
+  GenerateReplacementOptions,
   ReplaceableMatch,
 } from './index'
 import indentDebug from '../compileMatcher/indentDebug'
@@ -39,13 +40,16 @@ export default function compileGenericNodeReplacement(
   }
 
   return {
-    generate: (match: ReplaceableMatch): Node | Node[] => {
+    generate: (
+      match: ReplaceableMatch,
+      options: GenerateReplacementOptions
+    ): Node | Node[] => {
       const result: any = {
         type: pattern.type,
       }
 
       for (const [key, replacement] of childReplacements) {
-        const value = replacement.generate(match)
+        const value = replacement.generate(match, options)
 
         if (value !== undefined) result[key] = value
       }

src/compileReplacement/Identifier.ts

@@ -2,6 +2,7 @@ import { Node, Identifier, NodePath } from '../types'
 import {
   CompiledReplacement,
   CompileReplacementOptions,
+  GenerateReplacementOptions,
   ReplaceableMatch,
 } from './'
 import compilePlaceholderReplacement from './Placeholder'
@@ -29,11 +30,14 @@ export default function compileIdentifierReplacement(
       )
       return {
         ...placeholderReplacement,
-        generate: (match: ReplaceableMatch): Node | Node[] => {
-          const generated = placeholderReplacement.generate(match)
+        generate: (
+          match: ReplaceableMatch,
+          options: GenerateReplacementOptions
+        ): Node | Node[] => {
+          const generated = placeholderReplacement.generate(match, options)
           if (!Array.isArray(generated)) {
             ;(generated as any).typeAnnotation =
-              typeAnnotationReplacement.generate(match)
+              typeAnnotationReplacement.generate(match, options)
           }
           return generated
         },

src/compileReplacement/ImportDeclaration.ts

@@ -1,21 +1,41 @@
-import { ImportDeclaration, NodePath, Node } from '../types'
+import { ImportDeclaration, NodePath, Node, StringLiteral } from '../types'
 import {
   CompiledReplacement,
   CompileReplacementOptions,
+  GenerateReplacementOptions,
   ReplaceableMatch,
 } from '.'
 import compileGenericNodeReplacement from './GenericNodeReplacement'
 import transferComments from '../util/transferComments'
+import compileRelativeSourceReplacement from './RelativeSource'
 
 export default function compileImportDeclarationReplacement(
   path: NodePath<ImportDeclaration, ImportDeclaration>,
   compileOptions: CompileReplacementOptions
 ): CompiledReplacement | void {
   const n = compileOptions.backend.t.namedTypes
   const replacement = compileGenericNodeReplacement(path, compileOptions)
+
+  const sourceReplacement = compileRelativeSourceReplacement(
+    path.get('source'),
+    compileOptions
+  )
+
   return {
-    generate: (match: ReplaceableMatch): Node | Node[] => {
-      const result: ImportDeclaration = replacement.generate(match) as any
+    generate: (
+      match: ReplaceableMatch,
+      options: GenerateReplacementOptions
+    ): Node | Node[] => {
+      const result: ImportDeclaration = replacement.generate(
+        match,
+        options
+      ) as any
+      if (sourceReplacement) {
+        result.source = sourceReplacement.generate(
+          match,
+          options
+        ) as StringLiteral
+      }
       if (result.specifiers) {
         // move ImportDefaultSpecifier to beginning if necessary
         // because @babel/generator craps out otherwise

src/compileReplacement/RelativeSource.ts

@@ -0,0 +1,28 @@
+import { CompiledReplacement, CompileReplacementOptions } from '.'
+import { NodePath } from '../types'
+import * as t from '@babel/types'
+import Path from 'path'
+
+export default function compileRelativeSourceReplacement(
+  pattern: NodePath<any, any>,
+  compileReplacementOptions: CompileReplacementOptions
+): CompiledReplacement | void {
+  const source = pattern.value
+  const { getResolveAgainstDir } = compileReplacementOptions
+  if (
+    source.type === 'StringLiteral' &&
+    source.value.startsWith('.') &&
+    getResolveAgainstDir
+  ) {
+    const target = Path.resolve(getResolveAgainstDir(), source.value)
+    return {
+      generate: (match, { filename }) => {
+        if (!filename) return t.stringLiteral(source.value)
+        const relative = Path.relative(Path.dirname(filename), target)
+        return t.stringLiteral(
+          relative.startsWith('.') ? relative : `./${relative}`
+        )
+      },
+    }
+  }
+}

src/compileReplacement/TemplateLiteral.ts

@@ -5,9 +5,14 @@ import { unescapeIdentifier } from './Placeholder'
 import cloneNode from '../util/cloneNode'
 import * as t from '@babel/types'
 import transferComments from '../util/transferComments'
-
-function generateValue(cooked: string): { raw: string; cooked: string } {
-  return { raw: cooked.replace(/\\|`|\${/g, '\\$&'), cooked }
+function generateValue(cooked: string): {
+  raw: string
+  cooked: string
+} {
+  return {
+    raw: cooked.replace(/\\|`|\${/g, '\\$&'),
+    cooked,
+  }
 }
 
 export default function compileTemplateLiteralReplacement(

src/compileReplacement/index.ts

@@ -2,8 +2,10 @@ import { Node, NodePath, Debugger } from '../types'
 import __debug from 'debug'
 import compileGenericNodeReplacement from './GenericNodeReplacement'
 import compileGenericArrayReplacement from './GenericArrayReplacement'
+import CallExpression from './CallExpression'
 import ClassImplements from './ClassImplements'
 import ClassProperty from './ClassProperty'
+import ExportAllDeclaration from './ExportAllDeclaration'
 import ExportNamedDeclaration from './ExportNamedDeclaration'
 import ExportDefaultSpecifier from './ExportDefaultSpecifier'
 import ExportSpecifier from './ExportSpecifier'
@@ -39,18 +41,27 @@ export interface ReplaceableMatch {
   stringCaptures?: Record<string, string>
 }
 
+export type GenerateReplacementOptions = {
+  filename?: string
+}
+
 export interface CompiledReplacement {
-  generate: (match: ReplaceableMatch) => Node | Node[]
+  generate: (
+    match: ReplaceableMatch,
+    options: GenerateReplacementOptions
+  ) => Node | Node[]
 }
 
 export type RootCompileReplacementOptions = {
   debug?: Debugger
   backend: Backend
+  getResolveAgainstDir?: () => string
 }
 
 export type CompileReplacementOptions = {
   debug: Debugger
   backend: Backend
+  getResolveAgainstDir?: () => string
 }
 
 const nodeCompilers: Record<
@@ -60,8 +71,10 @@ const nodeCompilers: Record<
     options: CompileReplacementOptions
   ) => CompiledReplacement | undefined | void
 > = {
+  CallExpression,
   ClassImplements,
   ClassProperty,
+  ExportAllDeclaration,
   ExportNamedDeclaration,
   ExportDefaultSpecifier,
   ExportSpecifier,