@tamagui/babel-plugin-fully-specified 1.101.7 → 1.102.0

package/src/index.ts

@@ -1,168 +1,242 @@
 import { existsSync, readFileSync, lstatSync } from 'node:fs'
 import { resolve, extname, dirname } from 'node:path'
-import {
-  importDeclaration,
-  exportNamedDeclaration,
-  exportAllDeclaration,
-  stringLiteral,
-} from '@babel/types'
 
-import type { ConfigAPI, NodePath, PluginPass } from '@babel/core'
+import type { ConfigAPI, NodePath, PluginObj, PluginPass } from '@babel/core'
 import type {
-  ImportSpecifier,
-  ImportDeclaration,
   ExportAllDeclaration,
-  StringLiteral,
-  ExportSpecifier,
-  ExportDeclaration,
   ExportNamedDeclaration,
+  Import,
+  ImportDeclaration,
 } from '@babel/types'
 
-type ImportDeclarationFunc = (
-  specifiers: Array<ImportSpecifier>,
-  source: StringLiteral
-) => ImportDeclaration
-
-type ExportNamedDeclarationFunc = (
-  declaration?: ExportDeclaration,
-  specifiers?: Array<ExportSpecifier>,
-  source?: StringLiteral
-) => ExportNamedDeclaration
-
-type ExportAllDeclarationFunc = (source: StringLiteral) => ExportAllDeclaration
-
-type PathDeclaration = NodePath & {
-  node: ImportDeclaration & ExportNamedDeclaration & ExportAllDeclaration
-}
-
-type PackageData = {
-  hasPath: boolean
-  packagePath: string
-}
-
-interface FullySpecifiedOptions {
-  declaration:
-    | ImportDeclarationFunc
-    | ExportNamedDeclarationFunc
-    | ExportAllDeclarationFunc
-  makeNodes: (path: PathDeclaration) => Array<PathDeclaration>
-  ensureFileExists: boolean
+export interface FullySpecifiedOptions {
+  ensureFileExists:
+    | boolean
+    | {
+        /**
+         * If you're doing a non-in-place transformation (for example, outputting `.mjs` from `.js`) with `ensureFileExists` enabled, it's possible that the transform will be incorrect due to the imported file is not transformed and written into place yet (for example, we have `foo.js` and `bar.js` and we're transforming them into `foo.mjs` and `bar.mjs` respectively, in `bar.js` we have `import { ... } from './foo.js'` which we expect to be transformed into `import { ... } from './foo.mjs'`, but if `foo.mjs` is not transformed and written yet, it will be transformed into `import { ... } from './foo.js'` because `foo.mjs` can't be found at that time).
+         *
+         * To solve this, you can set this option to `'.mjs'` to force the extension to be transformed into that specified extension.
+         */
+        forceExtension?: string
+      }
   esExtensionDefault: string
+  /** List of all extensions which we try to find. */
   tryExtensions: Array<string>
+  /** List of extensions that can run in Node.js or in the Browser. */
   esExtensions: Array<string>
+  /** List of packages that also should be transformed with this plugin. */
   includePackages: Array<string>
 }
 
-const makeDeclaration = ({
-  declaration,
-  makeNodes,
-  ensureFileExists = false,
-  esExtensionDefault = '.js',
-
-  // List of all extensions which we try to find
-  tryExtensions = ['.js', '.mjs', '.cjs'],
-
-  // List of extensions that can run in Node.js or in the Browser
-  esExtensions = ['.js', '.mjs', '.cjs'],
-
-  // List of packages that also should be transformed with this plugin
-  includePackages = [],
-}: FullySpecifiedOptions) => {
-  return (
-    path: PathDeclaration,
-    {
-      file: {
-        opts: { filename },
-      },
-    }: PluginPass
+const DEFAULT_OPTIONS = {
+  ensureFileExists: false,
+  esExtensionDefault: '.js',
+  tryExtensions: ['.js', '.mjs', '.cjs'],
+  esExtensions: ['.js', '.mjs', '.cjs'],
+  includePackages: [],
+}
+
+export default function FullySpecified(
+  api: ConfigAPI,
+  rawOptions: FullySpecifiedOptions
+): PluginObj {
+  api.assertVersion(7)
+
+  const options = { ...DEFAULT_OPTIONS, ...rawOptions }
+
+  /** For `import ... from '...'`. */
+  const importDeclarationVisitor = (
+    path: NodePath<ImportDeclaration>,
+    state: PluginPass
   ) => {
-    const { source } = path.node
+    const filePath = state.file.opts.filename
+    if (!filePath) return // cannot determine file path therefore cannot proceed
+
+    const { node } = path
+    if (node.importKind === 'type') return // is a type-only import, skip
+
+    const originalModuleSpecifier = node.source.value
+    const fullySpecifiedModuleSpecifier = getFullySpecifiedModuleSpecifier(
+      originalModuleSpecifier,
+      {
+        filePath,
+        options,
+      }
+    )
 
-    if (!source || !filename) {
-      return // stop here
+    if (fullySpecifiedModuleSpecifier) {
+      node.source.value = fullySpecifiedModuleSpecifier
     }
+  }
 
-    const { exportKind, importKind } = path.node
-    const isTypeOnly = exportKind === 'type' || importKind === 'type'
-    if (isTypeOnly) {
-      return // stop here
-    }
+  /** For `export ... from '...'`. */
+  const exportDeclarationVisitor = (
+    path: NodePath<ExportNamedDeclaration> | NodePath<ExportAllDeclaration>,
+    state: PluginPass
+  ) => {
+    const filePath = state.file.opts.filename
+    if (!filePath) return // cannot determine file path therefore cannot proceed
 
-    const { value } = source
-    const module = value as string
+    const { node } = path
+    if (node.exportKind === 'type') return // is a type-only export, skip
 
-    let packageData: PackageData | null = null
+    const source = node.source
+    if (!source) return // is not a re-export, skip
 
-    if (!isLocalFile(module)) {
-      if (includePackages.some((name) => module.startsWith(name))) {
-        packageData = getPackageData(module)
+    const originalModuleSpecifier = source.value
+    const fullySpecifiedModuleSpecifier = getFullySpecifiedModuleSpecifier(
+      originalModuleSpecifier,
+      {
+        filePath,
+        options,
       }
+    )
 
-      if (!(packageData && packageData.hasPath)) {
-        return // stop here
-      }
+    if (fullySpecifiedModuleSpecifier) {
+      source.value = fullySpecifiedModuleSpecifier
     }
+  }
 
-    const filenameExtension = extname(filename)
-    const filenameDirectory = dirname(filename)
-    const isDirectory = isLocalDirectory(resolve(filenameDirectory, module))
-
-    const currentModuleExtension = extname(module)
-    const targetModule = evaluateTargetModule({
-      module,
-      filenameDirectory,
-      filenameExtension,
-      packageData,
-      currentModuleExtension,
-      isDirectory,
-      tryExtensions,
-      esExtensions,
-      esExtensionDefault,
-      ensureFileExists,
-    })
+  /** For dynamic `import()`s. */
+  const importVisitor = (path: NodePath<Import>, state) => {
+    const filePath = state.file.opts.filename
+    if (!filePath) return // cannot determine file path therefore cannot proceed
 
-    if (targetModule === false || currentModuleExtension === targetModule.extension) {
-      return // stop here
+    const parent = path.parent
+    if (parent.type !== 'CallExpression') {
+      return // we expect the usage of `import` is a call to it, e.g.: `import('...')`, other usages are not supported
     }
 
-    const nodes = makeNodes(path)
+    const firstArgOfImportCall = parent.arguments[0]
+    if (firstArgOfImportCall.type !== 'StringLiteral') {
+      return // we expect the first argument of `import` to be a string, e.g.: `import('./myModule')`, other types are not supported
+    }
 
-    path.replaceWith(
-      // @ts-ignore
-      declaration.apply(null, [...nodes, stringLiteral(targetModule.module)])
+    const originalModuleSpecifier = firstArgOfImportCall.value
+    const fullySpecifiedModuleSpecifier = getFullySpecifiedModuleSpecifier(
+      originalModuleSpecifier,
+      {
+        filePath,
+        options,
+      }
     )
-  }
-}
 
-export default function FullySpecified(api: ConfigAPI, options: FullySpecifiedOptions) {
-  api.assertVersion(7)
+    if (fullySpecifiedModuleSpecifier) {
+      firstArgOfImportCall.value = fullySpecifiedModuleSpecifier
+    }
+  }
 
   return {
     name: 'babel-plugin-fully-specified',
     visitor: {
-      ImportDeclaration: makeDeclaration({
-        ...options,
-        declaration: importDeclaration,
-        makeNodes: ({ node: { specifiers } }) => [specifiers],
-      }),
-      ExportNamedDeclaration: makeDeclaration({
-        ...options,
-        declaration: exportNamedDeclaration,
-        makeNodes: ({ node: { declaration, specifiers } }) => [declaration, specifiers],
-      }),
-      ExportAllDeclaration: makeDeclaration({
-        ...options,
-        declaration: exportAllDeclaration,
-        makeNodes: () => [],
-      }),
+      ImportDeclaration: importDeclarationVisitor,
+      ExportNamedDeclaration: exportDeclarationVisitor,
+      ExportAllDeclaration: exportDeclarationVisitor,
+      Import: importVisitor,
     },
   }
 }
 
-function getPackageData<PackageData>(module: string) {
+/**
+ * Returns a fully specified [module specifier](https://tc39.es/ecma262/multipage/ecmascript-language-scripts-and-modules.html#prod-ModuleSpecifier) (or `null` if it can't be determined or shouldn't be transformed).
+ */
+function getFullySpecifiedModuleSpecifier(
+  /**
+   * The original module specifier in the code.
+   *
+   * For example, `'./foo'` for `import { foo } from './foo'`.
+   */
+  originalModuleSpecifier: string,
+  {
+    filePath,
+    options,
+  }: {
+    /**
+     * The absolute file path of the file being transformed.
+     *
+     * Normally this can be obtained from the 2nd parameter in a visitor function (often named as `state`): `state.file.opts.filename`.
+     */
+    filePath: string
+    /** Options that users pass to babel-plugin-fully-specified. */
+    options: FullySpecifiedOptions
+  }
+): string | null {
+  const fileExt = extname(filePath)
+  const fileDir = dirname(filePath)
+
+  const { includePackages } = options
+
+  let packageData: PackageImportData | null = null
+  if (!isLocalFile(originalModuleSpecifier)) {
+    if (includePackages.some((name) => originalModuleSpecifier.startsWith(name))) {
+      packageData = getPackageData(originalModuleSpecifier, filePath)
+    }
+
+    if (!(packageData && packageData.isDeepImport)) {
+      return null
+    }
+  }
+
+  const isDirectory = isLocalDirectory(resolve(fileDir, originalModuleSpecifier))
+
+  const currentModuleExtension = extname(originalModuleSpecifier)
+
+  const { tryExtensions, esExtensions, esExtensionDefault, ensureFileExists } = options
+
+  const targetModule = evaluateTargetModule({
+    moduleSpecifier: originalModuleSpecifier,
+    filenameDirectory: fileDir,
+    filenameExtension: fileExt,
+    packageData,
+    currentModuleExtension,
+    isDirectory,
+    tryExtensions,
+    esExtensions,
+    esExtensionDefault,
+    ensureFileExists,
+  })
+
+  if (targetModule === false || currentModuleExtension === targetModule.extension) {
+    return null
+  }
+
+  return targetModule.module
+}
+
+/**
+ * Data about how a package is being imported.
+ */
+type PackageImportData = {
+  /**
+   * Indicates whether the import from the package is a deep import.
+   *
+   * Example:
+   *
+   * * `import { foo } from '@org/package'` -> `isDeepImport: false`
+   * * `import { foo } from '@org/package/lib/foo'` -> `isDeepImport: true`
+   */
+  isDeepImport: boolean
+  /**
+   * The resolved absolute path of the exact file being imported. This will always be a file path (such as `<project>/node_modules/my-pkg/dist/index.js`), not just a directory path.
+   */
+  modulePath: string
+}
+
+/**
+ * Given a module specifier and the file path of the source file which imports that module, returns the package data of that module if it can be found.
+ */
+function getPackageData(
+  /** The module specifier, e.g.: `@org/package/lib/someTool`. */
+  moduleSpecifier: string,
+  /** The file path of the source file which imports that module. */
+  filePath?: string
+): PackageImportData | null {
   try {
-    const packagePath = require.resolve(module)
-    const parts = packagePath.split('/')
+    const modulePath = require.resolve(moduleSpecifier, {
+      paths: filePath ? [filePath] : [],
+    })
+    const parts = modulePath.split('/')
 
     let packageDir = ''
     for (let i = parts.length; i >= 0; i--) {
@@ -178,15 +252,15 @@ function getPackageData<PackageData>(module: string) {
 
     const packageJson = JSON.parse(readFileSync(`${packageDir}/package.json`).toString())
 
-    const hasPath = !module.endsWith(packageJson.name)
-    return { hasPath, packagePath }
+    const isDeepImport = !moduleSpecifier.endsWith(packageJson.name)
+    return { isDeepImport, modulePath }
   } catch (e) {}
 
   return null
 }
 
-function isLocalFile(module: string) {
-  return module.startsWith('.') || module.startsWith('/')
+function isLocalFile(moduleSpecifier: string) {
+  return moduleSpecifier.startsWith('.') || moduleSpecifier.startsWith('/')
 }
 
 function isLocalDirectory(absoluteDirectory: string) {
@@ -194,7 +268,7 @@ function isLocalDirectory(absoluteDirectory: string) {
 }
 
 function evaluateTargetModule({
-  module,
+  moduleSpecifier,
   currentModuleExtension,
   packageData,
   isDirectory,
@@ -206,12 +280,15 @@ function evaluateTargetModule({
   ensureFileExists,
 }) {
   if (packageData) {
-    if (packageData.packagePath.endsWith('index.js') && !module.endsWith('index.js')) {
-      module = `${module}/index`
+    if (
+      packageData.modulePath.endsWith('index.js') &&
+      !moduleSpecifier.endsWith('index.js')
+    ) {
+      moduleSpecifier = `${moduleSpecifier}/index`
     }
 
     return {
-      module: module + esExtensionDefault,
+      module: moduleSpecifier + esExtensionDefault,
       extension: esExtensionDefault,
     }
   }
@@ -225,14 +302,14 @@ function evaluateTargetModule({
     !existsSync(
       resolve(
         filenameDirectory,
-        currentModuleExtension ? module : module + esExtensionDefault
+        currentModuleExtension ? moduleSpecifier : moduleSpecifier + esExtensionDefault
       )
     )
   ) {
-    module = `${module}/index`
+    moduleSpecifier = `${moduleSpecifier}/index`
   }
 
-  const targetFile = resolve(filenameDirectory, module)
+  const targetFile = resolve(filenameDirectory, moduleSpecifier)
 
   if (ensureFileExists) {
     // 1. try first with same extension
@@ -241,7 +318,7 @@ function evaluateTargetModule({
       existsSync(targetFile + filenameExtension)
     ) {
       return {
-        module: module + filenameExtension,
+        module: moduleSpecifier + (ensureFileExists.forceExtension || filenameExtension),
         extension: filenameExtension,
       }
     }
@@ -249,17 +326,20 @@ function evaluateTargetModule({
     // 2. then try with all others
     for (const extension of tryExtensions) {
       if (existsSync(targetFile + extension)) {
-        return { module: module + '.mjs', extension }
+        return {
+          module: moduleSpecifier + (ensureFileExists.forceExtension || extension),
+          extension,
+        }
       }
     }
   } else if (esExtensions.includes(filenameExtension)) {
     return {
-      module: module + filenameExtension,
+      module: moduleSpecifier + filenameExtension,
       extension: filenameExtension,
     }
   } else {
     return {
-      module: module + esExtensionDefault,
+      module: moduleSpecifier + esExtensionDefault,
       extension: esExtensionDefault,
     }
   }

package/types/index.d.ts

@@ -1,27 +1,20 @@
-import type { ConfigAPI, NodePath, PluginPass } from '@babel/core';
-import type { ImportSpecifier, ImportDeclaration, ExportAllDeclaration, StringLiteral, ExportSpecifier, ExportDeclaration, ExportNamedDeclaration } from '@babel/types';
-type ImportDeclarationFunc = (specifiers: Array<ImportSpecifier>, source: StringLiteral) => ImportDeclaration;
-type ExportNamedDeclarationFunc = (declaration?: ExportDeclaration, specifiers?: Array<ExportSpecifier>, source?: StringLiteral) => ExportNamedDeclaration;
-type ExportAllDeclarationFunc = (source: StringLiteral) => ExportAllDeclaration;
-type PathDeclaration = NodePath & {
-    node: ImportDeclaration & ExportNamedDeclaration & ExportAllDeclaration;
-};
-interface FullySpecifiedOptions {
-    declaration: ImportDeclarationFunc | ExportNamedDeclarationFunc | ExportAllDeclarationFunc;
-    makeNodes: (path: PathDeclaration) => Array<PathDeclaration>;
-    ensureFileExists: boolean;
+import type { ConfigAPI, PluginObj } from '@babel/core';
+export interface FullySpecifiedOptions {
+    ensureFileExists: boolean | {
+        /**
+         * If you're doing a non-in-place transformation (for example, outputting `.mjs` from `.js`) with `ensureFileExists` enabled, it's possible that the transform will be incorrect due to the imported file is not transformed and written into place yet (for example, we have `foo.js` and `bar.js` and we're transforming them into `foo.mjs` and `bar.mjs` respectively, in `bar.js` we have `import { ... } from './foo.js'` which we expect to be transformed into `import { ... } from './foo.mjs'`, but if `foo.mjs` is not transformed and written yet, it will be transformed into `import { ... } from './foo.js'` because `foo.mjs` can't be found at that time).
+         *
+         * To solve this, you can set this option to `'.mjs'` to force the extension to be transformed into that specified extension.
+         */
+        forceExtension?: string;
+    };
     esExtensionDefault: string;
+    /** List of all extensions which we try to find. */
     tryExtensions: Array<string>;
+    /** List of extensions that can run in Node.js or in the Browser. */
     esExtensions: Array<string>;
+    /** List of packages that also should be transformed with this plugin. */
     includePackages: Array<string>;
 }
-export default function FullySpecified(api: ConfigAPI, options: FullySpecifiedOptions): {
-    name: string;
-    visitor: {
-        ImportDeclaration: (path: PathDeclaration, { file: { opts: { filename }, }, }: PluginPass) => void;
-        ExportNamedDeclaration: (path: PathDeclaration, { file: { opts: { filename }, }, }: PluginPass) => void;
-        ExportAllDeclaration: (path: PathDeclaration, { file: { opts: { filename }, }, }: PluginPass) => void;
-    };
-};
-export {};
+export default function FullySpecified(api: ConfigAPI, rawOptions: FullySpecifiedOptions): PluginObj;
 //# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAClE,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,sBAAsB,EACvB,MAAM,cAAc,CAAA;AAErB,KAAK,qBAAqB,GAAG,CAC3B,UAAU,EAAE,KAAK,CAAC,eAAe,CAAC,EAClC,MAAM,EAAE,aAAa,KAClB,iBAAiB,CAAA;AAEtB,KAAK,0BAA0B,GAAG,CAChC,WAAW,CAAC,EAAE,iBAAiB,EAC/B,UAAU,CAAC,EAAE,KAAK,CAAC,eAAe,CAAC,EACnC,MAAM,CAAC,EAAE,aAAa,KACnB,sBAAsB,CAAA;AAE3B,KAAK,wBAAwB,GAAG,CAAC,MAAM,EAAE,aAAa,KAAK,oBAAoB,CAAA;AAE/E,KAAK,eAAe,GAAG,QAAQ,GAAG;IAChC,IAAI,EAAE,iBAAiB,GAAG,sBAAsB,GAAG,oBAAoB,CAAA;CACxE,CAAA;AAOD,UAAU,qBAAqB;IAC7B,WAAW,EACP,qBAAqB,GACrB,0BAA0B,GAC1B,wBAAwB,CAAA;IAC5B,SAAS,EAAE,CAAC,IAAI,EAAE,eAAe,KAAK,KAAK,CAAC,eAAe,CAAC,CAAA;IAC5D,gBAAgB,EAAE,OAAO,CAAA;IACzB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,aAAa,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IAC5B,YAAY,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IAC3B,eAAe,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;CAC/B;AAmFD,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,GAAG,EAAE,SAAS,EAAE,OAAO,EAAE,qBAAqB;;;kCAjE3E,eAAe,sCAKlB,UAAU;uCALP,eAAe,sCAKlB,UAAU;qCALP,eAAe,sCAKlB,UAAU;;EAmFhB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAY,SAAS,EAAc,MAAM,aAAa,CAAA;AAQ7E,MAAM,WAAW,qBAAqB;IACpC,gBAAgB,EACZ,OAAO,GACP;QACE;;;;WAIG;QACH,cAAc,CAAC,EAAE,MAAM,CAAA;KACxB,CAAA;IACL,kBAAkB,EAAE,MAAM,CAAA;IAC1B,mDAAmD;IACnD,aAAa,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IAC5B,oEAAoE;IACpE,YAAY,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IAC3B,yEAAyE;IACzE,eAAe,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;CAC/B;AAUD,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,GAAG,EAAE,SAAS,EACd,UAAU,EAAE,qBAAqB,GAChC,SAAS,CAgGX"}