@davidwells/extract-deps 0.0.1

package/src/get-exports.js

@@ -0,0 +1,299 @@
+const { getNames } = require('./utils')
+
+// https://regex101.com/r/example/1
+const EXPORT_DEFAULT_REGEX = /export\s+default\s+(?:function\s+([\w$]+)|class\s+([\w$]+)|([\w$]+|\([^)]*\)\s*=>|{[\s\S]*?}|\[[\s\S]*?\]|[\w$]+(?:\s*[+\-*/%]\s*[\w$]+)*))/gm
+// https://regex101.com/r/example/2
+const EXPORT_NAMED_REGEX = /export\s+(?:const|let|var|function|class|async\s+function)\s+([\w$]+)/gm
+// https://regex101.com/r/example/3
+const EXPORT_NAMED_DECLARATION_REGEX = /export\s*{([^}]+)}/gm
+// https://regex101.com/r/example/4
+const EXPORT_ALL_REGEX = /export\s*\*\s+from\s+["']([^"']+)["']/gm
+// https://regex101.com/r/example/5
+const EXPORT_AS_NAMESPACE_REGEX = /export\s*\*\s+as\s+([\w$]+)\s+from\s+["']([^"']+)["']/gm
+// https://regex101.com/r/example/6
+const EXPORT_TYPE_REGEX = /export\s+(?:type|interface)\s+([\w$]+)/gm
+// https://regex101.com/r/example/7
+const EXPORT_ASSERTION_REGEX = /export\s+(?:["'\s]*([\w*{}\n\r\t, ]+)from\s*)?["'\s](.*[@\w_-]+)["'\s]+(assert|with)\s*\{([^}]+)\};?$/gm
+
+function getExports(code, options = {}) {
+  const defaultExports = getDefaultExports(code)
+  const namedExports = getNamedExports(code)
+  const namedDeclarationExports = getNamedDeclarationExports(code)
+  const allExports = getAllExports(code)
+  const namespaceExports = getNamespaceExports(code)
+  const typeExports = getTypeExports(code)
+
+  /*
+  console.log('defaultExports', defaultExports)
+  console.log('namedExports', namedExports)
+  console.log('namedDeclarationExports', namedDeclarationExports)
+  console.log('allExports', allExports)
+  console.log('namespaceExports', namespaceExports)
+  console.log('typeExports', typeExports)
+  /** */
+  
+  let allExportStatements = []
+    .concat(defaultExports)
+    .concat(namedExports)
+    .concat(namedDeclarationExports)
+    .concat(allExports)
+    .concat(namespaceExports)
+    .concat(typeExports)
+  
+  if (options.includeAssertionExports) {
+    const assertionExports = getAssertionExports(code)
+    allExportStatements = allExportStatements.concat(assertionExports)
+  }
+  
+  return allExportStatements.sort((a, b) => a.index - b.index)
+}
+
+function getDefaultExports(targetText = '') {
+  let exportStatements = []
+  var result
+  while((result = EXPORT_DEFAULT_REGEX.exec(targetText)) !== null) {
+    const [ line, functionName, className, otherValue ] = result
+    let exportName, exportValue
+    
+    if (functionName) {
+      exportName = functionName
+      exportValue = `function ${functionName}`
+    } else if (className) {
+      exportName = className
+      exportValue = `class ${className}`
+    } else {
+      exportName = extractExportName(otherValue)
+      exportValue = otherValue
+    }
+    
+    exportStatements.push({
+      line: line.trim(),
+      exportType: 'default',
+      exportName,
+      exportValue: exportValue.trim(),
+      index: result.index,
+      isExport: true
+    })
+  }
+  return exportStatements
+}
+
+function getNamedExports(targetText = '') {
+  let exportStatements = []
+  var result
+  while((result = EXPORT_NAMED_REGEX.exec(targetText)) !== null) {
+    const [ line, exportName ] = result
+    
+    exportStatements.push({
+      line: line.trim(),
+      exportType: 'named',
+      exportName,
+      index: result.index,
+      isExport: true
+    })
+  }
+  return exportStatements
+}
+
+function getNamedDeclarationExports(targetText = '') {
+  let exportStatements = []
+  var result
+  while((result = EXPORT_NAMED_DECLARATION_REGEX.exec(targetText)) !== null) {
+    const [ line, exportsList ] = result
+    const exports = parseExportsList(exportsList)
+    
+    exports.forEach(exportItem => {
+      const name = exportItem.name.trim()
+      if (name === '') {
+        return
+      }
+      exportStatements.push({
+        line: line.trim(),
+        exportType: 'named',
+        exportName: name,
+        exportAlias: exportItem.alias,
+        index: result.index,
+        isExport: true
+      })
+    })
+  }
+  return exportStatements
+}
+
+function getAllExports(targetText = '') {
+  let exportStatements = []
+  var result
+  while((result = EXPORT_ALL_REGEX.exec(targetText)) !== null) {
+    const [ line, from ] = result
+    
+    exportStatements.push({
+      line: line.trim(),
+      exportType: 'all',
+      from,
+      index: result.index,
+      isExport: true
+    })
+  }
+  return exportStatements
+}
+
+function getNamespaceExports(targetText = '') {
+  let exportStatements = []
+  var result
+  while((result = EXPORT_AS_NAMESPACE_REGEX.exec(targetText)) !== null) {
+    const [ line, namespace, from ] = result
+    
+    exportStatements.push({
+      line: line.trim(),
+      exportType: 'namespace',
+      namespace,
+      from,
+      index: result.index,
+      isExport: true
+    })
+  }
+  return exportStatements
+}
+
+function getTypeExports(targetText = '') {
+  let exportStatements = []
+  var result
+  while((result = EXPORT_TYPE_REGEX.exec(targetText)) !== null) {
+    const [ line, typeName ] = result
+    
+    exportStatements.push({
+      line: line.trim(),
+      exportType: 'type',
+      exportName: typeName,
+      index: result.index,
+      isExport: true
+    })
+  }
+  return exportStatements
+}
+
+function getAssertionExports(targetText = '') {
+  let exportStatements = []
+  var result
+  while((result = EXPORT_ASSERTION_REGEX.exec(targetText)) !== null) {
+    let [ line, names, from, keyword, assertion ] = result
+    const namesValues = (names || '').trim()
+    // Remove leading newlines and whitespace from the line
+    line = line.replace(/^\s+|\s+$/g, '')
+    
+    exportStatements.push({
+      line,
+      exportType: 'assertion',
+      exportName: namesValues,
+      definitions: getNames(namesValues),
+      from,
+      assertion: assertion.trim(),
+      assertionType: keyword,
+      index: result.index,
+      isExport: true,
+      isAssertion: true
+    })
+  }
+  return exportStatements
+}
+
+function extractExportName(exportValue) {
+  // Handle function declarations
+  if (exportValue.includes('function') && !exportValue.includes('=>')) {
+    const match = exportValue.match(/function\s+([\w$]+)/)
+    return match ? match[1] : 'anonymous'
+  }
+  
+  // Handle class declarations
+  if (exportValue.includes('class')) {
+    const match = exportValue.match(/class\s+([\w$]+)/)
+    return match ? match[1] : 'anonymous'
+  }
+  
+  // Handle arrow functions
+  if (exportValue.includes('=>')) {
+    return 'anonymous'
+  }
+  
+  // Handle object/array literals
+  if (exportValue.startsWith('{') || exportValue.startsWith('[')) {
+    return 'literal'
+  }
+  
+  // Handle simple values
+  return exportValue.trim()
+}
+
+function parseExportsList(exportsList) {
+  const exports = []
+  const items = exportsList.split(',').map(item => item.trim())
+  
+  items.forEach(item => {
+    if (item.includes(' as ')) {
+      const [ name, alias ] = item.split(' as ')
+      exports.push({
+        name: name.trim(),
+        alias: alias.trim()
+      })
+    } else {
+      exports.push({
+        name: item,
+        alias: null
+      })
+    }
+  })
+  
+  return exports
+}
+
+if(require.main === module) {
+  const code = `
+// Default exports
+export default function myFunction() {}
+export default class MyClass {}
+export default { foo: 'bar' }
+export default [1, 2, 3]
+export default 'hello'
+export default 42
+
+// Named exports
+export const myVariable = 'value'
+export let anotherVariable = 'value'
+export var thirdVariable = 'value'
+export function myFunction() {}
+export class MyClass {}
+export async function asyncFunction() {}
+
+// Named declaration exports
+export { myFunction, anotherFunction }
+export { myFunction as aliasedFunction, anotherFunction }
+export { default } from './module'
+export { default as aliasedDefault } from './module'
+
+// Re-exports
+export * from './module'
+export * as namespace from './module'
+
+// Type exports
+export type MyType = string
+export interface MyInterface {}
+
+// Assertion exports
+export { default } from './module' assert { type: 'json' }
+export { Component } from './component' with { type: 'css' }
+  `
+
+  const exportsFound = getExports(code)
+  exportsFound.forEach(item => console.log(item))
+}
+
+module.exports = {
+  getExports,
+  getDefaultExports,
+  getNamedExports,
+  getNamedDeclarationExports,
+  getAllExports,
+  getNamespaceExports,
+  getTypeExports,
+  getAssertionExports
+} 

