@davidwells/extract-deps 0.0.1

package/README.md

@@ -0,0 +1,211 @@
+# extract-deps
+
+A lightweight utility for extracting imports, requires, and exports from JavaScript/TypeScript code without using AST parsing.
+
+## Features
+
+- Extract ES6 imports (static and dynamic)
+- Extract CommonJS requires (static and dynamic)
+- Extract ES6 exports (default, named, namespace, type exports)
+- Parse code without AST for better performance
+- Support for destructuring in imports/requires
+- TypeScript support for type exports and imports
+- Handles complex patterns like re-exports and aliased exports
+
+## Installation
+
+```bash
+npm install @davidwells/extract-deps
+```
+
+## Usage
+
+### Basic Usage
+
+```javascript
+const { extractDeps } = require('@davidwells/extract-deps')
+
+const code = `
+import { test } from 'uvu'
+import assert from 'uvu/assert'
+const { execSync } = require('child_process')
+const fs = require('fs')
+
+export const myFunction = () => {}
+export default class MyClass {}
+`
+
+const { imports, requires, exports } = extractDeps(code)
+
+console.log('Imports:', imports)
+console.log('Requires:', requires)  
+console.log('Exports:', exports)
+```
+
+### Extract Imports Only
+
+```javascript
+const { getImports, getStaticImports, getDynamicImports } = require('@davidwells/extract-deps')
+
+const code = `
+import { test } from 'uvu'
+import assert from 'uvu/assert'
+
+// Dynamic imports
+const dynamicModule = await import('./utils')
+const config = await import('./config.js')
+`
+
+// Get all imports
+const allImports = getImports(code)
+
+// Get only static imports
+const staticImports = getStaticImports(code)
+
+// Get only dynamic imports  
+const dynamicImports = getDynamicImports(code)
+
+console.log('All imports:', allImports)
+console.log('Static imports:', staticImports)
+console.log('Dynamic imports:', dynamicImports)
+```
+
+### Extract Requires Only
+
+```javascript
+const { getRequires, getStaticRequires, getDynamicRequires } = require('@davidwells/extract-deps')
+
+const code = `
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const fs = require('fs')
+`
+
+// Get all requires
+const allRequires = getRequires(code)
+
+// Get only static requires
+const staticRequires = getStaticRequires(code)
+
+// Get only dynamic requires
+const dynamicRequires = getDynamicRequires(code)
+
+console.log('All requires:', allRequires)
+console.log('Static requires:', staticRequires)
+console.log('Dynamic requires:', dynamicRequires)
+```
+
+### Extract Exports Only
+
+```javascript
+const { 
+  getExports, 
+  getDefaultExports, 
+  getNamedExports,
+  getNamespaceExports,
+  getTypeExports 
+} = require('@davidwells/extract-deps')
+
+const code = `
+// Default exports
+export default function myFunction() {}
+export default class MyClass {}
+
+// Named exports
+export const myVariable = 'value'
+export function myFunction() {}
+
+// Named declaration exports
+export { myFunction, anotherFunction }
+export { myFunction as aliasedFunction }
+
+// Re-exports
+export * from './module'
+export * as namespace from './module'
+
+// Type exports
+export type MyType = string
+export interface MyInterface {}
+`
+
+// Get all exports
+const allExports = getExports(code)
+
+// Get specific export types
+const defaultExports = getDefaultExports(code)
+const namedExports = getNamedExports(code)
+const namespaceExports = getNamespaceExports(code)
+const typeExports = getTypeExports(code)
+
+console.log('All exports:', allExports)
+console.log('Default exports:', defaultExports)
+console.log('Named exports:', namedExports)
+console.log('Namespace exports:', namespaceExports)
+console.log('Type exports:', typeExports)
+```
+
+## API Reference
+
+### `extractDeps(code)`
+
+Main function that extracts all imports, requires, and exports from the given code.
+
+**Parameters:**
+- `code` (string): The JavaScript/TypeScript code to analyze
+
+**Returns:**
+- Object with `imports`, `requires`, and `exports` arrays
+
+### Import Functions
+
+- `getImports(code)` - Get all imports (static and dynamic)
+- `getStaticImports(code)` - Get only static imports
+- `getDynamicImports(code)` - Get only dynamic imports
+
+### Require Functions
+
+- `getRequires(code)` - Get all requires (static and dynamic)
+- `getStaticRequires(code)` - Get only static requires
+- `getDynamicRequires(code)` - Get only dynamic requires
+
+### Export Functions
+
+- `getExports(code)` - Get all exports
+- `getDefaultExports(code)` - Get only default exports
+- `getNamedExports(code)` - Get only named exports
+- `getNamedDeclarationExports(code)` - Get named declaration exports
+- `getAllExports(code)` - Get all exports (alias for getExports)
+- `getNamespaceExports(code)` - Get namespace exports (export * as)
+- `getTypeExports(code)` - Get TypeScript type exports
+
+## Data Structure
+
+Each import/require/export object contains:
+
+```javascript
+{
+  moduleSpecifier: string,    // The module being imported/required
+  exportType: string,         // Type of export (for exports)
+  exportName: string,         // Name of export (for exports)
+  definitions: Array,         // Destructuring and variable definitions
+  // ... other properties specific to the type
+}
+```
+
+## Examples
+
+You can find more examples in the `examples/` directory and usage examples in `_usage.js`.
+
+## Performance
+
+This library avoids AST parsing for better performance when you only need to extract dependency information. It uses regex-based parsing optimized for common JavaScript/TypeScript patterns.
+
+## Alternative Approaches
+
+- Runtime analysis: [pkg-exports](https://github.com/antfu/pkg-exports/)
+- AST-based parsing: [parse-imports](https://github.com/import-js/parse-imports)
+- ESM/CJS utils https://www.npmjs.com/package/mlly
+
+## License
+
+MIT

package/_usage.js

@@ -0,0 +1,175 @@
+const path = require('path')
+const fs = require('fs')
+const { extractDeps } = require('./src/index')
+
+/**
+ * Example usage of extract-deps with lerna fixture
+ * This demonstrates how to analyze dependencies in a monorepo structure
+ */
+
+// Import the lerna fixture directory
+const lernaFixturePath = path.join(__dirname, '../packages-build-order/tests/lerna-fixture')
+
+/**
+ * Read and parse a package.json file
+ * @param {string} filePath - Path to the package.json file
+ * @returns {Object} Parsed package.json content
+ */
+function readPackageJson(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8')
+    return JSON.parse(content)
+  } catch (error) {
+    console.error(`Error reading package.json at ${filePath}:`, error.message)
+    return null
+  }
+}
+
+/**
+ * Get all package.json files in the lerna fixture
+ * @returns {Array} Array of package.json file paths
+ */
+function getPackageJsonFiles() {
+  const packages = []
+  
+  // Get root package.json
+  const rootPackageJson = path.join(lernaFixturePath, 'package.json')
+  if (fs.existsSync(rootPackageJson)) {
+    packages.push({ path: rootPackageJson, type: 'root' })
+  }
+  
+  // Get all subdirectory package.json files
+  const dirs = fs.readdirSync(lernaFixturePath, { withFileTypes: true })
+  
+  dirs.forEach(dirent => {
+    if (dirent.isDirectory()) {
+      const packageJsonPath = path.join(lernaFixturePath, dirent.name, 'package.json')
+      if (fs.existsSync(packageJsonPath)) {
+        packages.push({ path: packageJsonPath, type: 'package', name: dirent.name })
+      }
+    }
+  })
+  
+  return packages
+}
+
+/**
+ * Analyze dependencies in the lerna fixture
+ */
+function analyzeLernaFixture() {
+  console.log('🔍 Analyzing Lerna Fixture Dependencies\n')
+  
+  const packageFiles = getPackageJsonFiles()
+  
+  packageFiles.forEach(({ path: filePath, type, name }) => {
+    const packageJson = readPackageJson(filePath)
+    if (!packageJson) return
+    
+    console.log(`📦 ${type === 'root' ? 'Root Package' : `Package: ${name}`}`)
+    console.log(`   Version: ${packageJson.version}`)
+    console.log(`   Path: ${filePath}`)
+    
+    // Analyze dependencies
+    if (packageJson.dependencies) {
+      console.log(`   Dependencies (${Object.keys(packageJson.dependencies).length}):`)
+      Object.entries(packageJson.dependencies).forEach(([dep, version]) => {
+        console.log(`     - ${dep}: ${version}`)
+      })
+    }
+    
+    if (packageJson.devDependencies) {
+      console.log(`   Dev Dependencies (${Object.keys(packageJson.devDependencies).length}):`)
+      Object.entries(packageJson.devDependencies).forEach(([dep, version]) => {
+        console.log(`     - ${dep}: ${version}`)
+      })
+    }
+    
+    console.log('')
+  })
+}
+
+/**
+ * Example of using extractDeps with actual code files
+ */
+function analyzeCodeDependencies() {
+  console.log('🔍 Analyzing Code Dependencies\n')
+  
+  // Example code that might be found in the lerna fixture
+  const exampleCode = `
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+import { extractDeps } from './src/index'
+import path from 'path'
+import fs from 'fs'
+
+// Dynamic imports
+const dynamicModule = await import('./utils')
+const config = await import('./config.js')
+
+// More requires
+const lerna = require('lerna')
+const { execSync } = require('child_process')
+  `
+  
+  console.log('📝 Example Code:')
+  console.log(exampleCode)
+  console.log('')
+  
+  const { imports, requires } = extractDeps(exampleCode)
+  
+  console.log('📊 Extracted Dependencies:')
+  console.log(`   Imports (${imports.length}):`)
+  imports.forEach((imp, index) => {
+    console.log(`     ${index + 1}. ${imp.moduleSpecifier}`)
+    if (imp.definitions && imp.definitions[0] && imp.definitions[0].destructuredParameters) {
+      const params = imp.definitions[0].destructuredParameters
+      console.log(`        Destructured: ${params.map(p => p.name).join(', ')}`)
+    }
+  })
+  
+  console.log(`   Requires (${requires.length}):`)
+  requires.forEach((req, index) => {
+    console.log(`     ${index + 1}. ${req.moduleSpecifier}`)
+    if (req.definitions && req.definitions[0] && req.definitions[0].destructuredParameters) {
+      const params = req.definitions[0].destructuredParameters
+      console.log(`        Destructured: ${params.map(p => p.name).join(', ')}`)
+    }
+  })
+}
+
+/**
+ * Main function to run the examples
+ */
+function main() {
+  console.log('🚀 Extract Dependencies - Lerna Fixture Example\n')
+  console.log('=' .repeat(50))
+  
+  // Check if lerna fixture exists
+  if (!fs.existsSync(lernaFixturePath)) {
+    console.error('❌ Lerna fixture not found at:', lernaFixturePath)
+    console.log('Please ensure the fixture exists before running this example.')
+    return
+  }
+  
+  // Analyze the lerna fixture structure
+  analyzeLernaFixture()
+  
+  console.log('=' .repeat(50))
+  
+  // Analyze code dependencies
+  analyzeCodeDependencies()
+  
+  console.log('✅ Example completed!')
+}
+
+// Run the example if this file is executed directly
+if (require.main === module) {
+  main()
+}
+
+module.exports = {
+  analyzeLernaFixture,
+  analyzeCodeDependencies,
+  readPackageJson,
+  getPackageJsonFiles
+}

package/examples/get-exports.js

@@ -0,0 +1,31 @@
+const { getExports } = require('../src/get-exports')
+
+const testCode = `
+// Default exports
+export default function myFunction() {}
+export default class MyClass {}
+export default { foo: 'bar' }
+
+// Named exports
+export const myVariable = 'value'
+export function myFunction() {}
+export class MyClass {}
+
+// Named declaration exports
+export { myFunction, anotherFunction }
+export { myFunction as aliasedFunction }
+
+// Re-exports
+export * from './module'
+export * as namespace from './module'
+
+// Type exports
+export type MyType = string
+export interface MyInterface {}
+`
+
+const exportsFound = getExports(testCode)
+console.log('Found exports:')
+exportsFound.forEach((exp, index) => {
+  console.log(`${index + 1}. ${exp.exportType}: ${exp.exportName || exp.namespace || 'default'}`)
+}) 

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@davidwells/extract-deps",
+  "version": "0.0.1",
+  "description": "Get imports and requires from a codebase without AST",
+  "main": "src/index.js",
+  "types": "types/index.d.ts",
+  "author": "David Wells",
+  "license": "MIT",
+  "scripts": {
+    "watch": "watchlist index.js -- npm test",
+    "test": "npm run test:tests",
+    "test:examples": "uvu examples \".*\\.test.js$\"",
+    "test:tests": "uvu tests \".*\\.test.js$\"",
+    "build": "npm run types",
+    "types": "tsc --emitDeclarationOnly --declaration --outDir types",
+    "release:patch": "npm version patch && npm publish",
+    "release:minor": "npm version minor && npm publish",
+    "release:major": "npm version major && npm publish"
+  },
+  "dependencies": {
+    "inspect-parameters-declaration": "^0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.3",
+    "uvu": "^0.5.6"
+  }
+}

package/src/detect-syntax.js

@@ -0,0 +1,70 @@
+// via https://github.com/unjs/mlly/blob/6bf5ad4d784e314319f872a8df41d64edd4e5505/src/syntax.ts#L7
+
+const ESM_RE =
+  /([\s;]|^)(import\b[\s\w*,{}]*from|import\b\s*["'*{]|export\b\s*(?:[*{]|default|class|type|interface|enum|function|const|var|let|async function)|import\.meta\b)/m;
+
+const CJS_RE =
+  /([\s;]|^)(module\.exports\b|exports\.\w|require\s*\(|global\.\w)/m;
+
+const COMMENT_RE = /\/\*.+?\*\/|\/\/.*(?:\r?\n|$)/g;
+
+const BUILTIN_EXTENSIONS = new Set([".mjs", ".cjs", ".node", ".wasm"]);
+
+/**
+ * Options for detecting syntax within a code string.
+ * @typedef {Object} DetectSyntaxOptions
+ * @property {boolean} [stripComments=false] - Indicates whether comments should be stripped from the code before syntax checking.
+ */
+
+/**
+ * Determines if a given code string contains ECMAScript module syntax.
+ *
+ * @param {string} code - The source code to analyze.
+ * @param {DetectSyntaxOptions} opts - See {@link DetectSyntaxOptions}.
+ * @returns {boolean} `true` if the code contains ESM syntax, otherwise `false`.
+ */
+function hasESMSyntax(code, opts = {}) {
+  // Always strip comments to avoid false positives from commented syntax
+  code = code.replace(COMMENT_RE, "");
+  return ESM_RE.test(code);
+}
+
+/**
+ * Determines if a given string of code contains CommonJS syntax.
+ *
+ * @param {string} code - The source code to analyze.
+ * @param {DetectSyntaxOptions} opts - See {@link DetectSyntaxOptions}.
+ * @returns {boolean} `true` if the code contains CommonJS syntax, `false` otherwise.
+ */
+function hasCJSSyntax(code, opts = {}) {
+  // Always strip comments to avoid false positives from commented syntax
+  code = code.replace(COMMENT_RE, "");
+  return CJS_RE.test(code);
+}
+
+/**
+ * Analyzes the supplied code to determine if it contains ECMAScript module syntax, CommonJS syntax, or both.
+ *
+ * @param {string} code - The source code to analyze.
+ * @param {DetectSyntaxOptions} opts - See {@link DetectSyntaxOptions}.
+ * @returns {Object} An object indicating the presence of ESM syntax (`hasESM`), CJS syntax (`hasCJS`) and whether both syntaxes are present (`isMixed`).
+ */
+function detectSyntax(code, opts = {}) {
+  // Always strip comments to avoid false positives from commented syntax
+  code = code.replace(COMMENT_RE, "");
+  // We strip comments once hence not passing opts down to hasESMSyntax and hasCJSSyntax
+  const hasESM = hasESMSyntax(code, {});
+  const hasCJS = hasCJSSyntax(code, {});
+
+  return {
+    hasESM,
+    hasCJS,
+    isMixed: hasESM && hasCJS,
+  };
+}
+
+module.exports = {
+  hasESMSyntax,
+  hasCJSSyntax,
+  detectSyntax,
+};