package/src/get-imports.js

@@ -0,0 +1,165 @@
+const { isRelativeImport, isRelativeImportWithQuotes, getNames } = require('./utils')
+
+// https://regex101.com/r/cfEmlm/1
+const IMPORT_REGEX = /import(?:["'\s]*([\w*{}\n\r\t, ]+)from\s*)?["'\s](.*[@\w_-]+)["'\s]+;?$/gm
+// https://regex101.com/r/UDmXlb/1
+const IMPORT_TYPE_REGEX = /import\(['"](.*)['"]\)\.?([A-Za-z_0-9.]*)?/gm
+// https://regex101.com/r/UDjMoV/1
+const DYNAMIC_IMPORT_REGEX = /(?:(const|var|let)\s+([\w*{}\n\r\t,:= ]+)\s*=\s*)?await\s+import\(([^()]+(?:\([^()]*\)[^()]*)*)\)/gm
+// https://regex101.com/r/example/1
+const ASSERTION_IMPORT_REGEX = /(?:^|\n)\s*import\s+(?:["'\s]*([\w*{}\n\r\t, ]+)from\s*)?["'\s](.*[@\w_-]+)["'\s]+(assert|with)\s*\{([^}]+)\};?$/gm
+
+function getImports(code, options = {}) {
+  const staticImports = getStaticImports(code)
+  const dynamicImports = getDynamicImports(code)
+  if (options.includeAssertionImports) {
+    const assertionImports = getAssertionImports(code)
+    return staticImports.concat(dynamicImports).concat(assertionImports).sort((a, b) => a.index - b.index)
+  }
+  return staticImports.concat(dynamicImports).sort((a, b) => a.index - b.index)
+}
+
+// https://regex101.com/r/cfEmlm/1
+function getStaticImports(targetText = '') {
+  let importStatements = []
+  var result;
+  while((result = IMPORT_REGEX.exec(targetText)) !== null) {
+    const [ line, names, from ] = result
+    const namesValues = (names || '').trim()
+    importStatements.push({ 
+      line,
+      varType: 'const',
+      varName: namesValues,
+      definitions: getNames(namesValues),
+      from,
+      index: result.index,
+      isImport: true,
+      isRelative: isRelativeImport(from)
+    })
+  }
+  return importStatements
+}
+
+function getTypeImports(targetText = '') {
+  let importStatements = []
+  var result;
+  while((result = IMPORT_TYPE_REGEX.exec(targetText)) !== null) {
+    const [ importStatement, importPath, importName ] = result
+    // console.log('result', result)
+    importStatements.push({
+      importStatement,
+      importPath,
+      importName: (importName || '').trim(),
+      index: result.index,
+      isImport: true,
+      isRelative: isRelativeImport(importPath)
+    })
+  }
+  return importStatements
+}
+
+function getDynamicImports(targetText = '') {
+  let importStatements = []
+  var result;
+  while((result = DYNAMIC_IMPORT_REGEX.exec(targetText)) !== null) {
+    const [ line, varType, names, from ] = result
+    let namesValues = (names || '').trim()
+    
+    importStatements.push({
+      line,
+      varType: varType || '',
+      varName: namesValues,
+      definitions: names ? getNames(namesValues) : null,
+      from: from.trim(),
+      index: result.index,
+      isImport: true,
+      isRelative: isRelativeImport(from) || isRelativeImportWithQuotes(from),
+      isDynamic: true
+    })
+  }
+  return importStatements
+}
+
+function getAssertionImports(targetText = '') {
+  let importStatements = []
+  var result;
+  while((result = ASSERTION_IMPORT_REGEX.exec(targetText)) !== null) {
+    let [ line, names, from, keyword, assertion ] = result
+    const namesValues = (names || '').trim()
+    // Remove leading newlines and whitespace from the line
+    line = line.replace(/^\s+|\s+$/g, '')
+    
+    importStatements.push({
+      line,
+      varType: 'const',
+      varName: namesValues,
+      definitions: getNames(namesValues),
+      from,
+      assertion: assertion.trim(),
+      assertionType: keyword,
+      index: result.index,
+      isImport: true,
+      isRelative: isRelativeImport(from),
+      isAssertion: true
+    })
+  }
+  return importStatements
+}
+
+if(require.main === module) {
+  const code = `
+import {
+  Component
+} from '@angular2/core';
+import defaultMember from "module-name";
+import   *    as name from "module-name  ";
+import   React from react"
+import   {  member }   from "  module-name";
+import { member as alias } from "module-name";
+import { member1 , 
+member2 } from "module-name";
+import { member1 , member2 as alias2 , member3 as alias3 } from "module-name";
+import defaultMember, { member, member } from "module-name";
+import defaultMember, * as name from "module-name";
+import "module-name";
+import * from './smdn';
+  `
+
+const dynamicCode = `
+// Basic dynamic import
+const module = await import('./module.js')
+
+// With variable
+const moduleName = './utils.js'
+const utils = await import(moduleName)
+
+// With template literals
+const folder = 'components'
+const component = await import(\`./src/$\{folder}/Button.js\`)
+
+// With path building
+const modulePath = path.join('./src', 'helpers', 'api.js')
+const api = await import(modulePath)
+
+// Destructuring
+const { default: Component, helper } = await import('./Component.js')
+
+// Variable assignment
+const dynamicModule = await import(getModulePath())
+`
+  const dynamicImports = getDynamicImports(dynamicCode)
+  dynamicImports.forEach(item => console.log(item))
+
+  /*
+  const imports = getStaticImports(code)
+  imports.forEach(item => console.log(item))
+  /** */
+}
+
+module.exports = {
+  getImports,
+  getStaticImports,
+  getTypeImports,
+  getDynamicImports,
+  getAssertionImports
+}

package/src/get-requires.js

@@ -0,0 +1,104 @@
+const { isRelativeImport, getNames } = require('./utils')
+
+// Updated regex to exclude ES6 dynamic imports
+const REQUIRE_REGEX = /(?!.*await\s+import)(const|var|let)(?:["'\s]*([\w*{}:=\n\r\t,:= ]+)\s*=\s*require\(\s*)?["'\s](.*[@\w_-]+)["'\s]+\);?$|(?!.*await\s+import)require\(["'\s](.*[@\w_-]+)["'\s]\)/gm
+// https://regex101.com/r/kZ5xCk/3
+const DYNAMIC_REQUIRE_REGEX = /(?:(const|var|let)\s+([\w*{}\n\r\t,:= ]+)\s*=\s*)?require\(([^()'"]+(?:\([^()]*\)[^()'"]*)*)\)/gm
+
+function getDynamicRequires(code) {
+  const results = []
+  let match
+  
+  while ((match = DYNAMIC_REQUIRE_REGEX.exec(code)) !== null) {
+    const [line, varType, names, from] = match
+    /*
+    console.log('line', line)
+    console.log('varType', varType)
+    console.log('names', names || 'no names')
+    console.log('from', from)
+    /** */
+    let namesValues = (names || '').trim()
+    
+    results.push({
+      line,
+      varType: varType || '',
+      varName: namesValues,
+      definitions: names ? getNames(namesValues) : null,
+      from: from.trim(),
+      index: match.index,
+      isRequire: true,
+      isRelative: false,
+      isDynamic: true
+    })
+  }
+  
+  return results
+}
+
+// https://regex101.com/r/sR1TIP/1
+function getStaticRequires(targetText = '') {
+  let requireStatements = []
+  var result;
+  while((result = REQUIRE_REGEX.exec(targetText)) !== null) {
+    const [ line, varType, names, from, fromTwo ] = result
+    // console.log('getStaticRequires result', result)
+    const importLocation = from || fromTwo
+    const importItems = (names || '').trim()
+    requireStatements.push({
+      line,
+      varType: varType || '',
+      varName: importItems,
+      definitions: importItems ? getNames(importItems) : null,
+      from: importLocation,
+      index: result.index,
+      isRequire: true,
+      isRelative: isRelativeImport(importLocation),
+      isDynamic: false
+    })
+  }
+
+  return requireStatements
+}
+
+function getRequires(code) {
+  const staticRequires = getStaticRequires(code)
+  const dynamicRequires = getDynamicRequires(code)
+  return staticRequires.concat(dynamicRequires).sort((a, b) => a.index - b.index)
+}
+
+if (require.main === module) {
+  const code = `
+  const moduleName = 'fs'
+  const dynamicRequire = require(moduleName)
+  const path = require('path')
+  const relative = require('./relative')
+  const dynamicPath = require(path.join(__dirname, 'utils'))
+  const foo = require('foo-pkg')
+  require(\`./$\{folder}/file\`)
+  const { test : funky, foo = false } = require(moduleTwo)
+  `
+
+  const failCase = `
+// Dynamic imports
+const dynamicModule = await import('./utils')
+const config = await import('./config.js')
+  `
+
+  //*
+  const dynamicRequires = getDynamicRequires(code)
+  dynamicRequires.forEach(item => console.log(item))
+  /** */
+
+
+  //*
+  const requires = getRequires(failCase)
+  console.log('requires', requires)
+  requires.forEach(item => console.log(item))
+  /** */
+}
+
+module.exports = {
+  getRequires,
+  getStaticRequires,
+  getDynamicRequires,
+}

package/src/index.js

@@ -0,0 +1,90 @@
+const { getImports, getStaticImports, getDynamicImports } = require('./get-imports')
+const { getRequires, getStaticRequires, getDynamicRequires } = require('./get-requires')
+const { 
+  getExports, 
+  getDefaultExports, 
+  getNamedExports, 
+  getNamedDeclarationExports, 
+  getAllExports, 
+  getNamespaceExports, 
+  getTypeExports 
+} = require('./get-exports')
+
+// Alt approach import parseImports from 'parse-imports'
+// https://github.com/ganeshkbhat/get-imports/blob/main/index.js
+// Alt get imports https://github.com/beenotung/fix-esm-import-path/blob/master/fix-esm-import-path.js#L186
+
+function extractDeps(code, filePath = '') {
+  const imports = getImports(code)
+  //console.log('imports', imports)
+  const requires = getRequires(code)
+  // console.log('requires', requires)
+  const foundExports = getExports(code)
+  // console.log('exports', exports)
+  return { imports, requires, exports: foundExports }
+}
+
+if (require.main === module) {
+  const code = `
+  const { test : testTwo, lol: lolTwo } = require('uvu')
+  const assert = require('uvu/assert')
+  import { test } from 'uvu'
+  import assert from 'uvu/assert'
+  import funky from '../my-local-module'
+  import { test } from 'uvu'
+
+
+  export {
+    foo,
+    bar,
+  }
+  `
+
+  const failCase = `
+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, spawnSync } = require('child_process')
+`
+  const result = extractDeps(code)
+
+  const { imports, requires } = result
+
+  function logDefinitions(item) {
+    console.log(item)
+    const definitions = item.definitions
+    console.log(definitions)
+  }
+
+  imports.forEach(logDefinitions)
+  requires.forEach(logDefinitions)
+}
+
+module.exports = {
+  extractDeps,
+  /* Requires */
+  getRequires,
+  getDynamicRequires,
+  getStaticRequires,
+  /* Imports */
+  getImports,
+  getStaticImports,
+  getDynamicImports,
+  /* Exports */
+  getExports,
+  getDefaultExports,
+  getNamedExports,
+  getNamedDeclarationExports,
+  getAllExports,
+  getNamespaceExports,
+  getTypeExports,
+}